diff --git a/src/__tests__/cli/commands/list-agents.test.ts b/src/__tests__/cli/commands/list-agents.test.ts new file mode 100644 index 00000000..c17c4b6b --- /dev/null +++ b/src/__tests__/cli/commands/list-agents.test.ts @@ -0,0 +1,447 @@ +/** + * @file list-agents.test.ts + * @description Tests for the list-agents CLI command + * + * Tests all functionality of the list-agents command including: + * - Human-readable output formatting + * - JSON output mode + * - Group filtering + * - Empty agents handling + * - Error handling + */ + +import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'; +import type { SessionInfo, Group } from '../../../shared/types'; + +// Mock the storage service +vi.mock('../../../cli/services/storage', () => ({ + readSessions: vi.fn(), + readGroups: vi.fn(), + getSessionsByGroup: vi.fn(), + resolveGroupId: vi.fn((id: string) => id), +})); + +// Mock the formatter +vi.mock('../../../cli/output/formatter', () => ({ + formatAgents: vi.fn((agents, groupName) => { + if (agents.length === 0) { + return groupName ? `No agents in group "${groupName}"` : 'No agents found'; + } + const header = groupName ? `Agents in "${groupName}":\n` : 'Agents:\n'; + return header + agents.map((a: any) => `${a.name} (${a.toolType})`).join('\n'); + }), + formatError: vi.fn((msg) => `Error: ${msg}`), +})); + +import { listAgents } from '../../../cli/commands/list-agents'; +import { readSessions, readGroups, getSessionsByGroup, resolveGroupId } from '../../../cli/services/storage'; +import { formatAgents, formatError } from '../../../cli/output/formatter'; + +describe('list-agents command', () => { + let consoleSpy: ReturnType; + let consoleErrorSpy: ReturnType; + let processExitSpy: ReturnType; + + const mockSession = (overrides: Partial = {}): SessionInfo => ({ + id: 'sess-1', + name: 'Test Agent', + toolType: 'claude-code', + cwd: '/path/to/project', + groupId: undefined, + autoRunFolderPath: undefined, + ...overrides, + }); + + beforeEach(() => { + vi.clearAllMocks(); + consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {}); + consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {}); + processExitSpy = vi.spyOn(process, 'exit').mockImplementation((code?: string | number | null | undefined) => { + throw new Error(`process.exit(${code})`); + }); + }); + + afterEach(() => { + consoleSpy.mockRestore(); + consoleErrorSpy.mockRestore(); + processExitSpy.mockRestore(); + }); + + describe('human-readable output', () => { + it('should display agents in human-readable format', () => { + const mockSessions: SessionInfo[] = [ + mockSession({ id: 'a1', name: 'Agent One', toolType: 'claude-code' }), + mockSession({ id: 'a2', name: 'Agent Two', toolType: 'aider' }), + ]; + vi.mocked(readSessions).mockReturnValue(mockSessions); + + listAgents({}); + + expect(readSessions).toHaveBeenCalled(); + expect(formatAgents).toHaveBeenCalledWith( + expect.arrayContaining([ + expect.objectContaining({ id: 'a1', name: 'Agent One' }), + expect.objectContaining({ id: 'a2', name: 'Agent Two' }), + ]), + undefined + ); + expect(consoleSpy).toHaveBeenCalled(); + }); + + it('should handle empty agents list', () => { + vi.mocked(readSessions).mockReturnValue([]); + + listAgents({}); + + expect(formatAgents).toHaveBeenCalledWith([], undefined); + expect(consoleSpy).toHaveBeenCalledWith('No agents found'); + }); + + it('should display a single agent', () => { + const mockSessions: SessionInfo[] = [ + mockSession({ id: 'solo', name: 'Solo Agent' }), + ]; + vi.mocked(readSessions).mockReturnValue(mockSessions); + + listAgents({}); + + expect(formatAgents).toHaveBeenCalledWith( + [expect.objectContaining({ id: 'solo', name: 'Solo Agent' })], + undefined + ); + }); + + it('should include all agent properties', () => { + const mockSessions: SessionInfo[] = [ + mockSession({ + id: 'full', + name: 'Full Agent', + toolType: 'terminal', + cwd: '/home/user/project', + groupId: 'group-1', + autoRunFolderPath: '/home/user/playbooks', + }), + ]; + vi.mocked(readSessions).mockReturnValue(mockSessions); + + listAgents({}); + + expect(formatAgents).toHaveBeenCalledWith( + [expect.objectContaining({ + id: 'full', + name: 'Full Agent', + toolType: 'terminal', + cwd: '/home/user/project', + groupId: 'group-1', + autoRunFolderPath: '/home/user/playbooks', + })], + undefined + ); + }); + }); + + describe('JSON output', () => { + it('should output JSON when json option is true', () => { + const mockSessions: SessionInfo[] = [ + mockSession({ id: 'json-agent', name: 'JSON Agent', toolType: 'claude-code', cwd: '/test' }), + ]; + vi.mocked(readSessions).mockReturnValue(mockSessions); + + listAgents({ json: true }); + + expect(formatAgents).not.toHaveBeenCalled(); + expect(consoleSpy).toHaveBeenCalledTimes(1); + + const output = consoleSpy.mock.calls[0][0]; + const parsed = JSON.parse(output); + + expect(parsed).toHaveLength(1); + expect(parsed[0]).toEqual(expect.objectContaining({ + id: 'json-agent', + name: 'JSON Agent', + toolType: 'claude-code', + cwd: '/test', + })); + }); + + it('should output empty JSON array for no agents', () => { + vi.mocked(readSessions).mockReturnValue([]); + + listAgents({ json: true }); + + const output = consoleSpy.mock.calls[0][0]; + const parsed = JSON.parse(output); + + expect(parsed).toEqual([]); + }); + + it('should output multiple agents as JSON array', () => { + const mockSessions: SessionInfo[] = [ + mockSession({ id: 'a1', name: 'Agent 1' }), + mockSession({ id: 'a2', name: 'Agent 2' }), + mockSession({ id: 'a3', name: 'Agent 3' }), + ]; + vi.mocked(readSessions).mockReturnValue(mockSessions); + + listAgents({ json: true }); + + const output = consoleSpy.mock.calls[0][0]; + const parsed = JSON.parse(output); + + expect(parsed).toHaveLength(3); + expect(parsed[0].id).toBe('a1'); + expect(parsed[1].id).toBe('a2'); + expect(parsed[2].id).toBe('a3'); + }); + + it('should include all properties in JSON output', () => { + const mockSessions: SessionInfo[] = [ + mockSession({ + id: 'complete', + name: 'Complete Agent', + toolType: 'gemini-cli', + cwd: '/project', + groupId: 'dev-group', + autoRunFolderPath: '/project/autorun', + }), + ]; + vi.mocked(readSessions).mockReturnValue(mockSessions); + + listAgents({ json: true }); + + const output = consoleSpy.mock.calls[0][0]; + const parsed = JSON.parse(output); + + expect(parsed[0]).toHaveProperty('id', 'complete'); + expect(parsed[0]).toHaveProperty('name', 'Complete Agent'); + expect(parsed[0]).toHaveProperty('toolType', 'gemini-cli'); + expect(parsed[0]).toHaveProperty('cwd', '/project'); + expect(parsed[0]).toHaveProperty('groupId', 'dev-group'); + expect(parsed[0]).toHaveProperty('autoRunFolderPath', '/project/autorun'); + }); + }); + + describe('group filtering', () => { + it('should filter agents by group', () => { + const mockGroups: Group[] = [ + { id: 'group-frontend', name: 'Frontend', emoji: '🎨', collapsed: false }, + ]; + const mockGroupSessions: SessionInfo[] = [ + mockSession({ id: 'fe1', name: 'React App', groupId: 'group-frontend' }), + mockSession({ id: 'fe2', name: 'Vue App', groupId: 'group-frontend' }), + ]; + + vi.mocked(resolveGroupId).mockReturnValue('group-frontend'); + vi.mocked(getSessionsByGroup).mockReturnValue(mockGroupSessions); + vi.mocked(readGroups).mockReturnValue(mockGroups); + + listAgents({ group: 'group-frontend' }); + + expect(resolveGroupId).toHaveBeenCalledWith('group-frontend'); + expect(getSessionsByGroup).toHaveBeenCalledWith('group-frontend'); + expect(readGroups).toHaveBeenCalled(); + expect(formatAgents).toHaveBeenCalledWith( + expect.arrayContaining([ + expect.objectContaining({ id: 'fe1' }), + expect.objectContaining({ id: 'fe2' }), + ]), + 'Frontend' + ); + }); + + it('should resolve partial group ID', () => { + vi.mocked(resolveGroupId).mockReturnValue('group-full-id'); + vi.mocked(getSessionsByGroup).mockReturnValue([]); + vi.mocked(readGroups).mockReturnValue([ + { id: 'group-full-id', name: 'Full Group', emoji: '📁', collapsed: false }, + ]); + + listAgents({ group: 'group' }); + + expect(resolveGroupId).toHaveBeenCalledWith('group'); + expect(getSessionsByGroup).toHaveBeenCalledWith('group-full-id'); + }); + + it('should handle empty group', () => { + vi.mocked(resolveGroupId).mockReturnValue('empty-group'); + vi.mocked(getSessionsByGroup).mockReturnValue([]); + vi.mocked(readGroups).mockReturnValue([ + { id: 'empty-group', name: 'Empty Group', emoji: '📭', collapsed: false }, + ]); + + listAgents({ group: 'empty-group' }); + + expect(formatAgents).toHaveBeenCalledWith([], 'Empty Group'); + expect(consoleSpy).toHaveBeenCalledWith('No agents in group "Empty Group"'); + }); + + it('should filter by group in JSON mode', () => { + const mockGroupSessions: SessionInfo[] = [ + mockSession({ id: 'g1', name: 'Group Agent', groupId: 'test-group' }), + ]; + + vi.mocked(resolveGroupId).mockReturnValue('test-group'); + vi.mocked(getSessionsByGroup).mockReturnValue(mockGroupSessions); + vi.mocked(readGroups).mockReturnValue([ + { id: 'test-group', name: 'Test Group', emoji: '🧪', collapsed: false }, + ]); + + listAgents({ group: 'test', json: true }); + + expect(getSessionsByGroup).toHaveBeenCalledWith('test-group'); + expect(formatAgents).not.toHaveBeenCalled(); + + const output = consoleSpy.mock.calls[0][0]; + const parsed = JSON.parse(output); + expect(parsed).toHaveLength(1); + expect(parsed[0].id).toBe('g1'); + }); + + it('should handle group not found', () => { + vi.mocked(readGroups).mockReturnValue([ + { id: 'other-group', name: 'Other', emoji: '📁', collapsed: false }, + ]); + vi.mocked(getSessionsByGroup).mockReturnValue([]); + // Return undefined when group is not found + vi.mocked(readGroups).mockReturnValue([]); + + listAgents({ group: 'unknown' }); + + expect(formatAgents).toHaveBeenCalledWith([], undefined); + }); + }); + + describe('error handling', () => { + it('should handle storage read errors in human-readable mode', () => { + const error = new Error('Storage read failed'); + vi.mocked(readSessions).mockImplementation(() => { + throw error; + }); + + expect(() => listAgents({})).toThrow('process.exit(1)'); + + expect(consoleErrorSpy).toHaveBeenCalled(); + expect(formatError).toHaveBeenCalledWith('Failed to list agents: Storage read failed'); + }); + + it('should handle storage read errors in JSON mode', () => { + const error = new Error('JSON storage error'); + vi.mocked(readSessions).mockImplementation(() => { + throw error; + }); + + expect(() => listAgents({ json: true })).toThrow('process.exit(1)'); + + const errorOutput = consoleErrorSpy.mock.calls[0][0]; + const parsed = JSON.parse(errorOutput); + expect(parsed.error).toBe('JSON storage error'); + }); + + it('should handle group resolution errors', () => { + vi.mocked(resolveGroupId).mockImplementation(() => { + throw new Error('Ambiguous group ID'); + }); + + expect(() => listAgents({ group: 'amb' })).toThrow('process.exit(1)'); + + expect(formatError).toHaveBeenCalledWith('Failed to list agents: Ambiguous group ID'); + }); + + it('should handle non-Error objects thrown', () => { + vi.mocked(readSessions).mockImplementation(() => { + throw 'String error'; + }); + + expect(() => listAgents({})).toThrow('process.exit(1)'); + + expect(formatError).toHaveBeenCalledWith('Failed to list agents: Unknown error'); + }); + + it('should exit with code 1 on error', () => { + vi.mocked(readSessions).mockImplementation(() => { + throw new Error('Exit test'); + }); + + expect(() => listAgents({})).toThrow('process.exit(1)'); + expect(processExitSpy).toHaveBeenCalledWith(1); + }); + }); + + describe('edge cases', () => { + it('should handle agents with undefined optional fields', () => { + const mockSessions: SessionInfo[] = [ + mockSession({ + id: 'minimal', + name: 'Minimal', + groupId: undefined, + autoRunFolderPath: undefined, + }), + ]; + vi.mocked(readSessions).mockReturnValue(mockSessions); + + listAgents({ json: true }); + + const output = consoleSpy.mock.calls[0][0]; + const parsed = JSON.parse(output); + + expect(parsed[0].groupId).toBeUndefined(); + expect(parsed[0].autoRunFolderPath).toBeUndefined(); + }); + + it('should handle special characters in paths', () => { + const mockSessions: SessionInfo[] = [ + mockSession({ + id: 'special', + name: 'Special', + cwd: '/Users/dev/My Projects/Test "App"', + autoRunFolderPath: "/path with 'quotes'", + }), + ]; + vi.mocked(readSessions).mockReturnValue(mockSessions); + + listAgents({ json: true }); + + const output = consoleSpy.mock.calls[0][0]; + const parsed = JSON.parse(output); + + expect(parsed[0].cwd).toBe('/Users/dev/My Projects/Test "App"'); + expect(parsed[0].autoRunFolderPath).toBe("/path with 'quotes'"); + }); + + it('should handle all tool types', () => { + const toolTypes = ['claude-code', 'aider', 'terminal', 'gemini-cli', 'qwen3-coder']; + const mockSessions: SessionInfo[] = toolTypes.map((toolType, i) => + mockSession({ id: `agent-${i}`, name: `Agent ${i}`, toolType: toolType as any }) + ); + vi.mocked(readSessions).mockReturnValue(mockSessions); + + listAgents({ json: true }); + + const output = consoleSpy.mock.calls[0][0]; + const parsed = JSON.parse(output); + + expect(parsed).toHaveLength(5); + toolTypes.forEach((type, i) => { + expect(parsed[i].toolType).toBe(type); + }); + }); + + it('should preserve agent order from storage', () => { + const mockSessions: SessionInfo[] = [ + mockSession({ id: 'z-last', name: 'Z Last' }), + mockSession({ id: 'a-first', name: 'A First' }), + mockSession({ id: 'm-middle', name: 'M Middle' }), + ]; + vi.mocked(readSessions).mockReturnValue(mockSessions); + + listAgents({ json: true }); + + const output = consoleSpy.mock.calls[0][0]; + const parsed = JSON.parse(output); + + expect(parsed[0].id).toBe('z-last'); + expect(parsed[1].id).toBe('a-first'); + expect(parsed[2].id).toBe('m-middle'); + }); + }); +}); diff --git a/src/__tests__/cli/commands/list-groups.test.ts b/src/__tests__/cli/commands/list-groups.test.ts new file mode 100644 index 00000000..cbd5556b --- /dev/null +++ b/src/__tests__/cli/commands/list-groups.test.ts @@ -0,0 +1,330 @@ +/** + * @file list-groups.test.ts + * @description Tests for the list-groups CLI command + * + * Tests all functionality of the list-groups command including: + * - Human-readable output formatting + * - JSON output mode + * - Empty groups handling + * - Error handling + */ + +import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'; +import type { Group } from '../../../shared/types'; + +// Mock the storage service +vi.mock('../../../cli/services/storage', () => ({ + readGroups: vi.fn(), +})); + +// Mock the formatter +vi.mock('../../../cli/output/formatter', () => ({ + formatGroups: vi.fn((groups) => groups.length === 0 ? 'No groups found' : `Groups:\n${groups.map((g: any) => `${g.emoji} ${g.name}`).join('\n')}`), + formatError: vi.fn((msg) => `Error: ${msg}`), +})); + +import { listGroups } from '../../../cli/commands/list-groups'; +import { readGroups } from '../../../cli/services/storage'; +import { formatGroups, formatError } from '../../../cli/output/formatter'; + +describe('list-groups command', () => { + let consoleSpy: ReturnType; + let consoleErrorSpy: ReturnType; + let processExitSpy: ReturnType; + + beforeEach(() => { + vi.clearAllMocks(); + consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {}); + consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {}); + processExitSpy = vi.spyOn(process, 'exit').mockImplementation((code?: string | number | null | undefined) => { + throw new Error(`process.exit(${code})`); + }); + }); + + afterEach(() => { + consoleSpy.mockRestore(); + consoleErrorSpy.mockRestore(); + processExitSpy.mockRestore(); + }); + + describe('human-readable output', () => { + it('should display groups in human-readable format', () => { + const mockGroups: Group[] = [ + { id: 'group-1', name: 'Frontend', emoji: '🎨', collapsed: false }, + { id: 'group-2', name: 'Backend', emoji: '⚙️', collapsed: true }, + ]; + vi.mocked(readGroups).mockReturnValue(mockGroups); + + listGroups({}); + + expect(readGroups).toHaveBeenCalled(); + expect(formatGroups).toHaveBeenCalledWith([ + { id: 'group-1', name: 'Frontend', emoji: '🎨', collapsed: false }, + { id: 'group-2', name: 'Backend', emoji: '⚙️', collapsed: true }, + ]); + expect(consoleSpy).toHaveBeenCalled(); + }); + + it('should handle empty groups list', () => { + vi.mocked(readGroups).mockReturnValue([]); + + listGroups({}); + + expect(formatGroups).toHaveBeenCalledWith([]); + expect(consoleSpy).toHaveBeenCalledWith('No groups found'); + }); + + it('should display a single group', () => { + const mockGroups: Group[] = [ + { id: 'group-single', name: 'Solo Group', emoji: '🌟', collapsed: false }, + ]; + vi.mocked(readGroups).mockReturnValue(mockGroups); + + listGroups({}); + + expect(formatGroups).toHaveBeenCalledWith([ + { id: 'group-single', name: 'Solo Group', emoji: '🌟', collapsed: false }, + ]); + }); + + it('should pass collapsed state to formatter', () => { + const mockGroups: Group[] = [ + { id: 'g1', name: 'Expanded', emoji: '📂', collapsed: false }, + { id: 'g2', name: 'Collapsed', emoji: '📁', collapsed: true }, + ]; + vi.mocked(readGroups).mockReturnValue(mockGroups); + + listGroups({}); + + expect(formatGroups).toHaveBeenCalledWith(expect.arrayContaining([ + expect.objectContaining({ collapsed: false }), + expect.objectContaining({ collapsed: true }), + ])); + }); + }); + + describe('JSON output', () => { + it('should output JSON when json option is true', () => { + const mockGroups: Group[] = [ + { id: 'group-1', name: 'Test Group', emoji: '🔧', collapsed: false }, + ]; + vi.mocked(readGroups).mockReturnValue(mockGroups); + + listGroups({ json: true }); + + expect(formatGroups).not.toHaveBeenCalled(); + expect(consoleSpy).toHaveBeenCalledTimes(1); + + const output = consoleSpy.mock.calls[0][0]; + const parsed = JSON.parse(output); + + expect(parsed).toEqual([ + { id: 'group-1', name: 'Test Group', emoji: '🔧', collapsed: false }, + ]); + }); + + it('should output empty JSON array for no groups', () => { + vi.mocked(readGroups).mockReturnValue([]); + + listGroups({ json: true }); + + const output = consoleSpy.mock.calls[0][0]; + const parsed = JSON.parse(output); + + expect(parsed).toEqual([]); + }); + + it('should output multiple groups as JSON array', () => { + const mockGroups: Group[] = [ + { id: 'g1', name: 'Group One', emoji: '1️⃣', collapsed: false }, + { id: 'g2', name: 'Group Two', emoji: '2️⃣', collapsed: true }, + { id: 'g3', name: 'Group Three', emoji: '3️⃣', collapsed: false }, + ]; + vi.mocked(readGroups).mockReturnValue(mockGroups); + + listGroups({ json: true }); + + const output = consoleSpy.mock.calls[0][0]; + const parsed = JSON.parse(output); + + expect(parsed).toHaveLength(3); + expect(parsed[0].id).toBe('g1'); + expect(parsed[1].id).toBe('g2'); + expect(parsed[2].id).toBe('g3'); + }); + + it('should format JSON with indentation', () => { + const mockGroups: Group[] = [ + { id: 'g1', name: 'Test', emoji: '🧪', collapsed: false }, + ]; + vi.mocked(readGroups).mockReturnValue(mockGroups); + + listGroups({ json: true }); + + const output = consoleSpy.mock.calls[0][0]; + // JSON.stringify with null, 2 produces indented output + expect(output).toContain('\n'); + expect(output).toContain(' '); + }); + + it('should include all group properties in JSON output', () => { + const mockGroups: Group[] = [ + { id: 'full-group', name: 'Full Group', emoji: '✨', collapsed: true }, + ]; + vi.mocked(readGroups).mockReturnValue(mockGroups); + + listGroups({ json: true }); + + const output = consoleSpy.mock.calls[0][0]; + const parsed = JSON.parse(output); + + expect(parsed[0]).toHaveProperty('id', 'full-group'); + expect(parsed[0]).toHaveProperty('name', 'Full Group'); + expect(parsed[0]).toHaveProperty('emoji', '✨'); + expect(parsed[0]).toHaveProperty('collapsed', true); + }); + }); + + describe('error handling', () => { + it('should handle storage read errors in human-readable mode', () => { + const error = new Error('Storage read failed'); + vi.mocked(readGroups).mockImplementation(() => { + throw error; + }); + + expect(() => listGroups({})).toThrow('process.exit(1)'); + + expect(consoleErrorSpy).toHaveBeenCalled(); + expect(formatError).toHaveBeenCalledWith('Failed to list groups: Storage read failed'); + }); + + it('should handle storage read errors in JSON mode', () => { + const error = new Error('JSON storage error'); + vi.mocked(readGroups).mockImplementation(() => { + throw error; + }); + + expect(() => listGroups({ json: true })).toThrow('process.exit(1)'); + + expect(consoleErrorSpy).toHaveBeenCalledTimes(1); + const errorOutput = consoleErrorSpy.mock.calls[0][0]; + const parsed = JSON.parse(errorOutput); + expect(parsed.error).toBe('JSON storage error'); + }); + + it('should handle non-Error objects thrown', () => { + vi.mocked(readGroups).mockImplementation(() => { + throw 'String error'; + }); + + expect(() => listGroups({})).toThrow('process.exit(1)'); + + expect(formatError).toHaveBeenCalledWith('Failed to list groups: Unknown error'); + }); + + it('should handle non-Error objects in JSON mode', () => { + vi.mocked(readGroups).mockImplementation(() => { + throw { custom: 'error object' }; + }); + + expect(() => listGroups({ json: true })).toThrow('process.exit(1)'); + + const errorOutput = consoleErrorSpy.mock.calls[0][0]; + const parsed = JSON.parse(errorOutput); + expect(parsed.error).toBe('Unknown error'); + }); + + it('should exit with code 1 on error', () => { + vi.mocked(readGroups).mockImplementation(() => { + throw new Error('Exit test'); + }); + + expect(() => listGroups({})).toThrow('process.exit(1)'); + expect(processExitSpy).toHaveBeenCalledWith(1); + }); + }); + + describe('edge cases', () => { + it('should handle groups with empty emoji', () => { + const mockGroups: Group[] = [ + { id: 'no-emoji', name: 'No Emoji Group', emoji: '', collapsed: false }, + ]; + vi.mocked(readGroups).mockReturnValue(mockGroups); + + listGroups({ json: true }); + + const output = consoleSpy.mock.calls[0][0]; + const parsed = JSON.parse(output); + + expect(parsed[0].emoji).toBe(''); + }); + + it('should handle groups with special characters in name', () => { + const mockGroups: Group[] = [ + { id: 'special', name: 'Group "with" & chars', emoji: '🔥', collapsed: false }, + ]; + vi.mocked(readGroups).mockReturnValue(mockGroups); + + listGroups({ json: true }); + + const output = consoleSpy.mock.calls[0][0]; + const parsed = JSON.parse(output); + + expect(parsed[0].name).toBe('Group "with" & chars'); + }); + + it('should handle groups with unicode names', () => { + const mockGroups: Group[] = [ + { id: 'unicode', name: '日本語グループ', emoji: '🇯🇵', collapsed: false }, + ]; + vi.mocked(readGroups).mockReturnValue(mockGroups); + + listGroups({ json: true }); + + const output = consoleSpy.mock.calls[0][0]; + const parsed = JSON.parse(output); + + expect(parsed[0].name).toBe('日本語グループ'); + }); + + it('should handle options object with json: false', () => { + const mockGroups: Group[] = [ + { id: 'test', name: 'Test', emoji: '📝', collapsed: false }, + ]; + vi.mocked(readGroups).mockReturnValue(mockGroups); + + listGroups({ json: false }); + + expect(formatGroups).toHaveBeenCalled(); + }); + + it('should handle options object with undefined json', () => { + const mockGroups: Group[] = [ + { id: 'test', name: 'Test', emoji: '📝', collapsed: false }, + ]; + vi.mocked(readGroups).mockReturnValue(mockGroups); + + listGroups({ json: undefined }); + + expect(formatGroups).toHaveBeenCalled(); + }); + + it('should preserve group order from storage', () => { + const mockGroups: Group[] = [ + { id: 'z-last', name: 'Z Last', emoji: 'z', collapsed: false }, + { id: 'a-first', name: 'A First', emoji: 'a', collapsed: false }, + { id: 'm-middle', name: 'M Middle', emoji: 'm', collapsed: false }, + ]; + vi.mocked(readGroups).mockReturnValue(mockGroups); + + listGroups({ json: true }); + + const output = consoleSpy.mock.calls[0][0]; + const parsed = JSON.parse(output); + + expect(parsed[0].id).toBe('z-last'); + expect(parsed[1].id).toBe('a-first'); + expect(parsed[2].id).toBe('m-middle'); + }); + }); +}); diff --git a/src/__tests__/cli/commands/list-playbooks.test.ts b/src/__tests__/cli/commands/list-playbooks.test.ts new file mode 100644 index 00000000..7d69142d --- /dev/null +++ b/src/__tests__/cli/commands/list-playbooks.test.ts @@ -0,0 +1,589 @@ +/** + * @file list-playbooks.test.ts + * @description Tests for the list-playbooks CLI command + * + * Tests all functionality of the list-playbooks command including: + * - Listing playbooks for a specific agent + * - Listing all playbooks grouped by agent + * - JSON output mode + * - Filename normalization (.md extension) + * - Empty playbooks handling + * - Error handling + */ + +import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'; +import type { Playbook, SessionInfo } from '../../../shared/types'; + +// Mock the playbooks service +vi.mock('../../../cli/services/playbooks', () => ({ + readPlaybooks: vi.fn(), + listAllPlaybooks: vi.fn(), +})); + +// Mock the storage service +vi.mock('../../../cli/services/storage', () => ({ + getSessionById: vi.fn(), + resolveAgentId: vi.fn((id: string) => id), + readSessions: vi.fn(), +})); + +// Mock the formatter +vi.mock('../../../cli/output/formatter', () => ({ + formatPlaybooks: vi.fn((playbooks, agentName, folderPath) => { + if (playbooks.length === 0) { + return 'No playbooks found.'; + } + const header = agentName ? `Playbooks for ${agentName}:\n` : 'Playbooks:\n'; + return header + playbooks.map((p: any) => `${p.name} (${p.documents.length} docs)`).join('\n'); + }), + formatPlaybooksByAgent: vi.fn((groups) => { + const agentsWithPlaybooks = groups.filter((g: any) => g.playbooks.length > 0); + if (agentsWithPlaybooks.length === 0) { + return 'No playbooks found.'; + } + return agentsWithPlaybooks.map((g: any) => + `${g.agentName}:\n` + g.playbooks.map((p: any) => ` ${p.name}`).join('\n') + ).join('\n\n'); + }), + formatError: vi.fn((msg) => `Error: ${msg}`), +})); + +import { listPlaybooks } from '../../../cli/commands/list-playbooks'; +import { readPlaybooks, listAllPlaybooks } from '../../../cli/services/playbooks'; +import { getSessionById, resolveAgentId, readSessions } from '../../../cli/services/storage'; +import { formatPlaybooks, formatPlaybooksByAgent, formatError } from '../../../cli/output/formatter'; + +describe('list-playbooks command', () => { + let consoleSpy: ReturnType; + let consoleErrorSpy: ReturnType; + let processExitSpy: ReturnType; + + const mockPlaybook = (overrides: Partial = {}): Playbook => ({ + id: 'pb-123', + name: 'Test Playbook', + documents: [ + { filename: 'doc1.md', resetOnCompletion: false }, + ], + loopEnabled: false, + maxLoops: null, + ...overrides, + }); + + const mockSession = (overrides: Partial = {}): SessionInfo => ({ + id: 'agent-1', + name: 'Test Agent', + toolType: 'claude-code', + cwd: '/path/to/project', + autoRunFolderPath: '/path/to/playbooks', + ...overrides, + }); + + beforeEach(() => { + vi.clearAllMocks(); + consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {}); + consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {}); + processExitSpy = vi.spyOn(process, 'exit').mockImplementation((code?: string | number | null | undefined) => { + throw new Error(`process.exit(${code})`); + }); + }); + + afterEach(() => { + consoleSpy.mockRestore(); + consoleErrorSpy.mockRestore(); + processExitSpy.mockRestore(); + }); + + describe('listing playbooks for a specific agent', () => { + it('should list playbooks for a specific agent in human-readable format', () => { + const mockAgent = mockSession({ id: 'agent-1', name: 'My Agent', autoRunFolderPath: '/playbooks' }); + const mockPbs = [ + mockPlaybook({ id: 'pb-1', name: 'Playbook One', documents: [{ filename: 'doc1.md', resetOnCompletion: false }] }), + mockPlaybook({ id: 'pb-2', name: 'Playbook Two', documents: [{ filename: 'doc2.md', resetOnCompletion: true }] }), + ]; + + vi.mocked(resolveAgentId).mockReturnValue('agent-1'); + vi.mocked(readPlaybooks).mockReturnValue(mockPbs); + vi.mocked(getSessionById).mockReturnValue(mockAgent); + + listPlaybooks({ agent: 'agent-1' }); + + expect(resolveAgentId).toHaveBeenCalledWith('agent-1'); + expect(readPlaybooks).toHaveBeenCalledWith('agent-1'); + expect(getSessionById).toHaveBeenCalledWith('agent-1'); + expect(formatPlaybooks).toHaveBeenCalledWith( + expect.arrayContaining([ + expect.objectContaining({ id: 'pb-1', name: 'Playbook One' }), + expect.objectContaining({ id: 'pb-2', name: 'Playbook Two' }), + ]), + 'My Agent', + '/playbooks' + ); + expect(consoleSpy).toHaveBeenCalled(); + }); + + it('should handle agent with no autoRunFolderPath', () => { + const mockAgent = mockSession({ id: 'agent-1', name: 'My Agent', autoRunFolderPath: undefined }); + vi.mocked(resolveAgentId).mockReturnValue('agent-1'); + vi.mocked(readPlaybooks).mockReturnValue([mockPlaybook()]); + vi.mocked(getSessionById).mockReturnValue(mockAgent); + + listPlaybooks({ agent: 'agent-1' }); + + expect(formatPlaybooks).toHaveBeenCalledWith( + expect.any(Array), + 'My Agent', + undefined + ); + }); + + it('should handle agent that does not exist (getSessionById returns undefined)', () => { + vi.mocked(resolveAgentId).mockReturnValue('agent-1'); + vi.mocked(readPlaybooks).mockReturnValue([mockPlaybook()]); + vi.mocked(getSessionById).mockReturnValue(undefined); + + listPlaybooks({ agent: 'agent-1' }); + + expect(formatPlaybooks).toHaveBeenCalledWith( + expect.any(Array), + undefined, + undefined + ); + }); + + it('should handle empty playbooks for agent', () => { + vi.mocked(resolveAgentId).mockReturnValue('agent-1'); + vi.mocked(readPlaybooks).mockReturnValue([]); + vi.mocked(getSessionById).mockReturnValue(mockSession()); + + listPlaybooks({ agent: 'agent-1' }); + + expect(formatPlaybooks).toHaveBeenCalledWith([], 'Test Agent', '/path/to/playbooks'); + expect(consoleSpy).toHaveBeenCalledWith('No playbooks found.'); + }); + + it('should output JSON for specific agent when --json flag is used', () => { + const mockAgent = mockSession({ id: 'agent-1', name: 'Agent JSON', autoRunFolderPath: '/json/path' }); + const mockPbs = [ + mockPlaybook({ + id: 'pb-json-1', + name: 'JSON Playbook', + documents: [ + { filename: 'readme', resetOnCompletion: false }, + { filename: 'tasks.md', resetOnCompletion: true }, + ], + loopEnabled: true, + maxLoops: 5, + }), + ]; + + vi.mocked(resolveAgentId).mockReturnValue('agent-1'); + vi.mocked(readPlaybooks).mockReturnValue(mockPbs); + vi.mocked(getSessionById).mockReturnValue(mockAgent); + + listPlaybooks({ agent: 'agent-1', json: true }); + + expect(consoleSpy).toHaveBeenCalledTimes(1); + const outputCall = consoleSpy.mock.calls[0][0]; + const parsed = JSON.parse(outputCall); + + expect(parsed).toHaveLength(1); + expect(parsed[0]).toEqual({ + id: 'pb-json-1', + name: 'JSON Playbook', + agentId: 'agent-1', + agentName: 'Agent JSON', + folderPath: '/json/path', + loopEnabled: true, + maxLoops: 5, + documents: [ + { filename: 'readme.md', resetOnCompletion: false }, + { filename: 'tasks.md', resetOnCompletion: true }, + ], + }); + }); + + it('should normalize filenames without .md extension in JSON output', () => { + vi.mocked(resolveAgentId).mockReturnValue('agent-1'); + vi.mocked(readPlaybooks).mockReturnValue([ + mockPlaybook({ + documents: [ + { filename: 'no-extension', resetOnCompletion: false }, + { filename: 'already.md', resetOnCompletion: true }, + ], + }), + ]); + vi.mocked(getSessionById).mockReturnValue(mockSession()); + + listPlaybooks({ agent: 'agent-1', json: true }); + + const parsed = JSON.parse(consoleSpy.mock.calls[0][0]); + expect(parsed[0].documents[0].filename).toBe('no-extension.md'); + expect(parsed[0].documents[1].filename).toBe('already.md'); + }); + + it('should normalize filenames without .md extension in human-readable output', () => { + vi.mocked(resolveAgentId).mockReturnValue('agent-1'); + vi.mocked(readPlaybooks).mockReturnValue([ + mockPlaybook({ + documents: [ + { filename: 'no-extension', resetOnCompletion: false }, + ], + }), + ]); + vi.mocked(getSessionById).mockReturnValue(mockSession()); + + listPlaybooks({ agent: 'agent-1' }); + + // Check that formatPlaybooks was called with normalized filenames + const callArgs = vi.mocked(formatPlaybooks).mock.calls[0]; + expect(callArgs[0][0].documents[0].filename).toBe('no-extension.md'); + }); + }); + + describe('listing all playbooks grouped by agent', () => { + it('should list all playbooks grouped by agent in human-readable format', () => { + const mockPbs = [ + { ...mockPlaybook({ id: 'pb-1', name: 'Playbook A' }), sessionId: 'agent-1' }, + { ...mockPlaybook({ id: 'pb-2', name: 'Playbook B' }), sessionId: 'agent-1' }, + { ...mockPlaybook({ id: 'pb-3', name: 'Playbook C' }), sessionId: 'agent-2' }, + ]; + const mockSessionsList = [ + mockSession({ id: 'agent-1', name: 'Agent One' }), + mockSession({ id: 'agent-2', name: 'Agent Two' }), + ]; + + vi.mocked(listAllPlaybooks).mockReturnValue(mockPbs); + vi.mocked(readSessions).mockReturnValue(mockSessionsList); + + listPlaybooks({}); + + expect(listAllPlaybooks).toHaveBeenCalled(); + expect(readSessions).toHaveBeenCalled(); + expect(formatPlaybooksByAgent).toHaveBeenCalledWith( + expect.arrayContaining([ + expect.objectContaining({ + agentId: 'agent-1', + agentName: 'Agent One', + playbooks: expect.arrayContaining([ + expect.objectContaining({ id: 'pb-1', name: 'Playbook A' }), + expect.objectContaining({ id: 'pb-2', name: 'Playbook B' }), + ]), + }), + expect.objectContaining({ + agentId: 'agent-2', + agentName: 'Agent Two', + playbooks: expect.arrayContaining([ + expect.objectContaining({ id: 'pb-3', name: 'Playbook C' }), + ]), + }), + ]) + ); + expect(consoleSpy).toHaveBeenCalled(); + }); + + it('should handle empty playbooks list', () => { + vi.mocked(listAllPlaybooks).mockReturnValue([]); + vi.mocked(readSessions).mockReturnValue([]); + + listPlaybooks({}); + + expect(formatPlaybooksByAgent).toHaveBeenCalledWith([]); + expect(consoleSpy).toHaveBeenCalledWith('No playbooks found.'); + }); + + it('should use "Unknown Agent" when session is not found', () => { + const mockPbs = [ + { ...mockPlaybook({ id: 'pb-1', name: 'Orphan Playbook' }), sessionId: 'unknown-agent' }, + ]; + vi.mocked(listAllPlaybooks).mockReturnValue(mockPbs); + vi.mocked(readSessions).mockReturnValue([]); + + listPlaybooks({}); + + const callArgs = vi.mocked(formatPlaybooksByAgent).mock.calls[0][0]; + expect(callArgs[0].agentName).toBe('Unknown Agent'); + }); + + it('should output JSON for all playbooks when --json flag is used', () => { + const mockPbs = [ + { + ...mockPlaybook({ + id: 'pb-1', + name: 'Global PB 1', + loopEnabled: true, + maxLoops: 3, + documents: [{ filename: 'tasks', resetOnCompletion: false }] + }), + sessionId: 'agent-1' + }, + { + ...mockPlaybook({ + id: 'pb-2', + name: 'Global PB 2', + documents: [{ filename: 'work.md', resetOnCompletion: true }] + }), + sessionId: 'agent-2' + }, + ]; + const mockSessionsList = [ + mockSession({ id: 'agent-1', name: 'Agent Alpha', autoRunFolderPath: '/alpha/playbooks' }), + mockSession({ id: 'agent-2', name: 'Agent Beta', autoRunFolderPath: '/beta/playbooks' }), + ]; + + vi.mocked(listAllPlaybooks).mockReturnValue(mockPbs); + vi.mocked(readSessions).mockReturnValue(mockSessionsList); + + listPlaybooks({ json: true }); + + expect(consoleSpy).toHaveBeenCalledTimes(1); + const parsed = JSON.parse(consoleSpy.mock.calls[0][0]); + + expect(parsed).toHaveLength(2); + expect(parsed[0]).toEqual({ + id: 'pb-1', + name: 'Global PB 1', + agentId: 'agent-1', + agentName: 'Agent Alpha', + folderPath: '/alpha/playbooks', + loopEnabled: true, + maxLoops: 3, + documents: [{ filename: 'tasks.md', resetOnCompletion: false }], + }); + expect(parsed[1]).toEqual({ + id: 'pb-2', + name: 'Global PB 2', + agentId: 'agent-2', + agentName: 'Agent Beta', + folderPath: '/beta/playbooks', + loopEnabled: false, + maxLoops: null, + documents: [{ filename: 'work.md', resetOnCompletion: true }], + }); + }); + + it('should handle session not found in JSON output', () => { + const mockPbs = [ + { ...mockPlaybook({ id: 'pb-1', name: 'Orphan' }), sessionId: 'missing-agent' }, + ]; + vi.mocked(listAllPlaybooks).mockReturnValue(mockPbs); + vi.mocked(readSessions).mockReturnValue([]); + + listPlaybooks({ json: true }); + + const parsed = JSON.parse(consoleSpy.mock.calls[0][0]); + expect(parsed[0].agentName).toBeUndefined(); + expect(parsed[0].folderPath).toBeUndefined(); + }); + + it('should normalize filenames in grouped output', () => { + const mockPbs = [ + { + ...mockPlaybook({ + documents: [{ filename: 'no-ext', resetOnCompletion: false }] + }), + sessionId: 'agent-1' + }, + ]; + vi.mocked(listAllPlaybooks).mockReturnValue(mockPbs); + vi.mocked(readSessions).mockReturnValue([mockSession({ id: 'agent-1' })]); + + listPlaybooks({}); + + const callArgs = vi.mocked(formatPlaybooksByAgent).mock.calls[0][0]; + expect(callArgs[0].playbooks[0].documents[0].filename).toBe('no-ext.md'); + }); + }); + + describe('error handling', () => { + it('should handle resolveAgentId throwing an error', () => { + vi.mocked(resolveAgentId).mockImplementation(() => { + throw new Error('Agent not found: xyz'); + }); + + expect(() => listPlaybooks({ agent: 'xyz' })).toThrow('process.exit(1)'); + + expect(consoleErrorSpy).toHaveBeenCalled(); + expect(formatError).toHaveBeenCalledWith('Failed to list playbooks: Agent not found: xyz'); + }); + + it('should handle resolveAgentId error with JSON output', () => { + vi.mocked(resolveAgentId).mockImplementation(() => { + throw new Error('Agent not found: xyz'); + }); + + expect(() => listPlaybooks({ agent: 'xyz', json: true })).toThrow('process.exit(1)'); + + const errorOutput = consoleErrorSpy.mock.calls[0][0]; + expect(JSON.parse(errorOutput)).toEqual({ error: 'Agent not found: xyz' }); + }); + + it('should handle readPlaybooks throwing an error', () => { + vi.mocked(resolveAgentId).mockReturnValue('agent-1'); + vi.mocked(readPlaybooks).mockImplementation(() => { + throw new Error('Storage error'); + }); + + expect(() => listPlaybooks({ agent: 'agent-1' })).toThrow('process.exit(1)'); + + expect(formatError).toHaveBeenCalledWith('Failed to list playbooks: Storage error'); + }); + + it('should handle listAllPlaybooks throwing an error', () => { + vi.mocked(listAllPlaybooks).mockImplementation(() => { + throw new Error('Failed to read playbooks directory'); + }); + + expect(() => listPlaybooks({})).toThrow('process.exit(1)'); + + expect(formatError).toHaveBeenCalledWith('Failed to list playbooks: Failed to read playbooks directory'); + }); + + it('should handle listAllPlaybooks error with JSON output', () => { + vi.mocked(listAllPlaybooks).mockImplementation(() => { + throw new Error('Failed to read playbooks directory'); + }); + + expect(() => listPlaybooks({ json: true })).toThrow('process.exit(1)'); + + const errorOutput = consoleErrorSpy.mock.calls[0][0]; + expect(JSON.parse(errorOutput)).toEqual({ error: 'Failed to read playbooks directory' }); + }); + + it('should handle non-Error throws', () => { + vi.mocked(listAllPlaybooks).mockImplementation(() => { + throw 'string error'; + }); + + expect(() => listPlaybooks({})).toThrow('process.exit(1)'); + + expect(formatError).toHaveBeenCalledWith('Failed to list playbooks: Unknown error'); + }); + + it('should handle non-Error throws with JSON output', () => { + vi.mocked(listAllPlaybooks).mockImplementation(() => { + throw { custom: 'object error' }; + }); + + expect(() => listPlaybooks({ json: true })).toThrow('process.exit(1)'); + + const errorOutput = consoleErrorSpy.mock.calls[0][0]; + expect(JSON.parse(errorOutput)).toEqual({ error: 'Unknown error' }); + }); + }); + + describe('edge cases', () => { + it('should handle playbook with empty documents array', () => { + vi.mocked(resolveAgentId).mockReturnValue('agent-1'); + vi.mocked(readPlaybooks).mockReturnValue([ + mockPlaybook({ documents: [] }), + ]); + vi.mocked(getSessionById).mockReturnValue(mockSession()); + + listPlaybooks({ agent: 'agent-1' }); + + const callArgs = vi.mocked(formatPlaybooks).mock.calls[0]; + expect(callArgs[0][0].documents).toEqual([]); + }); + + it('should handle multiple agents with varying playbook counts', () => { + const mockPbs = [ + { ...mockPlaybook({ id: 'pb-1' }), sessionId: 'agent-1' }, + { ...mockPlaybook({ id: 'pb-2' }), sessionId: 'agent-1' }, + { ...mockPlaybook({ id: 'pb-3' }), sessionId: 'agent-1' }, + { ...mockPlaybook({ id: 'pb-4' }), sessionId: 'agent-2' }, + ]; + const mockSessionsList = [ + mockSession({ id: 'agent-1', name: 'Agent One' }), + mockSession({ id: 'agent-2', name: 'Agent Two' }), + ]; + + vi.mocked(listAllPlaybooks).mockReturnValue(mockPbs); + vi.mocked(readSessions).mockReturnValue(mockSessionsList); + + listPlaybooks({}); + + const callArgs = vi.mocked(formatPlaybooksByAgent).mock.calls[0][0]; + expect(callArgs.find((g: any) => g.agentId === 'agent-1').playbooks).toHaveLength(3); + expect(callArgs.find((g: any) => g.agentId === 'agent-2').playbooks).toHaveLength(1); + }); + + it('should handle playbook with null maxLoops', () => { + vi.mocked(resolveAgentId).mockReturnValue('agent-1'); + vi.mocked(readPlaybooks).mockReturnValue([ + mockPlaybook({ loopEnabled: true, maxLoops: null }), + ]); + vi.mocked(getSessionById).mockReturnValue(mockSession()); + + listPlaybooks({ agent: 'agent-1', json: true }); + + const parsed = JSON.parse(consoleSpy.mock.calls[0][0]); + expect(parsed[0].loopEnabled).toBe(true); + expect(parsed[0].maxLoops).toBe(null); + }); + + it('should handle playbook with specific maxLoops value', () => { + vi.mocked(resolveAgentId).mockReturnValue('agent-1'); + vi.mocked(readPlaybooks).mockReturnValue([ + mockPlaybook({ loopEnabled: true, maxLoops: 10 }), + ]); + vi.mocked(getSessionById).mockReturnValue(mockSession()); + + listPlaybooks({ agent: 'agent-1', json: true }); + + const parsed = JSON.parse(consoleSpy.mock.calls[0][0]); + expect(parsed[0].loopEnabled).toBe(true); + expect(parsed[0].maxLoops).toBe(10); + }); + + it('should handle special characters in playbook names', () => { + vi.mocked(resolveAgentId).mockReturnValue('agent-1'); + vi.mocked(readPlaybooks).mockReturnValue([ + mockPlaybook({ name: 'Playbook with "quotes" and ' }), + ]); + vi.mocked(getSessionById).mockReturnValue(mockSession()); + + listPlaybooks({ agent: 'agent-1', json: true }); + + const parsed = JSON.parse(consoleSpy.mock.calls[0][0]); + expect(parsed[0].name).toBe('Playbook with "quotes" and '); + }); + + it('should handle unicode characters in playbook names', () => { + vi.mocked(resolveAgentId).mockReturnValue('agent-1'); + vi.mocked(readPlaybooks).mockReturnValue([ + mockPlaybook({ name: '日本語プレイブック 🎭' }), + ]); + vi.mocked(getSessionById).mockReturnValue(mockSession()); + + listPlaybooks({ agent: 'agent-1', json: true }); + + const parsed = JSON.parse(consoleSpy.mock.calls[0][0]); + expect(parsed[0].name).toBe('日本語プレイブック 🎭'); + }); + + it('should handle very long filenames', () => { + const longFilename = 'a'.repeat(200); + vi.mocked(resolveAgentId).mockReturnValue('agent-1'); + vi.mocked(readPlaybooks).mockReturnValue([ + mockPlaybook({ documents: [{ filename: longFilename, resetOnCompletion: false }] }), + ]); + vi.mocked(getSessionById).mockReturnValue(mockSession()); + + listPlaybooks({ agent: 'agent-1', json: true }); + + const parsed = JSON.parse(consoleSpy.mock.calls[0][0]); + expect(parsed[0].documents[0].filename).toBe(longFilename + '.md'); + }); + + it('should handle partial agent ID resolution', () => { + vi.mocked(resolveAgentId).mockReturnValue('full-agent-id-1234'); + vi.mocked(readPlaybooks).mockReturnValue([mockPlaybook()]); + vi.mocked(getSessionById).mockReturnValue(mockSession({ id: 'full-agent-id-1234' })); + + listPlaybooks({ agent: 'full-agent' }); + + expect(resolveAgentId).toHaveBeenCalledWith('full-agent'); + expect(readPlaybooks).toHaveBeenCalledWith('full-agent-id-1234'); + }); + }); +}); diff --git a/src/__tests__/cli/commands/run-playbook.test.ts b/src/__tests__/cli/commands/run-playbook.test.ts new file mode 100644 index 00000000..779d5f10 --- /dev/null +++ b/src/__tests__/cli/commands/run-playbook.test.ts @@ -0,0 +1,774 @@ +/** + * @file run-playbook.test.ts + * @description Tests for the run-playbook CLI command + * + * Tests all functionality of the run-playbook command including: + * - Playbook execution with various options + * - Dry run mode + * - JSON output mode + * - Wait mode for busy agents + * - Error handling + * - Agent busy detection + */ + +import { describe, it, expect, vi, beforeEach, afterEach, type MockInstance } from 'vitest'; +import type { Playbook, SessionInfo } from '../../../shared/types'; + +// Mock fs and path first +vi.mock('fs', () => ({ + readFileSync: vi.fn(), + existsSync: vi.fn(), + mkdirSync: vi.fn(), + writeFileSync: vi.fn(), +})); + +vi.mock('os', () => ({ + platform: vi.fn(() => 'darwin'), + homedir: vi.fn(() => '/Users/test'), +})); + +// Mock the storage service +vi.mock('../../../cli/services/storage', () => ({ + getSessionById: vi.fn(), +})); + +// Mock the playbooks service +vi.mock('../../../cli/services/playbooks', () => ({ + findPlaybookById: vi.fn(), +})); + +// Mock the batch-processor service +vi.mock('../../../cli/services/batch-processor', () => ({ + runPlaybook: vi.fn(), +})); + +// Mock the agent-spawner service +vi.mock('../../../cli/services/agent-spawner', () => ({ + detectClaude: vi.fn(), +})); + +// Mock the jsonl output +vi.mock('../../../cli/output/jsonl', () => ({ + emitError: vi.fn((msg, code) => { + console.error(JSON.stringify({ type: 'error', message: msg, code })); + }), +})); + +// Mock the formatter +vi.mock('../../../cli/output/formatter', () => ({ + formatRunEvent: vi.fn((event: any) => `[${event.type}] ${event.message || ''}`), + formatError: vi.fn((msg) => `Error: ${msg}`), + formatInfo: vi.fn((msg) => `Info: ${msg}`), + formatWarning: vi.fn((msg) => `Warning: ${msg}`), +})); + +// Mock cli-activity +vi.mock('../../../shared/cli-activity', () => ({ + isSessionBusyWithCli: vi.fn(), + getCliActivityForSession: vi.fn(), +})); + +import * as fs from 'fs'; +import * as os from 'os'; +import { runPlaybook } from '../../../cli/commands/run-playbook'; +import { getSessionById } from '../../../cli/services/storage'; +import { findPlaybookById } from '../../../cli/services/playbooks'; +import { runPlaybook as executePlaybook } from '../../../cli/services/batch-processor'; +import { detectClaude } from '../../../cli/services/agent-spawner'; +import { emitError } from '../../../cli/output/jsonl'; +import { formatRunEvent, formatError, formatInfo, formatWarning } from '../../../cli/output/formatter'; +import { isSessionBusyWithCli, getCliActivityForSession } from '../../../shared/cli-activity'; + +describe('run-playbook command', () => { + let consoleSpy: MockInstance; + let consoleErrorSpy: MockInstance; + let processExitSpy: MockInstance; + + const mockPlaybook = (overrides: Partial = {}): Playbook => ({ + id: 'pb-123', + name: 'Test Playbook', + documents: [ + { filename: 'doc1.md', resetOnCompletion: false }, + ], + loopEnabled: false, + maxLoops: null, + ...overrides, + }); + + const mockSession = (overrides: Partial = {}): SessionInfo => ({ + id: 'agent-1', + name: 'Test Agent', + toolType: 'claude-code', + cwd: '/path/to/project', + autoRunFolderPath: '/path/to/playbooks', + ...overrides, + }); + + // Helper to create an async generator for batch-processor mock + async function* mockEventGenerator(events: any[]) { + for (const event of events) { + yield event; + } + } + + beforeEach(() => { + vi.clearAllMocks(); + consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {}); + consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {}); + processExitSpy = vi.spyOn(process, 'exit').mockImplementation((code?: string | number | null | undefined) => { + throw new Error(`process.exit(${code})`); + }); + + // Default: Claude is available + vi.mocked(detectClaude).mockResolvedValue({ available: true, version: '1.0.0', path: '/usr/local/bin/claude' }); + + // Default: agent is not busy + vi.mocked(isSessionBusyWithCli).mockReturnValue(false); + vi.mocked(getCliActivityForSession).mockReturnValue(undefined); + + // Default: No sessions in sessions file (agent not busy in desktop) + vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify({ sessions: [] })); + + // Default: platform is darwin + vi.mocked(os.platform).mockReturnValue('darwin'); + vi.mocked(os.homedir).mockReturnValue('/Users/test'); + }); + + afterEach(() => { + consoleSpy.mockRestore(); + consoleErrorSpy.mockRestore(); + processExitSpy.mockRestore(); + }); + + describe('successful execution', () => { + it('should execute a playbook and stream events in human-readable format', async () => { + const playbook = mockPlaybook(); + const agent = mockSession(); + + vi.mocked(findPlaybookById).mockReturnValue({ playbook, agentId: 'agent-1' }); + vi.mocked(getSessionById).mockReturnValue(agent); + vi.mocked(executePlaybook).mockReturnValue(mockEventGenerator([ + { type: 'start', timestamp: Date.now() }, + { type: 'document_start', document: 'doc1.md', taskCount: 1, timestamp: Date.now() }, + { type: 'complete', totalTasksCompleted: 1, totalElapsedMs: 1000, timestamp: Date.now() }, + ])); + + await runPlaybook('pb-123', {}); + + expect(findPlaybookById).toHaveBeenCalledWith('pb-123'); + expect(getSessionById).toHaveBeenCalledWith('agent-1'); + expect(executePlaybook).toHaveBeenCalledWith(agent, playbook, '/path/to/playbooks', { + dryRun: undefined, + writeHistory: true, + debug: undefined, + verbose: undefined, + }); + expect(formatInfo).toHaveBeenCalledWith('Running playbook: Test Playbook'); + expect(formatInfo).toHaveBeenCalledWith('Agent: Test Agent'); + expect(formatRunEvent).toHaveBeenCalled(); + }); + + it('should execute a playbook with JSON output', async () => { + const playbook = mockPlaybook(); + const agent = mockSession(); + + vi.mocked(findPlaybookById).mockReturnValue({ playbook, agentId: 'agent-1' }); + vi.mocked(getSessionById).mockReturnValue(agent); + vi.mocked(executePlaybook).mockReturnValue(mockEventGenerator([ + { type: 'start', timestamp: 12345 }, + { type: 'complete', totalTasksCompleted: 1, totalElapsedMs: 1000, timestamp: 12346 }, + ])); + + await runPlaybook('pb-123', { json: true }); + + // JSON mode should output raw JSON strings + expect(consoleSpy).toHaveBeenCalledWith(JSON.stringify({ type: 'start', timestamp: 12345 })); + expect(consoleSpy).toHaveBeenCalledWith(JSON.stringify({ type: 'complete', totalTasksCompleted: 1, totalElapsedMs: 1000, timestamp: 12346 })); + // formatInfo should NOT be called in JSON mode + expect(formatInfo).not.toHaveBeenCalled(); + }); + + it('should execute a playbook in dry run mode', async () => { + const playbook = mockPlaybook(); + const agent = mockSession(); + + vi.mocked(findPlaybookById).mockReturnValue({ playbook, agentId: 'agent-1' }); + vi.mocked(getSessionById).mockReturnValue(agent); + vi.mocked(executePlaybook).mockReturnValue(mockEventGenerator([ + { type: 'complete', dryRun: true, wouldProcess: 5, timestamp: Date.now() }, + ])); + + await runPlaybook('pb-123', { dryRun: true }); + + expect(executePlaybook).toHaveBeenCalledWith(agent, playbook, '/path/to/playbooks', { + dryRun: true, + writeHistory: true, + debug: undefined, + verbose: undefined, + }); + expect(formatInfo).toHaveBeenCalledWith('Dry run mode - no changes will be made'); + }); + + it('should execute a playbook with --no-history flag', async () => { + const playbook = mockPlaybook(); + const agent = mockSession(); + + vi.mocked(findPlaybookById).mockReturnValue({ playbook, agentId: 'agent-1' }); + vi.mocked(getSessionById).mockReturnValue(agent); + vi.mocked(executePlaybook).mockReturnValue(mockEventGenerator([])); + + await runPlaybook('pb-123', { history: false }); + + expect(executePlaybook).toHaveBeenCalledWith( + agent, + playbook, + '/path/to/playbooks', + expect.objectContaining({ + writeHistory: false, + }) + ); + }); + + it('should execute a playbook with debug option', async () => { + const playbook = mockPlaybook(); + const agent = mockSession(); + + vi.mocked(findPlaybookById).mockReturnValue({ playbook, agentId: 'agent-1' }); + vi.mocked(getSessionById).mockReturnValue(agent); + vi.mocked(executePlaybook).mockReturnValue(mockEventGenerator([])); + + await runPlaybook('pb-123', { debug: true }); + + expect(executePlaybook).toHaveBeenCalledWith( + agent, + playbook, + '/path/to/playbooks', + expect.objectContaining({ + debug: true, + }) + ); + }); + + it('should execute a playbook with verbose option', async () => { + const playbook = mockPlaybook(); + const agent = mockSession(); + + vi.mocked(findPlaybookById).mockReturnValue({ playbook, agentId: 'agent-1' }); + vi.mocked(getSessionById).mockReturnValue(agent); + vi.mocked(executePlaybook).mockReturnValue(mockEventGenerator([])); + + await runPlaybook('pb-123', { verbose: true }); + + expect(executePlaybook).toHaveBeenCalledWith( + agent, + playbook, + '/path/to/playbooks', + expect.objectContaining({ + verbose: true, + }) + ); + }); + + it('should display loop configuration when loopEnabled is true', async () => { + const playbook = mockPlaybook({ loopEnabled: true, maxLoops: 5 }); + const agent = mockSession(); + + vi.mocked(findPlaybookById).mockReturnValue({ playbook, agentId: 'agent-1' }); + vi.mocked(getSessionById).mockReturnValue(agent); + vi.mocked(executePlaybook).mockReturnValue(mockEventGenerator([])); + + await runPlaybook('pb-123', {}); + + expect(formatInfo).toHaveBeenCalledWith('Loop: enabled (max 5)'); + }); + + it('should display infinite loop configuration when maxLoops is null', async () => { + const playbook = mockPlaybook({ loopEnabled: true, maxLoops: null }); + const agent = mockSession(); + + vi.mocked(findPlaybookById).mockReturnValue({ playbook, agentId: 'agent-1' }); + vi.mocked(getSessionById).mockReturnValue(agent); + vi.mocked(executePlaybook).mockReturnValue(mockEventGenerator([])); + + await runPlaybook('pb-123', {}); + + expect(formatInfo).toHaveBeenCalledWith('Loop: enabled (∞)'); + }); + }); + + describe('Claude Code not found', () => { + it('should error when Claude Code is not available (human-readable)', async () => { + vi.mocked(detectClaude).mockResolvedValue({ available: false }); + + await expect(runPlaybook('pb-123', {})).rejects.toThrow('process.exit(1)'); + + expect(formatError).toHaveBeenCalledWith('Claude Code not found. Please install claude-code CLI.'); + }); + + it('should error when Claude Code is not available (JSON)', async () => { + vi.mocked(detectClaude).mockResolvedValue({ available: false }); + + await expect(runPlaybook('pb-123', { json: true })).rejects.toThrow('process.exit(1)'); + + expect(emitError).toHaveBeenCalledWith('Claude Code not found. Please install claude-code CLI.', 'CLAUDE_NOT_FOUND'); + }); + }); + + describe('playbook not found', () => { + it('should error when playbook is not found (human-readable)', async () => { + vi.mocked(findPlaybookById).mockImplementation(() => { + throw new Error('Playbook not found: xyz'); + }); + + await expect(runPlaybook('xyz', {})).rejects.toThrow('process.exit(1)'); + + expect(formatError).toHaveBeenCalledWith('Playbook not found: xyz'); + }); + + it('should error when playbook is not found (JSON)', async () => { + vi.mocked(findPlaybookById).mockImplementation(() => { + throw new Error('Playbook not found: xyz'); + }); + + await expect(runPlaybook('xyz', { json: true })).rejects.toThrow('process.exit(1)'); + + expect(emitError).toHaveBeenCalledWith('Playbook not found: xyz', 'PLAYBOOK_NOT_FOUND'); + }); + + it('should handle non-Error throws in playbook lookup', async () => { + vi.mocked(findPlaybookById).mockImplementation(() => { + throw 'string error'; + }); + + await expect(runPlaybook('xyz', {})).rejects.toThrow('process.exit(1)'); + + expect(formatError).toHaveBeenCalledWith('Unknown error'); + }); + }); + + describe('agent busy detection', () => { + it('should error when agent is busy in CLI (human-readable)', async () => { + const playbook = mockPlaybook(); + const agent = mockSession(); + + vi.mocked(findPlaybookById).mockReturnValue({ playbook, agentId: 'agent-1' }); + vi.mocked(getSessionById).mockReturnValue(agent); + vi.mocked(isSessionBusyWithCli).mockReturnValue(true); + vi.mocked(getCliActivityForSession).mockReturnValue({ + sessionId: 'agent-1', + playbookId: 'pb-other', + playbookName: 'Other Playbook', + startedAt: Date.now(), + pid: 12345, + }); + + await expect(runPlaybook('pb-123', {})).rejects.toThrow('process.exit(1)'); + + expect(formatError).toHaveBeenCalledWith( + expect.stringContaining('Agent "Test Agent" is busy: Running playbook "Other Playbook" from CLI') + ); + }); + + it('should error when agent is busy in CLI (JSON)', async () => { + const playbook = mockPlaybook(); + const agent = mockSession(); + + vi.mocked(findPlaybookById).mockReturnValue({ playbook, agentId: 'agent-1' }); + vi.mocked(getSessionById).mockReturnValue(agent); + vi.mocked(isSessionBusyWithCli).mockReturnValue(true); + vi.mocked(getCliActivityForSession).mockReturnValue({ + sessionId: 'agent-1', + playbookId: 'pb-other', + playbookName: 'Other Playbook', + startedAt: Date.now(), + pid: 12345, + }); + + await expect(runPlaybook('pb-123', { json: true })).rejects.toThrow('process.exit(1)'); + + expect(emitError).toHaveBeenCalledWith( + expect.stringContaining('Agent "Test Agent" is busy'), + 'AGENT_BUSY' + ); + }); + + it('should error when agent is busy in desktop app', async () => { + const playbook = mockPlaybook(); + const agent = mockSession(); + + vi.mocked(findPlaybookById).mockReturnValue({ playbook, agentId: 'agent-1' }); + vi.mocked(getSessionById).mockReturnValue(agent); + vi.mocked(isSessionBusyWithCli).mockReturnValue(false); + vi.mocked(getCliActivityForSession).mockReturnValue(undefined); + vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify({ + sessions: [{ id: 'agent-1', state: 'busy' }] + })); + + await expect(runPlaybook('pb-123', {})).rejects.toThrow('process.exit(1)'); + + expect(formatError).toHaveBeenCalledWith( + expect.stringContaining('Agent "Test Agent" is busy: Busy in desktop app') + ); + }); + + it('should handle sessions file read errors gracefully (assume not busy)', async () => { + const playbook = mockPlaybook(); + const agent = mockSession(); + + vi.mocked(findPlaybookById).mockReturnValue({ playbook, agentId: 'agent-1' }); + vi.mocked(getSessionById).mockReturnValue(agent); + vi.mocked(isSessionBusyWithCli).mockReturnValue(false); + vi.mocked(getCliActivityForSession).mockReturnValue(undefined); + vi.mocked(fs.readFileSync).mockImplementation(() => { + throw new Error('ENOENT'); + }); + vi.mocked(executePlaybook).mockReturnValue(mockEventGenerator([])); + + // Should NOT throw - assume not busy when file read fails + await runPlaybook('pb-123', {}); + + expect(executePlaybook).toHaveBeenCalled(); + }); + }); + + describe('wait mode', () => { + // These tests use fake timers to test the wait functionality without actual delays + + it('should wait for agent to become available in wait mode', async () => { + vi.useFakeTimers(); + try { + const playbook = mockPlaybook(); + const agent = mockSession(); + + vi.mocked(findPlaybookById).mockReturnValue({ playbook, agentId: 'agent-1' }); + vi.mocked(getSessionById).mockReturnValue(agent); + vi.mocked(executePlaybook).mockReturnValue(mockEventGenerator([])); + + // First call: busy, subsequent calls: not busy + let callCount = 0; + vi.mocked(isSessionBusyWithCli).mockImplementation(() => { + callCount++; + return callCount === 1; + }); + vi.mocked(getCliActivityForSession).mockImplementation(() => { + if (callCount <= 1) { + return { + sessionId: 'agent-1', + playbookId: 'pb-other', + playbookName: 'Other Playbook', + startedAt: Date.now(), + pid: 12345, + }; + } + return undefined; + }); + + // Start the async operation + const runPromise = runPlaybook('pb-123', { wait: true }); + + // Advance timers to trigger the poll interval (5 seconds) + await vi.advanceTimersByTimeAsync(5000); + + // Now let the promise complete + await runPromise; + + expect(formatWarning).toHaveBeenCalledWith(expect.stringContaining('Agent "Test Agent" is busy')); + expect(formatInfo).toHaveBeenCalledWith('Waiting for agent to become available...'); + expect(formatInfo).toHaveBeenCalledWith(expect.stringContaining('Agent available after waiting')); + expect(executePlaybook).toHaveBeenCalled(); + } finally { + vi.useRealTimers(); + } + }); + + it('should emit wait_complete event in JSON mode', async () => { + vi.useFakeTimers(); + try { + const playbook = mockPlaybook(); + const agent = mockSession(); + + vi.mocked(findPlaybookById).mockReturnValue({ playbook, agentId: 'agent-1' }); + vi.mocked(getSessionById).mockReturnValue(agent); + vi.mocked(executePlaybook).mockReturnValue(mockEventGenerator([])); + + let callCount = 0; + vi.mocked(isSessionBusyWithCli).mockImplementation(() => { + callCount++; + return callCount === 1; + }); + vi.mocked(getCliActivityForSession).mockImplementation(() => { + if (callCount <= 1) { + return { + sessionId: 'agent-1', + playbookId: 'pb-other', + playbookName: 'Other Playbook', + startedAt: Date.now(), + pid: 12345, + }; + } + return undefined; + }); + + // Start the async operation + const runPromise = runPlaybook('pb-123', { wait: true, json: true }); + + // Advance timers to trigger the poll interval (5 seconds) + await vi.advanceTimersByTimeAsync(5000); + + // Now let the promise complete + await runPromise; + + // Should emit wait_complete event + const waitCompleteCall = consoleSpy.mock.calls.find((call: any[]) => { + try { + const parsed = JSON.parse(call[0]); + return parsed.type === 'wait_complete'; + } catch { + return false; + } + }); + expect(waitCompleteCall).toBeDefined(); + } finally { + vi.useRealTimers(); + } + }); + }); + + describe('no Auto Run folder', () => { + it('should error when agent has no autoRunFolderPath (human-readable)', async () => { + const playbook = mockPlaybook(); + const agent = mockSession({ autoRunFolderPath: undefined }); + + vi.mocked(findPlaybookById).mockReturnValue({ playbook, agentId: 'agent-1' }); + vi.mocked(getSessionById).mockReturnValue(agent); + + await expect(runPlaybook('pb-123', {})).rejects.toThrow('process.exit(1)'); + + expect(formatError).toHaveBeenCalledWith('Agent does not have an Auto Run folder configured'); + }); + + it('should error when agent has no autoRunFolderPath (JSON)', async () => { + const playbook = mockPlaybook(); + const agent = mockSession({ autoRunFolderPath: undefined }); + + vi.mocked(findPlaybookById).mockReturnValue({ playbook, agentId: 'agent-1' }); + vi.mocked(getSessionById).mockReturnValue(agent); + + await expect(runPlaybook('pb-123', { json: true })).rejects.toThrow('process.exit(1)'); + + expect(emitError).toHaveBeenCalledWith('Agent does not have an Auto Run folder configured', 'NO_AUTORUN_FOLDER'); + }); + }); + + describe('execution errors', () => { + it('should handle execution errors (human-readable)', async () => { + const playbook = mockPlaybook(); + const agent = mockSession(); + + vi.mocked(findPlaybookById).mockReturnValue({ playbook, agentId: 'agent-1' }); + vi.mocked(getSessionById).mockReturnValue(agent); + vi.mocked(executePlaybook).mockImplementation(() => { + throw new Error('Execution failed'); + }); + + await expect(runPlaybook('pb-123', {})).rejects.toThrow('process.exit(1)'); + + expect(formatError).toHaveBeenCalledWith('Failed to run playbook: Execution failed'); + }); + + it('should handle execution errors (JSON)', async () => { + const playbook = mockPlaybook(); + const agent = mockSession(); + + vi.mocked(findPlaybookById).mockReturnValue({ playbook, agentId: 'agent-1' }); + vi.mocked(getSessionById).mockReturnValue(agent); + vi.mocked(executePlaybook).mockImplementation(() => { + throw new Error('Execution failed'); + }); + + await expect(runPlaybook('pb-123', { json: true })).rejects.toThrow('process.exit(1)'); + + expect(emitError).toHaveBeenCalledWith('Failed to run playbook: Execution failed', 'EXECUTION_ERROR'); + }); + + it('should handle non-Error throws in execution', async () => { + const playbook = mockPlaybook(); + const agent = mockSession(); + + vi.mocked(findPlaybookById).mockReturnValue({ playbook, agentId: 'agent-1' }); + vi.mocked(getSessionById).mockReturnValue(agent); + vi.mocked(executePlaybook).mockImplementation(() => { + throw { message: 'object error' }; + }); + + await expect(runPlaybook('pb-123', {})).rejects.toThrow('process.exit(1)'); + + expect(formatError).toHaveBeenCalledWith('Failed to run playbook: Unknown error'); + }); + }); + + describe('platform-specific paths', () => { + it('should use correct path on Windows', async () => { + const playbook = mockPlaybook(); + const agent = mockSession(); + + vi.mocked(os.platform).mockReturnValue('win32'); + vi.mocked(os.homedir).mockReturnValue('C:\\Users\\test'); + + vi.mocked(findPlaybookById).mockReturnValue({ playbook, agentId: 'agent-1' }); + vi.mocked(getSessionById).mockReturnValue(agent); + vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify({ + sessions: [{ id: 'agent-1', state: 'busy' }] + })); + + await expect(runPlaybook('pb-123', {})).rejects.toThrow('process.exit(1)'); + + // The path checking happens inside isSessionBusyInDesktop + // We can verify it ran by checking the error is about busy agent + expect(formatError).toHaveBeenCalledWith(expect.stringContaining('Busy in desktop app')); + }); + + it('should use correct path on Linux', async () => { + const playbook = mockPlaybook(); + const agent = mockSession(); + + vi.mocked(os.platform).mockReturnValue('linux'); + vi.mocked(os.homedir).mockReturnValue('/home/test'); + + vi.mocked(findPlaybookById).mockReturnValue({ playbook, agentId: 'agent-1' }); + vi.mocked(getSessionById).mockReturnValue(agent); + vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify({ + sessions: [{ id: 'agent-1', state: 'busy' }] + })); + + await expect(runPlaybook('pb-123', {})).rejects.toThrow('process.exit(1)'); + + expect(formatError).toHaveBeenCalledWith(expect.stringContaining('Busy in desktop app')); + }); + + it('should use XDG_CONFIG_HOME on Linux if set', async () => { + const playbook = mockPlaybook(); + const agent = mockSession(); + + const originalEnv = process.env.XDG_CONFIG_HOME; + process.env.XDG_CONFIG_HOME = '/custom/config'; + + vi.mocked(os.platform).mockReturnValue('linux'); + vi.mocked(os.homedir).mockReturnValue('/home/test'); + + vi.mocked(findPlaybookById).mockReturnValue({ playbook, agentId: 'agent-1' }); + vi.mocked(getSessionById).mockReturnValue(agent); + vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify({ + sessions: [{ id: 'agent-1', state: 'busy' }] + })); + + await expect(runPlaybook('pb-123', {})).rejects.toThrow('process.exit(1)'); + + expect(formatError).toHaveBeenCalledWith(expect.stringContaining('Busy in desktop app')); + + // Clean up + if (originalEnv === undefined) { + delete process.env.XDG_CONFIG_HOME; + } else { + process.env.XDG_CONFIG_HOME = originalEnv; + } + }); + + it('should use APPDATA on Windows if set', async () => { + const playbook = mockPlaybook(); + const agent = mockSession(); + + const originalEnv = process.env.APPDATA; + process.env.APPDATA = 'D:\\CustomAppData'; + + vi.mocked(os.platform).mockReturnValue('win32'); + vi.mocked(os.homedir).mockReturnValue('C:\\Users\\test'); + + vi.mocked(findPlaybookById).mockReturnValue({ playbook, agentId: 'agent-1' }); + vi.mocked(getSessionById).mockReturnValue(agent); + vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify({ + sessions: [{ id: 'agent-1', state: 'busy' }] + })); + + await expect(runPlaybook('pb-123', {})).rejects.toThrow('process.exit(1)'); + + expect(formatError).toHaveBeenCalledWith(expect.stringContaining('Busy in desktop app')); + + // Clean up + if (originalEnv === undefined) { + delete process.env.APPDATA; + } else { + process.env.APPDATA = originalEnv; + } + }); + }); + + describe('edge cases', () => { + it('should handle agent with state not "busy" (not busy)', async () => { + const playbook = mockPlaybook(); + const agent = mockSession(); + + vi.mocked(findPlaybookById).mockReturnValue({ playbook, agentId: 'agent-1' }); + vi.mocked(getSessionById).mockReturnValue(agent); + vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify({ + sessions: [{ id: 'agent-1', state: 'idle' }] + })); + vi.mocked(executePlaybook).mockReturnValue(mockEventGenerator([])); + + await runPlaybook('pb-123', {}); + + expect(executePlaybook).toHaveBeenCalled(); + }); + + it('should handle agent not in sessions list (not busy)', async () => { + const playbook = mockPlaybook(); + const agent = mockSession(); + + vi.mocked(findPlaybookById).mockReturnValue({ playbook, agentId: 'agent-1' }); + vi.mocked(getSessionById).mockReturnValue(agent); + vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify({ + sessions: [{ id: 'other-agent', state: 'busy' }] + })); + vi.mocked(executePlaybook).mockReturnValue(mockEventGenerator([])); + + await runPlaybook('pb-123', {}); + + expect(executePlaybook).toHaveBeenCalled(); + }); + + it('should handle empty sessions in file', async () => { + const playbook = mockPlaybook(); + const agent = mockSession(); + + vi.mocked(findPlaybookById).mockReturnValue({ playbook, agentId: 'agent-1' }); + vi.mocked(getSessionById).mockReturnValue(agent); + vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify({ + sessions: [] + })); + vi.mocked(executePlaybook).mockReturnValue(mockEventGenerator([])); + + await runPlaybook('pb-123', {}); + + expect(executePlaybook).toHaveBeenCalled(); + }); + + it('should handle playbook with multiple documents', async () => { + const playbook = mockPlaybook({ + documents: [ + { filename: 'doc1.md', resetOnCompletion: false }, + { filename: 'doc2.md', resetOnCompletion: true }, + { filename: 'doc3.md', resetOnCompletion: false }, + ], + }); + const agent = mockSession(); + + vi.mocked(findPlaybookById).mockReturnValue({ playbook, agentId: 'agent-1' }); + vi.mocked(getSessionById).mockReturnValue(agent); + vi.mocked(executePlaybook).mockReturnValue(mockEventGenerator([])); + + await runPlaybook('pb-123', {}); + + expect(formatInfo).toHaveBeenCalledWith('Documents: 3'); + }); + }); +}); diff --git a/src/__tests__/cli/commands/show-agent.test.ts b/src/__tests__/cli/commands/show-agent.test.ts new file mode 100644 index 00000000..a37f1303 --- /dev/null +++ b/src/__tests__/cli/commands/show-agent.test.ts @@ -0,0 +1,460 @@ +/** + * @file show-agent.test.ts + * @description Tests for the show-agent CLI command + * + * Tests all functionality of the show-agent command including: + * - Displaying agent details with history and stats + * - JSON output mode + * - Group name resolution + * - Usage statistics aggregation + * - Error handling + */ + +import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'; +import type { SessionInfo, Group, HistoryEntry } from '../../../shared/types'; + +// Mock the storage service +vi.mock('../../../cli/services/storage', () => ({ + getSessionById: vi.fn(), + readHistory: vi.fn(), + readGroups: vi.fn(), +})); + +// Mock the formatter +vi.mock('../../../cli/output/formatter', () => ({ + formatAgentDetail: vi.fn((detail) => `Agent: ${detail.name}\nPath: ${detail.cwd}`), + formatError: vi.fn((msg) => `Error: ${msg}`), +})); + +import { showAgent } from '../../../cli/commands/show-agent'; +import { getSessionById, readHistory, readGroups } from '../../../cli/services/storage'; +import { formatAgentDetail, formatError } from '../../../cli/output/formatter'; + +describe('show-agent command', () => { + let consoleSpy: ReturnType; + let consoleErrorSpy: ReturnType; + let processExitSpy: ReturnType; + + const mockSession = (overrides: Partial = {}): SessionInfo => ({ + id: 'agent-123', + name: 'Test Agent', + toolType: 'claude-code', + cwd: '/path/to/project', + projectRoot: '/path/to/project', + groupId: undefined, + autoRunFolderPath: undefined, + ...overrides, + }); + + const mockHistoryEntry = (overrides: Partial = {}): HistoryEntry => ({ + id: 'hist-1', + sessionId: 'agent-123', + projectPath: '/path/to/project', + timestamp: Date.now(), + type: 'command', + summary: 'Test command', + success: true, + elapsedTimeMs: 1000, + usageStats: { + inputTokens: 100, + outputTokens: 200, + cacheReadInputTokens: 50, + cacheCreationInputTokens: 25, + totalCostUsd: 0.01, + }, + ...overrides, + }); + + beforeEach(() => { + vi.clearAllMocks(); + consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {}); + consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {}); + processExitSpy = vi.spyOn(process, 'exit').mockImplementation((code?: string | number | null | undefined) => { + throw new Error(`process.exit(${code})`); + }); + }); + + afterEach(() => { + consoleSpy.mockRestore(); + consoleErrorSpy.mockRestore(); + processExitSpy.mockRestore(); + }); + + describe('basic display', () => { + it('should display agent details in human-readable format', () => { + vi.mocked(getSessionById).mockReturnValue(mockSession()); + vi.mocked(readGroups).mockReturnValue([]); + vi.mocked(readHistory).mockReturnValue([]); + + showAgent('agent-123', {}); + + expect(getSessionById).toHaveBeenCalledWith('agent-123'); + expect(formatAgentDetail).toHaveBeenCalled(); + expect(consoleSpy).toHaveBeenCalled(); + }); + + it('should include group name when agent belongs to a group', () => { + const groups: Group[] = [ + { id: 'group-1', name: 'Frontend', emoji: '🎨', collapsed: false }, + ]; + vi.mocked(getSessionById).mockReturnValue(mockSession({ groupId: 'group-1' })); + vi.mocked(readGroups).mockReturnValue(groups); + vi.mocked(readHistory).mockReturnValue([]); + + showAgent('agent-123', {}); + + expect(formatAgentDetail).toHaveBeenCalledWith( + expect.objectContaining({ + groupId: 'group-1', + groupName: 'Frontend', + }) + ); + }); + + it('should handle agent without group', () => { + vi.mocked(getSessionById).mockReturnValue(mockSession({ groupId: undefined })); + vi.mocked(readGroups).mockReturnValue([]); + vi.mocked(readHistory).mockReturnValue([]); + + showAgent('agent-123', {}); + + expect(formatAgentDetail).toHaveBeenCalledWith( + expect.objectContaining({ + groupId: undefined, + groupName: undefined, + }) + ); + }); + }); + + describe('usage statistics', () => { + it('should aggregate usage stats from history', () => { + const history: HistoryEntry[] = [ + mockHistoryEntry({ + usageStats: { inputTokens: 100, outputTokens: 200, cacheReadInputTokens: 50, cacheCreationInputTokens: 25, totalCostUsd: 0.01 }, + }), + mockHistoryEntry({ + usageStats: { inputTokens: 150, outputTokens: 300, cacheReadInputTokens: 75, cacheCreationInputTokens: 50, totalCostUsd: 0.02 }, + }), + ]; + + vi.mocked(getSessionById).mockReturnValue(mockSession()); + vi.mocked(readGroups).mockReturnValue([]); + vi.mocked(readHistory).mockReturnValue(history); + + showAgent('agent-123', { json: true }); + + const output = consoleSpy.mock.calls[0][0]; + const parsed = JSON.parse(output); + + expect(parsed.stats.totalInputTokens).toBe(250); + expect(parsed.stats.totalOutputTokens).toBe(500); + expect(parsed.stats.totalCacheReadTokens).toBe(125); + expect(parsed.stats.totalCacheCreationTokens).toBe(75); + expect(parsed.stats.totalCost).toBe(0.03); + }); + + it('should count success and failure entries', () => { + const history: HistoryEntry[] = [ + mockHistoryEntry({ success: true }), + mockHistoryEntry({ success: true }), + mockHistoryEntry({ success: false }), + ]; + + vi.mocked(getSessionById).mockReturnValue(mockSession()); + vi.mocked(readGroups).mockReturnValue([]); + vi.mocked(readHistory).mockReturnValue(history); + + showAgent('agent-123', { json: true }); + + const output = consoleSpy.mock.calls[0][0]; + const parsed = JSON.parse(output); + + expect(parsed.stats.successCount).toBe(2); + expect(parsed.stats.failureCount).toBe(1); + }); + + it('should aggregate elapsed time', () => { + const history: HistoryEntry[] = [ + mockHistoryEntry({ elapsedTimeMs: 1000 }), + mockHistoryEntry({ elapsedTimeMs: 2000 }), + mockHistoryEntry({ elapsedTimeMs: 3000 }), + ]; + + vi.mocked(getSessionById).mockReturnValue(mockSession()); + vi.mocked(readGroups).mockReturnValue([]); + vi.mocked(readHistory).mockReturnValue(history); + + showAgent('agent-123', { json: true }); + + const output = consoleSpy.mock.calls[0][0]; + const parsed = JSON.parse(output); + + expect(parsed.stats.totalElapsedMs).toBe(6000); + }); + + it('should handle entries without usageStats', () => { + const history: HistoryEntry[] = [ + mockHistoryEntry({ usageStats: undefined }), + mockHistoryEntry({ + usageStats: { inputTokens: 100, outputTokens: 200, cacheReadInputTokens: 0, cacheCreationInputTokens: 0, totalCostUsd: 0.01 }, + }), + ]; + + vi.mocked(getSessionById).mockReturnValue(mockSession()); + vi.mocked(readGroups).mockReturnValue([]); + vi.mocked(readHistory).mockReturnValue(history); + + showAgent('agent-123', { json: true }); + + const output = consoleSpy.mock.calls[0][0]; + const parsed = JSON.parse(output); + + expect(parsed.stats.totalInputTokens).toBe(100); + expect(parsed.stats.totalOutputTokens).toBe(200); + }); + + it('should handle entries without elapsedTimeMs', () => { + const history: HistoryEntry[] = [ + mockHistoryEntry({ elapsedTimeMs: undefined }), + mockHistoryEntry({ elapsedTimeMs: 1000 }), + ]; + + vi.mocked(getSessionById).mockReturnValue(mockSession()); + vi.mocked(readGroups).mockReturnValue([]); + vi.mocked(readHistory).mockReturnValue(history); + + showAgent('agent-123', { json: true }); + + const output = consoleSpy.mock.calls[0][0]; + const parsed = JSON.parse(output); + + expect(parsed.stats.totalElapsedMs).toBe(1000); + }); + + it('should handle entries with undefined success', () => { + const history: HistoryEntry[] = [ + mockHistoryEntry({ success: undefined }), + mockHistoryEntry({ success: true }), + ]; + + vi.mocked(getSessionById).mockReturnValue(mockSession()); + vi.mocked(readGroups).mockReturnValue([]); + vi.mocked(readHistory).mockReturnValue(history); + + showAgent('agent-123', { json: true }); + + const output = consoleSpy.mock.calls[0][0]; + const parsed = JSON.parse(output); + + expect(parsed.stats.successCount).toBe(1); + expect(parsed.stats.failureCount).toBe(0); + }); + }); + + describe('recent history', () => { + it('should include last 10 history entries sorted by timestamp', () => { + const history: HistoryEntry[] = Array.from({ length: 15 }, (_, i) => + mockHistoryEntry({ id: `hist-${i}`, timestamp: 1000 + i * 100 }) + ); + + vi.mocked(getSessionById).mockReturnValue(mockSession()); + vi.mocked(readGroups).mockReturnValue([]); + vi.mocked(readHistory).mockReturnValue(history); + + showAgent('agent-123', { json: true }); + + const output = consoleSpy.mock.calls[0][0]; + const parsed = JSON.parse(output); + + expect(parsed.recentHistory).toHaveLength(10); + // Should be sorted by timestamp descending (most recent first) + expect(parsed.recentHistory[0].id).toBe('hist-14'); + expect(parsed.recentHistory[9].id).toBe('hist-5'); + }); + + it('should include cost from history entries', () => { + const history: HistoryEntry[] = [ + mockHistoryEntry({ usageStats: { inputTokens: 0, outputTokens: 0, totalCostUsd: 0.05 } }), + ]; + + vi.mocked(getSessionById).mockReturnValue(mockSession()); + vi.mocked(readGroups).mockReturnValue([]); + vi.mocked(readHistory).mockReturnValue(history); + + showAgent('agent-123', { json: true }); + + const output = consoleSpy.mock.calls[0][0]; + const parsed = JSON.parse(output); + + expect(parsed.recentHistory[0].cost).toBe(0.05); + }); + + it('should handle history entries without usageStats', () => { + const history: HistoryEntry[] = [ + mockHistoryEntry({ usageStats: undefined }), + ]; + + vi.mocked(getSessionById).mockReturnValue(mockSession()); + vi.mocked(readGroups).mockReturnValue([]); + vi.mocked(readHistory).mockReturnValue(history); + + showAgent('agent-123', { json: true }); + + const output = consoleSpy.mock.calls[0][0]; + const parsed = JSON.parse(output); + + expect(parsed.recentHistory[0].cost).toBeUndefined(); + }); + }); + + describe('JSON output', () => { + it('should output JSON when json option is true', () => { + vi.mocked(getSessionById).mockReturnValue(mockSession()); + vi.mocked(readGroups).mockReturnValue([]); + vi.mocked(readHistory).mockReturnValue([]); + + showAgent('agent-123', { json: true }); + + expect(formatAgentDetail).not.toHaveBeenCalled(); + expect(consoleSpy).toHaveBeenCalledTimes(1); + + const output = consoleSpy.mock.calls[0][0]; + const parsed = JSON.parse(output); + + expect(parsed.id).toBe('agent-123'); + expect(parsed.name).toBe('Test Agent'); + expect(parsed.toolType).toBe('claude-code'); + }); + + it('should include all agent properties in JSON output', () => { + vi.mocked(getSessionById).mockReturnValue(mockSession({ + id: 'full-agent', + name: 'Full Agent', + toolType: 'gemini-cli', + cwd: '/project', + projectRoot: '/project/root', + groupId: 'group-1', + autoRunFolderPath: '/project/playbooks', + })); + vi.mocked(readGroups).mockReturnValue([ + { id: 'group-1', name: 'My Group', emoji: '🔧', collapsed: false }, + ]); + vi.mocked(readHistory).mockReturnValue([]); + + showAgent('full-agent', { json: true }); + + const output = consoleSpy.mock.calls[0][0]; + const parsed = JSON.parse(output); + + expect(parsed.id).toBe('full-agent'); + expect(parsed.name).toBe('Full Agent'); + expect(parsed.toolType).toBe('gemini-cli'); + expect(parsed.cwd).toBe('/project'); + expect(parsed.projectRoot).toBe('/project/root'); + expect(parsed.groupId).toBe('group-1'); + expect(parsed.groupName).toBe('My Group'); + expect(parsed.autoRunFolderPath).toBe('/project/playbooks'); + }); + }); + + describe('error handling', () => { + it('should throw error when agent not found', () => { + vi.mocked(getSessionById).mockReturnValue(undefined); + + expect(() => showAgent('nonexistent', {})).toThrow('process.exit(1)'); + + expect(formatError).toHaveBeenCalledWith('Agent not found: nonexistent'); + }); + + it('should output error as JSON when json option is true', () => { + vi.mocked(getSessionById).mockReturnValue(undefined); + + expect(() => showAgent('nonexistent', { json: true })).toThrow('process.exit(1)'); + + const errorOutput = consoleErrorSpy.mock.calls[0][0]; + const parsed = JSON.parse(errorOutput); + expect(parsed.error).toBe('Agent not found: nonexistent'); + }); + + it('should handle storage errors', () => { + vi.mocked(getSessionById).mockImplementation(() => { + throw new Error('Storage read failed'); + }); + + expect(() => showAgent('agent-123', {})).toThrow('process.exit(1)'); + + expect(formatError).toHaveBeenCalledWith('Storage read failed'); + }); + + it('should handle non-Error objects thrown', () => { + vi.mocked(getSessionById).mockImplementation(() => { + throw 'String error'; + }); + + expect(() => showAgent('agent-123', {})).toThrow('process.exit(1)'); + + expect(formatError).toHaveBeenCalledWith('Unknown error'); + }); + + it('should exit with code 1 on error', () => { + vi.mocked(getSessionById).mockReturnValue(undefined); + + expect(() => showAgent('nonexistent', {})).toThrow('process.exit(1)'); + expect(processExitSpy).toHaveBeenCalledWith(1); + }); + }); + + describe('edge cases', () => { + it('should handle empty history', () => { + vi.mocked(getSessionById).mockReturnValue(mockSession()); + vi.mocked(readGroups).mockReturnValue([]); + vi.mocked(readHistory).mockReturnValue([]); + + showAgent('agent-123', { json: true }); + + const output = consoleSpy.mock.calls[0][0]; + const parsed = JSON.parse(output); + + expect(parsed.stats.historyEntries).toBe(0); + expect(parsed.stats.successCount).toBe(0); + expect(parsed.stats.failureCount).toBe(0); + expect(parsed.stats.totalCost).toBe(0); + expect(parsed.recentHistory).toEqual([]); + }); + + it('should handle partial ID lookup', () => { + vi.mocked(getSessionById).mockReturnValue(mockSession()); + vi.mocked(readGroups).mockReturnValue([]); + vi.mocked(readHistory).mockReturnValue([]); + + showAgent('agent', {}); + + expect(getSessionById).toHaveBeenCalledWith('agent'); + }); + + it('should handle group not found for groupId', () => { + vi.mocked(getSessionById).mockReturnValue(mockSession({ groupId: 'missing-group' })); + vi.mocked(readGroups).mockReturnValue([]); + vi.mocked(readHistory).mockReturnValue([]); + + showAgent('agent-123', { json: true }); + + const output = consoleSpy.mock.calls[0][0]; + const parsed = JSON.parse(output); + + expect(parsed.groupId).toBe('missing-group'); + expect(parsed.groupName).toBeUndefined(); + }); + + it('should pass correct sessionId to readHistory', () => { + vi.mocked(getSessionById).mockReturnValue(mockSession({ id: 'specific-agent' })); + vi.mocked(readGroups).mockReturnValue([]); + vi.mocked(readHistory).mockReturnValue([]); + + showAgent('specific-agent', {}); + + expect(readHistory).toHaveBeenCalledWith(undefined, 'specific-agent'); + }); + }); +}); diff --git a/src/__tests__/cli/commands/show-playbook.test.ts b/src/__tests__/cli/commands/show-playbook.test.ts new file mode 100644 index 00000000..10cac938 --- /dev/null +++ b/src/__tests__/cli/commands/show-playbook.test.ts @@ -0,0 +1,433 @@ +/** + * @file show-playbook.test.ts + * @description Tests for the show-playbook CLI command + * + * Tests all functionality of the show-playbook command including: + * - Displaying playbook details with documents and tasks + * - JSON output mode + * - Document task counting + * - Error handling + */ + +import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'; +import type { SessionInfo, Playbook } from '../../../shared/types'; + +// Mock the services +vi.mock('../../../cli/services/playbooks', () => ({ + findPlaybookById: vi.fn(), +})); + +vi.mock('../../../cli/services/storage', () => ({ + getSessionById: vi.fn(), +})); + +vi.mock('../../../cli/services/agent-spawner', () => ({ + readDocAndGetTasks: vi.fn(), +})); + +// Mock the formatter +vi.mock('../../../cli/output/formatter', () => ({ + formatPlaybookDetail: vi.fn((detail) => `Playbook: ${detail.name}\nAgent: ${detail.agentName}`), + formatError: vi.fn((msg) => `Error: ${msg}`), +})); + +import { showPlaybook } from '../../../cli/commands/show-playbook'; +import { findPlaybookById } from '../../../cli/services/playbooks'; +import { getSessionById } from '../../../cli/services/storage'; +import { readDocAndGetTasks } from '../../../cli/services/agent-spawner'; +import { formatPlaybookDetail, formatError } from '../../../cli/output/formatter'; + +describe('show-playbook command', () => { + let consoleSpy: ReturnType; + let consoleErrorSpy: ReturnType; + let processExitSpy: ReturnType; + + const mockSession = (overrides: Partial = {}): SessionInfo => ({ + id: 'agent-123', + name: 'Test Agent', + toolType: 'claude-code', + cwd: '/path/to/project', + projectRoot: '/path/to/project', + groupId: undefined, + autoRunFolderPath: '/path/to/playbooks', + ...overrides, + }); + + const mockPlaybook = (overrides: Partial = {}): Playbook => ({ + id: 'playbook-123', + name: 'Test Playbook', + documents: [ + { filename: 'doc1.md', resetOnCompletion: false }, + { filename: 'doc2.md', resetOnCompletion: true }, + ], + loopEnabled: false, + maxLoops: null, + prompt: null, + ...overrides, + }); + + beforeEach(() => { + vi.clearAllMocks(); + consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {}); + consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {}); + processExitSpy = vi.spyOn(process, 'exit').mockImplementation((code?: string | number | null | undefined) => { + throw new Error(`process.exit(${code})`); + }); + }); + + afterEach(() => { + consoleSpy.mockRestore(); + consoleErrorSpy.mockRestore(); + processExitSpy.mockRestore(); + }); + + describe('basic display', () => { + it('should display playbook details in human-readable format', () => { + vi.mocked(findPlaybookById).mockReturnValue({ + playbook: mockPlaybook(), + agentId: 'agent-123', + }); + vi.mocked(getSessionById).mockReturnValue(mockSession()); + vi.mocked(readDocAndGetTasks).mockReturnValue({ tasks: ['Task 1', 'Task 2'] }); + + showPlaybook('playbook-123', {}); + + expect(findPlaybookById).toHaveBeenCalledWith('playbook-123'); + expect(formatPlaybookDetail).toHaveBeenCalled(); + expect(consoleSpy).toHaveBeenCalled(); + }); + + it('should include document details with task counts', () => { + vi.mocked(findPlaybookById).mockReturnValue({ + playbook: mockPlaybook(), + agentId: 'agent-123', + }); + vi.mocked(getSessionById).mockReturnValue(mockSession()); + vi.mocked(readDocAndGetTasks) + .mockReturnValueOnce({ tasks: ['Task 1', 'Task 2', 'Task 3'] }) + .mockReturnValueOnce({ tasks: ['Task A'] }); + + showPlaybook('playbook-123', { json: true }); + + const output = consoleSpy.mock.calls[0][0]; + const parsed = JSON.parse(output); + + expect(parsed.documents).toHaveLength(2); + expect(parsed.documents[0].taskCount).toBe(3); + expect(parsed.documents[1].taskCount).toBe(1); + expect(parsed.totalTasks).toBe(4); + }); + + it('should add .md extension if not present', () => { + const playbook = mockPlaybook({ + documents: [ + { filename: 'doc-without-extension', resetOnCompletion: false }, + ], + }); + vi.mocked(findPlaybookById).mockReturnValue({ + playbook, + agentId: 'agent-123', + }); + vi.mocked(getSessionById).mockReturnValue(mockSession()); + vi.mocked(readDocAndGetTasks).mockReturnValue({ tasks: [] }); + + showPlaybook('playbook-123', { json: true }); + + const output = consoleSpy.mock.calls[0][0]; + const parsed = JSON.parse(output); + + expect(parsed.documents[0].filename).toBe('doc-without-extension.md'); + }); + + it('should not duplicate .md extension', () => { + const playbook = mockPlaybook({ + documents: [ + { filename: 'doc.md', resetOnCompletion: false }, + ], + }); + vi.mocked(findPlaybookById).mockReturnValue({ + playbook, + agentId: 'agent-123', + }); + vi.mocked(getSessionById).mockReturnValue(mockSession()); + vi.mocked(readDocAndGetTasks).mockReturnValue({ tasks: [] }); + + showPlaybook('playbook-123', { json: true }); + + const output = consoleSpy.mock.calls[0][0]; + const parsed = JSON.parse(output); + + expect(parsed.documents[0].filename).toBe('doc.md'); + }); + }); + + describe('loop settings', () => { + it('should include loop settings in output', () => { + vi.mocked(findPlaybookById).mockReturnValue({ + playbook: mockPlaybook({ loopEnabled: true, maxLoops: 5 }), + agentId: 'agent-123', + }); + vi.mocked(getSessionById).mockReturnValue(mockSession()); + vi.mocked(readDocAndGetTasks).mockReturnValue({ tasks: [] }); + + showPlaybook('playbook-123', { json: true }); + + const output = consoleSpy.mock.calls[0][0]; + const parsed = JSON.parse(output); + + expect(parsed.loopEnabled).toBe(true); + expect(parsed.maxLoops).toBe(5); + }); + + it('should include null maxLoops for infinite loop', () => { + vi.mocked(findPlaybookById).mockReturnValue({ + playbook: mockPlaybook({ loopEnabled: true, maxLoops: null }), + agentId: 'agent-123', + }); + vi.mocked(getSessionById).mockReturnValue(mockSession()); + vi.mocked(readDocAndGetTasks).mockReturnValue({ tasks: [] }); + + showPlaybook('playbook-123', { json: true }); + + const output = consoleSpy.mock.calls[0][0]; + const parsed = JSON.parse(output); + + expect(parsed.loopEnabled).toBe(true); + expect(parsed.maxLoops).toBe(null); + }); + }); + + describe('prompt handling', () => { + it('should include custom prompt in output', () => { + vi.mocked(findPlaybookById).mockReturnValue({ + playbook: mockPlaybook({ prompt: 'Custom instructions for the agent' }), + agentId: 'agent-123', + }); + vi.mocked(getSessionById).mockReturnValue(mockSession()); + vi.mocked(readDocAndGetTasks).mockReturnValue({ tasks: [] }); + + showPlaybook('playbook-123', { json: true }); + + const output = consoleSpy.mock.calls[0][0]; + const parsed = JSON.parse(output); + + expect(parsed.prompt).toBe('Custom instructions for the agent'); + }); + + it('should include null prompt when not set', () => { + vi.mocked(findPlaybookById).mockReturnValue({ + playbook: mockPlaybook({ prompt: null }), + agentId: 'agent-123', + }); + vi.mocked(getSessionById).mockReturnValue(mockSession()); + vi.mocked(readDocAndGetTasks).mockReturnValue({ tasks: [] }); + + showPlaybook('playbook-123', { json: true }); + + const output = consoleSpy.mock.calls[0][0]; + const parsed = JSON.parse(output); + + expect(parsed.prompt).toBe(null); + }); + }); + + describe('agent without autoRunFolderPath', () => { + it('should return empty tasks when agent has no autoRunFolderPath', () => { + vi.mocked(findPlaybookById).mockReturnValue({ + playbook: mockPlaybook(), + agentId: 'agent-123', + }); + vi.mocked(getSessionById).mockReturnValue(mockSession({ autoRunFolderPath: undefined })); + + showPlaybook('playbook-123', { json: true }); + + expect(readDocAndGetTasks).not.toHaveBeenCalled(); + + const output = consoleSpy.mock.calls[0][0]; + const parsed = JSON.parse(output); + + expect(parsed.documents[0].taskCount).toBe(0); + expect(parsed.documents[0].tasks).toEqual([]); + }); + }); + + describe('JSON output', () => { + it('should output JSON when json option is true', () => { + vi.mocked(findPlaybookById).mockReturnValue({ + playbook: mockPlaybook(), + agentId: 'agent-123', + }); + vi.mocked(getSessionById).mockReturnValue(mockSession()); + vi.mocked(readDocAndGetTasks).mockReturnValue({ tasks: [] }); + + showPlaybook('playbook-123', { json: true }); + + expect(formatPlaybookDetail).not.toHaveBeenCalled(); + expect(consoleSpy).toHaveBeenCalledTimes(1); + + const output = consoleSpy.mock.calls[0][0]; + expect(() => JSON.parse(output)).not.toThrow(); + }); + + it('should include all properties in JSON output', () => { + vi.mocked(findPlaybookById).mockReturnValue({ + playbook: mockPlaybook({ + id: 'pb-full', + name: 'Full Playbook', + loopEnabled: true, + maxLoops: 3, + prompt: 'Do the thing', + documents: [{ filename: 'task.md', resetOnCompletion: true }], + }), + agentId: 'agent-full', + }); + vi.mocked(getSessionById).mockReturnValue(mockSession({ + id: 'agent-full', + name: 'Full Agent', + autoRunFolderPath: '/playbooks', + })); + vi.mocked(readDocAndGetTasks).mockReturnValue({ tasks: ['Task 1', 'Task 2'] }); + + showPlaybook('pb-full', { json: true }); + + const output = consoleSpy.mock.calls[0][0]; + const parsed = JSON.parse(output); + + expect(parsed.id).toBe('pb-full'); + expect(parsed.name).toBe('Full Playbook'); + expect(parsed.agentId).toBe('agent-full'); + expect(parsed.agentName).toBe('Full Agent'); + expect(parsed.folderPath).toBe('/playbooks'); + expect(parsed.loopEnabled).toBe(true); + expect(parsed.maxLoops).toBe(3); + expect(parsed.prompt).toBe('Do the thing'); + expect(parsed.documents).toHaveLength(1); + expect(parsed.documents[0].resetOnCompletion).toBe(true); + expect(parsed.documents[0].tasks).toEqual(['Task 1', 'Task 2']); + expect(parsed.totalTasks).toBe(2); + }); + }); + + describe('error handling', () => { + it('should throw error when playbook not found', () => { + vi.mocked(findPlaybookById).mockImplementation(() => { + throw new Error('Playbook not found: nonexistent'); + }); + + expect(() => showPlaybook('nonexistent', {})).toThrow('process.exit(1)'); + + expect(formatError).toHaveBeenCalledWith('Playbook not found: nonexistent'); + }); + + it('should throw error when agent not found', () => { + vi.mocked(findPlaybookById).mockReturnValue({ + playbook: mockPlaybook(), + agentId: 'missing-agent', + }); + vi.mocked(getSessionById).mockReturnValue(undefined); + + expect(() => showPlaybook('playbook-123', {})).toThrow('process.exit(1)'); + + expect(formatError).toHaveBeenCalledWith('Agent not found: missing-agent'); + }); + + it('should output error as JSON when json option is true', () => { + vi.mocked(findPlaybookById).mockImplementation(() => { + throw new Error('Ambiguous playbook ID'); + }); + + expect(() => showPlaybook('amb', { json: true })).toThrow('process.exit(1)'); + + const errorOutput = consoleErrorSpy.mock.calls[0][0]; + const parsed = JSON.parse(errorOutput); + expect(parsed.error).toBe('Ambiguous playbook ID'); + }); + + it('should handle non-Error objects thrown', () => { + vi.mocked(findPlaybookById).mockImplementation(() => { + throw 'String error'; + }); + + expect(() => showPlaybook('playbook-123', {})).toThrow('process.exit(1)'); + + expect(formatError).toHaveBeenCalledWith('Unknown error'); + }); + + it('should exit with code 1 on error', () => { + vi.mocked(findPlaybookById).mockImplementation(() => { + throw new Error('Test error'); + }); + + expect(() => showPlaybook('playbook-123', {})).toThrow('process.exit(1)'); + expect(processExitSpy).toHaveBeenCalledWith(1); + }); + }); + + describe('edge cases', () => { + it('should handle playbook with no documents', () => { + vi.mocked(findPlaybookById).mockReturnValue({ + playbook: mockPlaybook({ documents: [] }), + agentId: 'agent-123', + }); + vi.mocked(getSessionById).mockReturnValue(mockSession()); + + showPlaybook('playbook-123', { json: true }); + + const output = consoleSpy.mock.calls[0][0]; + const parsed = JSON.parse(output); + + expect(parsed.documents).toEqual([]); + expect(parsed.totalTasks).toBe(0); + }); + + it('should handle partial playbook ID', () => { + vi.mocked(findPlaybookById).mockReturnValue({ + playbook: mockPlaybook(), + agentId: 'agent-123', + }); + vi.mocked(getSessionById).mockReturnValue(mockSession()); + vi.mocked(readDocAndGetTasks).mockReturnValue({ tasks: [] }); + + showPlaybook('pb', {}); + + expect(findPlaybookById).toHaveBeenCalledWith('pb'); + }); + + it('should include resetOnCompletion for each document', () => { + vi.mocked(findPlaybookById).mockReturnValue({ + playbook: mockPlaybook({ + documents: [ + { filename: 'reset.md', resetOnCompletion: true }, + { filename: 'keep.md', resetOnCompletion: false }, + ], + }), + agentId: 'agent-123', + }); + vi.mocked(getSessionById).mockReturnValue(mockSession()); + vi.mocked(readDocAndGetTasks).mockReturnValue({ tasks: [] }); + + showPlaybook('playbook-123', { json: true }); + + const output = consoleSpy.mock.calls[0][0]; + const parsed = JSON.parse(output); + + expect(parsed.documents[0].resetOnCompletion).toBe(true); + expect(parsed.documents[1].resetOnCompletion).toBe(false); + }); + + it('should pass correct params to readDocAndGetTasks', () => { + vi.mocked(findPlaybookById).mockReturnValue({ + playbook: mockPlaybook({ + documents: [{ filename: 'task.md', resetOnCompletion: false }], + }), + agentId: 'agent-123', + }); + vi.mocked(getSessionById).mockReturnValue(mockSession({ autoRunFolderPath: '/my/playbooks' })); + vi.mocked(readDocAndGetTasks).mockReturnValue({ tasks: [] }); + + showPlaybook('playbook-123', {}); + + expect(readDocAndGetTasks).toHaveBeenCalledWith('/my/playbooks', 'task.md'); + }); + }); +}); diff --git a/src/__tests__/cli/output/formatter.test.ts b/src/__tests__/cli/output/formatter.test.ts new file mode 100644 index 00000000..4bd3eb7a --- /dev/null +++ b/src/__tests__/cli/output/formatter.test.ts @@ -0,0 +1,1262 @@ +/** + * @fileoverview Tests for CLI output formatter + * + * This file contains comprehensive tests for the human-readable output formatter + * used by the Maestro CLI. It tests all formatting functions including: + * - Color and style helpers (c, bold, dim, truncate) + * - Group formatting (formatGroups) + * - Agent formatting (formatAgents, formatAgentDetail) + * - Playbook formatting (formatPlaybooks, formatPlaybookDetail, formatPlaybooksByAgent) + * - Run event formatting (formatRunEvent) + * - Message formatting (formatError, formatSuccess, formatInfo, formatWarning) + */ + +import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'; +import { + formatGroups, + formatAgents, + formatPlaybooks, + formatPlaybookDetail, + formatPlaybooksByAgent, + formatRunEvent, + formatAgentDetail, + formatError, + formatSuccess, + formatInfo, + formatWarning, + type GroupDisplay, + type AgentDisplay, + type PlaybookDisplay, + type PlaybookDetailDisplay, + type PlaybooksByAgent, + type RunEvent, + type AgentDetailDisplay, +} from '../../../cli/output/formatter'; + +// Store original process.stdout.isTTY +const originalIsTTY = process.stdout.isTTY; + +describe('formatter', () => { + beforeEach(() => { + vi.clearAllMocks(); + }); + + afterEach(() => { + // Restore original isTTY + Object.defineProperty(process.stdout, 'isTTY', { + value: originalIsTTY, + writable: true, + }); + }); + + // ============================================================================ + // Color and Style Helper Tests + // ============================================================================ + + describe('Color and style handling', () => { + it('should include ANSI codes when stdout is TTY', () => { + // Simulate TTY environment + Object.defineProperty(process.stdout, 'isTTY', { + value: true, + writable: true, + }); + + // Re-import to pick up new isTTY value - the module caches supportsColor + // So we test through the public functions that use colors + const result = formatError('Test error'); + + // Error format uses red color + expect(result).toContain('Error:'); + expect(result).toContain('Test error'); + }); + + it('should not include ANSI codes when stdout is not TTY', () => { + // Simulate non-TTY environment + Object.defineProperty(process.stdout, 'isTTY', { + value: false, + writable: true, + }); + + // The formatter module checks isTTY at load time + // Since we can't easily reload the module, test that output works + const result = formatError('Test error'); + expect(result).toContain('Error:'); + expect(result).toContain('Test error'); + }); + }); + + // ============================================================================ + // formatGroups Tests + // ============================================================================ + + describe('formatGroups', () => { + it('should return "No groups found" for empty array', () => { + const result = formatGroups([]); + expect(result).toContain('No groups found'); + }); + + it('should format a single group', () => { + const groups: GroupDisplay[] = [ + { id: 'group-123', name: 'My Project', emoji: '🚀' }, + ]; + + const result = formatGroups(groups); + + expect(result).toContain('GROUPS'); + expect(result).toContain('(1)'); + expect(result).toContain('🚀'); + expect(result).toContain('My Project'); + expect(result).toContain('group-123'); + }); + + it('should format multiple groups', () => { + const groups: GroupDisplay[] = [ + { id: 'group-1', name: 'Frontend', emoji: '🎨' }, + { id: 'group-2', name: 'Backend', emoji: '⚙️' }, + { id: 'group-3', name: 'DevOps' }, // No emoji - should default to 📁 + ]; + + const result = formatGroups(groups); + + expect(result).toContain('GROUPS'); + expect(result).toContain('(3)'); + expect(result).toContain('🎨'); + expect(result).toContain('Frontend'); + expect(result).toContain('⚙️'); + expect(result).toContain('Backend'); + expect(result).toContain('📁'); // Default emoji + expect(result).toContain('DevOps'); + }); + + it('should use default emoji when none provided', () => { + const groups: GroupDisplay[] = [ + { id: 'group-1', name: 'No Emoji Group' }, + ]; + + const result = formatGroups(groups); + expect(result).toContain('📁'); + }); + }); + + // ============================================================================ + // formatAgents Tests + // ============================================================================ + + describe('formatAgents', () => { + it('should return "No agents found" for empty array', () => { + const result = formatAgents([]); + expect(result).toContain('No agents found'); + }); + + it('should format a single agent', () => { + const agents: AgentDisplay[] = [ + { + id: 'agent-abc123', + name: 'Test Agent', + toolType: 'claude-code', + cwd: '/home/user/projects/test', + }, + ]; + + const result = formatAgents(agents); + + expect(result).toContain('AGENTS'); + expect(result).toContain('(1)'); + expect(result).toContain('Test Agent'); + expect(result).toContain('claude-code'); + expect(result).toContain('/home/user/projects/test'); + expect(result).toContain('agent-abc123'); + }); + + it('should format multiple agents', () => { + const agents: AgentDisplay[] = [ + { + id: 'agent-1', + name: 'Agent One', + toolType: 'claude-code', + cwd: '/path/one', + }, + { + id: 'agent-2', + name: 'Agent Two', + toolType: 'openai-codex', + cwd: '/path/two', + }, + ]; + + const result = formatAgents(agents); + + expect(result).toContain('(2)'); + expect(result).toContain('Agent One'); + expect(result).toContain('Agent Two'); + }); + + it('should show group name in title when provided', () => { + const agents: AgentDisplay[] = [ + { + id: 'agent-1', + name: 'Test', + toolType: 'claude-code', + cwd: '/path', + }, + ]; + + const result = formatAgents(agents, 'My Group'); + + expect(result).toContain('in My Group'); + }); + + it('should show Auto Run badge for agents with autoRunFolderPath', () => { + const agents: AgentDisplay[] = [ + { + id: 'agent-1', + name: 'Auto Agent', + toolType: 'claude-code', + cwd: '/path', + autoRunFolderPath: '/path/to/playbooks', + }, + ]; + + const result = formatAgents(agents); + + expect(result).toContain('[Auto Run]'); + }); + + it('should truncate long paths', () => { + const longPath = '/very/long/path/that/exceeds/sixty/characters/for/the/working/directory/test'; + const agents: AgentDisplay[] = [ + { + id: 'agent-1', + name: 'Agent', + toolType: 'claude-code', + cwd: longPath, + }, + ]; + + const result = formatAgents(agents); + + // Path should be truncated with ellipsis + expect(result).toContain('…'); + expect(result.length).toBeLessThan(result.length + longPath.length); + }); + }); + + // ============================================================================ + // formatPlaybooks Tests + // ============================================================================ + + describe('formatPlaybooks', () => { + it('should return "No playbooks found" for empty array', () => { + const result = formatPlaybooks([]); + expect(result).toContain('No playbooks found'); + }); + + it('should format a single playbook', () => { + const playbooks: PlaybookDisplay[] = [ + { + id: 'pb-123456789', + name: 'Test Playbook', + sessionId: 'session-1', + documents: [ + { filename: 'task1.md', resetOnCompletion: false }, + ], + }, + ]; + + const result = formatPlaybooks(playbooks); + + expect(result).toContain('PLAYBOOKS'); + expect(result).toContain('(1)'); + expect(result).toContain('Test Playbook'); + expect(result).toContain('1 doc'); + expect(result).toContain('task1.md'); + }); + + it('should format multiple documents with plural', () => { + const playbooks: PlaybookDisplay[] = [ + { + id: 'pb-123', + name: 'Multi Doc', + sessionId: 'session-1', + documents: [ + { filename: 'doc1.md', resetOnCompletion: false }, + { filename: 'doc2.md', resetOnCompletion: false }, + { filename: 'doc3.md', resetOnCompletion: true }, + ], + }, + ]; + + const result = formatPlaybooks(playbooks); + + expect(result).toContain('3 docs'); + expect(result).toContain('doc1.md'); + expect(result).toContain('doc2.md'); + expect(result).toContain('doc3.md'); + }); + + it('should show loop indicator when enabled', () => { + const playbooks: PlaybookDisplay[] = [ + { + id: 'pb-123', + name: 'Loop Playbook', + sessionId: 'session-1', + documents: [], + loopEnabled: true, + }, + ]; + + const result = formatPlaybooks(playbooks); + + expect(result).toContain('↻ loop'); + }); + + it('should show max loops when specified', () => { + const playbooks: PlaybookDisplay[] = [ + { + id: 'pb-123', + name: 'Limited Loop', + sessionId: 'session-1', + documents: [], + loopEnabled: true, + maxLoops: 5, + }, + ]; + + const result = formatPlaybooks(playbooks); + + expect(result).toContain('max 5'); + }); + + it('should show reset indicator for documents with resetOnCompletion', () => { + const playbooks: PlaybookDisplay[] = [ + { + id: 'pb-123', + name: 'Reset Playbook', + sessionId: 'session-1', + documents: [ + { filename: 'reset.md', resetOnCompletion: true }, + ], + }, + ]; + + const result = formatPlaybooks(playbooks); + + expect(result).toContain('↺'); + }); + + it('should show agent name when provided', () => { + const playbooks: PlaybookDisplay[] = [ + { + id: 'pb-123', + name: 'Test', + sessionId: 'session-1', + documents: [], + }, + ]; + + const result = formatPlaybooks(playbooks, 'My Agent'); + + expect(result).toContain('for My Agent'); + }); + + it('should show folder path when provided', () => { + const playbooks: PlaybookDisplay[] = [ + { + id: 'pb-123', + name: 'Test', + sessionId: 'session-1', + documents: [], + }, + ]; + + const result = formatPlaybooks(playbooks, undefined, '/path/to/playbooks'); + + expect(result).toContain('📁 /path/to/playbooks'); + }); + }); + + // ============================================================================ + // formatPlaybookDetail Tests + // ============================================================================ + + describe('formatPlaybookDetail', () => { + const basePlaybook: PlaybookDetailDisplay = { + id: 'pb-detailed', + name: 'Detailed Playbook', + agentId: 'agent-123456789', + agentName: 'Test Agent', + prompt: 'This is the prompt', + documents: [], + }; + + it('should format basic playbook details', () => { + const result = formatPlaybookDetail(basePlaybook); + + expect(result).toContain('PLAYBOOK'); + expect(result).toContain('Name:'); + expect(result).toContain('Detailed Playbook'); + expect(result).toContain('ID:'); + expect(result).toContain('pb-detailed'); + expect(result).toContain('Agent:'); + expect(result).toContain('Test Agent'); + }); + + it('should show folder path when provided', () => { + const playbook: PlaybookDetailDisplay = { + ...basePlaybook, + folderPath: '/custom/folder', + }; + + const result = formatPlaybookDetail(playbook); + + expect(result).toContain('Folder:'); + expect(result).toContain('/custom/folder'); + }); + + it('should show loop enabled with infinite loops', () => { + const playbook: PlaybookDetailDisplay = { + ...basePlaybook, + loopEnabled: true, + }; + + const result = formatPlaybookDetail(playbook); + + expect(result).toContain('Loop:'); + expect(result).toContain('enabled'); + expect(result).toContain('∞'); + }); + + it('should show loop enabled with max loops', () => { + const playbook: PlaybookDetailDisplay = { + ...basePlaybook, + loopEnabled: true, + maxLoops: 10, + }; + + const result = formatPlaybookDetail(playbook); + + expect(result).toContain('max 10'); + }); + + it('should show loop disabled', () => { + const playbook: PlaybookDetailDisplay = { + ...basePlaybook, + loopEnabled: false, + }; + + const result = formatPlaybookDetail(playbook); + + expect(result).toContain('Loop:'); + expect(result).toContain('disabled'); + }); + + it('should format multi-line prompts', () => { + const playbook: PlaybookDetailDisplay = { + ...basePlaybook, + prompt: 'Line 1\nLine 2\nLine 3', + }; + + const result = formatPlaybookDetail(playbook); + + expect(result).toContain('Prompt:'); + expect(result).toContain('Line 1'); + expect(result).toContain('Line 2'); + expect(result).toContain('Line 3'); + }); + + it('should format documents with tasks', () => { + const playbook: PlaybookDetailDisplay = { + ...basePlaybook, + documents: [ + { + filename: 'tasks.md', + resetOnCompletion: false, + taskCount: 3, + tasks: ['Task 1', 'Task 2', 'Task 3'], + }, + ], + }; + + const result = formatPlaybookDetail(playbook); + + expect(result).toContain('Documents:'); + expect(result).toContain('1 files'); + expect(result).toContain('3 pending tasks'); + expect(result).toContain('tasks.md'); + expect(result).toContain('3 tasks'); + expect(result).toContain('Task 1'); + expect(result).toContain('Task 2'); + expect(result).toContain('Task 3'); + }); + + it('should show reset indicator for documents', () => { + const playbook: PlaybookDetailDisplay = { + ...basePlaybook, + documents: [ + { + filename: 'reset.md', + resetOnCompletion: true, + taskCount: 0, + tasks: [], + }, + ], + }; + + const result = formatPlaybookDetail(playbook); + + expect(result).toContain('↺ reset'); + }); + + it('should show only first 5 tasks and indicate more', () => { + const playbook: PlaybookDetailDisplay = { + ...basePlaybook, + documents: [ + { + filename: 'many.md', + resetOnCompletion: false, + taskCount: 8, + tasks: [ + 'Task 1', 'Task 2', 'Task 3', 'Task 4', 'Task 5', + 'Task 6', 'Task 7', 'Task 8', + ], + }, + ], + }; + + const result = formatPlaybookDetail(playbook); + + expect(result).toContain('Task 1'); + expect(result).toContain('Task 5'); + expect(result).not.toContain('Task 6'); + expect(result).toContain('... and 3 more'); + }); + + it('should handle documents with zero tasks', () => { + const playbook: PlaybookDetailDisplay = { + ...basePlaybook, + documents: [ + { + filename: 'empty.md', + resetOnCompletion: false, + taskCount: 0, + tasks: [], + }, + ], + }; + + const result = formatPlaybookDetail(playbook); + + expect(result).toContain('0 tasks'); + }); + }); + + // ============================================================================ + // formatPlaybooksByAgent Tests + // ============================================================================ + + describe('formatPlaybooksByAgent', () => { + it('should return "No playbooks found" when all agents have empty playbooks', () => { + const groups: PlaybooksByAgent[] = [ + { agentId: 'agent-1', agentName: 'Agent 1', playbooks: [] }, + ]; + + const result = formatPlaybooksByAgent(groups); + + expect(result).toContain('No playbooks found'); + }); + + it('should return "No playbooks found" for empty array', () => { + const result = formatPlaybooksByAgent([]); + expect(result).toContain('No playbooks found'); + }); + + it('should format playbooks grouped by agent', () => { + const groups: PlaybooksByAgent[] = [ + { + agentId: 'agent-123456789', + agentName: 'Agent One', + playbooks: [ + { + id: 'pb-1', + name: 'Playbook A', + sessionId: 'session-1', + documents: [{ filename: 'doc.md', resetOnCompletion: false }], + }, + ], + }, + { + agentId: 'agent-987654321', + agentName: 'Agent Two', + playbooks: [ + { + id: 'pb-2', + name: 'Playbook B', + sessionId: 'session-2', + documents: [], + loopEnabled: true, + }, + ], + }, + ]; + + const result = formatPlaybooksByAgent(groups); + + expect(result).toContain('PLAYBOOKS'); + expect(result).toContain('2 across 2 agents'); + expect(result).toContain('Agent One'); + expect(result).toContain('Playbook A'); + expect(result).toContain('Agent Two'); + expect(result).toContain('Playbook B'); + }); + + it('should use singular "agent" for single agent', () => { + const groups: PlaybooksByAgent[] = [ + { + agentId: 'agent-1', + agentName: 'Solo Agent', + playbooks: [ + { + id: 'pb-1', + name: 'Single', + sessionId: 'session-1', + documents: [], + }, + ], + }, + ]; + + const result = formatPlaybooksByAgent(groups); + + expect(result).toContain('1 across 1 agent'); + }); + + it('should show loop indicator for playbooks with loops', () => { + const groups: PlaybooksByAgent[] = [ + { + agentId: 'agent-1', + agentName: 'Agent', + playbooks: [ + { + id: 'pb-1', + name: 'Looper', + sessionId: 'session-1', + documents: [], + loopEnabled: true, + }, + ], + }, + ]; + + const result = formatPlaybooksByAgent(groups); + + expect(result).toContain('↻'); + }); + }); + + // ============================================================================ + // formatRunEvent Tests + // ============================================================================ + + describe('formatRunEvent', () => { + const timestamp = Date.now(); + + it('should format start event', () => { + const event: RunEvent = { + type: 'start', + timestamp, + }; + + const result = formatRunEvent(event); + + expect(result).toContain('▶'); + expect(result).toContain('Starting playbook run'); + }); + + it('should format document_start event', () => { + const event: RunEvent = { + type: 'document_start', + timestamp, + document: 'tasks.md', + taskCount: 5, + }; + + const result = formatRunEvent(event); + + expect(result).toContain('📄'); + expect(result).toContain('tasks.md'); + expect(result).toContain('5 tasks'); + }); + + it('should format task_start event', () => { + const event: RunEvent = { + type: 'task_start', + timestamp, + taskIndex: 0, + task: 'First task description', + }; + + const result = formatRunEvent(event); + + expect(result).toContain('⏳'); + expect(result).toContain('Task 1:'); + expect(result).toContain('First task description'); + }); + + it('should format task_preview event', () => { + const event: RunEvent = { + type: 'task_preview', + timestamp, + taskIndex: 2, + task: 'Preview task', + }; + + const result = formatRunEvent(event); + + expect(result).toContain('3.'); + expect(result).toContain('Preview task'); + }); + + it('should format successful task_complete event', () => { + const event: RunEvent = { + type: 'task_complete', + timestamp, + success: true, + elapsedMs: 5000, + summary: 'Task completed successfully', + }; + + const result = formatRunEvent(event); + + expect(result).toContain('✓'); + expect(result).toContain('Task completed successfully'); + expect(result).toContain('5.0s'); + }); + + it('should format failed task_complete event', () => { + const event: RunEvent = { + type: 'task_complete', + timestamp, + success: false, + elapsedMs: 3000, + summary: 'Task failed', + }; + + const result = formatRunEvent(event); + + expect(result).toContain('✗'); + expect(result).toContain('Task failed'); + }); + + it('should format task_complete in debug mode with full response', () => { + const event: RunEvent = { + type: 'task_complete', + timestamp, + success: true, + elapsedMs: 2000, + fullResponse: 'First line of response\nSecond line', + claudeSessionId: 'claude-session-12345678', + }; + + const result = formatRunEvent(event, { debug: true }); + + expect(result).toContain('First line of response'); + expect(result).toContain('2.0s'); + expect(result).toContain('claude-s'); // First 8 chars of session ID + }); + + it('should format history_write event', () => { + const event: RunEvent = { + type: 'history_write', + timestamp, + entryId: 'entry-12345678901234', + }; + + const result = formatRunEvent(event); + + expect(result).toContain('🔖'); + expect(result).toContain('[history]'); + expect(result).toContain('entry-12'); // First 8 chars + }); + + it('should format document_complete event', () => { + const event: RunEvent = { + type: 'document_complete', + timestamp, + tasksCompleted: 10, + }; + + const result = formatRunEvent(event); + + expect(result).toContain('✓'); + expect(result).toContain('Document complete'); + expect(result).toContain('10 tasks'); + }); + + it('should format loop_complete event', () => { + const event: RunEvent = { + type: 'loop_complete', + timestamp, + iteration: 3, + }; + + const result = formatRunEvent(event); + + expect(result).toContain('↻'); + expect(result).toContain('Loop 3 complete'); + }); + + it('should format complete event', () => { + const event: RunEvent = { + type: 'complete', + timestamp, + dryRun: false, + totalTasksCompleted: 15, + totalElapsedMs: 30000, + }; + + const result = formatRunEvent(event); + + expect(result).toContain('✓'); + expect(result).toContain('Playbook complete'); + expect(result).toContain('15 tasks'); + expect(result).toContain('30.0s'); + }); + + it('should format complete event for dry run', () => { + const event: RunEvent = { + type: 'complete', + timestamp, + dryRun: true, + wouldProcess: 5, + }; + + const result = formatRunEvent(event); + + expect(result).toContain('ℹ'); + expect(result).toContain('Dry run complete'); + expect(result).toContain('5 tasks would be processed'); + }); + + it('should format error event', () => { + const event: RunEvent = { + type: 'error', + timestamp, + message: 'Something went wrong', + }; + + const result = formatRunEvent(event); + + expect(result).toContain('✗'); + expect(result).toContain('Error:'); + expect(result).toContain('Something went wrong'); + }); + + it('should format debug event with different categories', () => { + const categories = ['config', 'scan', 'loop', 'reset', 'unknown']; + + for (const category of categories) { + const event: RunEvent = { + type: 'debug', + timestamp, + category, + message: `Debug message for ${category}`, + }; + + const result = formatRunEvent(event); + + expect(result).toContain('🔍'); + expect(result).toContain(`[${category}]`); + expect(result).toContain(`Debug message for ${category}`); + } + }); + + it('should format verbose event', () => { + const event: RunEvent = { + type: 'verbose', + timestamp, + category: 'task', + document: 'test.md', + taskIndex: 1, + prompt: 'The full prompt text here', + }; + + const result = formatRunEvent(event); + + expect(result).toContain('📝'); + expect(result).toContain('[task]'); + expect(result).toContain('test.md'); + expect(result).toContain('Task 2'); + expect(result).toContain('The full prompt text here'); + expect(result).toContain('─'); // Separator line + }); + + it('should format unknown event type', () => { + const event: RunEvent = { + type: 'unknown_event', + timestamp, + }; + + const result = formatRunEvent(event); + + expect(result).toContain('unknown_event'); + }); + + it('should truncate long task descriptions', () => { + const longTask = 'A'.repeat(100); + const event: RunEvent = { + type: 'task_start', + timestamp, + taskIndex: 0, + task: longTask, + }; + + const result = formatRunEvent(event); + + // Should be truncated to 60 chars with ellipsis + expect(result).toContain('…'); + expect(result.length).toBeLessThan(longTask.length + 50); + }); + + it('should handle empty task description', () => { + const event: RunEvent = { + type: 'task_start', + timestamp, + taskIndex: 0, + task: '', + }; + + const result = formatRunEvent(event); + + expect(result).toContain('Task 1:'); + }); + }); + + // ============================================================================ + // formatAgentDetail Tests + // ============================================================================ + + describe('formatAgentDetail', () => { + const baseAgent: AgentDetailDisplay = { + id: 'agent-123', + name: 'Test Agent', + toolType: 'claude-code', + cwd: '/home/user/project', + projectRoot: '/home/user/project', + stats: { + historyEntries: 10, + successCount: 8, + failureCount: 2, + totalInputTokens: 50000, + totalOutputTokens: 25000, + totalCacheReadTokens: 10000, + totalCacheCreationTokens: 5000, + totalCost: 1.5, + totalElapsedMs: 300000, + }, + recentHistory: [], + }; + + it('should format basic agent details', () => { + const result = formatAgentDetail(baseAgent); + + expect(result).toContain('AGENT'); + expect(result).toContain('Name:'); + expect(result).toContain('Test Agent'); + expect(result).toContain('ID:'); + expect(result).toContain('agent-123'); + expect(result).toContain('Type:'); + expect(result).toContain('claude-code'); + expect(result).toContain('Directory:'); + expect(result).toContain('/home/user/project'); + }); + + it('should show group name when provided', () => { + const agent: AgentDetailDisplay = { + ...baseAgent, + groupName: 'My Group', + }; + + const result = formatAgentDetail(agent); + + expect(result).toContain('Group:'); + expect(result).toContain('My Group'); + }); + + it('should show auto run folder when provided', () => { + const agent: AgentDetailDisplay = { + ...baseAgent, + autoRunFolderPath: '/path/to/playbooks', + }; + + const result = formatAgentDetail(agent); + + expect(result).toContain('Auto Run:'); + expect(result).toContain('/path/to/playbooks'); + }); + + it('should format usage stats correctly', () => { + const result = formatAgentDetail(baseAgent); + + expect(result).toContain('USAGE STATS'); + expect(result).toContain('Sessions:'); + expect(result).toContain('10 total'); + expect(result).toContain('8 success'); + expect(result).toContain('2 failed'); + expect(result).toContain('80% success rate'); + expect(result).toContain('Total Cost:'); + expect(result).toContain('$1.5000'); + expect(result).toContain('Total Time:'); + expect(result).toContain('5.0m'); // 300000ms = 5 minutes + }); + + it('should format token counts with K suffix', () => { + const result = formatAgentDetail(baseAgent); + + expect(result).toContain('Tokens:'); + expect(result).toContain('50.0K'); // 50000 input tokens + expect(result).toContain('25.0K'); // 25000 output tokens + }); + + it('should format token counts with M suffix for millions', () => { + const agent: AgentDetailDisplay = { + ...baseAgent, + stats: { + ...baseAgent.stats, + totalInputTokens: 1500000, + totalOutputTokens: 2500000, + }, + }; + + const result = formatAgentDetail(agent); + + expect(result).toContain('1.5M'); + expect(result).toContain('2.5M'); + }); + + it('should format small token counts without suffix', () => { + const agent: AgentDetailDisplay = { + ...baseAgent, + stats: { + ...baseAgent.stats, + totalInputTokens: 500, + totalOutputTokens: 250, + }, + }; + + const result = formatAgentDetail(agent); + + expect(result).toContain('500'); + expect(result).toContain('250'); + }); + + it('should format different durations correctly', () => { + // Test milliseconds + const agentMs: AgentDetailDisplay = { + ...baseAgent, + stats: { ...baseAgent.stats, totalElapsedMs: 500 }, + }; + expect(formatAgentDetail(agentMs)).toContain('500ms'); + + // Test seconds + const agentSec: AgentDetailDisplay = { + ...baseAgent, + stats: { ...baseAgent.stats, totalElapsedMs: 5000 }, + }; + expect(formatAgentDetail(agentSec)).toContain('5.0s'); + + // Test minutes + const agentMin: AgentDetailDisplay = { + ...baseAgent, + stats: { ...baseAgent.stats, totalElapsedMs: 120000 }, + }; + expect(formatAgentDetail(agentMin)).toContain('2.0m'); + + // Test hours + const agentHour: AgentDetailDisplay = { + ...baseAgent, + stats: { ...baseAgent.stats, totalElapsedMs: 7200000 }, + }; + expect(formatAgentDetail(agentHour)).toContain('2.0h'); + }); + + it('should handle zero history entries', () => { + const agent: AgentDetailDisplay = { + ...baseAgent, + stats: { + ...baseAgent.stats, + historyEntries: 0, + successCount: 0, + failureCount: 0, + }, + }; + + const result = formatAgentDetail(agent); + + expect(result).toContain('0 total'); + expect(result).toContain('0% success rate'); + }); + + it('should format recent history entries', () => { + const agent: AgentDetailDisplay = { + ...baseAgent, + recentHistory: [ + { + id: 'history-1', + type: 'chat', + timestamp: Date.now(), + summary: 'Fixed a bug', + success: true, + elapsedTimeMs: 5000, + cost: 0.05, + }, + { + id: 'history-2', + type: 'task', + timestamp: Date.now() - 3600000, + summary: 'Failed task', + success: false, + }, + { + id: 'history-3', + type: 'unknown', + timestamp: Date.now() - 7200000, + summary: 'Neutral entry', + }, + ], + }; + + const result = formatAgentDetail(agent); + + expect(result).toContain('RECENT HISTORY'); + expect(result).toContain('last 3'); + expect(result).toContain('✓'); // Success + expect(result).toContain('✗'); // Failure + expect(result).toContain('•'); // Neutral + expect(result).toContain('[chat]'); + expect(result).toContain('[task]'); + expect(result).toContain('Fixed a bug'); + expect(result).toContain('$0.0500'); + expect(result).toContain('5.0s'); + }); + + it('should not show history section when empty', () => { + const result = formatAgentDetail(baseAgent); + + expect(result).not.toContain('RECENT HISTORY'); + }); + }); + + // ============================================================================ + // Message Formatting Tests + // ============================================================================ + + describe('Message formatting', () => { + describe('formatError', () => { + it('should format error messages', () => { + const result = formatError('Something went wrong'); + + expect(result).toContain('✗'); + expect(result).toContain('Error:'); + expect(result).toContain('Something went wrong'); + }); + }); + + describe('formatSuccess', () => { + it('should format success messages', () => { + const result = formatSuccess('Operation completed'); + + expect(result).toContain('✓'); + expect(result).toContain('Operation completed'); + }); + }); + + describe('formatInfo', () => { + it('should format info messages', () => { + const result = formatInfo('Some information'); + + expect(result).toContain('ℹ'); + expect(result).toContain('Some information'); + }); + }); + + describe('formatWarning', () => { + it('should format warning messages', () => { + const result = formatWarning('Be careful'); + + expect(result).toContain('⚠'); + expect(result).toContain('Be careful'); + }); + }); + }); + + // ============================================================================ + // Edge Cases and Truncation Tests + // ============================================================================ + + describe('Edge cases', () => { + it('should handle empty strings gracefully', () => { + const result = formatError(''); + expect(result).toContain('Error:'); + }); + + it('should handle special characters in names', () => { + const agents: AgentDisplay[] = [ + { + id: 'agent-1', + name: 'Test & "Special"', + toolType: 'claude-code', + cwd: '/path', + }, + ]; + + const result = formatAgents(agents); + + expect(result).toContain('Test & "Special"'); + }); + + it('should handle unicode in names', () => { + const groups: GroupDisplay[] = [ + { id: 'group-1', name: '日本語プロジェクト', emoji: '🇯🇵' }, + ]; + + const result = formatGroups(groups); + + expect(result).toContain('日本語プロジェクト'); + expect(result).toContain('🇯🇵'); + }); + + it('should truncate strings at correct length', () => { + const longPath = 'a'.repeat(100); + const agents: AgentDisplay[] = [ + { + id: 'agent-1', + name: 'Agent', + toolType: 'claude-code', + cwd: longPath, + }, + ]; + + const result = formatAgents(agents); + + // Truncated to 60 chars with ellipsis (59 chars + …) + expect(result).toContain('…'); + }); + + it('should not truncate strings shorter than max length', () => { + const shortPath = '/short/path'; + const agents: AgentDisplay[] = [ + { + id: 'agent-1', + name: 'Agent', + toolType: 'claude-code', + cwd: shortPath, + }, + ]; + + const result = formatAgents(agents); + + expect(result).toContain(shortPath); + expect(result).not.toContain('…'); + }); + }); +}); diff --git a/src/__tests__/cli/output/jsonl.test.ts b/src/__tests__/cli/output/jsonl.test.ts new file mode 100644 index 00000000..afc2b1fb --- /dev/null +++ b/src/__tests__/cli/output/jsonl.test.ts @@ -0,0 +1,782 @@ +/** + * @file jsonl.test.ts + * @description Tests for CLI JSONL output functions + * + * Tests all JSONL event emitters used for machine-parseable CLI output. + */ + +import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'; +import { + emitJsonl, + emitError, + emitStart, + emitDocumentStart, + emitTaskStart, + emitTaskComplete, + emitDocumentComplete, + emitLoopComplete, + emitComplete, + emitGroup, + emitAgent, + emitPlaybook, +} from '../../../cli/output/jsonl'; +import type { UsageStats } from '../../../shared/types'; + +describe('jsonl output', () => { + let consoleSpy: ReturnType; + let dateNowSpy: ReturnType; + const mockTimestamp = 1702000000000; + + beforeEach(() => { + consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {}); + dateNowSpy = vi.spyOn(Date, 'now').mockReturnValue(mockTimestamp); + }); + + afterEach(() => { + consoleSpy.mockRestore(); + dateNowSpy.mockRestore(); + }); + + describe('emitJsonl', () => { + it('should emit a JSON line with timestamp', () => { + emitJsonl({ type: 'test', data: 'value' }); + + expect(consoleSpy).toHaveBeenCalledTimes(1); + const output = consoleSpy.mock.calls[0][0]; + const parsed = JSON.parse(output); + + expect(parsed.type).toBe('test'); + expect(parsed.data).toBe('value'); + expect(parsed.timestamp).toBe(mockTimestamp); + }); + + it('should emit valid JSON', () => { + emitJsonl({ type: 'test', nested: { a: 1, b: [2, 3] } }); + + const output = consoleSpy.mock.calls[0][0]; + expect(() => JSON.parse(output)).not.toThrow(); + }); + + it('should handle special characters in values', () => { + emitJsonl({ type: 'test', message: 'Hello "world"\nNew line\ttab' }); + + const output = consoleSpy.mock.calls[0][0]; + const parsed = JSON.parse(output); + expect(parsed.message).toBe('Hello "world"\nNew line\ttab'); + }); + + it('should preserve all event properties', () => { + const event = { + type: 'custom', + stringProp: 'value', + numberProp: 42, + boolProp: true, + nullProp: null, + arrayProp: [1, 2, 3], + objectProp: { nested: true }, + }; + + emitJsonl(event); + + const output = consoleSpy.mock.calls[0][0]; + const parsed = JSON.parse(output); + + expect(parsed.type).toBe('custom'); + expect(parsed.stringProp).toBe('value'); + expect(parsed.numberProp).toBe(42); + expect(parsed.boolProp).toBe(true); + expect(parsed.nullProp).toBe(null); + expect(parsed.arrayProp).toEqual([1, 2, 3]); + expect(parsed.objectProp).toEqual({ nested: true }); + }); + + it('should add timestamp even if event already has one', () => { + // The timestamp is always added with current Date.now() + emitJsonl({ type: 'test', timestamp: 999 }); + + const output = consoleSpy.mock.calls[0][0]; + const parsed = JSON.parse(output); + // The new timestamp should override any existing one + expect(parsed.timestamp).toBe(mockTimestamp); + }); + }); + + describe('emitError', () => { + it('should emit error event with message', () => { + emitError('Something went wrong'); + + const output = consoleSpy.mock.calls[0][0]; + const parsed = JSON.parse(output); + + expect(parsed.type).toBe('error'); + expect(parsed.message).toBe('Something went wrong'); + expect(parsed.timestamp).toBe(mockTimestamp); + }); + + it('should emit error event with message and code', () => { + emitError('Connection failed', 'ERR_CONNECTION'); + + const output = consoleSpy.mock.calls[0][0]; + const parsed = JSON.parse(output); + + expect(parsed.type).toBe('error'); + expect(parsed.message).toBe('Connection failed'); + expect(parsed.code).toBe('ERR_CONNECTION'); + }); + + it('should emit error event without code when not provided', () => { + emitError('Simple error'); + + const output = consoleSpy.mock.calls[0][0]; + const parsed = JSON.parse(output); + + expect(parsed.type).toBe('error'); + expect(parsed.message).toBe('Simple error'); + expect(parsed.code).toBeUndefined(); + }); + + it('should handle empty error message', () => { + emitError(''); + + const output = consoleSpy.mock.calls[0][0]; + const parsed = JSON.parse(output); + + expect(parsed.type).toBe('error'); + expect(parsed.message).toBe(''); + }); + }); + + describe('emitStart', () => { + it('should emit start event with playbook and session info', () => { + const playbook = { id: 'pb-123', name: 'Test Playbook' }; + const session = { id: 'sess-456', name: 'Test Session', cwd: '/path/to/project' }; + + emitStart(playbook, session); + + const output = consoleSpy.mock.calls[0][0]; + const parsed = JSON.parse(output); + + expect(parsed.type).toBe('start'); + expect(parsed.playbook).toEqual(playbook); + expect(parsed.session).toEqual(session); + expect(parsed.timestamp).toBe(mockTimestamp); + }); + + it('should handle complex paths in session cwd', () => { + const playbook = { id: 'pb-1', name: 'PB' }; + const session = { id: 's-1', name: 'S', cwd: '/Users/dev/Projects/My App/src' }; + + emitStart(playbook, session); + + const output = consoleSpy.mock.calls[0][0]; + const parsed = JSON.parse(output); + + expect(parsed.session.cwd).toBe('/Users/dev/Projects/My App/src'); + }); + }); + + describe('emitDocumentStart', () => { + it('should emit document start event', () => { + emitDocumentStart('README.md', 0, 5); + + const output = consoleSpy.mock.calls[0][0]; + const parsed = JSON.parse(output); + + expect(parsed.type).toBe('document_start'); + expect(parsed.document).toBe('README.md'); + expect(parsed.index).toBe(0); + expect(parsed.taskCount).toBe(5); + expect(parsed.timestamp).toBe(mockTimestamp); + }); + + it('should handle zero task count', () => { + emitDocumentStart('empty.md', 3, 0); + + const output = consoleSpy.mock.calls[0][0]; + const parsed = JSON.parse(output); + + expect(parsed.taskCount).toBe(0); + }); + + it('should handle nested document paths', () => { + emitDocumentStart('docs/setup/README.md', 2, 10); + + const output = consoleSpy.mock.calls[0][0]; + const parsed = JSON.parse(output); + + expect(parsed.document).toBe('docs/setup/README.md'); + }); + }); + + describe('emitTaskStart', () => { + it('should emit task start event', () => { + emitTaskStart('README.md', 0); + + const output = consoleSpy.mock.calls[0][0]; + const parsed = JSON.parse(output); + + expect(parsed.type).toBe('task_start'); + expect(parsed.document).toBe('README.md'); + expect(parsed.taskIndex).toBe(0); + expect(parsed.timestamp).toBe(mockTimestamp); + }); + + it('should handle large task indices', () => { + emitTaskStart('large.md', 999); + + const output = consoleSpy.mock.calls[0][0]; + const parsed = JSON.parse(output); + + expect(parsed.taskIndex).toBe(999); + }); + }); + + describe('emitTaskComplete', () => { + it('should emit task complete event with success', () => { + emitTaskComplete('README.md', 0, true, 'Task completed successfully', 1500); + + const output = consoleSpy.mock.calls[0][0]; + const parsed = JSON.parse(output); + + expect(parsed.type).toBe('task_complete'); + expect(parsed.document).toBe('README.md'); + expect(parsed.taskIndex).toBe(0); + expect(parsed.success).toBe(true); + expect(parsed.summary).toBe('Task completed successfully'); + expect(parsed.elapsedMs).toBe(1500); + expect(parsed.timestamp).toBe(mockTimestamp); + }); + + it('should emit task complete event with failure', () => { + emitTaskComplete('README.md', 1, false, 'Task failed', 500); + + const output = consoleSpy.mock.calls[0][0]; + const parsed = JSON.parse(output); + + expect(parsed.success).toBe(false); + expect(parsed.summary).toBe('Task failed'); + }); + + it('should include optional fullResponse', () => { + emitTaskComplete('README.md', 0, true, 'Done', 1000, { + fullResponse: 'This is the full response from the agent.', + }); + + const output = consoleSpy.mock.calls[0][0]; + const parsed = JSON.parse(output); + + expect(parsed.fullResponse).toBe('This is the full response from the agent.'); + }); + + it('should include optional usageStats', () => { + const usageStats: UsageStats = { + inputTokens: 100, + outputTokens: 200, + totalCost: 0.05, + }; + + emitTaskComplete('README.md', 0, true, 'Done', 1000, { usageStats }); + + const output = consoleSpy.mock.calls[0][0]; + const parsed = JSON.parse(output); + + expect(parsed.usageStats).toEqual(usageStats); + }); + + it('should include optional claudeSessionId', () => { + emitTaskComplete('README.md', 0, true, 'Done', 1000, { + claudeSessionId: 'claude-sess-abc123', + }); + + const output = consoleSpy.mock.calls[0][0]; + const parsed = JSON.parse(output); + + expect(parsed.claudeSessionId).toBe('claude-sess-abc123'); + }); + + it('should include all optional fields together', () => { + const usageStats: UsageStats = { + inputTokens: 50, + outputTokens: 100, + totalCost: 0.02, + }; + + emitTaskComplete('README.md', 0, true, 'All done', 2000, { + fullResponse: 'Full response here', + usageStats, + claudeSessionId: 'sess-xyz', + }); + + const output = consoleSpy.mock.calls[0][0]; + const parsed = JSON.parse(output); + + expect(parsed.fullResponse).toBe('Full response here'); + expect(parsed.usageStats).toEqual(usageStats); + expect(parsed.claudeSessionId).toBe('sess-xyz'); + }); + + it('should work without optional fields', () => { + emitTaskComplete('doc.md', 2, true, 'OK', 500); + + const output = consoleSpy.mock.calls[0][0]; + const parsed = JSON.parse(output); + + expect(parsed.fullResponse).toBeUndefined(); + expect(parsed.usageStats).toBeUndefined(); + expect(parsed.claudeSessionId).toBeUndefined(); + }); + }); + + describe('emitDocumentComplete', () => { + it('should emit document complete event', () => { + emitDocumentComplete('README.md', 5); + + const output = consoleSpy.mock.calls[0][0]; + const parsed = JSON.parse(output); + + expect(parsed.type).toBe('document_complete'); + expect(parsed.document).toBe('README.md'); + expect(parsed.tasksCompleted).toBe(5); + expect(parsed.timestamp).toBe(mockTimestamp); + }); + + it('should handle zero completed tasks', () => { + emitDocumentComplete('empty.md', 0); + + const output = consoleSpy.mock.calls[0][0]; + const parsed = JSON.parse(output); + + expect(parsed.tasksCompleted).toBe(0); + }); + }); + + describe('emitLoopComplete', () => { + it('should emit loop complete event without usage stats', () => { + emitLoopComplete(1, 10, 5000); + + const output = consoleSpy.mock.calls[0][0]; + const parsed = JSON.parse(output); + + expect(parsed.type).toBe('loop_complete'); + expect(parsed.iteration).toBe(1); + expect(parsed.tasksCompleted).toBe(10); + expect(parsed.elapsedMs).toBe(5000); + expect(parsed.timestamp).toBe(mockTimestamp); + expect(parsed.usageStats).toBeUndefined(); + }); + + it('should emit loop complete event with usage stats', () => { + const usageStats: UsageStats = { + inputTokens: 1000, + outputTokens: 2000, + totalCost: 0.50, + }; + + emitLoopComplete(3, 15, 10000, usageStats); + + const output = consoleSpy.mock.calls[0][0]; + const parsed = JSON.parse(output); + + expect(parsed.iteration).toBe(3); + expect(parsed.usageStats).toEqual(usageStats); + }); + + it('should handle first iteration (0)', () => { + emitLoopComplete(0, 5, 2000); + + const output = consoleSpy.mock.calls[0][0]; + const parsed = JSON.parse(output); + + expect(parsed.iteration).toBe(0); + }); + }); + + describe('emitComplete', () => { + it('should emit complete event with success', () => { + emitComplete(true, 20, 60000); + + const output = consoleSpy.mock.calls[0][0]; + const parsed = JSON.parse(output); + + expect(parsed.type).toBe('complete'); + expect(parsed.success).toBe(true); + expect(parsed.totalTasksCompleted).toBe(20); + expect(parsed.totalElapsedMs).toBe(60000); + expect(parsed.timestamp).toBe(mockTimestamp); + expect(parsed.totalCost).toBeUndefined(); + }); + + it('should emit complete event with failure', () => { + emitComplete(false, 5, 10000); + + const output = consoleSpy.mock.calls[0][0]; + const parsed = JSON.parse(output); + + expect(parsed.success).toBe(false); + expect(parsed.totalTasksCompleted).toBe(5); + }); + + it('should emit complete event with total cost', () => { + emitComplete(true, 100, 300000, 15.50); + + const output = consoleSpy.mock.calls[0][0]; + const parsed = JSON.parse(output); + + expect(parsed.success).toBe(true); + expect(parsed.totalCost).toBe(15.50); + }); + + it('should handle zero tasks completed', () => { + emitComplete(false, 0, 1000); + + const output = consoleSpy.mock.calls[0][0]; + const parsed = JSON.parse(output); + + expect(parsed.totalTasksCompleted).toBe(0); + }); + + it('should handle zero cost', () => { + emitComplete(true, 1, 1000, 0); + + const output = consoleSpy.mock.calls[0][0]; + const parsed = JSON.parse(output); + + expect(parsed.totalCost).toBe(0); + }); + }); + + describe('emitGroup', () => { + it('should emit group event', () => { + const group = { + id: 'group-123', + name: 'My Group', + emoji: '🚀', + collapsed: false, + }; + + emitGroup(group); + + const output = consoleSpy.mock.calls[0][0]; + const parsed = JSON.parse(output); + + expect(parsed.type).toBe('group'); + expect(parsed.id).toBe('group-123'); + expect(parsed.name).toBe('My Group'); + expect(parsed.emoji).toBe('🚀'); + expect(parsed.collapsed).toBe(false); + expect(parsed.timestamp).toBe(mockTimestamp); + }); + + it('should emit collapsed group', () => { + const group = { + id: 'group-456', + name: 'Collapsed Group', + emoji: '📁', + collapsed: true, + }; + + emitGroup(group); + + const output = consoleSpy.mock.calls[0][0]; + const parsed = JSON.parse(output); + + expect(parsed.collapsed).toBe(true); + }); + + it('should handle empty emoji', () => { + const group = { + id: 'group-789', + name: 'No Emoji Group', + emoji: '', + collapsed: false, + }; + + emitGroup(group); + + const output = consoleSpy.mock.calls[0][0]; + const parsed = JSON.parse(output); + + expect(parsed.emoji).toBe(''); + }); + }); + + describe('emitAgent', () => { + it('should emit agent event with required fields', () => { + const agent = { + id: 'agent-123', + name: 'Test Agent', + toolType: 'claude-code', + cwd: '/path/to/project', + }; + + emitAgent(agent); + + const output = consoleSpy.mock.calls[0][0]; + const parsed = JSON.parse(output); + + expect(parsed.type).toBe('agent'); + expect(parsed.id).toBe('agent-123'); + expect(parsed.name).toBe('Test Agent'); + expect(parsed.toolType).toBe('claude-code'); + expect(parsed.cwd).toBe('/path/to/project'); + expect(parsed.timestamp).toBe(mockTimestamp); + }); + + it('should emit agent event with groupId', () => { + const agent = { + id: 'agent-456', + name: 'Grouped Agent', + toolType: 'aider', + cwd: '/path', + groupId: 'group-123', + }; + + emitAgent(agent); + + const output = consoleSpy.mock.calls[0][0]; + const parsed = JSON.parse(output); + + expect(parsed.groupId).toBe('group-123'); + }); + + it('should emit agent event with autoRunFolderPath', () => { + const agent = { + id: 'agent-789', + name: 'Auto Run Agent', + toolType: 'claude-code', + cwd: '/project', + autoRunFolderPath: '/project/playbooks', + }; + + emitAgent(agent); + + const output = consoleSpy.mock.calls[0][0]; + const parsed = JSON.parse(output); + + expect(parsed.autoRunFolderPath).toBe('/project/playbooks'); + }); + + it('should emit agent event with all optional fields', () => { + const agent = { + id: 'agent-full', + name: 'Full Agent', + toolType: 'terminal', + cwd: '/home/user/project', + groupId: 'dev-group', + autoRunFolderPath: '/home/user/project/auto', + }; + + emitAgent(agent); + + const output = consoleSpy.mock.calls[0][0]; + const parsed = JSON.parse(output); + + expect(parsed.groupId).toBe('dev-group'); + expect(parsed.autoRunFolderPath).toBe('/home/user/project/auto'); + }); + + it('should handle different tool types', () => { + const toolTypes = ['claude-code', 'aider', 'terminal', 'gemini-cli', 'qwen3-coder']; + + toolTypes.forEach((toolType, index) => { + consoleSpy.mockClear(); + emitAgent({ + id: `agent-${index}`, + name: `Agent ${index}`, + toolType, + cwd: '/path', + }); + + const output = consoleSpy.mock.calls[0][0]; + const parsed = JSON.parse(output); + expect(parsed.toolType).toBe(toolType); + }); + }); + }); + + describe('emitPlaybook', () => { + it('should emit playbook event without loop', () => { + const playbook = { + id: 'pb-123', + name: 'Test Playbook', + sessionId: 'sess-456', + documents: ['doc1.md', 'doc2.md'], + loopEnabled: false, + }; + + emitPlaybook(playbook); + + const output = consoleSpy.mock.calls[0][0]; + const parsed = JSON.parse(output); + + expect(parsed.type).toBe('playbook'); + expect(parsed.id).toBe('pb-123'); + expect(parsed.name).toBe('Test Playbook'); + expect(parsed.sessionId).toBe('sess-456'); + expect(parsed.documents).toEqual(['doc1.md', 'doc2.md']); + expect(parsed.loopEnabled).toBe(false); + expect(parsed.timestamp).toBe(mockTimestamp); + }); + + it('should emit playbook event with loop enabled and max loops', () => { + const playbook = { + id: 'pb-loop', + name: 'Loop Playbook', + sessionId: 'sess-789', + documents: ['task.md'], + loopEnabled: true, + maxLoops: 5, + }; + + emitPlaybook(playbook); + + const output = consoleSpy.mock.calls[0][0]; + const parsed = JSON.parse(output); + + expect(parsed.loopEnabled).toBe(true); + expect(parsed.maxLoops).toBe(5); + }); + + it('should emit playbook event with infinite loop (maxLoops null)', () => { + const playbook = { + id: 'pb-infinite', + name: 'Infinite Playbook', + sessionId: 'sess-inf', + documents: ['infinite.md'], + loopEnabled: true, + maxLoops: null, + }; + + emitPlaybook(playbook); + + const output = consoleSpy.mock.calls[0][0]; + const parsed = JSON.parse(output); + + expect(parsed.loopEnabled).toBe(true); + expect(parsed.maxLoops).toBe(null); + }); + + it('should handle empty documents array', () => { + const playbook = { + id: 'pb-empty', + name: 'Empty Playbook', + sessionId: 'sess-e', + documents: [], + loopEnabled: false, + }; + + emitPlaybook(playbook); + + const output = consoleSpy.mock.calls[0][0]; + const parsed = JSON.parse(output); + + expect(parsed.documents).toEqual([]); + }); + + it('should handle many documents', () => { + const documents = Array.from({ length: 100 }, (_, i) => `doc${i}.md`); + const playbook = { + id: 'pb-many', + name: 'Many Docs Playbook', + sessionId: 'sess-m', + documents, + loopEnabled: false, + }; + + emitPlaybook(playbook); + + const output = consoleSpy.mock.calls[0][0]; + const parsed = JSON.parse(output); + + expect(parsed.documents).toHaveLength(100); + expect(parsed.documents[0]).toBe('doc0.md'); + expect(parsed.documents[99]).toBe('doc99.md'); + }); + }); + + describe('JSON output format', () => { + it('should output single line JSON (no newlines in output)', () => { + emitJsonl({ type: 'test', data: 'multiline\nvalue' }); + + const output = consoleSpy.mock.calls[0][0]; + // The output itself should be a single line (newline is inside the JSON string) + expect(output.split('\n')).toHaveLength(1); + }); + + it('should produce parseable JSON for all event types', () => { + const events = [ + () => emitError('error'), + () => emitStart({ id: 'p1', name: 'p' }, { id: 's1', name: 's', cwd: '/' }), + () => emitDocumentStart('doc', 0, 1), + () => emitTaskStart('doc', 0), + () => emitTaskComplete('doc', 0, true, 'ok', 100), + () => emitDocumentComplete('doc', 1), + () => emitLoopComplete(1, 1, 100), + () => emitComplete(true, 1, 100), + () => emitGroup({ id: 'g1', name: 'g', emoji: '', collapsed: false }), + () => emitAgent({ id: 'a1', name: 'a', toolType: 't', cwd: '/' }), + () => emitPlaybook({ id: 'p1', name: 'p', sessionId: 's1', documents: [], loopEnabled: false }), + ]; + + events.forEach((emitFn, index) => { + consoleSpy.mockClear(); + emitFn(); + const output = consoleSpy.mock.calls[0][0]; + expect(() => JSON.parse(output), `Event at index ${index} should produce valid JSON`).not.toThrow(); + }); + }); + }); + + describe('edge cases', () => { + it('should handle unicode characters', () => { + emitError('错误: 发生了问题 🔥'); + + const output = consoleSpy.mock.calls[0][0]; + const parsed = JSON.parse(output); + + expect(parsed.message).toBe('错误: 发生了问题 🔥'); + }); + + it('should handle very long strings', () => { + const longString = 'a'.repeat(10000); + emitError(longString); + + const output = consoleSpy.mock.calls[0][0]; + const parsed = JSON.parse(output); + + expect(parsed.message).toBe(longString); + }); + + it('should handle special JSON characters in strings', () => { + emitError('Backslash: \\ Quote: " Tab: \t Newline: \n'); + + const output = consoleSpy.mock.calls[0][0]; + const parsed = JSON.parse(output); + + expect(parsed.message).toContain('\\'); + expect(parsed.message).toContain('"'); + expect(parsed.message).toContain('\t'); + expect(parsed.message).toContain('\n'); + }); + + it('should handle negative numbers', () => { + // This tests that negative numbers are properly serialized + emitTaskComplete('doc', -1, true, 'ok', -100); + + const output = consoleSpy.mock.calls[0][0]; + const parsed = JSON.parse(output); + + expect(parsed.taskIndex).toBe(-1); + expect(parsed.elapsedMs).toBe(-100); + }); + + it('should handle floating point numbers', () => { + emitComplete(true, 10, 1000, 0.123456789); + + const output = consoleSpy.mock.calls[0][0]; + const parsed = JSON.parse(output); + + expect(parsed.totalCost).toBe(0.123456789); + }); + }); +}); diff --git a/src/__tests__/cli/services/agent-spawner.test.ts b/src/__tests__/cli/services/agent-spawner.test.ts new file mode 100644 index 00000000..5ce60c89 --- /dev/null +++ b/src/__tests__/cli/services/agent-spawner.test.ts @@ -0,0 +1,1255 @@ +/** + * @file agent-spawner.test.ts + * @description Tests for the agent-spawner CLI service + * + * Tests all exported functions and internal utilities: + * - Document reading and task counting + * - Document reading and task extraction + * - Checkbox manipulation (uncheckAllTasks) + * - Document writing + * - Claude detection and spawning + * - UUID generation + * - PATH expansion + * - Executable detection + */ + +import { describe, it, expect, vi, beforeEach, afterEach, type Mock } from 'vitest'; +import * as fs from 'fs'; +import * as os from 'os'; +import { EventEmitter } from 'events'; + +// Create mock spawn function at module level +const mockSpawn = vi.fn(); +const mockStdin = { + end: vi.fn(), +}; +const mockStdout = new EventEmitter(); +const mockStderr = new EventEmitter(); +const mockChild = Object.assign(new EventEmitter(), { + stdin: mockStdin, + stdout: mockStdout, + stderr: mockStderr, +}); + +// Mock child_process before imports +vi.mock('child_process', async (importOriginal) => { + const actual = await importOriginal(); + return { + ...actual, + spawn: (...args: unknown[]) => mockSpawn(...args), + default: { + ...actual, + spawn: (...args: unknown[]) => mockSpawn(...args), + }, + }; +}); + +// Mock fs module +vi.mock('fs', async (importOriginal) => { + const actual = await importOriginal(); + return { + ...actual, + readFileSync: vi.fn(), + writeFileSync: vi.fn(), + promises: { + stat: vi.fn(), + access: vi.fn(), + }, + constants: { + X_OK: 1, + }, + }; +}); + +// Mock os module +vi.mock('os', () => ({ + homedir: vi.fn(() => '/Users/testuser'), +})); + +// Mock storage service +const mockGetAgentCustomPath = vi.fn(); +vi.mock('../../../cli/services/storage', () => ({ + getAgentCustomPath: (...args: unknown[]) => mockGetAgentCustomPath(...args), +})); + +import { + readDocAndCountTasks, + readDocAndGetTasks, + uncheckAllTasks, + writeDoc, + getClaudeCommand, + detectClaude, + spawnAgent, + AgentResult, +} from '../../../cli/services/agent-spawner'; + +describe('agent-spawner', () => { + beforeEach(() => { + vi.clearAllMocks(); + // Reset mock child emitter for each test + mockStdout.removeAllListeners(); + mockStderr.removeAllListeners(); + (mockChild as EventEmitter).removeAllListeners(); + mockGetAgentCustomPath.mockReturnValue(undefined); + }); + + afterEach(() => { + vi.restoreAllMocks(); + }); + + describe('readDocAndCountTasks', () => { + it('should count unchecked tasks in a document', () => { + vi.mocked(fs.readFileSync).mockReturnValue(` +# Task List + +- [ ] First task +- [ ] Second task +- [x] Completed task +- [ ] Third task + `); + + const result = readDocAndCountTasks('/playbooks', 'tasks'); + + expect(result.taskCount).toBe(3); + expect(result.content).toContain('First task'); + }); + + it('should return zero count for document with no unchecked tasks', () => { + vi.mocked(fs.readFileSync).mockReturnValue(` +# Task List + +- [x] Completed task +- [x] Another completed + `); + + const result = readDocAndCountTasks('/playbooks', 'tasks'); + + expect(result.taskCount).toBe(0); + }); + + it('should return empty content and zero count when file does not exist', () => { + vi.mocked(fs.readFileSync).mockImplementation(() => { + throw new Error('ENOENT'); + }); + + const result = readDocAndCountTasks('/playbooks', 'missing'); + + expect(result.content).toBe(''); + expect(result.taskCount).toBe(0); + }); + + it('should handle various checkbox formats', () => { + vi.mocked(fs.readFileSync).mockReturnValue(` +- [ ] Basic unchecked + - [ ] Nested unchecked + - [ ] Deeply nested +- [ ] Extra spaces after checkbox + `); + + const result = readDocAndCountTasks('/playbooks', 'tasks'); + + expect(result.taskCount).toBe(4); + }); + + it('should append .md extension to filename', () => { + vi.mocked(fs.readFileSync).mockReturnValue('- [ ] Task'); + + readDocAndCountTasks('/playbooks', 'tasks'); + + expect(fs.readFileSync).toHaveBeenCalledWith('/playbooks/tasks.md', 'utf-8'); + }); + + it('should handle document with only whitespace', () => { + vi.mocked(fs.readFileSync).mockReturnValue(' \n \n '); + + const result = readDocAndCountTasks('/playbooks', 'empty'); + + expect(result.taskCount).toBe(0); + expect(result.content).toBe(' \n \n '); + }); + + it('should count tasks with varying indentation levels', () => { + vi.mocked(fs.readFileSync).mockReturnValue(` +- [ ] No indent + - [ ] One space + - [ ] Two spaces + - [ ] Three spaces + - [ ] Four spaces + `); + + const result = readDocAndCountTasks('/playbooks', 'indented'); + + expect(result.taskCount).toBe(5); + }); + + it('should not count tasks with text before checkbox', () => { + vi.mocked(fs.readFileSync).mockReturnValue(` +text - [ ] This should not count +- [ ] This should count + `); + + const result = readDocAndCountTasks('/playbooks', 'mixed'); + + // The regex only matches lines starting with optional whitespace then - + expect(result.taskCount).toBe(1); + }); + + it('should count empty checkbox tasks', () => { + vi.mocked(fs.readFileSync).mockReturnValue(` +- [ ] +- [ ] Task with content + `); + + const result = readDocAndCountTasks('/playbooks', 'empty-tasks'); + + // Empty checkbox line might not match due to regex requiring content + // Let's verify behavior + expect(result.taskCount).toBeGreaterThanOrEqual(1); + }); + }); + + describe('readDocAndGetTasks', () => { + it('should extract task text from unchecked items', () => { + vi.mocked(fs.readFileSync).mockReturnValue(` +# Task List + +- [ ] First task +- [ ] Second task with details +- [x] Completed task (should not appear) +- [ ] Third task + `); + + const result = readDocAndGetTasks('/playbooks', 'tasks'); + + expect(result.tasks).toEqual([ + 'First task', + 'Second task with details', + 'Third task', + ]); + }); + + it('should return empty array for document with no unchecked tasks', () => { + vi.mocked(fs.readFileSync).mockReturnValue(` +# All Done! + +- [x] Completed + `); + + const result = readDocAndGetTasks('/playbooks', 'tasks'); + + expect(result.tasks).toEqual([]); + }); + + it('should return empty content and tasks when file does not exist', () => { + vi.mocked(fs.readFileSync).mockImplementation(() => { + throw new Error('ENOENT'); + }); + + const result = readDocAndGetTasks('/playbooks', 'missing'); + + expect(result.content).toBe(''); + expect(result.tasks).toEqual([]); + }); + + it('should trim task text properly', () => { + vi.mocked(fs.readFileSync).mockReturnValue(` +- [ ] Task with leading spaces +- [ ] Task with trailing spaces + `); + + const result = readDocAndGetTasks('/playbooks', 'tasks'); + + expect(result.tasks[0]).toBe('Task with leading spaces'); + expect(result.tasks[1]).toBe('Task with trailing spaces'); + }); + + it('should preserve task content with special characters', () => { + vi.mocked(fs.readFileSync).mockReturnValue(` +- [ ] Task with "quotes" and 'apostrophes' +- [ ] Task with code: \`npm install\` +- [ ] Task with **bold** and *italic* +- [ ] Task with emoji 🚀 + `); + + const result = readDocAndGetTasks('/playbooks', 'special'); + + expect(result.tasks).toHaveLength(4); + expect(result.tasks[0]).toContain('"quotes"'); + expect(result.tasks[3]).toContain('🚀'); + }); + + it('should handle nested tasks', () => { + vi.mocked(fs.readFileSync).mockReturnValue(` +- [ ] Parent task + - [ ] Child task + - [ ] Grandchild task + `); + + const result = readDocAndGetTasks('/playbooks', 'nested'); + + expect(result.tasks).toEqual([ + 'Parent task', + 'Child task', + 'Grandchild task', + ]); + }); + + it('should append .md extension to filename', () => { + vi.mocked(fs.readFileSync).mockReturnValue('- [ ] Task'); + + readDocAndGetTasks('/playbooks', 'tasks'); + + expect(fs.readFileSync).toHaveBeenCalledWith('/playbooks/tasks.md', 'utf-8'); + }); + }); + + describe('uncheckAllTasks', () => { + it('should uncheck all checked tasks', () => { + const content = ` +# Task List + +- [x] First completed +- [X] Second completed (uppercase) +- [ ] Already unchecked +- [x] Third completed + `; + + const result = uncheckAllTasks(content); + + expect(result).not.toContain('[x]'); + expect(result).not.toContain('[X]'); + expect(result.match(/\[ \]/g)?.length).toBe(4); + }); + + it('should preserve indentation', () => { + const content = ` + - [x] Indented task + - [x] Nested task + `; + + const result = uncheckAllTasks(content); + + expect(result).toContain(' - [ ] Indented task'); + expect(result).toContain(' - [ ] Nested task'); + }); + + it('should not modify non-list checkbox patterns', () => { + const content = ` +# Title + +Some text with [x] in it that's not a checkbox + +- [x] Real checkbox + `; + + const result = uncheckAllTasks(content); + + // The inline [x] should not be changed - only list item checkboxes + expect(result).toContain('# Title'); + expect(result).toContain('Some text with [x] in it'); + expect(result).toContain('- [ ] Real checkbox'); + }); + + it('should handle empty content', () => { + expect(uncheckAllTasks('')).toBe(''); + }); + + it('should handle content with no checkboxes', () => { + const content = '# Just a title\n\nSome text'; + expect(uncheckAllTasks(content)).toBe(content); + }); + + it('should handle mixed checked and unchecked tasks', () => { + const content = ` +- [x] Done +- [ ] Not done +- [X] Also done +- [ ] Also not done + `; + + const result = uncheckAllTasks(content); + + // All should be unchecked now + const checkboxMatches = result.match(/- \[.\]/g) || []; + expect(checkboxMatches.every(m => m === '- [ ]')).toBe(true); + }); + + it('should handle multiline content correctly', () => { + const content = `# Project Tasks + +## Phase 1 +- [x] Setup repository +- [x] Initialize project +- [ ] Configure CI/CD + +## Phase 2 +- [x] Implement feature A +- [ ] Implement feature B +- [x] Write tests +`; + + const result = uncheckAllTasks(content); + + expect(result).toContain('## Phase 1'); + expect(result).toContain('## Phase 2'); + expect(result).not.toContain('[x]'); + expect(result).not.toContain('[X]'); + }); + + it('should preserve other markdown formatting', () => { + const content = ` +**Bold text** +*Italic text* +\`code\` +> Blockquote +- [x] Task + +1. Numbered item +2. Another item + `; + + const result = uncheckAllTasks(content); + + expect(result).toContain('**Bold text**'); + expect(result).toContain('*Italic text*'); + expect(result).toContain('`code`'); + expect(result).toContain('> Blockquote'); + expect(result).toContain('1. Numbered item'); + }); + + it('should handle Windows line endings', () => { + const content = '- [x] Task 1\r\n- [x] Task 2\r\n'; + + const result = uncheckAllTasks(content); + + expect(result).toContain('- [ ] Task 1'); + expect(result).toContain('- [ ] Task 2'); + }); + + it('should handle tasks with no space after checkbox', () => { + // Edge case: malformed checkbox + const content = '- [x]Task without space'; + + const result = uncheckAllTasks(content); + + // The regex requires - [x] pattern at line start + expect(result).toContain('- [ ]Task without space'); + }); + }); + + describe('writeDoc', () => { + it('should write content to file', () => { + writeDoc('/playbooks', 'tasks.md', '# New Content'); + + expect(fs.writeFileSync).toHaveBeenCalledWith( + '/playbooks/tasks.md', + '# New Content', + 'utf-8' + ); + }); + + it('should write to correct path', () => { + writeDoc('/path/to/folder', 'doc.md', 'content'); + + expect(fs.writeFileSync).toHaveBeenCalledWith( + '/path/to/folder/doc.md', + 'content', + 'utf-8' + ); + }); + + it('should handle empty content', () => { + writeDoc('/playbooks', 'empty.md', ''); + + expect(fs.writeFileSync).toHaveBeenCalledWith( + '/playbooks/empty.md', + '', + 'utf-8' + ); + }); + + it('should handle content with special characters', () => { + const content = '# Title\n\n- [ ] Task with "quotes" and \'apostrophes\' and `code`'; + + writeDoc('/playbooks', 'special.md', content); + + expect(fs.writeFileSync).toHaveBeenCalledWith( + '/playbooks/special.md', + content, + 'utf-8' + ); + }); + + it('should handle unicode content', () => { + const content = '# 任务列表\n\n- [ ] 任务一 🚀'; + + writeDoc('/playbooks', 'unicode.md', content); + + expect(fs.writeFileSync).toHaveBeenCalledWith( + '/playbooks/unicode.md', + content, + 'utf-8' + ); + }); + + it('should concatenate folder and filename with slash', () => { + writeDoc('/some/path', 'file.md', 'content'); + + const calledPath = (fs.writeFileSync as Mock).mock.calls[0][0]; + expect(calledPath).toBe('/some/path/file.md'); + }); + }); + + describe('getClaudeCommand', () => { + it('should return a non-empty string', () => { + const command = getClaudeCommand(); + expect(typeof command).toBe('string'); + expect(command.length).toBeGreaterThan(0); + }); + + it('should return default command when no cached path', () => { + // Before any detection is done, should return default 'claude' + const command = getClaudeCommand(); + // Either 'claude' or a cached path + expect(command).toBeTruthy(); + }); + }); + + describe('detectClaude', () => { + beforeEach(() => { + // Reset the cached path by reimporting + vi.resetModules(); + }); + + it('should detect Claude with custom path from settings', async () => { + // Mock custom path from settings + mockGetAgentCustomPath.mockReturnValue('/custom/path/to/claude'); + + // Mock file exists and is executable + vi.mocked(fs.promises.stat).mockResolvedValue({ + isFile: () => true, + } as fs.Stats); + vi.mocked(fs.promises.access).mockResolvedValue(undefined); + + // Re-import to get fresh module without cached path + const { detectClaude: freshDetectClaude } = await import('../../../cli/services/agent-spawner'); + + const result = await freshDetectClaude(); + + expect(result.available).toBe(true); + expect(result.path).toBe('/custom/path/to/claude'); + expect(result.source).toBe('settings'); + }); + + it('should fall back to PATH detection when custom path is invalid', async () => { + // Mock custom path from settings + mockGetAgentCustomPath.mockReturnValue('/invalid/path/to/claude'); + + // Mock file does not exist + vi.mocked(fs.promises.stat).mockRejectedValue(new Error('ENOENT')); + + // Mock which command finding claude + mockSpawn.mockReturnValue(mockChild); + + // Re-import to get fresh module + const { detectClaude: freshDetectClaude } = await import('../../../cli/services/agent-spawner'); + + const resultPromise = freshDetectClaude(); + + // Simulate which finding claude + await new Promise(resolve => setTimeout(resolve, 0)); + mockStdout.emit('data', Buffer.from('/usr/local/bin/claude\n')); + await new Promise(resolve => setTimeout(resolve, 0)); + mockChild.emit('close', 0); + + const result = await resultPromise; + + expect(result.available).toBe(true); + expect(result.path).toBe('/usr/local/bin/claude'); + expect(result.source).toBe('path'); + }); + + it('should return unavailable when Claude is not found', async () => { + // No custom path + mockGetAgentCustomPath.mockReturnValue(undefined); + + // Mock which command not finding claude + mockSpawn.mockReturnValue(mockChild); + + // Re-import to get fresh module + vi.resetModules(); + const { detectClaude: freshDetectClaude } = await import('../../../cli/services/agent-spawner'); + + const resultPromise = freshDetectClaude(); + + // Simulate which not finding claude + await new Promise(resolve => setTimeout(resolve, 0)); + mockChild.emit('close', 1); + + const result = await resultPromise; + + expect(result.available).toBe(false); + expect(result.path).toBeUndefined(); + }); + + it('should handle which command error', async () => { + mockGetAgentCustomPath.mockReturnValue(undefined); + mockSpawn.mockReturnValue(mockChild); + + vi.resetModules(); + const { detectClaude: freshDetectClaude } = await import('../../../cli/services/agent-spawner'); + + const resultPromise = freshDetectClaude(); + + // Simulate error event + await new Promise(resolve => setTimeout(resolve, 0)); + mockChild.emit('error', new Error('spawn error')); + + const result = await resultPromise; + + expect(result.available).toBe(false); + }); + + it('should return cached result on subsequent calls', async () => { + // First call - setup + mockGetAgentCustomPath.mockReturnValue('/custom/path/to/claude'); + vi.mocked(fs.promises.stat).mockResolvedValue({ + isFile: () => true, + } as fs.Stats); + vi.mocked(fs.promises.access).mockResolvedValue(undefined); + + vi.resetModules(); + const { detectClaude: freshDetectClaude } = await import('../../../cli/services/agent-spawner'); + + const result1 = await freshDetectClaude(); + expect(result1.available).toBe(true); + + // Clear the mock to verify caching + vi.mocked(fs.promises.stat).mockClear(); + + // Second call - should use cache + const result2 = await freshDetectClaude(); + expect(result2.available).toBe(true); + expect(result2.source).toBe('settings'); + + // stat should not be called again (cached) + // Note: Due to how caching works, if path is cached, isExecutable isn't rechecked + }); + + it('should reject non-file paths', async () => { + mockGetAgentCustomPath.mockReturnValue('/path/to/directory'); + + // Mock stat returning directory + vi.mocked(fs.promises.stat).mockResolvedValue({ + isFile: () => false, + } as fs.Stats); + + // Mock which not finding claude + mockSpawn.mockReturnValue(mockChild); + + vi.resetModules(); + const { detectClaude: freshDetectClaude } = await import('../../../cli/services/agent-spawner'); + + const resultPromise = freshDetectClaude(); + + // which command won't find it either + await new Promise(resolve => setTimeout(resolve, 0)); + mockChild.emit('close', 1); + + const result = await resultPromise; + + expect(result.available).toBe(false); + }); + + it('should reject non-executable files on Unix', async () => { + // Save original platform + const originalPlatform = process.platform; + Object.defineProperty(process, 'platform', { value: 'linux', configurable: true }); + + mockGetAgentCustomPath.mockReturnValue('/path/to/claude'); + + // Mock file exists but is not executable + vi.mocked(fs.promises.stat).mockResolvedValue({ + isFile: () => true, + } as fs.Stats); + vi.mocked(fs.promises.access).mockRejectedValue(new Error('EACCES')); + + // Mock which not finding claude + mockSpawn.mockReturnValue(mockChild); + + vi.resetModules(); + const { detectClaude: freshDetectClaude } = await import('../../../cli/services/agent-spawner'); + + const resultPromise = freshDetectClaude(); + + await new Promise(resolve => setTimeout(resolve, 0)); + mockChild.emit('close', 1); + + const result = await resultPromise; + + // Restore platform + Object.defineProperty(process, 'platform', { value: originalPlatform, configurable: true }); + + expect(result.available).toBe(false); + }); + }); + + describe('spawnAgent', () => { + beforeEach(() => { + mockSpawn.mockReturnValue(mockChild); + }); + + it('should spawn Claude with correct arguments', async () => { + const resultPromise = spawnAgent('/project/path', 'Test prompt'); + + // Let the async operations start + await new Promise(resolve => setTimeout(resolve, 0)); + + // Verify spawn was called + expect(mockSpawn).toHaveBeenCalled(); + const [cmd, args, options] = mockSpawn.mock.calls[0]; + + // Command should be 'claude' or cached path + expect(cmd).toBeTruthy(); + + // Should have base args + session-id + prompt + expect(args).toContain('--print'); + expect(args).toContain('--verbose'); + expect(args).toContain('--output-format'); + expect(args).toContain('stream-json'); + expect(args).toContain('--dangerously-skip-permissions'); + expect(args).toContain('--session-id'); + expect(args).toContain('--'); + expect(args).toContain('Test prompt'); + + // Options + expect(options.cwd).toBe('/project/path'); + expect(options.env.PATH).toBeDefined(); + + // Complete the spawn + mockStdout.emit('data', Buffer.from('{"type":"result","result":"Success"}\n')); + await new Promise(resolve => setTimeout(resolve, 0)); + mockChild.emit('close', 0); + + const result = await resultPromise; + expect(result.success).toBe(true); + }); + + it('should use --resume for existing session', async () => { + const resultPromise = spawnAgent('/project/path', 'Test prompt', 'existing-session-id'); + + await new Promise(resolve => setTimeout(resolve, 0)); + + const [, args] = mockSpawn.mock.calls[0]; + expect(args).toContain('--resume'); + expect(args).toContain('existing-session-id'); + expect(args).not.toContain('--session-id'); + + // Complete + mockStdout.emit('data', Buffer.from('{"type":"result","result":"Done"}\n')); + await new Promise(resolve => setTimeout(resolve, 0)); + mockChild.emit('close', 0); + + const result = await resultPromise; + expect(result.success).toBe(true); + }); + + it('should parse result from stdout', async () => { + const resultPromise = spawnAgent('/project', 'prompt'); + + await new Promise(resolve => setTimeout(resolve, 0)); + + // Emit result JSON + mockStdout.emit('data', Buffer.from('{"type":"result","result":"The response text"}\n')); + await new Promise(resolve => setTimeout(resolve, 0)); + mockChild.emit('close', 0); + + const result = await resultPromise; + + expect(result.success).toBe(true); + expect(result.response).toBe('The response text'); + }); + + it('should capture session_id from stdout', async () => { + const resultPromise = spawnAgent('/project', 'prompt'); + + await new Promise(resolve => setTimeout(resolve, 0)); + + // Emit session_id and result + mockStdout.emit('data', Buffer.from('{"session_id":"abc-123"}\n')); + mockStdout.emit('data', Buffer.from('{"type":"result","result":"Done"}\n')); + await new Promise(resolve => setTimeout(resolve, 0)); + mockChild.emit('close', 0); + + const result = await resultPromise; + + expect(result.success).toBe(true); + expect(result.claudeSessionId).toBe('abc-123'); + }); + + it('should parse usage statistics from modelUsage', async () => { + const resultPromise = spawnAgent('/project', 'prompt'); + + await new Promise(resolve => setTimeout(resolve, 0)); + + // Emit usage stats + mockStdout.emit('data', Buffer.from(JSON.stringify({ + modelUsage: { + 'claude-3': { + inputTokens: 100, + outputTokens: 50, + cacheReadInputTokens: 20, + cacheCreationInputTokens: 10, + contextWindow: 200000, + }, + }, + total_cost_usd: 0.05, + }) + '\n')); + mockStdout.emit('data', Buffer.from('{"type":"result","result":"Done"}\n')); + await new Promise(resolve => setTimeout(resolve, 0)); + mockChild.emit('close', 0); + + const result = await resultPromise; + + expect(result.success).toBe(true); + expect(result.usageStats).toEqual({ + inputTokens: 100, + outputTokens: 50, + cacheReadInputTokens: 20, + cacheCreationInputTokens: 10, + totalCostUsd: 0.05, + contextWindow: 200000, + }); + }); + + it('should parse usage statistics from usage field', async () => { + const resultPromise = spawnAgent('/project', 'prompt'); + + await new Promise(resolve => setTimeout(resolve, 0)); + + // Emit usage stats via 'usage' field + mockStdout.emit('data', Buffer.from(JSON.stringify({ + usage: { + input_tokens: 200, + output_tokens: 100, + cache_read_input_tokens: 30, + cache_creation_input_tokens: 15, + }, + total_cost_usd: 0.08, + }) + '\n')); + mockStdout.emit('data', Buffer.from('{"type":"result","result":"Done"}\n')); + await new Promise(resolve => setTimeout(resolve, 0)); + mockChild.emit('close', 0); + + const result = await resultPromise; + + expect(result.usageStats?.inputTokens).toBe(200); + expect(result.usageStats?.outputTokens).toBe(100); + }); + + it('should aggregate usage from multiple models', async () => { + const resultPromise = spawnAgent('/project', 'prompt'); + + await new Promise(resolve => setTimeout(resolve, 0)); + + mockStdout.emit('data', Buffer.from(JSON.stringify({ + modelUsage: { + 'model-a': { + inputTokens: 100, + outputTokens: 50, + }, + 'model-b': { + inputTokens: 200, + outputTokens: 100, + contextWindow: 300000, + }, + }, + total_cost_usd: 0.1, + }) + '\n')); + mockStdout.emit('data', Buffer.from('{"type":"result","result":"Done"}\n')); + await new Promise(resolve => setTimeout(resolve, 0)); + mockChild.emit('close', 0); + + const result = await resultPromise; + + expect(result.usageStats?.inputTokens).toBe(300); // 100 + 200 + expect(result.usageStats?.outputTokens).toBe(150); // 50 + 100 + expect(result.usageStats?.contextWindow).toBe(300000); // Larger window + }); + + it('should return error on non-zero exit code', async () => { + const resultPromise = spawnAgent('/project', 'prompt'); + + await new Promise(resolve => setTimeout(resolve, 0)); + + // Emit stderr + mockStderr.emit('data', Buffer.from('Error: Something went wrong\n')); + await new Promise(resolve => setTimeout(resolve, 0)); + mockChild.emit('close', 1); + + const result = await resultPromise; + + expect(result.success).toBe(false); + expect(result.error).toContain('Something went wrong'); + }); + + it('should return error when no result and non-zero exit', async () => { + const resultPromise = spawnAgent('/project', 'prompt'); + + await new Promise(resolve => setTimeout(resolve, 0)); + mockChild.emit('close', 1); + + const result = await resultPromise; + + expect(result.success).toBe(false); + expect(result.error).toContain('Process exited with code 1'); + }); + + it('should handle spawn error', async () => { + const resultPromise = spawnAgent('/project', 'prompt'); + + await new Promise(resolve => setTimeout(resolve, 0)); + mockChild.emit('error', new Error('spawn ENOENT')); + + const result = await resultPromise; + + expect(result.success).toBe(false); + expect(result.error).toContain('Failed to spawn Claude'); + expect(result.error).toContain('spawn ENOENT'); + }); + + it('should close stdin immediately', async () => { + const resultPromise = spawnAgent('/project', 'prompt'); + + await new Promise(resolve => setTimeout(resolve, 0)); + + expect(mockStdin.end).toHaveBeenCalled(); + + mockStdout.emit('data', Buffer.from('{"type":"result","result":"Done"}\n')); + mockChild.emit('close', 0); + + await resultPromise; + }); + + it('should handle partial JSON lines (buffering)', async () => { + const resultPromise = spawnAgent('/project', 'prompt'); + + await new Promise(resolve => setTimeout(resolve, 0)); + + // Send data in chunks + mockStdout.emit('data', Buffer.from('{"type":"result",')); + mockStdout.emit('data', Buffer.from('"result":"Complete"}\n')); + await new Promise(resolve => setTimeout(resolve, 0)); + mockChild.emit('close', 0); + + const result = await resultPromise; + + expect(result.success).toBe(true); + expect(result.response).toBe('Complete'); + }); + + it('should ignore non-JSON lines', async () => { + const resultPromise = spawnAgent('/project', 'prompt'); + + await new Promise(resolve => setTimeout(resolve, 0)); + + // Mix of JSON and non-JSON + mockStdout.emit('data', Buffer.from('Some debug output\n')); + mockStdout.emit('data', Buffer.from('{"type":"result","result":"Done"}\n')); + mockStdout.emit('data', Buffer.from('More output\n')); + await new Promise(resolve => setTimeout(resolve, 0)); + mockChild.emit('close', 0); + + const result = await resultPromise; + + expect(result.success).toBe(true); + expect(result.response).toBe('Done'); + }); + + it('should only capture first result', async () => { + const resultPromise = spawnAgent('/project', 'prompt'); + + await new Promise(resolve => setTimeout(resolve, 0)); + + // Multiple results + mockStdout.emit('data', Buffer.from('{"type":"result","result":"First"}\n')); + mockStdout.emit('data', Buffer.from('{"type":"result","result":"Second"}\n')); + await new Promise(resolve => setTimeout(resolve, 0)); + mockChild.emit('close', 0); + + const result = await resultPromise; + + expect(result.response).toBe('First'); + }); + + it('should only capture first session_id', async () => { + const resultPromise = spawnAgent('/project', 'prompt'); + + await new Promise(resolve => setTimeout(resolve, 0)); + + mockStdout.emit('data', Buffer.from('{"session_id":"first-id"}\n')); + mockStdout.emit('data', Buffer.from('{"session_id":"second-id"}\n')); + mockStdout.emit('data', Buffer.from('{"type":"result","result":"Done"}\n')); + await new Promise(resolve => setTimeout(resolve, 0)); + mockChild.emit('close', 0); + + const result = await resultPromise; + + expect(result.claudeSessionId).toBe('first-id'); + }); + + it('should preserve session_id and usageStats on error', async () => { + const resultPromise = spawnAgent('/project', 'prompt'); + + await new Promise(resolve => setTimeout(resolve, 0)); + + mockStdout.emit('data', Buffer.from('{"session_id":"error-session"}\n')); + mockStdout.emit('data', Buffer.from('{"total_cost_usd":0.01}\n')); + mockStderr.emit('data', Buffer.from('Error!\n')); + await new Promise(resolve => setTimeout(resolve, 0)); + mockChild.emit('close', 1); + + const result = await resultPromise; + + expect(result.success).toBe(false); + expect(result.claudeSessionId).toBe('error-session'); + expect(result.usageStats?.totalCostUsd).toBe(0.01); + }); + + it('should handle empty lines in output', async () => { + const resultPromise = spawnAgent('/project', 'prompt'); + + await new Promise(resolve => setTimeout(resolve, 0)); + + mockStdout.emit('data', Buffer.from('\n\n{"type":"result","result":"Done"}\n\n')); + await new Promise(resolve => setTimeout(resolve, 0)); + mockChild.emit('close', 0); + + const result = await resultPromise; + + expect(result.success).toBe(true); + }); + + it('should handle success without result field', async () => { + const resultPromise = spawnAgent('/project', 'prompt'); + + await new Promise(resolve => setTimeout(resolve, 0)); + + // No result emitted, but process exits cleanly + mockChild.emit('close', 0); + + const result = await resultPromise; + + // Without a result, success is false even with exit code 0 + expect(result.success).toBe(false); + }); + + it('should include expanded PATH in environment', async () => { + const resultPromise = spawnAgent('/project', 'prompt'); + + await new Promise(resolve => setTimeout(resolve, 0)); + + const [, , options] = mockSpawn.mock.calls[0]; + const pathEnv = options.env.PATH; + + // Should include common paths + expect(pathEnv).toContain('/opt/homebrew/bin'); + expect(pathEnv).toContain('/usr/local/bin'); + expect(pathEnv).toContain('/Users/testuser/.local/bin'); + + mockStdout.emit('data', Buffer.from('{"type":"result","result":"Done"}\n')); + mockChild.emit('close', 0); + + await resultPromise; + }); + + it('should generate unique session-id for each spawn', async () => { + // First spawn + const promise1 = spawnAgent('/project', 'prompt1'); + await new Promise(resolve => setTimeout(resolve, 0)); + const args1 = mockSpawn.mock.calls[0][1]; + + mockStdout.emit('data', Buffer.from('{"type":"result","result":"Done"}\n')); + mockChild.emit('close', 0); + await promise1; + + // Reset emitters + mockStdout.removeAllListeners(); + mockStderr.removeAllListeners(); + (mockChild as EventEmitter).removeAllListeners(); + mockSpawn.mockClear(); + mockSpawn.mockReturnValue(mockChild); + + // Second spawn + const promise2 = spawnAgent('/project', 'prompt2'); + await new Promise(resolve => setTimeout(resolve, 0)); + const args2 = mockSpawn.mock.calls[0][1]; + + mockStdout.emit('data', Buffer.from('{"type":"result","result":"Done"}\n')); + mockChild.emit('close', 0); + await promise2; + + // Extract session IDs + const sessionIdIndex1 = args1.indexOf('--session-id'); + const sessionIdIndex2 = args2.indexOf('--session-id'); + + if (sessionIdIndex1 !== -1 && sessionIdIndex2 !== -1) { + const id1 = args1[sessionIdIndex1 + 1]; + const id2 = args2[sessionIdIndex2 + 1]; + + // UUIDs should be different + expect(id1).not.toBe(id2); + // Should be valid UUID format + expect(id1).toMatch(/^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/); + expect(id2).toMatch(/^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/); + } + }); + }); + + describe('PATH expansion (via spawnAgent)', () => { + beforeEach(() => { + mockSpawn.mockReturnValue(mockChild); + }); + + it('should include homebrew paths', async () => { + const resultPromise = spawnAgent('/project', 'prompt'); + await new Promise(resolve => setTimeout(resolve, 0)); + + const pathEnv = mockSpawn.mock.calls[0][2].env.PATH; + expect(pathEnv).toContain('/opt/homebrew/bin'); + expect(pathEnv).toContain('/opt/homebrew/sbin'); + + mockStdout.emit('data', Buffer.from('{"type":"result","result":"Done"}\n')); + mockChild.emit('close', 0); + await resultPromise; + }); + + it('should include user home paths', async () => { + const resultPromise = spawnAgent('/project', 'prompt'); + await new Promise(resolve => setTimeout(resolve, 0)); + + const pathEnv = mockSpawn.mock.calls[0][2].env.PATH; + expect(pathEnv).toContain('/Users/testuser/.local/bin'); + expect(pathEnv).toContain('/Users/testuser/.npm-global/bin'); + expect(pathEnv).toContain('/Users/testuser/bin'); + expect(pathEnv).toContain('/Users/testuser/.claude/local'); + + mockStdout.emit('data', Buffer.from('{"type":"result","result":"Done"}\n')); + mockChild.emit('close', 0); + await resultPromise; + }); + + it('should include system paths', async () => { + const resultPromise = spawnAgent('/project', 'prompt'); + await new Promise(resolve => setTimeout(resolve, 0)); + + const pathEnv = mockSpawn.mock.calls[0][2].env.PATH; + expect(pathEnv).toContain('/usr/bin'); + expect(pathEnv).toContain('/bin'); + expect(pathEnv).toContain('/usr/sbin'); + expect(pathEnv).toContain('/sbin'); + expect(pathEnv).toContain('/usr/local/bin'); + expect(pathEnv).toContain('/usr/local/sbin'); + + mockStdout.emit('data', Buffer.from('{"type":"result","result":"Done"}\n')); + mockChild.emit('close', 0); + await resultPromise; + }); + + it('should not duplicate existing paths', async () => { + // Set PATH to include a path that would be added + const originalPath = process.env.PATH; + process.env.PATH = '/opt/homebrew/bin:/usr/bin'; + + const resultPromise = spawnAgent('/project', 'prompt'); + await new Promise(resolve => setTimeout(resolve, 0)); + + const pathEnv = mockSpawn.mock.calls[0][2].env.PATH; + + // Count occurrences of /opt/homebrew/bin + const parts = pathEnv.split(':'); + const homebrewCount = parts.filter((p: string) => p === '/opt/homebrew/bin').length; + + // Should only appear once + expect(homebrewCount).toBe(1); + + // Restore + process.env.PATH = originalPath; + + mockStdout.emit('data', Buffer.from('{"type":"result","result":"Done"}\n')); + mockChild.emit('close', 0); + await resultPromise; + }); + }); + + describe('platform-specific behavior', () => { + it('should use where command on Windows for findClaudeInPath', async () => { + const originalPlatform = process.platform; + Object.defineProperty(process, 'platform', { value: 'win32', configurable: true }); + + mockGetAgentCustomPath.mockReturnValue(undefined); + mockSpawn.mockReturnValue(mockChild); + + vi.resetModules(); + const { detectClaude: freshDetectClaude } = await import('../../../cli/services/agent-spawner'); + + const resultPromise = freshDetectClaude(); + + await new Promise(resolve => setTimeout(resolve, 0)); + + // On Windows, 'where' should be used + const command = mockSpawn.mock.calls[0][0]; + expect(command).toBe('where'); + + mockChild.emit('close', 1); + await resultPromise; + + Object.defineProperty(process, 'platform', { value: originalPlatform, configurable: true }); + }); + + it('should use which command on Unix', async () => { + const originalPlatform = process.platform; + Object.defineProperty(process, 'platform', { value: 'darwin', configurable: true }); + + mockGetAgentCustomPath.mockReturnValue(undefined); + mockSpawn.mockReturnValue(mockChild); + + vi.resetModules(); + const { detectClaude: freshDetectClaude } = await import('../../../cli/services/agent-spawner'); + + const resultPromise = freshDetectClaude(); + + await new Promise(resolve => setTimeout(resolve, 0)); + + const command = mockSpawn.mock.calls[0][0]; + expect(command).toBe('which'); + + mockChild.emit('close', 1); + await resultPromise; + + Object.defineProperty(process, 'platform', { value: originalPlatform, configurable: true }); + }); + + it('should skip X_OK check on Windows', async () => { + const originalPlatform = process.platform; + Object.defineProperty(process, 'platform', { value: 'win32', configurable: true }); + + mockGetAgentCustomPath.mockReturnValue('C:\\Program Files\\claude\\claude.exe'); + vi.mocked(fs.promises.stat).mockResolvedValue({ + isFile: () => true, + } as fs.Stats); + // Don't mock access - it shouldn't be called on Windows + + vi.resetModules(); + const { detectClaude: freshDetectClaude } = await import('../../../cli/services/agent-spawner'); + + const result = await freshDetectClaude(); + + // On Windows, just checking if it's a file is enough + expect(result.available).toBe(true); + expect(fs.promises.access).not.toHaveBeenCalled(); + + Object.defineProperty(process, 'platform', { value: originalPlatform, configurable: true }); + }); + }); +}); diff --git a/src/__tests__/cli/services/batch-processor.test.ts b/src/__tests__/cli/services/batch-processor.test.ts new file mode 100644 index 00000000..17b54f3c --- /dev/null +++ b/src/__tests__/cli/services/batch-processor.test.ts @@ -0,0 +1,1052 @@ +/** + * @file batch-processor.test.ts + * @description Tests for the CLI batch processor service + * + * Tests the runPlaybook async generator function which: + * - Processes playbooks and yields JSONL events + * - Handles dry-run mode + * - Tracks task completion and usage statistics + * - Supports loop iteration with various exit conditions + * - Writes history entries + * - Resets documents on completion + * + * Internal helper functions tested indirectly through generator output: + * - parseSynopsis: Parse synopsis response into summary and full text + * - generateUUID: Generate UUID strings + * - formatLoopDuration: Format milliseconds to human-readable duration + * - getGitBranch: Get current git branch + * - isGitRepo: Check if directory is a git repo + */ + +import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'; +import * as childProcess from 'child_process'; +import type { SessionInfo, Playbook, UsageStats } from '../../../shared/types'; +import type { JsonlEvent } from '../../../cli/output/jsonl'; + +// Mock child_process with hoisted mock +vi.mock('child_process', () => { + const mockExecFileSync = vi.fn(); + return { + execFileSync: mockExecFileSync, + default: { execFileSync: mockExecFileSync }, + }; +}); + +// Mock agent-spawner +vi.mock('../../../cli/services/agent-spawner', () => ({ + spawnAgent: vi.fn(), + readDocAndCountTasks: vi.fn(), + readDocAndGetTasks: vi.fn(), + uncheckAllTasks: vi.fn(), + writeDoc: vi.fn(), +})); + +// Mock storage +vi.mock('../../../cli/services/storage', () => ({ + addHistoryEntry: vi.fn(), + readGroups: vi.fn(), +})); + +// Mock cli-activity +vi.mock('../../../shared/cli-activity', () => ({ + registerCliActivity: vi.fn(), + updateCliActivity: vi.fn(), + unregisterCliActivity: vi.fn(), +})); + +// Import after mocks +import { runPlaybook } from '../../../cli/services/batch-processor'; +import { + spawnAgent, + readDocAndCountTasks, + readDocAndGetTasks, + uncheckAllTasks, + writeDoc, +} from '../../../cli/services/agent-spawner'; +import { addHistoryEntry, readGroups } from '../../../cli/services/storage'; +import { + registerCliActivity, + unregisterCliActivity, +} from '../../../shared/cli-activity'; + +describe('batch-processor', () => { + // Helper to create mock session + const mockSession = (overrides: Partial = {}): SessionInfo => ({ + id: 'session-123', + name: 'Test Session', + toolType: 'claude-code', + cwd: '/path/to/project', + projectRoot: '/path/to/project', + groupId: 'group-456', + ...overrides, + }); + + // Helper to create mock playbook + const mockPlaybook = (overrides: Partial = {}): Playbook => ({ + id: 'playbook-789', + name: 'Test Playbook', + prompt: 'Process the task', + documents: [{ filename: 'tasks', resetOnCompletion: false }], + loopEnabled: false, + ...overrides, + }); + + // Helper to collect all events from async generator + async function collectEvents( + generator: AsyncGenerator + ): Promise { + const events: JsonlEvent[] = []; + for await (const event of generator) { + events.push(event); + } + return events; + } + + beforeEach(() => { + vi.clearAllMocks(); + + // Default mock implementations + vi.mocked(childProcess.execFileSync).mockReturnValue('main'); + vi.mocked(readGroups).mockReturnValue([ + { id: 'group-456', name: 'Test Group', emoji: '🧪', collapsed: false }, + ]); + // By default, return 0 tasks to prevent infinite loops + vi.mocked(readDocAndCountTasks).mockReturnValue({ content: '', taskCount: 0 }); + vi.mocked(readDocAndGetTasks).mockReturnValue({ content: '', tasks: [] }); + vi.mocked(spawnAgent).mockResolvedValue({ + success: true, + response: 'Task completed', + claudeSessionId: 'claude-session-123', + }); + vi.mocked(uncheckAllTasks).mockImplementation((content) => content.replace(/\[x\]/gi, '[ ]')); + }); + + afterEach(() => { + vi.restoreAllMocks(); + }); + + describe('runPlaybook - start event', () => { + it('should emit start event with playbook and session info', async () => { + const session = mockSession(); + const playbook = mockPlaybook(); + + const generator = runPlaybook(session, playbook, '/playbooks'); + const events = await collectEvents(generator); + + const startEvent = events.find((e) => e.type === 'start'); + expect(startEvent).toBeDefined(); + expect(startEvent?.playbook).toEqual({ id: playbook.id, name: playbook.name }); + expect(startEvent?.session).toEqual({ + id: session.id, + name: session.name, + cwd: session.cwd, + }); + }); + + it('should register CLI activity on start', async () => { + const session = mockSession(); + const playbook = mockPlaybook(); + + await collectEvents(runPlaybook(session, playbook, '/playbooks')); + + expect(registerCliActivity).toHaveBeenCalledWith( + expect.objectContaining({ + sessionId: session.id, + playbookId: playbook.id, + playbookName: playbook.name, + }) + ); + }); + }); + + describe('runPlaybook - no tasks', () => { + it('should emit error when no unchecked tasks found', async () => { + vi.mocked(readDocAndCountTasks).mockReturnValue({ content: '', taskCount: 0 }); + + const session = mockSession(); + const playbook = mockPlaybook(); + + const events = await collectEvents(runPlaybook(session, playbook, '/playbooks')); + + const errorEvent = events.find((e) => e.type === 'error'); + expect(errorEvent).toBeDefined(); + expect(errorEvent?.message).toBe('No unchecked tasks found in any documents'); + expect(errorEvent?.code).toBe('NO_TASKS'); + }); + + it('should unregister CLI activity when no tasks', async () => { + vi.mocked(readDocAndCountTasks).mockReturnValue({ content: '', taskCount: 0 }); + + const session = mockSession(); + const playbook = mockPlaybook(); + + await collectEvents(runPlaybook(session, playbook, '/playbooks')); + + expect(unregisterCliActivity).toHaveBeenCalledWith(session.id); + }); + }); + + describe('runPlaybook - dry run mode', () => { + it('should emit task_preview events in dry run mode', async () => { + // For dry run, we need tasks to preview + vi.mocked(readDocAndCountTasks).mockReturnValue({ content: '- [ ] Task', taskCount: 1 }); + vi.mocked(readDocAndGetTasks).mockReturnValue({ content: '- [ ] Task', tasks: ['Task'] }); + + const session = mockSession(); + const playbook = mockPlaybook(); + + const events = await collectEvents( + runPlaybook(session, playbook, '/playbooks', { dryRun: true }) + ); + + const taskPreviewEvents = events.filter((e) => e.type === 'task_preview'); + expect(taskPreviewEvents.length).toBeGreaterThan(0); + expect(taskPreviewEvents[0]?.document).toBe('tasks'); + expect(taskPreviewEvents[0]?.task).toBe('Task'); + }); + + it('should emit document_start with dryRun flag', async () => { + vi.mocked(readDocAndCountTasks).mockReturnValue({ content: '', taskCount: 1 }); + vi.mocked(readDocAndGetTasks).mockReturnValue({ content: '', tasks: ['Task'] }); + + const session = mockSession(); + const playbook = mockPlaybook(); + + const events = await collectEvents( + runPlaybook(session, playbook, '/playbooks', { dryRun: true }) + ); + + const docStartEvents = events.filter((e) => e.type === 'document_start'); + expect(docStartEvents[0]?.dryRun).toBe(true); + }); + + it('should emit document_complete with dryRun flag', async () => { + vi.mocked(readDocAndCountTasks).mockReturnValue({ content: '', taskCount: 1 }); + vi.mocked(readDocAndGetTasks).mockReturnValue({ content: '', tasks: ['Task'] }); + + const session = mockSession(); + const playbook = mockPlaybook(); + + const events = await collectEvents( + runPlaybook(session, playbook, '/playbooks', { dryRun: true }) + ); + + const docCompleteEvents = events.filter((e) => e.type === 'document_complete'); + expect(docCompleteEvents[0]?.dryRun).toBe(true); + }); + + it('should emit complete event with wouldProcess count in dry run', async () => { + vi.mocked(readDocAndCountTasks).mockReturnValue({ content: '', taskCount: 3 }); + vi.mocked(readDocAndGetTasks).mockReturnValue({ + content: '', + tasks: ['Task 1', 'Task 2', 'Task 3'], + }); + + const session = mockSession(); + const playbook = mockPlaybook(); + + const events = await collectEvents( + runPlaybook(session, playbook, '/playbooks', { dryRun: true }) + ); + + const completeEvent = events.find((e) => e.type === 'complete'); + expect(completeEvent?.dryRun).toBe(true); + expect(completeEvent?.wouldProcess).toBe(3); + expect(completeEvent?.totalTasksCompleted).toBe(0); + }); + + it('should not call spawnAgent in dry run mode', async () => { + vi.mocked(readDocAndCountTasks).mockReturnValue({ content: '', taskCount: 1 }); + vi.mocked(readDocAndGetTasks).mockReturnValue({ content: '', tasks: ['Task'] }); + + const session = mockSession(); + const playbook = mockPlaybook(); + + await collectEvents(runPlaybook(session, playbook, '/playbooks', { dryRun: true })); + + expect(spawnAgent).not.toHaveBeenCalled(); + }); + + it('should skip documents with no tasks in dry run', async () => { + // First document has no tasks, second has tasks + // In dry run mode, readDocAndGetTasks is called instead of readDocAndCountTasks for the actual scan + vi.mocked(readDocAndCountTasks) + .mockReturnValueOnce({ content: '', taskCount: 0 }) // empty doc initial + .mockReturnValueOnce({ content: '', taskCount: 2 }); // tasks doc initial + vi.mocked(readDocAndGetTasks) + .mockReturnValueOnce({ content: '', tasks: [] }) // empty doc - no tasks + .mockReturnValueOnce({ content: '', tasks: ['Task 1', 'Task 2'] }); // tasks doc + + const session = mockSession(); + const playbook = mockPlaybook({ + documents: [ + { filename: 'empty', resetOnCompletion: false }, + { filename: 'tasks', resetOnCompletion: false }, + ], + }); + + const events = await collectEvents( + runPlaybook(session, playbook, '/playbooks', { dryRun: true }) + ); + + const docStartEvents = events.filter((e) => e.type === 'document_start'); + // Both documents may have start events but only the one with tasks will have previews + const taskPreviewEvents = events.filter((e) => e.type === 'task_preview'); + expect(taskPreviewEvents.length).toBe(2); + expect(taskPreviewEvents.every(e => e.document === 'tasks')).toBe(true); + }); + }); + + describe('runPlaybook - task execution', () => { + it('should emit task_start and task_complete events', async () => { + // Set up mock to simulate one task then completion + // Call 1: Initial scan - 1 task + // Call 2: Processing loop check - 1 task (to enter the loop) + // Call 3: After task completion - 0 tasks + let callCount = 0; + vi.mocked(readDocAndCountTasks).mockImplementation(() => { + callCount++; + if (callCount <= 2) return { content: '- [ ] Task', taskCount: 1 }; + return { content: '', taskCount: 0 }; + }); + + const session = mockSession(); + const playbook = mockPlaybook(); + + const events = await collectEvents(runPlaybook(session, playbook, '/playbooks')); + + const taskStartEvents = events.filter((e) => e.type === 'task_start'); + const taskCompleteEvents = events.filter((e) => e.type === 'task_complete'); + + expect(taskStartEvents.length).toBe(1); + expect(taskCompleteEvents.length).toBe(1); + expect(taskCompleteEvents[0]?.success).toBe(true); + }); + + it('should call spawnAgent with combined prompt and document', async () => { + // readDocAndCountTasks is called multiple times: + // 1. Initial scan for task count + // 2. Processing loop check + // 3. During task execution to get content for prompt + // 4. After task to check remaining tasks + let callCount = 0; + vi.mocked(readDocAndCountTasks).mockImplementation(() => { + callCount++; + // Return task content for all calls during processing (calls 1-3) + // Call 4 (after processing) returns 0 tasks + if (callCount <= 3) { + return { content: '- [ ] My task', taskCount: 1 }; + } + return { content: '', taskCount: 0 }; + }); + + const session = mockSession(); + // Use a prompt without template variables to test the basic prompt + document combination + const playbook = mockPlaybook({ prompt: 'Custom prompt for processing' }); + + await collectEvents(runPlaybook(session, playbook, '/playbooks')); + + expect(spawnAgent).toHaveBeenCalled(); + const promptArg = vi.mocked(spawnAgent).mock.calls[0][1]; + expect(promptArg).toContain('Custom prompt for processing'); + expect(promptArg).toContain('My task'); + }); + + it('should track usage statistics', async () => { + const usageStats: UsageStats = { + inputTokens: 1000, + outputTokens: 500, + cacheReadInputTokens: 0, + cacheCreationInputTokens: 0, + totalCostUsd: 0.05, + contextWindow: 200000, + }; + + let callCount = 0; + vi.mocked(readDocAndCountTasks).mockImplementation(() => { + callCount++; + if (callCount <= 2) return { content: '- [ ] Task', taskCount: 1 }; + return { content: '', taskCount: 0 }; + }); + + vi.mocked(spawnAgent).mockResolvedValue({ + success: true, + response: 'Done', + usageStats, + }); + + const session = mockSession(); + const playbook = mockPlaybook(); + + const events = await collectEvents(runPlaybook(session, playbook, '/playbooks')); + + const taskCompleteEvent = events.find((e) => e.type === 'task_complete'); + expect(taskCompleteEvent?.usageStats).toEqual(usageStats); + + const completeEvent = events.find((e) => e.type === 'complete'); + expect(completeEvent?.totalCost).toBe(0.05); + }); + + it('should handle task failure', async () => { + let callCount = 0; + vi.mocked(readDocAndCountTasks).mockImplementation(() => { + callCount++; + if (callCount <= 2) return { content: '- [ ] Task', taskCount: 1 }; + return { content: '', taskCount: 0 }; + }); + + vi.mocked(spawnAgent).mockResolvedValue({ + success: false, + error: 'Agent error occurred', + }); + + const session = mockSession(); + const playbook = mockPlaybook(); + + const events = await collectEvents(runPlaybook(session, playbook, '/playbooks')); + + const taskCompleteEvent = events.find((e) => e.type === 'task_complete'); + expect(taskCompleteEvent?.success).toBe(false); + expect(taskCompleteEvent?.fullResponse).toContain('Agent error occurred'); + }); + }); + + describe('runPlaybook - synopsis parsing', () => { + it('should parse synopsis with summary and details', async () => { + // Mock needs proper counts: initial scan + processing scan + after task + let callCount = 0; + vi.mocked(readDocAndCountTasks).mockImplementation(() => { + callCount++; + if (callCount <= 2) return { content: '- [ ] Task', taskCount: 1 }; + return { content: '', taskCount: 0 }; + }); + + // First call is main task, second call is synopsis request + vi.mocked(spawnAgent) + .mockResolvedValueOnce({ + success: true, + response: 'Task done', + claudeSessionId: 'session-123', + }) + .mockResolvedValueOnce({ + success: true, + response: `**Summary:** Fixed the authentication bug + +**Details:** Updated the login handler to properly validate tokens and handle edge cases.`, + }); + + const session = mockSession(); + const playbook = mockPlaybook(); + + const events = await collectEvents(runPlaybook(session, playbook, '/playbooks')); + + const taskCompleteEvent = events.find((e) => e.type === 'task_complete'); + expect(taskCompleteEvent?.summary).toBe('Fixed the authentication bug'); + expect(taskCompleteEvent?.fullResponse).toContain( + 'Updated the login handler to properly validate tokens' + ); + }); + + it('should handle synopsis without details section', async () => { + let callCount = 0; + vi.mocked(readDocAndCountTasks).mockImplementation(() => { + callCount++; + if (callCount <= 2) return { content: '- [ ] Task', taskCount: 1 }; + return { content: '', taskCount: 0 }; + }); + + vi.mocked(spawnAgent) + .mockResolvedValueOnce({ + success: true, + response: 'Task done', + claudeSessionId: 'session-123', + }) + .mockResolvedValueOnce({ + success: true, + response: '**Summary:** No changes made.', + }); + + const session = mockSession(); + const playbook = mockPlaybook(); + + const events = await collectEvents(runPlaybook(session, playbook, '/playbooks')); + + const taskCompleteEvent = events.find((e) => e.type === 'task_complete'); + expect(taskCompleteEvent?.summary).toBe('No changes made.'); + }); + + it('should handle synopsis with ANSI codes and box drawing chars', async () => { + let callCount = 0; + vi.mocked(readDocAndCountTasks).mockImplementation(() => { + callCount++; + if (callCount <= 2) return { content: '- [ ] Task', taskCount: 1 }; + return { content: '', taskCount: 0 }; + }); + + vi.mocked(spawnAgent) + .mockResolvedValueOnce({ + success: true, + response: 'Done', + claudeSessionId: 'session-123', + }) + .mockResolvedValueOnce({ + success: true, + response: + '\x1b[32m───────────────────\x1b[0m\n│**Summary:** Test summary│\n└──────────────────┘', + }); + + const session = mockSession(); + const playbook = mockPlaybook(); + + const events = await collectEvents(runPlaybook(session, playbook, '/playbooks')); + + const taskCompleteEvent = events.find((e) => e.type === 'task_complete'); + expect(taskCompleteEvent?.summary).toBe('Test summary'); + }); + }); + + describe('runPlaybook - history writing', () => { + it('should write history entry for each completed task', async () => { + // Mock sequence: + // Call 1: Initial scan - 1 task + // Call 2: Processing scan - 1 task (enter processing loop) + // Call 3: After spawn agent - 0 tasks (task completed) + let callCount = 0; + vi.mocked(readDocAndCountTasks).mockImplementation(() => { + callCount++; + if (callCount <= 2) return { content: '- [ ] Task', taskCount: 1 }; + return { content: '', taskCount: 0 }; + }); + + const session = mockSession(); + const playbook = mockPlaybook(); + + await collectEvents( + runPlaybook(session, playbook, '/playbooks', { writeHistory: true }) + ); + + expect(addHistoryEntry).toHaveBeenCalled(); + const historyEntry = vi.mocked(addHistoryEntry).mock.calls[0][0]; + expect(historyEntry).toMatchObject({ + type: 'AUTO', + projectPath: session.cwd, + sessionId: session.id, + success: true, + }); + }); + + it('should not write history when writeHistory is false', async () => { + let callCount = 0; + vi.mocked(readDocAndCountTasks).mockImplementation(() => { + callCount++; + if (callCount <= 2) return { content: '- [ ] Task', taskCount: 1 }; + return { content: '', taskCount: 0 }; + }); + + const session = mockSession(); + const playbook = mockPlaybook(); + + await collectEvents( + runPlaybook(session, playbook, '/playbooks', { writeHistory: false }) + ); + + expect(addHistoryEntry).not.toHaveBeenCalled(); + }); + }); + + describe('runPlaybook - document reset', () => { + it('should reset document when resetOnCompletion is true', async () => { + // Mock pattern: initial scan, processing scan, after task completion + let callCount = 0; + vi.mocked(readDocAndCountTasks).mockImplementation(() => { + callCount++; + // Call 1: Initial scan - 1 task + // Call 2: Processing scan - 1 task to enter loop + // Call 3: After task - 0 tasks (triggers reset) + // Call 4: After reset check - shows reset count + if (callCount <= 2) return { content: '- [ ] Task', taskCount: 1 }; + return { content: '- [x] Done', taskCount: 0 }; + }); + + const session = mockSession(); + const playbook = mockPlaybook({ + documents: [{ filename: 'tasks', resetOnCompletion: true }], + }); + + await collectEvents(runPlaybook(session, playbook, '/playbooks')); + + expect(uncheckAllTasks).toHaveBeenCalled(); + expect(writeDoc).toHaveBeenCalledWith('/playbooks', 'tasks.md', expect.any(String)); + }); + + it('should not reset document when resetOnCompletion is false', async () => { + let callCount = 0; + vi.mocked(readDocAndCountTasks).mockImplementation(() => { + callCount++; + if (callCount <= 2) return { content: '- [ ] Task', taskCount: 1 }; + return { content: '', taskCount: 0 }; + }); + + const session = mockSession(); + const playbook = mockPlaybook({ + documents: [{ filename: 'tasks', resetOnCompletion: false }], + }); + + await collectEvents(runPlaybook(session, playbook, '/playbooks')); + + // uncheckAllTasks should not be called for reset + expect(uncheckAllTasks).not.toHaveBeenCalled(); + }); + }); + + describe('runPlaybook - debug mode', () => { + it('should emit debug events when debug is true', async () => { + vi.mocked(readDocAndCountTasks).mockReturnValue({ content: '', taskCount: 0 }); + + const session = mockSession(); + const playbook = mockPlaybook(); + + const events = await collectEvents( + runPlaybook(session, playbook, '/playbooks', { debug: true }) + ); + + const debugEvents = events.filter((e) => e.type === 'debug'); + expect(debugEvents.length).toBeGreaterThan(0); + expect(debugEvents[0]?.category).toBe('config'); + }); + + it('should emit debug scan events for each document', async () => { + vi.mocked(readDocAndCountTasks).mockReturnValue({ content: '', taskCount: 2 }); + vi.mocked(readDocAndGetTasks).mockReturnValue({ content: '', tasks: ['T1', 'T2'] }); + + const session = mockSession(); + const playbook = mockPlaybook({ + documents: [ + { filename: 'doc1', resetOnCompletion: false }, + { filename: 'doc2', resetOnCompletion: false }, + ], + }); + + const events = await collectEvents( + runPlaybook(session, playbook, '/playbooks', { debug: true, dryRun: true }) + ); + + const scanEvents = events.filter( + (e) => e.type === 'debug' && e.category === 'scan' + ); + expect(scanEvents.length).toBeGreaterThanOrEqual(2); + }); + + it('should include history_write debug event when history is written', async () => { + let callCount = 0; + vi.mocked(readDocAndCountTasks).mockImplementation(() => { + callCount++; + if (callCount <= 2) return { content: '- [ ] Task', taskCount: 1 }; + return { content: '', taskCount: 0 }; + }); + + const session = mockSession(); + const playbook = mockPlaybook(); + + const events = await collectEvents( + runPlaybook(session, playbook, '/playbooks', { debug: true, writeHistory: true }) + ); + + const historyWriteEvent = events.find( + (e) => e.type === 'history_write' + ); + expect(historyWriteEvent).toBeDefined(); + expect(historyWriteEvent?.entryId).toBeDefined(); + }); + }); + + describe('runPlaybook - verbose mode', () => { + it('should emit verbose events with full prompt when verbose is true', async () => { + let callCount = 0; + vi.mocked(readDocAndCountTasks).mockImplementation(() => { + callCount++; + if (callCount <= 2) return { content: '- [ ] Task', taskCount: 1 }; + return { content: '', taskCount: 0 }; + }); + + const session = mockSession(); + const playbook = mockPlaybook({ prompt: 'Process this task' }); + + const events = await collectEvents( + runPlaybook(session, playbook, '/playbooks', { verbose: true }) + ); + + const verboseEvent = events.find((e) => e.type === 'verbose'); + expect(verboseEvent).toBeDefined(); + expect(verboseEvent?.category).toBe('prompt'); + expect(verboseEvent?.prompt).toContain('Process this task'); + }); + }); + + describe('runPlaybook - loop mode', () => { + it('should not loop when loopEnabled is false', async () => { + let callCount = 0; + vi.mocked(readDocAndCountTasks).mockImplementation(() => { + callCount++; + if (callCount <= 2) return { content: '- [ ] Task', taskCount: 1 }; + return { content: '', taskCount: 0 }; + }); + + const session = mockSession(); + const playbook = mockPlaybook({ loopEnabled: false }); + + const events = await collectEvents(runPlaybook(session, playbook, '/playbooks')); + + // Should only have one loop iteration - no loop_complete events + const loopCompleteEvents = events.filter((e) => e.type === 'loop_complete'); + expect(loopCompleteEvents.length).toBe(0); + }); + + // NOTE: Testing maxLoops limit is skipped because the async generator + // requires careful mock coordination to simulate proper task completion + // patterns across multiple loop iterations without causing memory issues. + it.skip('should respect maxLoops limit', async () => { + // Test skipped - requires complex mock state management + }); + + it('should exit when all non-reset documents have no tasks', async () => { + let callCount = 0; + vi.mocked(readDocAndCountTasks).mockImplementation(() => { + callCount++; + // Call 1: Initial scan - 1 task + // Call 2: Processing scan - 1 task + // Call 3+: After processing - 0 tasks + if (callCount <= 2) return { content: '- [ ] Task', taskCount: 1 }; + return { content: '', taskCount: 0 }; + }); + + const session = mockSession(); + const playbook = mockPlaybook({ + loopEnabled: true, + documents: [{ filename: 'tasks', resetOnCompletion: false }], + }); + + const events = await collectEvents( + runPlaybook(session, playbook, '/playbooks', { debug: true }) + ); + + // Should exit due to all tasks completed + const exitDebug = events.find( + (e) => + e.type === 'debug' && + (e.message?.includes('all non-reset documents have 0 remaining tasks') || + e.message?.includes('All tasks completed')) + ); + expect(exitDebug).toBeDefined(); + }); + + it('should exit when all documents have resetOnCompletion', async () => { + let callCount = 0; + vi.mocked(readDocAndCountTasks).mockImplementation(() => { + callCount++; + if (callCount <= 2) return { content: '- [ ] Task', taskCount: 1 }; + return { content: '', taskCount: 0 }; + }); + + const session = mockSession(); + const playbook = mockPlaybook({ + loopEnabled: true, + documents: [{ filename: 'tasks', resetOnCompletion: true }], + }); + + const events = await collectEvents( + runPlaybook(session, playbook, '/playbooks', { debug: true }) + ); + + // Should exit because all docs are reset docs + const exitDebug = events.find( + (e) => + e.type === 'debug' && + e.message?.includes('ALL documents have resetOnCompletion=true') + ); + expect(exitDebug).toBeDefined(); + }); + }); + + describe('runPlaybook - git integration', () => { + it('should get git branch from cwd', async () => { + vi.mocked(childProcess.execFileSync).mockReturnValue('feature-branch\n'); + vi.mocked(readDocAndCountTasks).mockReturnValue({ content: '', taskCount: 0 }); + + const session = mockSession(); + const playbook = mockPlaybook(); + + await collectEvents(runPlaybook(session, playbook, '/playbooks')); + + expect(childProcess.execFileSync).toHaveBeenCalledWith( + 'git', + ['rev-parse', '--abbrev-ref', 'HEAD'], + expect.objectContaining({ cwd: session.cwd }) + ); + }); + + it('should handle non-git directory gracefully', async () => { + vi.mocked(childProcess.execFileSync).mockImplementation(() => { + throw new Error('not a git repository'); + }); + vi.mocked(readDocAndCountTasks).mockReturnValue({ content: '', taskCount: 0 }); + + const session = mockSession(); + const playbook = mockPlaybook(); + + // Should not throw + const events = await collectEvents(runPlaybook(session, playbook, '/playbooks')); + + // Should still emit events + const startEvent = events.find((e) => e.type === 'start'); + expect(startEvent).toBeDefined(); + }); + }); + + describe('runPlaybook - template variables', () => { + it('should include session info in prompt context', async () => { + // Template variable substitution is handled by substituteTemplateVariables from shared module + // The actual substitution happens internally; we verify the prompt includes session data + let callCount = 0; + vi.mocked(readDocAndCountTasks).mockImplementation(() => { + callCount++; + if (callCount <= 2) return { content: '- [ ] Task', taskCount: 1 }; + return { content: '', taskCount: 0 }; + }); + + const session = mockSession({ name: 'My Session', cwd: '/path/to/project' }); + const playbook = mockPlaybook({ + prompt: 'Process the task in this session', + }); + + await collectEvents(runPlaybook(session, playbook, '/playbooks')); + + // Verify spawnAgent was called at least once with session cwd + // First call is the main task (no session ID), second call is synopsis (with session ID) + expect(spawnAgent).toHaveBeenCalled(); + const firstCall = vi.mocked(spawnAgent).mock.calls[0]; + expect(firstCall[0]).toBe(session.cwd); + expect(firstCall[1]).toContain('Process the task in this session'); + }); + + it('should include group name in template context', async () => { + vi.mocked(readGroups).mockReturnValue([ + { id: 'my-group', name: 'Development', emoji: '🚀', collapsed: false }, + ]); + + let callCount = 0; + vi.mocked(readDocAndCountTasks).mockImplementation(() => { + callCount++; + if (callCount <= 2) return { content: '- [ ] Task', taskCount: 1 }; + return { content: '', taskCount: 0 }; + }); + + const session = mockSession({ groupId: 'my-group' }); + const playbook = mockPlaybook({ prompt: 'Group: ${group.name}' }); + + await collectEvents(runPlaybook(session, playbook, '/playbooks')); + + // Verify readGroups was called to get group info + expect(readGroups).toHaveBeenCalled(); + }); + }); + + describe('runPlaybook - complete event', () => { + it('should emit complete event with totals', async () => { + const usageStats: UsageStats = { + inputTokens: 1000, + outputTokens: 500, + cacheReadInputTokens: 0, + cacheCreationInputTokens: 0, + totalCostUsd: 0.05, + contextWindow: 200000, + }; + + let callCount = 0; + vi.mocked(readDocAndCountTasks).mockImplementation(() => { + callCount++; + if (callCount <= 2) return { content: '- [ ] Task', taskCount: 1 }; + return { content: '', taskCount: 0 }; + }); + + vi.mocked(spawnAgent).mockResolvedValue({ + success: true, + response: 'Done', + usageStats, + }); + + const session = mockSession(); + const playbook = mockPlaybook(); + + const events = await collectEvents(runPlaybook(session, playbook, '/playbooks')); + + const completeEvent = events.find((e) => e.type === 'complete'); + expect(completeEvent).toBeDefined(); + expect(completeEvent?.success).toBe(true); + expect(completeEvent?.totalTasksCompleted).toBeGreaterThanOrEqual(1); + expect(completeEvent?.totalElapsedMs).toBeGreaterThanOrEqual(0); + expect(completeEvent?.totalCost).toBe(0.05); + }); + + it('should unregister CLI activity on complete', async () => { + let callCount = 0; + vi.mocked(readDocAndCountTasks).mockImplementation(() => { + callCount++; + if (callCount <= 2) return { content: '- [ ] Task', taskCount: 1 }; + return { content: '', taskCount: 0 }; + }); + + const session = mockSession(); + const playbook = mockPlaybook(); + + await collectEvents(runPlaybook(session, playbook, '/playbooks')); + + expect(unregisterCliActivity).toHaveBeenCalledWith(session.id); + }); + }); + + describe('runPlaybook - multiple documents', () => { + it('should process multiple documents in order', async () => { + // Mock for two documents: initial scan for both, then processing + let callCount = 0; + vi.mocked(readDocAndCountTasks).mockImplementation(() => { + callCount++; + // Calls 1-2: Initial scan for doc1 and doc2 + // Call 3: Processing check for doc1 - has tasks + // Call 4: After task - no more tasks in doc1 + // Call 5: Processing check for doc2 - has tasks + // Call 6: After task - no more tasks in doc2 + if (callCount <= 3) return { content: '- [ ] Task', taskCount: 1 }; + return { content: '', taskCount: 0 }; + }); + + const session = mockSession(); + const playbook = mockPlaybook({ + documents: [ + { filename: 'doc1', resetOnCompletion: false }, + { filename: 'doc2', resetOnCompletion: false }, + ], + }); + + const events = await collectEvents(runPlaybook(session, playbook, '/playbooks')); + + const docStartEvents = events.filter((e) => e.type === 'document_start'); + expect(docStartEvents.length).toBeGreaterThanOrEqual(1); + }); + }); + + describe('internal functions - generateUUID', () => { + // Test UUID generation indirectly through history entries + it('should generate valid UUIDs for history entries', async () => { + let callCount = 0; + vi.mocked(readDocAndCountTasks).mockImplementation(() => { + callCount++; + if (callCount <= 2) return { content: '- [ ] Task', taskCount: 1 }; + return { content: '', taskCount: 0 }; + }); + + const session = mockSession(); + const playbook = mockPlaybook(); + + await collectEvents( + runPlaybook(session, playbook, '/playbooks', { writeHistory: true }) + ); + + expect(addHistoryEntry).toHaveBeenCalled(); + const historyEntry = vi.mocked(addHistoryEntry).mock.calls[0][0]; + + // UUID v4 format validation + const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i; + expect(historyEntry.id).toMatch(uuidRegex); + }); + }); + + describe('edge cases', () => { + it('should handle empty document list', async () => { + const session = mockSession(); + const playbook = mockPlaybook({ documents: [] }); + + vi.mocked(readDocAndCountTasks).mockReturnValue({ content: '', taskCount: 0 }); + + const events = await collectEvents(runPlaybook(session, playbook, '/playbooks')); + + const errorEvent = events.find((e) => e.type === 'error'); + expect(errorEvent).toBeDefined(); + expect(errorEvent?.code).toBe('NO_TASKS'); + }); + + it('should handle spawnAgent returning no claudeSessionId', async () => { + let callCount = 0; + vi.mocked(readDocAndCountTasks).mockImplementation(() => { + callCount++; + if (callCount <= 2) return { content: '- [ ] Task', taskCount: 1 }; + return { content: '', taskCount: 0 }; + }); + + vi.mocked(spawnAgent).mockResolvedValue({ + success: true, + response: 'Done', + // No claudeSessionId - synopsis won't be requested + }); + + const session = mockSession(); + const playbook = mockPlaybook(); + + const events = await collectEvents(runPlaybook(session, playbook, '/playbooks')); + + // Should still complete successfully + const completeEvent = events.find((e) => e.type === 'complete'); + expect(completeEvent?.success).toBe(true); + }); + + it('should handle template expansion in document content', async () => { + let callCount = 0; + vi.mocked(readDocAndCountTasks).mockImplementation(() => { + callCount++; + if (callCount === 1) { + // Initial scan with template + return { content: '- [ ] Deploy to ${session.cwd}', taskCount: 1 }; + } + if (callCount === 2) { + // Processing scan - still has task + return { content: '- [ ] Deploy to /path/to/project', taskCount: 1 }; + } + // After template substitution and task completion + return { content: '', taskCount: 0 }; + }); + + const session = mockSession({ cwd: '/path/to/project' }); + const playbook = mockPlaybook(); + + const events = await collectEvents(runPlaybook(session, playbook, '/playbooks')); + + // Should complete successfully + const completeEvent = events.find((e) => e.type === 'complete'); + expect(completeEvent?.success).toBe(true); + }); + + it('should handle safety check for no tasks processed in a loop iteration', async () => { + let callCount = 0; + vi.mocked(readDocAndCountTasks).mockImplementation(() => { + callCount++; + // Initial scan shows tasks, but processing shows none - triggers safety exit + if (callCount === 1) return { content: '', taskCount: 1 }; + return { content: '', taskCount: 0 }; + }); + + const session = mockSession(); + const playbook = mockPlaybook({ + loopEnabled: true, + documents: [{ filename: 'tasks', resetOnCompletion: false }], + }); + + const events = await collectEvents( + runPlaybook(session, playbook, '/playbooks', { debug: true }) + ); + + // Should complete without infinite loop + const completeEvent = events.find((e) => e.type === 'complete'); + expect(completeEvent).toBeDefined(); + }); + }); +}); diff --git a/src/__tests__/cli/services/playbooks.test.ts b/src/__tests__/cli/services/playbooks.test.ts new file mode 100644 index 00000000..c83e239b --- /dev/null +++ b/src/__tests__/cli/services/playbooks.test.ts @@ -0,0 +1,691 @@ +/** + * @file playbooks.test.ts + * @description Tests for the playbooks CLI service + * + * Tests all functionality of the playbooks service including: + * - readPlaybooks: Reading playbooks for a session + * - getPlaybook: Getting a specific playbook by ID + * - resolvePlaybookId: Resolving partial playbook IDs + * - findPlaybookById: Finding playbooks across all agents + * - listAllPlaybooks: Listing all playbooks from all sessions + */ + +import { describe, it, expect, vi, beforeEach } from 'vitest'; +import * as fs from 'fs'; +import * as path from 'path'; +import type { Playbook } from '../../../shared/types'; + +// Mock the fs module +vi.mock('fs', () => ({ + readFileSync: vi.fn(), + readdirSync: vi.fn(), + existsSync: vi.fn(), +})); + +// Mock the storage service - must mock getConfigDirectory +vi.mock('../../../cli/services/storage', () => ({ + getConfigDirectory: vi.fn(() => '/mock/config'), +})); + +import { + readPlaybooks, + getPlaybook, + resolvePlaybookId, + findPlaybookById, + listAllPlaybooks, +} from '../../../cli/services/playbooks'; + +describe('playbooks service', () => { + const mockPlaybook = (overrides: Partial = {}): Playbook => ({ + id: 'playbook-123', + name: 'Test Playbook', + createdAt: Date.now(), + updatedAt: Date.now(), + documents: [{ filename: 'doc1.md', resetOnCompletion: false }], + loopEnabled: false, + maxLoops: null, + prompt: 'Test prompt', + ...overrides, + }); + + beforeEach(() => { + vi.clearAllMocks(); + }); + + describe('readPlaybooks', () => { + it('should read playbooks from the correct file path', () => { + const playbook = mockPlaybook(); + vi.mocked(fs.readFileSync).mockReturnValue( + JSON.stringify({ playbooks: [playbook] }) + ); + + const result = readPlaybooks('session-1'); + + expect(fs.readFileSync).toHaveBeenCalledWith( + path.join('/mock/config', 'playbooks', 'session-1.json'), + 'utf-8' + ); + expect(result).toEqual([playbook]); + }); + + it('should return empty array when playbooks array is empty', () => { + vi.mocked(fs.readFileSync).mockReturnValue( + JSON.stringify({ playbooks: [] }) + ); + + const result = readPlaybooks('session-1'); + + expect(result).toEqual([]); + }); + + it('should return empty array when playbooks property is not an array', () => { + vi.mocked(fs.readFileSync).mockReturnValue( + JSON.stringify({ playbooks: 'not-an-array' }) + ); + + const result = readPlaybooks('session-1'); + + expect(result).toEqual([]); + }); + + it('should return empty array when playbooks property is null', () => { + vi.mocked(fs.readFileSync).mockReturnValue( + JSON.stringify({ playbooks: null }) + ); + + const result = readPlaybooks('session-1'); + + expect(result).toEqual([]); + }); + + it('should return empty array when file does not exist (ENOENT)', () => { + const error = new Error('File not found') as NodeJS.ErrnoException; + error.code = 'ENOENT'; + vi.mocked(fs.readFileSync).mockImplementation(() => { + throw error; + }); + + const result = readPlaybooks('session-1'); + + expect(result).toEqual([]); + }); + + it('should throw error for other file system errors', () => { + const error = new Error('Permission denied') as NodeJS.ErrnoException; + error.code = 'EACCES'; + vi.mocked(fs.readFileSync).mockImplementation(() => { + throw error; + }); + + expect(() => readPlaybooks('session-1')).toThrow('Permission denied'); + }); + + it('should return multiple playbooks correctly', () => { + const playbooks = [ + mockPlaybook({ id: 'pb-1', name: 'First' }), + mockPlaybook({ id: 'pb-2', name: 'Second' }), + mockPlaybook({ id: 'pb-3', name: 'Third' }), + ]; + vi.mocked(fs.readFileSync).mockReturnValue( + JSON.stringify({ playbooks }) + ); + + const result = readPlaybooks('session-1'); + + expect(result).toHaveLength(3); + expect(result[0].name).toBe('First'); + expect(result[2].name).toBe('Third'); + }); + }); + + describe('getPlaybook', () => { + it('should return playbook by exact ID match', () => { + const playbook = mockPlaybook({ id: 'exact-id-123' }); + vi.mocked(fs.readFileSync).mockReturnValue( + JSON.stringify({ playbooks: [playbook] }) + ); + + const result = getPlaybook('session-1', 'exact-id-123'); + + expect(result).toEqual(playbook); + }); + + it('should return playbook by prefix match when single match', () => { + const playbooks = [ + mockPlaybook({ id: 'abc-123-xyz' }), + mockPlaybook({ id: 'def-456-xyz' }), + ]; + vi.mocked(fs.readFileSync).mockReturnValue( + JSON.stringify({ playbooks }) + ); + + const result = getPlaybook('session-1', 'abc'); + + expect(result?.id).toBe('abc-123-xyz'); + }); + + it('should return undefined when no match found', () => { + const playbook = mockPlaybook({ id: 'playbook-123' }); + vi.mocked(fs.readFileSync).mockReturnValue( + JSON.stringify({ playbooks: [playbook] }) + ); + + const result = getPlaybook('session-1', 'nonexistent'); + + expect(result).toBeUndefined(); + }); + + it('should return undefined when multiple prefix matches exist', () => { + const playbooks = [ + mockPlaybook({ id: 'test-123' }), + mockPlaybook({ id: 'test-456' }), + ]; + vi.mocked(fs.readFileSync).mockReturnValue( + JSON.stringify({ playbooks }) + ); + + const result = getPlaybook('session-1', 'test'); + + expect(result).toBeUndefined(); + }); + + it('should prefer exact match over prefix match', () => { + const playbooks = [ + mockPlaybook({ id: 'test', name: 'Exact Match' }), + mockPlaybook({ id: 'test-extended', name: 'Prefix Match' }), + ]; + vi.mocked(fs.readFileSync).mockReturnValue( + JSON.stringify({ playbooks }) + ); + + const result = getPlaybook('session-1', 'test'); + + expect(result?.name).toBe('Exact Match'); + }); + + it('should return undefined when playbooks is empty', () => { + vi.mocked(fs.readFileSync).mockReturnValue( + JSON.stringify({ playbooks: [] }) + ); + + const result = getPlaybook('session-1', 'any-id'); + + expect(result).toBeUndefined(); + }); + }); + + describe('resolvePlaybookId', () => { + it('should return exact match ID', () => { + const playbook = mockPlaybook({ id: 'exact-playbook-id' }); + vi.mocked(fs.readFileSync).mockReturnValue( + JSON.stringify({ playbooks: [playbook] }) + ); + + const result = resolvePlaybookId('session-1', 'exact-playbook-id'); + + expect(result).toBe('exact-playbook-id'); + }); + + it('should return ID from single prefix match', () => { + const playbooks = [ + mockPlaybook({ id: 'unique-prefix-123' }), + mockPlaybook({ id: 'different-456' }), + ]; + vi.mocked(fs.readFileSync).mockReturnValue( + JSON.stringify({ playbooks }) + ); + + const result = resolvePlaybookId('session-1', 'unique'); + + expect(result).toBe('unique-prefix-123'); + }); + + it('should throw error when playbook not found', () => { + vi.mocked(fs.readFileSync).mockReturnValue( + JSON.stringify({ playbooks: [] }) + ); + + expect(() => resolvePlaybookId('session-1', 'nonexistent')).toThrow( + 'Playbook not found: nonexistent' + ); + }); + + it('should throw error with match list when ambiguous', () => { + const playbooks = [ + mockPlaybook({ id: 'test-playbook-1', name: 'First Playbook' }), + mockPlaybook({ id: 'test-playbook-2', name: 'Second Playbook' }), + ]; + vi.mocked(fs.readFileSync).mockReturnValue( + JSON.stringify({ playbooks }) + ); + + expect(() => resolvePlaybookId('session-1', 'test')).toThrow( + /Ambiguous playbook ID 'test'/ + ); + }); + + it('should include playbook names and truncated IDs in ambiguous error', () => { + const playbooks = [ + mockPlaybook({ id: 'test-abcdefgh-1', name: 'Alpha Playbook' }), + mockPlaybook({ id: 'test-ijklmnop-2', name: 'Beta Playbook' }), + ]; + vi.mocked(fs.readFileSync).mockReturnValue( + JSON.stringify({ playbooks }) + ); + + try { + resolvePlaybookId('session-1', 'test'); + expect.fail('Should have thrown'); + } catch (error) { + expect((error as Error).message).toContain('test-abc'); + expect((error as Error).message).toContain('Alpha Playbook'); + expect((error as Error).message).toContain('test-ijk'); + expect((error as Error).message).toContain('Beta Playbook'); + } + }); + + it('should show Unknown when playbook name is missing in ambiguous error', () => { + const playbooks = [ + { ...mockPlaybook({ id: 'test-123' }), name: undefined as unknown as string }, + mockPlaybook({ id: 'test-456', name: 'Has Name' }), + ]; + vi.mocked(fs.readFileSync).mockReturnValue( + JSON.stringify({ playbooks }) + ); + + try { + resolvePlaybookId('session-1', 'test'); + expect.fail('Should have thrown'); + } catch (error) { + expect((error as Error).message).toContain('Unknown'); + expect((error as Error).message).toContain('Has Name'); + } + }); + }); + + describe('listAllPlaybooks', () => { + it('should return empty array when playbooks directory does not exist', () => { + vi.mocked(fs.existsSync).mockReturnValue(false); + + const result = listAllPlaybooks(); + + expect(result).toEqual([]); + expect(fs.readdirSync).not.toHaveBeenCalled(); + }); + + it('should list playbooks from all session files', () => { + vi.mocked(fs.existsSync).mockReturnValue(true); + vi.mocked(fs.readdirSync).mockReturnValue([ + 'session-1.json', + 'session-2.json', + ] as unknown as fs.Dirent[]); + + const session1Playbooks = [mockPlaybook({ id: 'pb-1', name: 'Playbook 1' })]; + const session2Playbooks = [ + mockPlaybook({ id: 'pb-2', name: 'Playbook 2' }), + mockPlaybook({ id: 'pb-3', name: 'Playbook 3' }), + ]; + + vi.mocked(fs.readFileSync).mockImplementation((filepath) => { + if (String(filepath).includes('session-1.json')) { + return JSON.stringify({ playbooks: session1Playbooks }); + } + if (String(filepath).includes('session-2.json')) { + return JSON.stringify({ playbooks: session2Playbooks }); + } + throw new Error(`Unexpected file: ${filepath}`); + }); + + const result = listAllPlaybooks(); + + expect(result).toHaveLength(3); + expect(result.map((p) => p.sessionId)).toEqual([ + 'session-1', + 'session-2', + 'session-2', + ]); + }); + + it('should skip non-json files', () => { + vi.mocked(fs.existsSync).mockReturnValue(true); + vi.mocked(fs.readdirSync).mockReturnValue([ + 'session-1.json', + 'readme.txt', + '.hidden', + 'session-2.json', + ] as unknown as fs.Dirent[]); + + vi.mocked(fs.readFileSync).mockImplementation((filepath) => { + if (String(filepath).includes('session-1.json')) { + return JSON.stringify({ playbooks: [mockPlaybook({ id: 'pb-1' })] }); + } + if (String(filepath).includes('session-2.json')) { + return JSON.stringify({ playbooks: [mockPlaybook({ id: 'pb-2' })] }); + } + throw new Error(`Unexpected file read: ${filepath}`); + }); + + const result = listAllPlaybooks(); + + expect(result).toHaveLength(2); + }); + + it('should return empty array on ENOENT error during readdir', () => { + vi.mocked(fs.existsSync).mockReturnValue(true); + const error = new Error('Directory not found') as NodeJS.ErrnoException; + error.code = 'ENOENT'; + vi.mocked(fs.readdirSync).mockImplementation(() => { + throw error; + }); + + const result = listAllPlaybooks(); + + expect(result).toEqual([]); + }); + + it('should throw error for non-ENOENT errors during readdir', () => { + vi.mocked(fs.existsSync).mockReturnValue(true); + const error = new Error('Permission denied') as NodeJS.ErrnoException; + error.code = 'EACCES'; + vi.mocked(fs.readdirSync).mockImplementation(() => { + throw error; + }); + + expect(() => listAllPlaybooks()).toThrow('Permission denied'); + }); + + it('should handle empty playbooks in session files', () => { + vi.mocked(fs.existsSync).mockReturnValue(true); + vi.mocked(fs.readdirSync).mockReturnValue([ + 'session-1.json', + ] as unknown as fs.Dirent[]); + vi.mocked(fs.readFileSync).mockReturnValue( + JSON.stringify({ playbooks: [] }) + ); + + const result = listAllPlaybooks(); + + expect(result).toEqual([]); + }); + + it('should correctly extract session ID from filename', () => { + vi.mocked(fs.existsSync).mockReturnValue(true); + vi.mocked(fs.readdirSync).mockReturnValue([ + 'complex-session-id-123.json', + ] as unknown as fs.Dirent[]); + vi.mocked(fs.readFileSync).mockReturnValue( + JSON.stringify({ playbooks: [mockPlaybook({ id: 'pb-1' })] }) + ); + + const result = listAllPlaybooks(); + + expect(result[0].sessionId).toBe('complex-session-id-123'); + }); + + it('should include all playbook properties plus sessionId', () => { + vi.mocked(fs.existsSync).mockReturnValue(true); + vi.mocked(fs.readdirSync).mockReturnValue([ + 'session-1.json', + ] as unknown as fs.Dirent[]); + + const playbook = mockPlaybook({ + id: 'pb-1', + name: 'My Playbook', + loopEnabled: true, + maxLoops: 5, + prompt: 'Custom prompt', + documents: [ + { filename: 'doc1.md', resetOnCompletion: true }, + { filename: 'doc2.md', resetOnCompletion: false }, + ], + }); + vi.mocked(fs.readFileSync).mockReturnValue( + JSON.stringify({ playbooks: [playbook] }) + ); + + const result = listAllPlaybooks(); + + expect(result[0]).toMatchObject({ + ...playbook, + sessionId: 'session-1', + }); + }); + }); + + describe('findPlaybookById', () => { + it('should find playbook by exact ID match', () => { + vi.mocked(fs.existsSync).mockReturnValue(true); + vi.mocked(fs.readdirSync).mockReturnValue([ + 'session-1.json', + ] as unknown as fs.Dirent[]); + + const playbook = mockPlaybook({ id: 'exact-match-id' }); + vi.mocked(fs.readFileSync).mockReturnValue( + JSON.stringify({ playbooks: [playbook] }) + ); + + const result = findPlaybookById('exact-match-id'); + + expect(result.playbook.id).toBe('exact-match-id'); + expect(result.agentId).toBe('session-1'); + }); + + it('should find playbook by prefix match when single match', () => { + vi.mocked(fs.existsSync).mockReturnValue(true); + vi.mocked(fs.readdirSync).mockReturnValue([ + 'session-1.json', + ] as unknown as fs.Dirent[]); + + const playbooks = [ + mockPlaybook({ id: 'unique-prefix-123' }), + mockPlaybook({ id: 'different-456' }), + ]; + vi.mocked(fs.readFileSync).mockReturnValue( + JSON.stringify({ playbooks }) + ); + + const result = findPlaybookById('unique'); + + expect(result.playbook.id).toBe('unique-prefix-123'); + }); + + it('should throw error when playbook not found', () => { + vi.mocked(fs.existsSync).mockReturnValue(true); + vi.mocked(fs.readdirSync).mockReturnValue([ + 'session-1.json', + ] as unknown as fs.Dirent[]); + vi.mocked(fs.readFileSync).mockReturnValue( + JSON.stringify({ playbooks: [] }) + ); + + expect(() => findPlaybookById('nonexistent')).toThrow( + 'Playbook not found: nonexistent' + ); + }); + + it('should throw error with match list when ambiguous across sessions', () => { + vi.mocked(fs.existsSync).mockReturnValue(true); + vi.mocked(fs.readdirSync).mockReturnValue([ + 'session-1.json', + 'session-2.json', + ] as unknown as fs.Dirent[]); + + vi.mocked(fs.readFileSync).mockImplementation((filepath) => { + if (String(filepath).includes('session-1.json')) { + return JSON.stringify({ + playbooks: [mockPlaybook({ id: 'test-123', name: 'First' })], + }); + } + if (String(filepath).includes('session-2.json')) { + return JSON.stringify({ + playbooks: [mockPlaybook({ id: 'test-456', name: 'Second' })], + }); + } + throw new Error(`Unexpected file: ${filepath}`); + }); + + expect(() => findPlaybookById('test')).toThrow( + /Ambiguous playbook ID 'test'/ + ); + }); + + it('should include playbook names in ambiguous error message', () => { + vi.mocked(fs.existsSync).mockReturnValue(true); + vi.mocked(fs.readdirSync).mockReturnValue([ + 'session-1.json', + ] as unknown as fs.Dirent[]); + + const playbooks = [ + mockPlaybook({ id: 'ambig-1', name: 'Alpha' }), + mockPlaybook({ id: 'ambig-2', name: 'Beta' }), + ]; + vi.mocked(fs.readFileSync).mockReturnValue( + JSON.stringify({ playbooks }) + ); + + try { + findPlaybookById('ambig'); + expect.fail('Should have thrown'); + } catch (error) { + expect((error as Error).message).toContain('Alpha'); + expect((error as Error).message).toContain('Beta'); + } + }); + + it('should throw when no playbooks directory exists', () => { + vi.mocked(fs.existsSync).mockReturnValue(false); + + expect(() => findPlaybookById('any-id')).toThrow( + 'Playbook not found: any-id' + ); + }); + + it('should return correct sessionId from containing file', () => { + vi.mocked(fs.existsSync).mockReturnValue(true); + vi.mocked(fs.readdirSync).mockReturnValue([ + 'agent-abc-123.json', + 'agent-xyz-789.json', + ] as unknown as fs.Dirent[]); + + vi.mocked(fs.readFileSync).mockImplementation((filepath) => { + if (String(filepath).includes('agent-abc-123.json')) { + return JSON.stringify({ playbooks: [] }); + } + if (String(filepath).includes('agent-xyz-789.json')) { + return JSON.stringify({ + playbooks: [mockPlaybook({ id: 'target-playbook' })], + }); + } + throw new Error(`Unexpected file: ${filepath}`); + }); + + const result = findPlaybookById('target-playbook'); + + expect(result.agentId).toBe('agent-xyz-789'); + }); + }); + + describe('edge cases', () => { + it('should handle playbooks with special characters in IDs', () => { + const playbook = mockPlaybook({ id: 'playbook_with-special.chars!123' }); + vi.mocked(fs.readFileSync).mockReturnValue( + JSON.stringify({ playbooks: [playbook] }) + ); + + const result = getPlaybook('session-1', 'playbook_with-special.chars!123'); + + expect(result).toEqual(playbook); + }); + + it('should handle very long playbook IDs', () => { + const longId = 'a'.repeat(200); + const playbook = mockPlaybook({ id: longId }); + vi.mocked(fs.readFileSync).mockReturnValue( + JSON.stringify({ playbooks: [playbook] }) + ); + + const result = resolvePlaybookId('session-1', longId); + + expect(result).toBe(longId); + }); + + it('should handle unicode in playbook names', () => { + const playbook = mockPlaybook({ + id: 'unicode-pb', + name: '日本語プレイブック 🎮', + }); + vi.mocked(fs.readFileSync).mockReturnValue( + JSON.stringify({ playbooks: [playbook] }) + ); + + const result = readPlaybooks('session-1'); + + expect(result[0].name).toBe('日本語プレイブック 🎮'); + }); + + it('should handle playbooks with empty documents array', () => { + const playbook = mockPlaybook({ id: 'pb-1', documents: [] }); + vi.mocked(fs.readFileSync).mockReturnValue( + JSON.stringify({ playbooks: [playbook] }) + ); + + const result = readPlaybooks('session-1'); + + expect(result[0].documents).toEqual([]); + }); + + it('should handle playbooks with worktreeSettings', () => { + const playbook = mockPlaybook({ + id: 'pb-with-worktree', + worktreeSettings: { + branchNameTemplate: 'feature/{{date}}', + createPROnCompletion: true, + prTargetBranch: 'main', + }, + }); + vi.mocked(fs.readFileSync).mockReturnValue( + JSON.stringify({ playbooks: [playbook] }) + ); + + const result = readPlaybooks('session-1'); + + expect(result[0].worktreeSettings).toEqual({ + branchNameTemplate: 'feature/{{date}}', + createPROnCompletion: true, + prTargetBranch: 'main', + }); + }); + + it('should throw SyntaxError when JSON is invalid', () => { + // Direct test of readPlaybooks with invalid JSON + vi.mocked(fs.readFileSync).mockReturnValue('not valid json {'); + + expect(() => readPlaybooks('any-session')).toThrow(SyntaxError); + }); + + it('should propagate JSON parse errors from listAllPlaybooks', () => { + vi.mocked(fs.existsSync).mockReturnValue(true); + vi.mocked(fs.readdirSync).mockReturnValue([ + 'broken-session.json', + ] as unknown as fs.Dirent[]); + vi.mocked(fs.readFileSync).mockReturnValue('invalid { json'); + + expect(() => listAllPlaybooks()).toThrow(SyntaxError); + }); + + it('should handle empty string session ID', () => { + vi.mocked(fs.readFileSync).mockReturnValue( + JSON.stringify({ playbooks: [] }) + ); + + const result = readPlaybooks(''); + + // Should still work, just with empty session ID in path + expect(fs.readFileSync).toHaveBeenCalledWith( + path.join('/mock/config', 'playbooks', '.json'), + 'utf-8' + ); + expect(result).toEqual([]); + }); + }); +}); diff --git a/src/__tests__/cli/services/storage.test.ts b/src/__tests__/cli/services/storage.test.ts new file mode 100644 index 00000000..0cf530ce --- /dev/null +++ b/src/__tests__/cli/services/storage.test.ts @@ -0,0 +1,984 @@ +/** + * @file storage.test.ts + * @description Tests for the CLI storage service + * + * Tests all functionality of the storage service including: + * - Platform-specific config directory detection + * - Reading sessions, groups, history, settings, agent configs + * - Partial ID resolution for agents and groups + * - Session lookup by ID and group + * - History entry writing + */ + +import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'; +import * as fs from 'fs'; +import * as os from 'os'; +import type { Group, SessionInfo, HistoryEntry } from '../../../shared/types'; + +// Store original env values +const originalEnv = { ...process.env }; + +// Mock the fs module +vi.mock('fs', () => ({ + readFileSync: vi.fn(), + writeFileSync: vi.fn(), +})); + +// Mock the os module +vi.mock('os', () => ({ + platform: vi.fn(), + homedir: vi.fn(), +})); + +import { + readSessions, + readGroups, + readHistory, + readSettings, + readAgentConfigs, + getAgentCustomPath, + resolveAgentId, + resolveGroupId, + getSessionById, + getSessionsByGroup, + getConfigDirectory, + addHistoryEntry, +} from '../../../cli/services/storage'; + +describe('storage service', () => { + const mockSession = (overrides: Partial = {}): SessionInfo => ({ + id: 'session-123', + name: 'Test Session', + toolType: 'claude-code', + cwd: '/path/to/project', + projectRoot: '/path/to/project', + ...overrides, + }); + + const mockGroup = (overrides: Partial = {}): Group => ({ + id: 'group-123', + name: 'Test Group', + emoji: '🚀', + collapsed: false, + ...overrides, + }); + + const mockHistoryEntry = (overrides: Partial = {}): HistoryEntry => ({ + id: 'entry-123', + type: 'AUTO', + timestamp: Date.now(), + summary: 'Test entry', + projectPath: '/path/to/project', + ...overrides, + }); + + beforeEach(() => { + vi.clearAllMocks(); + // Reset environment + process.env = { ...originalEnv }; + // Default to macOS + vi.mocked(os.platform).mockReturnValue('darwin'); + vi.mocked(os.homedir).mockReturnValue('/Users/testuser'); + }); + + afterEach(() => { + process.env = { ...originalEnv }; + }); + + describe('getConfigDirectory', () => { + it('should return macOS config path on darwin', () => { + vi.mocked(os.platform).mockReturnValue('darwin'); + vi.mocked(os.homedir).mockReturnValue('/Users/testuser'); + + const result = getConfigDirectory(); + + expect(result).toBe('/Users/testuser/Library/Application Support/Maestro'); + }); + + it('should return Windows config path with APPDATA', () => { + vi.mocked(os.platform).mockReturnValue('win32'); + vi.mocked(os.homedir).mockReturnValue('C:\\Users\\testuser'); + process.env.APPDATA = 'C:\\Users\\testuser\\AppData\\Roaming'; + + const result = getConfigDirectory(); + + expect(result).toContain('Roaming'); + expect(result).toContain('Maestro'); + }); + + it('should return Windows config path fallback without APPDATA', () => { + vi.mocked(os.platform).mockReturnValue('win32'); + vi.mocked(os.homedir).mockReturnValue('C:\\Users\\testuser'); + delete process.env.APPDATA; + + const result = getConfigDirectory(); + + expect(result).toContain('testuser'); + expect(result).toContain('Maestro'); + }); + + it('should return Linux config path with XDG_CONFIG_HOME', () => { + vi.mocked(os.platform).mockReturnValue('linux'); + vi.mocked(os.homedir).mockReturnValue('/home/testuser'); + process.env.XDG_CONFIG_HOME = '/home/testuser/.custom-config'; + + const result = getConfigDirectory(); + + expect(result).toBe('/home/testuser/.custom-config/Maestro'); + }); + + it('should return Linux config path fallback without XDG_CONFIG_HOME', () => { + vi.mocked(os.platform).mockReturnValue('linux'); + vi.mocked(os.homedir).mockReturnValue('/home/testuser'); + delete process.env.XDG_CONFIG_HOME; + + const result = getConfigDirectory(); + + expect(result).toBe('/home/testuser/.config/Maestro'); + }); + + it('should use Linux path for unknown platforms', () => { + vi.mocked(os.platform).mockReturnValue('freebsd' as NodeJS.Platform); + vi.mocked(os.homedir).mockReturnValue('/home/testuser'); + delete process.env.XDG_CONFIG_HOME; + + const result = getConfigDirectory(); + + expect(result).toBe('/home/testuser/.config/Maestro'); + }); + }); + + describe('readSessions', () => { + it('should return sessions from file', () => { + const sessions = [mockSession({ id: 'sess-1' }), mockSession({ id: 'sess-2' })]; + vi.mocked(fs.readFileSync).mockReturnValue( + JSON.stringify({ sessions }) + ); + + const result = readSessions(); + + expect(result).toHaveLength(2); + expect(result[0].id).toBe('sess-1'); + }); + + it('should return empty array when file does not exist', () => { + const error = new Error('File not found') as NodeJS.ErrnoException; + error.code = 'ENOENT'; + vi.mocked(fs.readFileSync).mockImplementation(() => { + throw error; + }); + + const result = readSessions(); + + expect(result).toEqual([]); + }); + + it('should return empty array when sessions is undefined', () => { + vi.mocked(fs.readFileSync).mockReturnValue( + JSON.stringify({}) + ); + + const result = readSessions(); + + expect(result).toEqual([]); + }); + + it('should throw error for non-ENOENT errors', () => { + const error = new Error('Permission denied') as NodeJS.ErrnoException; + error.code = 'EACCES'; + vi.mocked(fs.readFileSync).mockImplementation(() => { + throw error; + }); + + expect(() => readSessions()).toThrow('Permission denied'); + }); + }); + + describe('readGroups', () => { + it('should return groups from file', () => { + const groups = [mockGroup({ id: 'grp-1' }), mockGroup({ id: 'grp-2' })]; + vi.mocked(fs.readFileSync).mockReturnValue( + JSON.stringify({ groups }) + ); + + const result = readGroups(); + + expect(result).toHaveLength(2); + expect(result[0].id).toBe('grp-1'); + }); + + it('should return empty array when file does not exist', () => { + const error = new Error('File not found') as NodeJS.ErrnoException; + error.code = 'ENOENT'; + vi.mocked(fs.readFileSync).mockImplementation(() => { + throw error; + }); + + const result = readGroups(); + + expect(result).toEqual([]); + }); + + it('should return empty array when groups is undefined', () => { + vi.mocked(fs.readFileSync).mockReturnValue( + JSON.stringify({}) + ); + + const result = readGroups(); + + expect(result).toEqual([]); + }); + }); + + describe('readHistory', () => { + it('should return all entries when no filters provided', () => { + const entries = [ + mockHistoryEntry({ id: 'e1', projectPath: '/proj1' }), + mockHistoryEntry({ id: 'e2', projectPath: '/proj2' }), + ]; + vi.mocked(fs.readFileSync).mockReturnValue( + JSON.stringify({ entries }) + ); + + const result = readHistory(); + + expect(result).toHaveLength(2); + }); + + it('should filter by projectPath', () => { + const entries = [ + mockHistoryEntry({ id: 'e1', projectPath: '/proj1' }), + mockHistoryEntry({ id: 'e2', projectPath: '/proj2' }), + mockHistoryEntry({ id: 'e3', projectPath: '/proj1' }), + ]; + vi.mocked(fs.readFileSync).mockReturnValue( + JSON.stringify({ entries }) + ); + + const result = readHistory('/proj1'); + + expect(result).toHaveLength(2); + expect(result.every((e) => e.projectPath === '/proj1')).toBe(true); + }); + + it('should filter by sessionId', () => { + const entries = [ + mockHistoryEntry({ id: 'e1', sessionId: 'sess-1' }), + mockHistoryEntry({ id: 'e2', sessionId: 'sess-2' }), + mockHistoryEntry({ id: 'e3', sessionId: 'sess-1' }), + ]; + vi.mocked(fs.readFileSync).mockReturnValue( + JSON.stringify({ entries }) + ); + + const result = readHistory(undefined, 'sess-1'); + + expect(result).toHaveLength(2); + expect(result.every((e) => e.sessionId === 'sess-1')).toBe(true); + }); + + it('should filter by both projectPath and sessionId', () => { + const entries = [ + mockHistoryEntry({ id: 'e1', projectPath: '/proj1', sessionId: 'sess-1' }), + mockHistoryEntry({ id: 'e2', projectPath: '/proj1', sessionId: 'sess-2' }), + mockHistoryEntry({ id: 'e3', projectPath: '/proj2', sessionId: 'sess-1' }), + ]; + vi.mocked(fs.readFileSync).mockReturnValue( + JSON.stringify({ entries }) + ); + + const result = readHistory('/proj1', 'sess-1'); + + expect(result).toHaveLength(1); + expect(result[0].id).toBe('e1'); + }); + + it('should return empty array when file does not exist', () => { + const error = new Error('File not found') as NodeJS.ErrnoException; + error.code = 'ENOENT'; + vi.mocked(fs.readFileSync).mockImplementation(() => { + throw error; + }); + + const result = readHistory(); + + expect(result).toEqual([]); + }); + + it('should return empty array when entries is undefined', () => { + vi.mocked(fs.readFileSync).mockReturnValue( + JSON.stringify({}) + ); + + const result = readHistory(); + + expect(result).toEqual([]); + }); + }); + + describe('readSettings', () => { + it('should return settings from file', () => { + const settings = { activeThemeId: 'dark', customSetting: 'value' }; + vi.mocked(fs.readFileSync).mockReturnValue( + JSON.stringify(settings) + ); + + const result = readSettings(); + + expect(result.activeThemeId).toBe('dark'); + expect(result.customSetting).toBe('value'); + }); + + it('should return empty object when file does not exist', () => { + const error = new Error('File not found') as NodeJS.ErrnoException; + error.code = 'ENOENT'; + vi.mocked(fs.readFileSync).mockImplementation(() => { + throw error; + }); + + const result = readSettings(); + + expect(result).toEqual({}); + }); + }); + + describe('readAgentConfigs', () => { + it('should return agent configs from file', () => { + const configs = { + configs: { + 'claude-code': { customPath: '/custom/path' }, + 'aider': { setting: 'value' }, + }, + }; + vi.mocked(fs.readFileSync).mockReturnValue( + JSON.stringify(configs) + ); + + const result = readAgentConfigs(); + + expect(result['claude-code']).toEqual({ customPath: '/custom/path' }); + expect(result['aider']).toEqual({ setting: 'value' }); + }); + + it('should return empty object when file does not exist', () => { + const error = new Error('File not found') as NodeJS.ErrnoException; + error.code = 'ENOENT'; + vi.mocked(fs.readFileSync).mockImplementation(() => { + throw error; + }); + + const result = readAgentConfigs(); + + expect(result).toEqual({}); + }); + + it('should return empty object when configs is undefined', () => { + vi.mocked(fs.readFileSync).mockReturnValue( + JSON.stringify({}) + ); + + const result = readAgentConfigs(); + + expect(result).toEqual({}); + }); + }); + + describe('getAgentCustomPath', () => { + it('should return custom path when configured', () => { + vi.mocked(fs.readFileSync).mockReturnValue( + JSON.stringify({ + configs: { + 'claude-code': { customPath: '/custom/claude/path' }, + }, + }) + ); + + const result = getAgentCustomPath('claude-code'); + + expect(result).toBe('/custom/claude/path'); + }); + + it('should return undefined when agent not in configs', () => { + vi.mocked(fs.readFileSync).mockReturnValue( + JSON.stringify({ + configs: { + 'claude-code': { customPath: '/custom/path' }, + }, + }) + ); + + const result = getAgentCustomPath('aider'); + + expect(result).toBeUndefined(); + }); + + it('should return undefined when customPath is not a string', () => { + vi.mocked(fs.readFileSync).mockReturnValue( + JSON.stringify({ + configs: { + 'claude-code': { customPath: 123 }, + }, + }) + ); + + const result = getAgentCustomPath('claude-code'); + + expect(result).toBeUndefined(); + }); + + it('should return undefined when customPath is empty string', () => { + vi.mocked(fs.readFileSync).mockReturnValue( + JSON.stringify({ + configs: { + 'claude-code': { customPath: '' }, + }, + }) + ); + + const result = getAgentCustomPath('claude-code'); + + expect(result).toBeUndefined(); + }); + + it('should return undefined when agent config has no customPath', () => { + vi.mocked(fs.readFileSync).mockReturnValue( + JSON.stringify({ + configs: { + 'claude-code': { otherSetting: 'value' }, + }, + }) + ); + + const result = getAgentCustomPath('claude-code'); + + expect(result).toBeUndefined(); + }); + }); + + describe('resolveAgentId', () => { + it('should return exact match', () => { + vi.mocked(fs.readFileSync).mockReturnValue( + JSON.stringify({ + sessions: [mockSession({ id: 'exact-session-id' })], + }) + ); + + const result = resolveAgentId('exact-session-id'); + + expect(result).toBe('exact-session-id'); + }); + + it('should return single prefix match', () => { + vi.mocked(fs.readFileSync).mockReturnValue( + JSON.stringify({ + sessions: [ + mockSession({ id: 'unique-abc-123' }), + mockSession({ id: 'different-xyz-456' }), + ], + }) + ); + + const result = resolveAgentId('unique'); + + expect(result).toBe('unique-abc-123'); + }); + + it('should throw when agent not found', () => { + vi.mocked(fs.readFileSync).mockReturnValue( + JSON.stringify({ sessions: [] }) + ); + + expect(() => resolveAgentId('nonexistent')).toThrow( + 'Agent not found: nonexistent' + ); + }); + + it('should throw with match list when ambiguous', () => { + vi.mocked(fs.readFileSync).mockReturnValue( + JSON.stringify({ + sessions: [ + mockSession({ id: 'test-abc-123', name: 'First Agent' }), + mockSession({ id: 'test-def-456', name: 'Second Agent' }), + ], + }) + ); + + expect(() => resolveAgentId('test')).toThrow( + /Ambiguous agent ID 'test'/ + ); + }); + + it('should include agent names and truncated IDs in ambiguous error', () => { + vi.mocked(fs.readFileSync).mockReturnValue( + JSON.stringify({ + sessions: [ + mockSession({ id: 'test-abcdefgh-1', name: 'Alpha Agent' }), + mockSession({ id: 'test-ijklmnop-2', name: 'Beta Agent' }), + ], + }) + ); + + try { + resolveAgentId('test'); + expect.fail('Should have thrown'); + } catch (error) { + expect((error as Error).message).toContain('test-abc'); + expect((error as Error).message).toContain('Alpha Agent'); + expect((error as Error).message).toContain('test-ijk'); + expect((error as Error).message).toContain('Beta Agent'); + } + }); + + it('should show Unknown when agent name is missing', () => { + vi.mocked(fs.readFileSync).mockReturnValue( + JSON.stringify({ + sessions: [ + { ...mockSession({ id: 'test-123' }), name: undefined }, + mockSession({ id: 'test-456', name: 'Named Agent' }), + ], + }) + ); + + try { + resolveAgentId('test'); + expect.fail('Should have thrown'); + } catch (error) { + expect((error as Error).message).toContain('Unknown'); + expect((error as Error).message).toContain('Named Agent'); + } + }); + }); + + describe('resolveGroupId', () => { + it('should return exact match', () => { + vi.mocked(fs.readFileSync).mockReturnValue( + JSON.stringify({ + groups: [mockGroup({ id: 'exact-group-id' })], + }) + ); + + const result = resolveGroupId('exact-group-id'); + + expect(result).toBe('exact-group-id'); + }); + + it('should return single prefix match', () => { + vi.mocked(fs.readFileSync).mockReturnValue( + JSON.stringify({ + groups: [ + mockGroup({ id: 'unique-grp-abc' }), + mockGroup({ id: 'different-grp-xyz' }), + ], + }) + ); + + const result = resolveGroupId('unique'); + + expect(result).toBe('unique-grp-abc'); + }); + + it('should throw when group not found', () => { + vi.mocked(fs.readFileSync).mockReturnValue( + JSON.stringify({ groups: [] }) + ); + + expect(() => resolveGroupId('nonexistent')).toThrow( + 'Group not found: nonexistent' + ); + }); + + it('should throw with match list when ambiguous', () => { + vi.mocked(fs.readFileSync).mockReturnValue( + JSON.stringify({ + groups: [ + mockGroup({ id: 'test-group-1', name: 'First Group' }), + mockGroup({ id: 'test-group-2', name: 'Second Group' }), + ], + }) + ); + + expect(() => resolveGroupId('test')).toThrow( + /Ambiguous group ID 'test'/ + ); + }); + + it('should include group names in ambiguous error', () => { + vi.mocked(fs.readFileSync).mockReturnValue( + JSON.stringify({ + groups: [ + mockGroup({ id: 'work-projects', name: 'Work' }), + mockGroup({ id: 'work-personal', name: 'Personal' }), + ], + }) + ); + + try { + resolveGroupId('work'); + expect.fail('Should have thrown'); + } catch (error) { + expect((error as Error).message).toContain('work-projects'); + expect((error as Error).message).toContain('Work'); + expect((error as Error).message).toContain('work-personal'); + expect((error as Error).message).toContain('Personal'); + } + }); + + it('should show Unknown when group name is missing', () => { + vi.mocked(fs.readFileSync).mockReturnValue( + JSON.stringify({ + groups: [ + { ...mockGroup({ id: 'test-1' }), name: undefined }, + mockGroup({ id: 'test-2', name: 'Named Group' }), + ], + }) + ); + + try { + resolveGroupId('test'); + expect.fail('Should have thrown'); + } catch (error) { + expect((error as Error).message).toContain('Unknown'); + expect((error as Error).message).toContain('Named Group'); + } + }); + }); + + describe('getSessionById', () => { + it('should return exact match', () => { + const session = mockSession({ id: 'exact-id-123', name: 'My Session' }); + vi.mocked(fs.readFileSync).mockReturnValue( + JSON.stringify({ sessions: [session] }) + ); + + const result = getSessionById('exact-id-123'); + + expect(result?.name).toBe('My Session'); + }); + + it('should return single prefix match', () => { + vi.mocked(fs.readFileSync).mockReturnValue( + JSON.stringify({ + sessions: [ + mockSession({ id: 'unique-abc-123', name: 'Target' }), + mockSession({ id: 'different-xyz', name: 'Other' }), + ], + }) + ); + + const result = getSessionById('unique'); + + expect(result?.name).toBe('Target'); + }); + + it('should return undefined when not found', () => { + vi.mocked(fs.readFileSync).mockReturnValue( + JSON.stringify({ sessions: [] }) + ); + + const result = getSessionById('nonexistent'); + + expect(result).toBeUndefined(); + }); + + it('should return undefined when multiple prefix matches', () => { + vi.mocked(fs.readFileSync).mockReturnValue( + JSON.stringify({ + sessions: [ + mockSession({ id: 'test-123' }), + mockSession({ id: 'test-456' }), + ], + }) + ); + + const result = getSessionById('test'); + + expect(result).toBeUndefined(); + }); + + it('should prefer exact match over prefix match', () => { + vi.mocked(fs.readFileSync).mockReturnValue( + JSON.stringify({ + sessions: [ + mockSession({ id: 'test', name: 'Exact' }), + mockSession({ id: 'test-extended', name: 'Extended' }), + ], + }) + ); + + const result = getSessionById('test'); + + expect(result?.name).toBe('Exact'); + }); + }); + + describe('getSessionsByGroup', () => { + it('should return sessions for exact group ID', () => { + vi.mocked(fs.readFileSync).mockImplementation((filepath) => { + if (String(filepath).includes('sessions')) { + return JSON.stringify({ + sessions: [ + mockSession({ id: 's1', groupId: 'group-123' }), + mockSession({ id: 's2', groupId: 'group-456' }), + mockSession({ id: 's3', groupId: 'group-123' }), + ], + }); + } + return JSON.stringify({ + groups: [ + mockGroup({ id: 'group-123' }), + mockGroup({ id: 'group-456' }), + ], + }); + }); + + const result = getSessionsByGroup('group-123'); + + expect(result).toHaveLength(2); + expect(result.every((s) => s.groupId === 'group-123')).toBe(true); + }); + + it('should return sessions for prefix group ID match', () => { + vi.mocked(fs.readFileSync).mockImplementation((filepath) => { + if (String(filepath).includes('sessions')) { + return JSON.stringify({ + sessions: [ + mockSession({ id: 's1', groupId: 'unique-group-123' }), + mockSession({ id: 's2', groupId: 'other-group' }), + ], + }); + } + return JSON.stringify({ + groups: [ + mockGroup({ id: 'unique-group-123' }), + mockGroup({ id: 'other-group' }), + ], + }); + }); + + const result = getSessionsByGroup('unique'); + + expect(result).toHaveLength(1); + expect(result[0].id).toBe('s1'); + }); + + it('should return empty array when group not found', () => { + vi.mocked(fs.readFileSync).mockImplementation((filepath) => { + if (String(filepath).includes('sessions')) { + return JSON.stringify({ sessions: [mockSession()] }); + } + return JSON.stringify({ groups: [] }); + }); + + const result = getSessionsByGroup('nonexistent'); + + expect(result).toEqual([]); + }); + + it('should return empty array when multiple prefix matches', () => { + vi.mocked(fs.readFileSync).mockImplementation((filepath) => { + if (String(filepath).includes('sessions')) { + return JSON.stringify({ + sessions: [ + mockSession({ id: 's1', groupId: 'test-group-1' }), + mockSession({ id: 's2', groupId: 'test-group-2' }), + ], + }); + } + return JSON.stringify({ + groups: [ + mockGroup({ id: 'test-group-1' }), + mockGroup({ id: 'test-group-2' }), + ], + }); + }); + + const result = getSessionsByGroup('test'); + + expect(result).toEqual([]); + }); + }); + + describe('addHistoryEntry', () => { + let consoleErrorSpy: ReturnType; + + beforeEach(() => { + consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {}); + }); + + afterEach(() => { + consoleErrorSpy.mockRestore(); + }); + + it('should write entry to history file', () => { + const existingEntries = [mockHistoryEntry({ id: 'existing' })]; + vi.mocked(fs.readFileSync).mockReturnValue( + JSON.stringify({ entries: existingEntries }) + ); + + const newEntry = mockHistoryEntry({ id: 'new-entry' }); + addHistoryEntry(newEntry); + + expect(fs.writeFileSync).toHaveBeenCalled(); + const writeCall = vi.mocked(fs.writeFileSync).mock.calls[0]; + const writtenData = JSON.parse(writeCall[1] as string); + expect(writtenData.entries).toHaveLength(2); + expect(writtenData.entries[0].id).toBe('new-entry'); // New entry at beginning + expect(writtenData.entries[1].id).toBe('existing'); + }); + + it('should create entries array if file does not exist', () => { + const error = new Error('File not found') as NodeJS.ErrnoException; + error.code = 'ENOENT'; + vi.mocked(fs.readFileSync).mockImplementation(() => { + throw error; + }); + + const newEntry = mockHistoryEntry({ id: 'first-entry' }); + addHistoryEntry(newEntry); + + expect(fs.writeFileSync).toHaveBeenCalled(); + const writeCall = vi.mocked(fs.writeFileSync).mock.calls[0]; + const writtenData = JSON.parse(writeCall[1] as string); + expect(writtenData.entries).toHaveLength(1); + expect(writtenData.entries[0].id).toBe('first-entry'); + }); + + it('should log error but not throw on write failure', () => { + vi.mocked(fs.readFileSync).mockReturnValue( + JSON.stringify({ entries: [] }) + ); + vi.mocked(fs.writeFileSync).mockImplementation(() => { + throw new Error('Disk full'); + }); + + const newEntry = mockHistoryEntry({ id: 'entry' }); + + // Should not throw + expect(() => addHistoryEntry(newEntry)).not.toThrow(); + expect(consoleErrorSpy).toHaveBeenCalledWith( + expect.stringContaining('Failed to write history entry') + ); + expect(consoleErrorSpy).toHaveBeenCalledWith( + expect.stringContaining('Disk full') + ); + }); + + it('should log error with non-Error thrown value', () => { + vi.mocked(fs.readFileSync).mockReturnValue( + JSON.stringify({ entries: [] }) + ); + vi.mocked(fs.writeFileSync).mockImplementation(() => { + throw 'String error'; // eslint-disable-line no-throw-literal + }); + + const newEntry = mockHistoryEntry({ id: 'entry' }); + + expect(() => addHistoryEntry(newEntry)).not.toThrow(); + expect(consoleErrorSpy).toHaveBeenCalledWith( + expect.stringContaining('String error') + ); + }); + + it('should write to correct file path', () => { + vi.mocked(os.platform).mockReturnValue('darwin'); + vi.mocked(os.homedir).mockReturnValue('/Users/testuser'); + vi.mocked(fs.readFileSync).mockReturnValue( + JSON.stringify({ entries: [] }) + ); + + addHistoryEntry(mockHistoryEntry()); + + const writeCall = vi.mocked(fs.writeFileSync).mock.calls[0]; + expect(writeCall[0]).toContain('maestro-history.json'); + expect(writeCall[0]).toContain('/Users/testuser/Library/Application Support/Maestro'); + }); + }); + + describe('edge cases', () => { + it('should handle sessions with special characters in names', () => { + const session = mockSession({ + id: 'special-session', + name: 'Test <>&"\'Session', + }); + vi.mocked(fs.readFileSync).mockReturnValue( + JSON.stringify({ sessions: [session] }) + ); + + const result = getSessionById('special-session'); + + expect(result?.name).toBe('Test <>&"\'Session'); + }); + + it('should handle unicode in group names', () => { + const group = mockGroup({ + id: 'unicode-group', + name: '日本語グループ 🎮', + emoji: '🚀', + }); + vi.mocked(fs.readFileSync).mockReturnValue( + JSON.stringify({ groups: [group] }) + ); + + const result = readGroups(); + + expect(result[0].name).toBe('日本語グループ 🎮'); + }); + + it('should handle very long session IDs', () => { + const longId = 'a'.repeat(200); + vi.mocked(fs.readFileSync).mockReturnValue( + JSON.stringify({ + sessions: [mockSession({ id: longId })], + }) + ); + + const result = resolveAgentId(longId); + + expect(result).toBe(longId); + }); + + it('should handle history entries with all optional fields', () => { + const entry: HistoryEntry = { + id: 'full-entry', + type: 'USER', + timestamp: Date.now(), + summary: 'Full entry', + projectPath: '/project', + fullResponse: 'Full response text', + claudeSessionId: 'claude-123', + sessionName: 'My Session', + sessionId: 'session-123', + contextUsage: 50000, + usageStats: { + inputTokens: 1000, + outputTokens: 500, + cacheReadInputTokens: 100, + cacheCreationInputTokens: 50, + totalCostUsd: 0.05, + contextWindow: 100000, + }, + success: true, + elapsedTimeMs: 5000, + validated: true, + }; + vi.mocked(fs.readFileSync).mockReturnValue( + JSON.stringify({ entries: [entry] }) + ); + + const result = readHistory(); + + expect(result[0].fullResponse).toBe('Full response text'); + expect(result[0].usageStats?.inputTokens).toBe(1000); + }); + + it('should handle empty config file', () => { + vi.mocked(fs.readFileSync).mockReturnValue('{}'); + + expect(readSessions()).toEqual([]); + expect(readGroups()).toEqual([]); + expect(readHistory()).toEqual([]); + expect(readSettings()).toEqual({}); + expect(readAgentConfigs()).toEqual({}); + }); + }); +}); diff --git a/src/__tests__/main/agent-detector.test.ts b/src/__tests__/main/agent-detector.test.ts new file mode 100644 index 00000000..0db9be7a --- /dev/null +++ b/src/__tests__/main/agent-detector.test.ts @@ -0,0 +1,771 @@ +import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'; +import { AgentDetector, AgentConfig, AgentConfigOption } from '../../main/agent-detector'; + +// Mock dependencies +vi.mock('../../main/utils/execFile', () => ({ + execFileNoThrow: vi.fn(), +})); + +vi.mock('../../main/utils/logger', () => ({ + logger: { + info: vi.fn(), + warn: vi.fn(), + error: vi.fn(), + debug: vi.fn(), + }, +})); + +// Get mocked modules +import { execFileNoThrow } from '../../main/utils/execFile'; +import { logger } from '../../main/utils/logger'; +import * as fs from 'fs'; +import * as os from 'os'; + +describe('agent-detector', () => { + let detector: AgentDetector; + const mockExecFileNoThrow = vi.mocked(execFileNoThrow); + + beforeEach(() => { + vi.clearAllMocks(); + detector = new AgentDetector(); + // Default: no binaries found + mockExecFileNoThrow.mockResolvedValue({ stdout: '', stderr: '', exitCode: 1 }); + }); + + afterEach(() => { + vi.restoreAllMocks(); + }); + + describe('Type exports', () => { + it('should export AgentConfigOption interface', () => { + const option: AgentConfigOption = { + key: 'test', + type: 'checkbox', + label: 'Test', + description: 'Test description', + default: false, + }; + expect(option.key).toBe('test'); + expect(option.type).toBe('checkbox'); + }); + + it('should export AgentConfig interface', () => { + const config: AgentConfig = { + id: 'test-agent', + name: 'Test Agent', + binaryName: 'test', + command: 'test', + args: ['--flag'], + available: true, + path: '/usr/bin/test', + }; + expect(config.id).toBe('test-agent'); + expect(config.available).toBe(true); + }); + + it('should support optional AgentConfig fields', () => { + const config: AgentConfig = { + id: 'test-agent', + name: 'Test Agent', + binaryName: 'test', + command: 'test', + args: [], + available: false, + customPath: '/custom/path', + requiresPty: true, + configOptions: [{ key: 'k', type: 'text', label: 'L', description: 'D', default: '' }], + hidden: true, + }; + expect(config.customPath).toBe('/custom/path'); + expect(config.requiresPty).toBe(true); + expect(config.hidden).toBe(true); + }); + + it('should support select type with options in AgentConfigOption', () => { + const option: AgentConfigOption = { + key: 'theme', + type: 'select', + label: 'Theme', + description: 'Select theme', + default: 'dark', + options: ['dark', 'light'], + }; + expect(option.options).toEqual(['dark', 'light']); + }); + + it('should support argBuilder function in AgentConfigOption', () => { + const option: AgentConfigOption = { + key: 'verbose', + type: 'checkbox', + label: 'Verbose', + description: 'Enable verbose', + default: false, + argBuilder: (value: boolean) => value ? ['--verbose'] : [], + }; + expect(option.argBuilder!(true)).toEqual(['--verbose']); + expect(option.argBuilder!(false)).toEqual([]); + }); + }); + + describe('setCustomPaths', () => { + it('should set custom paths', () => { + detector.setCustomPaths({ 'claude-code': '/custom/claude' }); + expect(detector.getCustomPaths()).toEqual({ 'claude-code': '/custom/claude' }); + }); + + it('should override previous custom paths', () => { + detector.setCustomPaths({ 'claude-code': '/first' }); + detector.setCustomPaths({ 'openai-codex': '/second' }); + expect(detector.getCustomPaths()).toEqual({ 'openai-codex': '/second' }); + }); + + it('should clear cache when paths are set', async () => { + // First detection - cache the result + mockExecFileNoThrow.mockResolvedValue({ stdout: '/usr/bin/bash\n', stderr: '', exitCode: 0 }); + await detector.detectAgents(); + const initialCallCount = mockExecFileNoThrow.mock.calls.length; + + // Set custom paths - should clear cache + detector.setCustomPaths({ 'claude-code': '/custom/claude' }); + + // Detect again - should re-detect since cache was cleared + await detector.detectAgents(); + expect(mockExecFileNoThrow.mock.calls.length).toBeGreaterThan(initialCallCount); + }); + }); + + describe('getCustomPaths', () => { + it('should return empty object initially', () => { + expect(detector.getCustomPaths()).toEqual({}); + }); + + it('should return a copy of custom paths', () => { + detector.setCustomPaths({ 'claude-code': '/custom/claude' }); + const paths1 = detector.getCustomPaths(); + const paths2 = detector.getCustomPaths(); + expect(paths1).toEqual(paths2); + expect(paths1).not.toBe(paths2); // Different object references + }); + + it('should not be affected by modifications to returned object', () => { + detector.setCustomPaths({ 'claude-code': '/original' }); + const paths = detector.getCustomPaths(); + paths['claude-code'] = '/modified'; + expect(detector.getCustomPaths()['claude-code']).toBe('/original'); + }); + }); + + describe('detectAgents', () => { + it('should return cached agents on subsequent calls', async () => { + mockExecFileNoThrow.mockResolvedValue({ stdout: '/usr/bin/bash\n', stderr: '', exitCode: 0 }); + + const result1 = await detector.detectAgents(); + const callCount = mockExecFileNoThrow.mock.calls.length; + + const result2 = await detector.detectAgents(); + expect(result2).toBe(result1); // Same reference + expect(mockExecFileNoThrow.mock.calls.length).toBe(callCount); // No additional calls + }); + + it('should detect all defined agent types', async () => { + mockExecFileNoThrow.mockResolvedValue({ stdout: '/usr/bin/found\n', stderr: '', exitCode: 0 }); + + const agents = await detector.detectAgents(); + + // Should have all 5 agents + expect(agents.length).toBe(5); + + const agentIds = agents.map(a => a.id); + expect(agentIds).toContain('terminal'); + expect(agentIds).toContain('claude-code'); + expect(agentIds).toContain('openai-codex'); + expect(agentIds).toContain('gemini-cli'); + expect(agentIds).toContain('qwen3-coder'); + }); + + it('should mark agents as available when binary is found', async () => { + mockExecFileNoThrow.mockResolvedValue({ stdout: '/usr/bin/claude\n', stderr: '', exitCode: 0 }); + + const agents = await detector.detectAgents(); + const claudeAgent = agents.find(a => a.id === 'claude-code'); + + expect(claudeAgent?.available).toBe(true); + expect(claudeAgent?.path).toBe('/usr/bin/claude'); + }); + + it('should mark agents as unavailable when binary is not found', async () => { + mockExecFileNoThrow.mockResolvedValue({ stdout: '', stderr: 'not found', exitCode: 1 }); + + const agents = await detector.detectAgents(); + const codexAgent = agents.find(a => a.id === 'openai-codex'); + + expect(codexAgent?.available).toBe(false); + expect(codexAgent?.path).toBeUndefined(); + }); + + it('should handle mixed availability', async () => { + mockExecFileNoThrow.mockImplementation(async (cmd, args) => { + const binaryName = args[0]; + if (binaryName === 'bash' || binaryName === 'claude') { + return { stdout: `/usr/bin/${binaryName}\n`, stderr: '', exitCode: 0 }; + } + return { stdout: '', stderr: 'not found', exitCode: 1 }; + }); + + const agents = await detector.detectAgents(); + + expect(agents.find(a => a.id === 'terminal')?.available).toBe(true); + expect(agents.find(a => a.id === 'claude-code')?.available).toBe(true); + expect(agents.find(a => a.id === 'openai-codex')?.available).toBe(false); + }); + + it('should use deduplication for parallel calls', async () => { + let callCount = 0; + mockExecFileNoThrow.mockImplementation(async () => { + callCount++; + // Simulate slow detection + await new Promise(resolve => setTimeout(resolve, 50)); + return { stdout: '/usr/bin/found\n', stderr: '', exitCode: 0 }; + }); + + // Start multiple detections simultaneously + const promises = [ + detector.detectAgents(), + detector.detectAgents(), + detector.detectAgents(), + ]; + + const results = await Promise.all(promises); + + // All should return the same result (same reference) + expect(results[0]).toBe(results[1]); + expect(results[1]).toBe(results[2]); + }); + + it('should include agent metadata', async () => { + mockExecFileNoThrow.mockResolvedValue({ stdout: '/usr/bin/claude\n', stderr: '', exitCode: 0 }); + + const agents = await detector.detectAgents(); + const claudeAgent = agents.find(a => a.id === 'claude-code'); + + expect(claudeAgent?.name).toBe('Claude Code'); + expect(claudeAgent?.binaryName).toBe('claude'); + expect(claudeAgent?.command).toBe('claude'); + expect(claudeAgent?.args).toContain('--print'); + expect(claudeAgent?.args).toContain('--verbose'); + expect(claudeAgent?.args).toContain('--dangerously-skip-permissions'); + }); + + it('should include terminal as hidden agent', async () => { + mockExecFileNoThrow.mockResolvedValue({ stdout: '/bin/bash\n', stderr: '', exitCode: 0 }); + + const agents = await detector.detectAgents(); + const terminal = agents.find(a => a.id === 'terminal'); + + expect(terminal?.hidden).toBe(true); + expect(terminal?.requiresPty).toBe(true); + }); + + it('should log agent detection progress', async () => { + mockExecFileNoThrow.mockResolvedValue({ stdout: '/usr/bin/claude\n', stderr: '', exitCode: 0 }); + + await detector.detectAgents(); + + expect(logger.info).toHaveBeenCalledWith( + expect.stringContaining('Agent detection starting'), + 'AgentDetector' + ); + expect(logger.info).toHaveBeenCalledWith( + expect.stringContaining('Agent detection complete'), + 'AgentDetector' + ); + }); + + it('should log when agents are found', async () => { + mockExecFileNoThrow.mockImplementation(async (cmd, args) => { + const binaryName = args[0]; + if (binaryName === 'claude') { + return { stdout: '/usr/bin/claude\n', stderr: '', exitCode: 0 }; + } + return { stdout: '', stderr: '', exitCode: 1 }; + }); + + await detector.detectAgents(); + + expect(logger.info).toHaveBeenCalledWith( + expect.stringContaining('Claude Code'), + 'AgentDetector' + ); + }); + + it('should log warnings for missing agents (except bash)', async () => { + mockExecFileNoThrow.mockResolvedValue({ stdout: '', stderr: '', exitCode: 1 }); + + await detector.detectAgents(); + + // Should warn about missing agents + expect(logger.warn).toHaveBeenCalledWith( + expect.stringContaining('Claude Code'), + 'AgentDetector' + ); + + // But not about bash (it's always present) + const bashWarning = (logger.warn as any).mock.calls.find( + (call: any[]) => call[0].includes('Terminal') && call[0].includes('bash') + ); + expect(bashWarning).toBeUndefined(); + }); + }); + + describe('custom path detection', () => { + beforeEach(() => { + vi.spyOn(fs.promises, 'stat').mockImplementation(async () => { + throw new Error('ENOENT'); + }); + vi.spyOn(fs.promises, 'access').mockImplementation(async () => undefined); + }); + + it('should check custom path when set', async () => { + const statMock = vi.spyOn(fs.promises, 'stat').mockResolvedValue({ + isFile: () => true, + } as fs.Stats); + + detector.setCustomPaths({ 'claude-code': '/custom/claude' }); + await detector.detectAgents(); + + expect(statMock).toHaveBeenCalledWith('/custom/claude'); + }); + + it('should use custom path when valid', async () => { + vi.spyOn(fs.promises, 'stat').mockResolvedValue({ + isFile: () => true, + } as fs.Stats); + + detector.setCustomPaths({ 'claude-code': '/custom/claude' }); + const agents = await detector.detectAgents(); + + const claude = agents.find(a => a.id === 'claude-code'); + expect(claude?.available).toBe(true); + expect(claude?.path).toBe('/custom/claude'); + expect(claude?.customPath).toBe('/custom/claude'); + }); + + it('should reject non-file custom paths', async () => { + vi.spyOn(fs.promises, 'stat').mockResolvedValue({ + isFile: () => false, // Directory + } as fs.Stats); + + detector.setCustomPaths({ 'claude-code': '/custom/claude-dir' }); + const agents = await detector.detectAgents(); + + const claude = agents.find(a => a.id === 'claude-code'); + expect(claude?.available).toBe(false); + }); + + it('should reject non-executable custom paths on Unix', async () => { + const originalPlatform = process.platform; + Object.defineProperty(process, 'platform', { value: 'darwin', configurable: true }); + + vi.spyOn(fs.promises, 'stat').mockResolvedValue({ + isFile: () => true, + } as fs.Stats); + vi.spyOn(fs.promises, 'access').mockRejectedValue(new Error('EACCES')); + + detector.setCustomPaths({ 'claude-code': '/custom/claude' }); + const agents = await detector.detectAgents(); + + const claude = agents.find(a => a.id === 'claude-code'); + expect(claude?.available).toBe(false); + + expect(logger.warn).toHaveBeenCalledWith( + expect.stringContaining('not executable'), + 'AgentDetector' + ); + + Object.defineProperty(process, 'platform', { value: originalPlatform, configurable: true }); + }); + + it('should skip executable check on Windows', async () => { + const originalPlatform = process.platform; + Object.defineProperty(process, 'platform', { value: 'win32', configurable: true }); + + const accessMock = vi.spyOn(fs.promises, 'access'); + vi.spyOn(fs.promises, 'stat').mockResolvedValue({ + isFile: () => true, + } as fs.Stats); + + detector.setCustomPaths({ 'claude-code': 'C:\\custom\\claude.exe' }); + const agents = await detector.detectAgents(); + + const claude = agents.find(a => a.id === 'claude-code'); + expect(claude?.available).toBe(true); + expect(accessMock).not.toHaveBeenCalled(); + + Object.defineProperty(process, 'platform', { value: originalPlatform, configurable: true }); + }); + + it('should fall back to PATH when custom path is invalid', async () => { + vi.spyOn(fs.promises, 'stat').mockRejectedValue(new Error('ENOENT')); + mockExecFileNoThrow.mockImplementation(async (cmd, args) => { + if (args[0] === 'claude') { + return { stdout: '/usr/bin/claude\n', stderr: '', exitCode: 0 }; + } + return { stdout: '', stderr: '', exitCode: 1 }; + }); + + detector.setCustomPaths({ 'claude-code': '/invalid/path' }); + const agents = await detector.detectAgents(); + + const claude = agents.find(a => a.id === 'claude-code'); + expect(claude?.available).toBe(true); + expect(claude?.path).toBe('/usr/bin/claude'); + + expect(logger.warn).toHaveBeenCalledWith( + expect.stringContaining('custom path not valid'), + 'AgentDetector' + ); + }); + + it('should log when found at custom path', async () => { + vi.spyOn(fs.promises, 'stat').mockResolvedValue({ + isFile: () => true, + } as fs.Stats); + + detector.setCustomPaths({ 'claude-code': '/custom/claude' }); + await detector.detectAgents(); + + expect(logger.info).toHaveBeenCalledWith( + expect.stringContaining('custom path'), + 'AgentDetector' + ); + }); + + it('should log when falling back to PATH after invalid custom path', async () => { + vi.spyOn(fs.promises, 'stat').mockRejectedValue(new Error('ENOENT')); + mockExecFileNoThrow.mockImplementation(async (cmd, args) => { + if (args[0] === 'claude') { + return { stdout: '/usr/bin/claude\n', stderr: '', exitCode: 0 }; + } + return { stdout: '', stderr: '', exitCode: 1 }; + }); + + detector.setCustomPaths({ 'claude-code': '/invalid/path' }); + await detector.detectAgents(); + + expect(logger.info).toHaveBeenCalledWith( + expect.stringContaining('found in PATH'), + 'AgentDetector' + ); + }); + }); + + describe('binary detection', () => { + it('should use which command on Unix', async () => { + const originalPlatform = process.platform; + Object.defineProperty(process, 'platform', { value: 'darwin', configurable: true }); + + // Create a new detector to pick up the platform change + const unixDetector = new AgentDetector(); + mockExecFileNoThrow.mockResolvedValue({ stdout: '/usr/bin/claude\n', stderr: '', exitCode: 0 }); + + await unixDetector.detectAgents(); + + expect(mockExecFileNoThrow).toHaveBeenCalledWith( + 'which', + expect.any(Array), + undefined, + expect.any(Object) + ); + + Object.defineProperty(process, 'platform', { value: originalPlatform, configurable: true }); + }); + + it('should use where command on Windows', async () => { + const originalPlatform = process.platform; + Object.defineProperty(process, 'platform', { value: 'win32', configurable: true }); + + const winDetector = new AgentDetector(); + mockExecFileNoThrow.mockResolvedValue({ stdout: 'C:\\claude.exe\n', stderr: '', exitCode: 0 }); + + await winDetector.detectAgents(); + + expect(mockExecFileNoThrow).toHaveBeenCalledWith( + 'where', + expect.any(Array), + undefined, + expect.any(Object) + ); + + Object.defineProperty(process, 'platform', { value: originalPlatform, configurable: true }); + }); + + it('should take first match when multiple paths returned', async () => { + mockExecFileNoThrow.mockResolvedValue({ + stdout: '/usr/local/bin/claude\n/usr/bin/claude\n/home/user/bin/claude\n', + stderr: '', + exitCode: 0, + }); + + const agents = await detector.detectAgents(); + const claude = agents.find(a => a.id === 'claude-code'); + + expect(claude?.path).toBe('/usr/local/bin/claude'); + }); + + it('should handle exceptions in binary detection', async () => { + mockExecFileNoThrow.mockRejectedValue(new Error('spawn failed')); + + const agents = await detector.detectAgents(); + + // All agents should be marked as unavailable + expect(agents.every(a => !a.available)).toBe(true); + }); + }); + + describe('expanded environment', () => { + it('should expand PATH with common directories', async () => { + // Can't mock os.homedir in ESM, but we can verify the static paths are added + await detector.detectAgents(); + + // Check that execFileNoThrow was called with expanded env + expect(mockExecFileNoThrow).toHaveBeenCalledWith( + expect.any(String), + expect.any(Array), + undefined, + expect.objectContaining({ + PATH: expect.stringContaining('/opt/homebrew/bin'), + }) + ); + + expect(mockExecFileNoThrow).toHaveBeenCalledWith( + expect.any(String), + expect.any(Array), + undefined, + expect.objectContaining({ + PATH: expect.stringContaining('/usr/local/bin'), + }) + ); + }); + + it('should include user-specific paths based on actual homedir', async () => { + // Since we can't mock os.homedir in ESM, verify paths include actual home directory + const actualHome = os.homedir(); + + await detector.detectAgents(); + + expect(mockExecFileNoThrow).toHaveBeenCalledWith( + expect.any(String), + expect.any(Array), + undefined, + expect.objectContaining({ + PATH: expect.stringContaining(`${actualHome}/.local/bin`), + }) + ); + + expect(mockExecFileNoThrow).toHaveBeenCalledWith( + expect.any(String), + expect.any(Array), + undefined, + expect.objectContaining({ + PATH: expect.stringContaining(`${actualHome}/.claude/local`), + }) + ); + }); + + it('should preserve existing PATH', async () => { + const originalPath = process.env.PATH; + process.env.PATH = '/existing/path:/another/path'; + + const newDetector = new AgentDetector(); + await newDetector.detectAgents(); + + expect(mockExecFileNoThrow).toHaveBeenCalledWith( + expect.any(String), + expect.any(Array), + undefined, + expect.objectContaining({ + PATH: expect.stringContaining('/existing/path'), + }) + ); + + process.env.PATH = originalPath; + }); + + it('should not duplicate paths already in PATH', async () => { + const originalPath = process.env.PATH; + process.env.PATH = '/opt/homebrew/bin:/usr/bin'; + + const newDetector = new AgentDetector(); + await newDetector.detectAgents(); + + const call = mockExecFileNoThrow.mock.calls[0]; + const env = call[3] as NodeJS.ProcessEnv; + const pathParts = (env.PATH || '').split(':'); + + // Should only appear once + const homebrewCount = pathParts.filter(p => p === '/opt/homebrew/bin').length; + expect(homebrewCount).toBe(1); + + process.env.PATH = originalPath; + }); + + it('should handle empty PATH', async () => { + const originalPath = process.env.PATH; + process.env.PATH = ''; + + const newDetector = new AgentDetector(); + await newDetector.detectAgents(); + + expect(mockExecFileNoThrow).toHaveBeenCalledWith( + expect.any(String), + expect.any(Array), + undefined, + expect.objectContaining({ + PATH: expect.stringContaining('/opt/homebrew/bin'), + }) + ); + + process.env.PATH = originalPath; + }); + }); + + describe('getAgent', () => { + it('should return agent by ID', async () => { + mockExecFileNoThrow.mockResolvedValue({ stdout: '/usr/bin/claude\n', stderr: '', exitCode: 0 }); + + const agent = await detector.getAgent('claude-code'); + + expect(agent).not.toBeNull(); + expect(agent?.id).toBe('claude-code'); + expect(agent?.name).toBe('Claude Code'); + }); + + it('should return null for unknown ID', async () => { + mockExecFileNoThrow.mockResolvedValue({ stdout: '', stderr: '', exitCode: 1 }); + + const agent = await detector.getAgent('unknown-agent'); + + expect(agent).toBeNull(); + }); + + it('should trigger detection if not cached', async () => { + mockExecFileNoThrow.mockResolvedValue({ stdout: '/usr/bin/claude\n', stderr: '', exitCode: 0 }); + + await detector.getAgent('claude-code'); + + expect(mockExecFileNoThrow).toHaveBeenCalled(); + }); + + it('should use cache for subsequent calls', async () => { + mockExecFileNoThrow.mockResolvedValue({ stdout: '/usr/bin/claude\n', stderr: '', exitCode: 0 }); + + await detector.getAgent('claude-code'); + const callCount = mockExecFileNoThrow.mock.calls.length; + + await detector.getAgent('terminal'); + expect(mockExecFileNoThrow.mock.calls.length).toBe(callCount); + }); + }); + + describe('clearCache', () => { + it('should clear cached agents', async () => { + mockExecFileNoThrow.mockResolvedValue({ stdout: '/usr/bin/claude\n', stderr: '', exitCode: 0 }); + + await detector.detectAgents(); + const initialCallCount = mockExecFileNoThrow.mock.calls.length; + + detector.clearCache(); + await detector.detectAgents(); + + expect(mockExecFileNoThrow.mock.calls.length).toBeGreaterThan(initialCallCount); + }); + + it('should allow re-detection with different results', async () => { + // First detection: claude available + mockExecFileNoThrow.mockImplementation(async (cmd, args) => { + if (args[0] === 'claude') { + return { stdout: '/usr/bin/claude\n', stderr: '', exitCode: 0 }; + } + return { stdout: '', stderr: '', exitCode: 1 }; + }); + + const agents1 = await detector.detectAgents(); + expect(agents1.find(a => a.id === 'claude-code')?.available).toBe(true); + + detector.clearCache(); + + // Second detection: claude unavailable + mockExecFileNoThrow.mockResolvedValue({ stdout: '', stderr: '', exitCode: 1 }); + + const agents2 = await detector.detectAgents(); + expect(agents2.find(a => a.id === 'claude-code')?.available).toBe(false); + }); + }); + + describe('edge cases', () => { + it('should handle whitespace-only stdout from which', async () => { + mockExecFileNoThrow.mockResolvedValue({ stdout: ' \n\t\n', stderr: '', exitCode: 0 }); + + const agents = await detector.detectAgents(); + + // Empty stdout should mean not found + expect(agents.every(a => !a.available || a.id === 'terminal')).toBe(true); + }); + + it('should handle concurrent detectAgents and clearCache', async () => { + mockExecFileNoThrow.mockImplementation(async () => { + await new Promise(resolve => setTimeout(resolve, 50)); + return { stdout: '/usr/bin/found\n', stderr: '', exitCode: 0 }; + }); + + const detectPromise = detector.detectAgents(); + detector.clearCache(); // Clear during detection + + const result = await detectPromise; + expect(result).toBeDefined(); + expect(result.length).toBe(5); + }); + + it('should handle very long PATH', async () => { + const originalPath = process.env.PATH; + // Create a very long PATH + const longPath = Array(1000).fill('/some/path').join(':'); + process.env.PATH = longPath; + + const newDetector = new AgentDetector(); + await newDetector.detectAgents(); + + // Should still work + expect(mockExecFileNoThrow).toHaveBeenCalled(); + + process.env.PATH = originalPath; + }); + + it('should include all system paths in expanded environment', async () => { + // Test that system paths are properly included + await detector.detectAgents(); + + const call = mockExecFileNoThrow.mock.calls[0]; + const env = call[3] as NodeJS.ProcessEnv; + const path = env.PATH || ''; + + // Check critical system paths + expect(path).toContain('/usr/bin'); + expect(path).toContain('/bin'); + expect(path).toContain('/usr/local/bin'); + expect(path).toContain('/opt/homebrew/bin'); + }); + + it('should handle undefined PATH', async () => { + const originalPath = process.env.PATH; + delete process.env.PATH; + + const newDetector = new AgentDetector(); + await newDetector.detectAgents(); + + expect(mockExecFileNoThrow).toHaveBeenCalled(); + + process.env.PATH = originalPath; + }); + }); +}); diff --git a/src/__tests__/main/themes.test.ts b/src/__tests__/main/themes.test.ts new file mode 100644 index 00000000..360d1cdd --- /dev/null +++ b/src/__tests__/main/themes.test.ts @@ -0,0 +1,228 @@ +/** + * Tests for src/main/themes.ts + * + * Tests cover theme definitions and the getThemeById function. + * This module mirrors the renderer themes for use in the main process. + */ + +import { describe, it, expect } from 'vitest'; +import { THEMES, getThemeById } from '../../main/themes'; +import type { Theme, ThemeId } from '../../shared/theme-types'; + +describe('themes.ts', () => { + describe('THEMES constant', () => { + it('should export a Record of themes', () => { + expect(THEMES).toBeDefined(); + expect(typeof THEMES).toBe('object'); + }); + + it('should contain all expected theme IDs', () => { + const expectedThemeIds: ThemeId[] = [ + 'dracula', + 'monokai', + 'nord', + 'tokyo-night', + 'catppuccin-mocha', + 'gruvbox-dark', + 'github-light', + 'solarized-light', + 'one-light', + 'gruvbox-light', + 'catppuccin-latte', + 'ayu-light', + 'pedurple', + 'maestros-choice', + 'dre-synth', + 'inquest', + ]; + + expectedThemeIds.forEach((id) => { + expect(THEMES[id]).toBeDefined(); + }); + }); + + describe('dark themes', () => { + const darkThemes = ['dracula', 'monokai', 'nord', 'tokyo-night', 'catppuccin-mocha', 'gruvbox-dark']; + + darkThemes.forEach((themeId) => { + it(`${themeId} should have mode "dark"`, () => { + expect(THEMES[themeId as ThemeId].mode).toBe('dark'); + }); + }); + }); + + describe('light themes', () => { + const lightThemes = ['github-light', 'solarized-light', 'one-light', 'gruvbox-light', 'catppuccin-latte', 'ayu-light']; + + lightThemes.forEach((themeId) => { + it(`${themeId} should have mode "light"`, () => { + expect(THEMES[themeId as ThemeId].mode).toBe('light'); + }); + }); + }); + + describe('vibe themes', () => { + const vibeThemes = ['pedurple', 'maestros-choice', 'dre-synth', 'inquest']; + + vibeThemes.forEach((themeId) => { + it(`${themeId} should have mode "vibe"`, () => { + expect(THEMES[themeId as ThemeId].mode).toBe('vibe'); + }); + }); + }); + + describe('theme structure', () => { + Object.entries(THEMES).forEach(([id, theme]) => { + describe(`${id} theme`, () => { + it('should have an id matching the key', () => { + expect(theme.id).toBe(id); + }); + + it('should have a name', () => { + expect(theme.name).toBeTruthy(); + expect(typeof theme.name).toBe('string'); + }); + + it('should have a valid mode', () => { + expect(['dark', 'light', 'vibe']).toContain(theme.mode); + }); + + it('should have all required color properties', () => { + const requiredColors = [ + 'bgMain', + 'bgSidebar', + 'bgActivity', + 'border', + 'textMain', + 'textDim', + 'accent', + 'accentDim', + 'accentText', + 'accentForeground', + 'success', + 'warning', + 'error', + ]; + + requiredColors.forEach((colorKey) => { + expect(theme.colors).toHaveProperty(colorKey); + expect(theme.colors[colorKey as keyof typeof theme.colors]).toBeTruthy(); + }); + }); + + it('should have valid hex colors for main properties', () => { + const hexColorPattern = /^#[0-9a-fA-F]{6}$/; + const hexColors = ['bgMain', 'bgSidebar', 'bgActivity', 'border', 'textMain', 'textDim', 'success', 'warning', 'error']; + + hexColors.forEach((colorKey) => { + const color = theme.colors[colorKey as keyof typeof theme.colors]; + expect(color).toMatch(hexColorPattern); + }); + }); + + it('should have valid colors for accent properties', () => { + // Accent colors can be hex or rgba + const hexOrRgbaPattern = /^(#[0-9a-fA-F]{6}|rgba?\([^)]+\))$/; + const accentColors = ['accent', 'accentDim', 'accentText', 'accentForeground']; + + accentColors.forEach((colorKey) => { + const color = theme.colors[colorKey as keyof typeof theme.colors]; + expect(color).toMatch(hexOrRgbaPattern); + }); + }); + }); + }); + }); + }); + + describe('getThemeById', () => { + it('should return a theme for valid theme IDs', () => { + const theme = getThemeById('dracula'); + + expect(theme).not.toBeNull(); + expect(theme?.id).toBe('dracula'); + expect(theme?.name).toBe('Dracula'); + }); + + it('should return null for unknown theme IDs', () => { + const theme = getThemeById('nonexistent-theme'); + + expect(theme).toBeNull(); + }); + + it('should return null for empty string', () => { + const theme = getThemeById(''); + + expect(theme).toBeNull(); + }); + + it('should return correct theme for all valid IDs', () => { + Object.keys(THEMES).forEach((themeId) => { + const theme = getThemeById(themeId); + + expect(theme).not.toBeNull(); + expect(theme?.id).toBe(themeId); + }); + }); + + it('should return the exact same object from THEMES', () => { + const themeId = 'nord'; + const theme = getThemeById(themeId); + + expect(theme).toBe(THEMES[themeId]); + }); + + describe('specific theme properties', () => { + it('should return correct dracula theme colors', () => { + const theme = getThemeById('dracula'); + + expect(theme?.colors.bgMain).toBe('#0b0b0d'); + expect(theme?.colors.accent).toBe('#6366f1'); + }); + + it('should return correct github-light theme colors', () => { + const theme = getThemeById('github-light'); + + expect(theme?.colors.bgMain).toBe('#ffffff'); + expect(theme?.colors.accent).toBe('#0969da'); + }); + + it('should return correct pedurple (vibe) theme colors', () => { + const theme = getThemeById('pedurple'); + + expect(theme?.colors.accent).toBe('#ff69b4'); + expect(theme?.mode).toBe('vibe'); + }); + }); + + describe('type safety', () => { + it('should accept string parameter', () => { + const themeId: string = 'monokai'; + const theme = getThemeById(themeId); + + expect(theme).not.toBeNull(); + }); + + it('should return Theme type or null', () => { + const theme: Theme | null = getThemeById('nord'); + + if (theme) { + // TypeScript should know theme is Theme here + expect(theme.id).toBe('nord'); + expect(theme.colors.bgMain).toBeDefined(); + } + }); + }); + }); + + describe('type exports', () => { + it('should export Theme and ThemeId types', () => { + // Type check - ensure the types are usable + const theme: Theme = THEMES['dracula']; + const themeId: ThemeId = 'dracula'; + + expect(theme).toBeDefined(); + expect(themeId).toBe('dracula'); + }); + }); +}); diff --git a/src/__tests__/main/tunnel-manager.test.ts b/src/__tests__/main/tunnel-manager.test.ts new file mode 100644 index 00000000..0fe36040 --- /dev/null +++ b/src/__tests__/main/tunnel-manager.test.ts @@ -0,0 +1,338 @@ +/** + * @file tunnel-manager.test.ts + * @description Tests for the TunnelManager class + * + * TunnelManager manages cloudflared tunnels for exposing local servers: + * - start(port) - starts a tunnel on the specified port + * - stop() - stops the running tunnel + * - getStatus() - returns the current tunnel status + * + * Note: Tests for async operations involving URLs and events are in separate + * test files with proper timeout handling. This file focuses on synchronous + * and fast-resolving tests. + */ + +import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'; +import { EventEmitter } from 'events'; + +// Create mock functions using vi.hoisted +const mocks = vi.hoisted(() => ({ + mockSpawn: vi.fn(), + mockIsCloudflaredInstalled: vi.fn(), + mockGetCloudflaredPath: vi.fn(), + mockLoggerInfo: vi.fn(), + mockLoggerError: vi.fn(), +})); + +// Mock child_process using dynamic import for the original +vi.mock('child_process', async (importOriginal) => { + const actual = await importOriginal(); + return { + ...actual, + default: { + ...actual, + spawn: mocks.mockSpawn, + }, + spawn: mocks.mockSpawn, + }; +}); + +// Mock logger +vi.mock('../../main/utils/logger', () => ({ + logger: { + info: mocks.mockLoggerInfo, + error: mocks.mockLoggerError, + }, +})); + +// Mock cliDetection +vi.mock('../../main/utils/cliDetection', () => ({ + isCloudflaredInstalled: mocks.mockIsCloudflaredInstalled, + getCloudflaredPath: mocks.mockGetCloudflaredPath, +})); + +// Helper to create a mock ChildProcess +const createMockProcess = () => { + const process = new EventEmitter() as EventEmitter & { + stderr: EventEmitter; + stdout: EventEmitter; + killed: boolean; + kill: ReturnType; + }; + process.stderr = new EventEmitter(); + process.stdout = new EventEmitter(); + process.kill = vi.fn(); + process.killed = false; + return process; +}; + +describe('TunnelManager', () => { + let tunnelManager: typeof import('../../main/tunnel-manager').tunnelManager; + let mockProcess: ReturnType; + + beforeEach(async () => { + vi.clearAllMocks(); + + // Reset module to get fresh TunnelManager instance + vi.resetModules(); + + // Default mock setup + mockProcess = createMockProcess(); + mocks.mockSpawn.mockReturnValue(mockProcess); + mocks.mockIsCloudflaredInstalled.mockResolvedValue(true); + mocks.mockGetCloudflaredPath.mockReturnValue('/usr/local/bin/cloudflared'); + + // Import fresh module + const module = await import('../../main/tunnel-manager'); + tunnelManager = module.tunnelManager; + }); + + afterEach(() => { + vi.clearAllMocks(); + }); + + // ============================================================================= + // GETSTATUS TESTS + // ============================================================================= + + describe('getStatus', () => { + it('returns initial status when no tunnel is running', () => { + const status = tunnelManager.getStatus(); + + expect(status).toEqual({ + isRunning: false, + url: null, + error: null, + }); + }); + + it('TunnelStatus has correct properties', () => { + const status = tunnelManager.getStatus(); + + expect(status).toHaveProperty('isRunning'); + expect(status).toHaveProperty('url'); + expect(status).toHaveProperty('error'); + expect(typeof status.isRunning).toBe('boolean'); + }); + }); + + // ============================================================================= + // START PORT VALIDATION TESTS + // ============================================================================= + + describe('start - port validation', () => { + it('rejects negative port', async () => { + const result = await tunnelManager.start(-1); + + expect(result.success).toBe(false); + expect(result.error).toContain('Invalid port number'); + expect(result.error).toContain('-1'); + }); + + it('rejects port 0', async () => { + const result = await tunnelManager.start(0); + + expect(result.success).toBe(false); + expect(result.error).toContain('Invalid port number'); + }); + + it('rejects port > 65535', async () => { + const result = await tunnelManager.start(65536); + + expect(result.success).toBe(false); + expect(result.error).toContain('Invalid port number'); + }); + + it('rejects port 100000', async () => { + const result = await tunnelManager.start(100000); + + expect(result.success).toBe(false); + expect(result.error).toContain('Invalid port number'); + }); + + it('rejects non-integer port 3000.5', async () => { + const result = await tunnelManager.start(3000.5); + + expect(result.success).toBe(false); + expect(result.error).toContain('Invalid port number'); + }); + + it('rejects non-integer port 1.1', async () => { + const result = await tunnelManager.start(1.1); + + expect(result.success).toBe(false); + expect(result.error).toContain('Invalid port number'); + }); + + it('TunnelResult error shape on invalid port', async () => { + const result = await tunnelManager.start(-1); + + expect(result).toHaveProperty('success', false); + expect(result).toHaveProperty('error'); + expect(typeof result.error).toBe('string'); + expect(result.url).toBeUndefined(); + }); + }); + + // ============================================================================= + // START CLOUDFLARED DETECTION TESTS + // ============================================================================= + + describe('start - cloudflared detection', () => { + it('returns error when cloudflared is not installed', async () => { + mocks.mockIsCloudflaredInstalled.mockResolvedValue(false); + + const result = await tunnelManager.start(3000); + + expect(result.success).toBe(false); + expect(result.error).toBe('cloudflared is not installed'); + }); + + it('checks cloudflared installation before spawning', async () => { + mocks.mockIsCloudflaredInstalled.mockResolvedValue(false); + + await tunnelManager.start(3000); + + expect(mocks.mockIsCloudflaredInstalled).toHaveBeenCalled(); + // Should NOT spawn when cloudflared is not installed + expect(mocks.mockSpawn).not.toHaveBeenCalled(); + }); + }); + + // ============================================================================= + // SPAWN CONFIGURATION TESTS + // Note: These tests verify spawn is called correctly by waiting for the + // async cloudflared installation check to complete first. + // ============================================================================= + + describe('start - spawn configuration', () => { + it('spawns cloudflared with correct binary path', async () => { + mocks.mockGetCloudflaredPath.mockReturnValue('/custom/path/cloudflared'); + + // Start and let the async cloudflared check complete + const promise = tunnelManager.start(3000); + + // Give time for the async isCloudflaredInstalled to resolve + await new Promise(resolve => setImmediate(resolve)); + + expect(mocks.mockSpawn).toHaveBeenCalledWith( + '/custom/path/cloudflared', + expect.any(Array) + ); + + // Clean up by emitting exit (don't wait for it) + mockProcess.emit('exit', 0); + }); + + it('uses default cloudflared when path is null', async () => { + mocks.mockGetCloudflaredPath.mockReturnValue(null); + + tunnelManager.start(3000); + await new Promise(resolve => setImmediate(resolve)); + + expect(mocks.mockSpawn).toHaveBeenCalledWith( + 'cloudflared', + expect.any(Array) + ); + + mockProcess.emit('exit', 0); + }); + + it('spawns with tunnel command', async () => { + tunnelManager.start(3000); + await new Promise(resolve => setImmediate(resolve)); + + expect(mocks.mockSpawn).toHaveBeenCalledWith( + expect.any(String), + expect.arrayContaining(['tunnel']) + ); + + mockProcess.emit('exit', 0); + }); + + it('spawns with --url argument', async () => { + tunnelManager.start(3000); + await new Promise(resolve => setImmediate(resolve)); + + expect(mocks.mockSpawn).toHaveBeenCalledWith( + expect.any(String), + expect.arrayContaining(['--url']) + ); + + mockProcess.emit('exit', 0); + }); + + it('passes localhost URL with correct port', async () => { + tunnelManager.start(8080); + await new Promise(resolve => setImmediate(resolve)); + + expect(mocks.mockSpawn).toHaveBeenCalledWith( + expect.any(String), + expect.arrayContaining(['http://localhost:8080']) + ); + + mockProcess.emit('exit', 0); + }); + + it('passes different ports correctly', async () => { + tunnelManager.start(9000); + await new Promise(resolve => setImmediate(resolve)); + + expect(mocks.mockSpawn).toHaveBeenCalledWith( + expect.any(String), + expect.arrayContaining(['http://localhost:9000']) + ); + + mockProcess.emit('exit', 0); + }); + + it('logs start message', async () => { + tunnelManager.start(3000); + await new Promise(resolve => setImmediate(resolve)); + + expect(mocks.mockLoggerInfo).toHaveBeenCalledWith( + expect.stringContaining('Starting cloudflared tunnel for port 3000'), + 'TunnelManager' + ); + + mockProcess.emit('exit', 0); + }); + + it('logs binary path in start message', async () => { + mocks.mockGetCloudflaredPath.mockReturnValue('/custom/cloudflared'); + + tunnelManager.start(3000); + await new Promise(resolve => setImmediate(resolve)); + + expect(mocks.mockLoggerInfo).toHaveBeenCalledWith( + expect.stringContaining('/custom/cloudflared'), + 'TunnelManager' + ); + + mockProcess.emit('exit', 0); + }); + }); + + // ============================================================================= + // INTERFACE EXPORTS + // ============================================================================= + + describe('exports', () => { + it('exports tunnelManager singleton', async () => { + const module = await import('../../main/tunnel-manager'); + expect(module.tunnelManager).toBeDefined(); + expect(typeof module.tunnelManager.start).toBe('function'); + expect(typeof module.tunnelManager.stop).toBe('function'); + expect(typeof module.tunnelManager.getStatus).toBe('function'); + }); + + it('TunnelStatus interface shape from getStatus', () => { + const status = tunnelManager.getStatus(); + + // Verify all expected properties exist + expect('isRunning' in status).toBe(true); + expect('url' in status).toBe(true); + expect('error' in status).toBe(true); + }); + }); +}); diff --git a/src/__tests__/main/utils/cliDetection.test.ts b/src/__tests__/main/utils/cliDetection.test.ts new file mode 100644 index 00000000..bd07c177 --- /dev/null +++ b/src/__tests__/main/utils/cliDetection.test.ts @@ -0,0 +1,457 @@ +/** + * Tests for src/main/utils/cliDetection.ts + * + * Tests cover cloudflared detection functionality including: + * - isCloudflaredInstalled + * - getCloudflaredPath + * - clearCloudflaredCache + */ + +import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'; + +// Mock execFileNoThrow before importing the module +vi.mock('../../../main/utils/execFile', () => ({ + execFileNoThrow: vi.fn(), +})); + +// Mock os module for homedir +vi.mock('os', () => ({ + default: { homedir: () => '/home/testuser' }, + homedir: () => '/home/testuser', +})); + +import { + isCloudflaredInstalled, + getCloudflaredPath, + clearCloudflaredCache, +} from '../../../main/utils/cliDetection'; +import { execFileNoThrow } from '../../../main/utils/execFile'; + +const mockedExecFileNoThrow = vi.mocked(execFileNoThrow); + +describe('cliDetection.ts', () => { + const originalPlatform = process.platform; + + beforeEach(() => { + vi.clearAllMocks(); + // Always clear cache before each test to ensure fresh state + clearCloudflaredCache(); + }); + + afterEach(() => { + vi.restoreAllMocks(); + // Restore platform + Object.defineProperty(process, 'platform', { value: originalPlatform }); + }); + + describe('isCloudflaredInstalled', () => { + describe('on Unix-like systems', () => { + beforeEach(() => { + Object.defineProperty(process, 'platform', { value: 'darwin' }); + }); + + it('should return true when cloudflared is found', async () => { + mockedExecFileNoThrow.mockResolvedValue({ + stdout: '/usr/local/bin/cloudflared\n', + stderr: '', + exitCode: 0, + }); + + const result = await isCloudflaredInstalled(); + + expect(result).toBe(true); + expect(mockedExecFileNoThrow).toHaveBeenCalledWith( + 'which', + ['cloudflared'], + undefined, + expect.any(Object) + ); + }); + + it('should return false when cloudflared is not found', async () => { + mockedExecFileNoThrow.mockResolvedValue({ + stdout: '', + stderr: 'cloudflared not found', + exitCode: 1, + }); + + const result = await isCloudflaredInstalled(); + + expect(result).toBe(false); + }); + + it('should return false when stdout is empty even with exit code 0', async () => { + mockedExecFileNoThrow.mockResolvedValue({ + stdout: '', + stderr: '', + exitCode: 0, + }); + + const result = await isCloudflaredInstalled(); + + expect(result).toBe(false); + }); + + it('should return false when stdout is whitespace only', async () => { + mockedExecFileNoThrow.mockResolvedValue({ + stdout: ' \n\t ', + stderr: '', + exitCode: 0, + }); + + // Clear cache and retry + clearCloudflaredCache(); + const result = await isCloudflaredInstalled(); + + expect(result).toBe(false); + }); + + it('should use expanded PATH environment', async () => { + mockedExecFileNoThrow.mockResolvedValue({ + stdout: '/opt/homebrew/bin/cloudflared\n', + stderr: '', + exitCode: 0, + }); + + await isCloudflaredInstalled(); + + // Verify the env parameter contains expanded PATH + expect(mockedExecFileNoThrow).toHaveBeenCalledWith( + 'which', + ['cloudflared'], + undefined, + expect.objectContaining({ + PATH: expect.stringContaining('/opt/homebrew/bin'), + }) + ); + }); + + it('should include common binary locations in PATH', async () => { + mockedExecFileNoThrow.mockResolvedValue({ + stdout: '/usr/local/bin/cloudflared\n', + stderr: '', + exitCode: 0, + }); + + await isCloudflaredInstalled(); + + const callEnv = mockedExecFileNoThrow.mock.calls[0][3] as NodeJS.ProcessEnv; + const path = callEnv.PATH || ''; + + expect(path).toContain('/opt/homebrew/bin'); + expect(path).toContain('/usr/local/bin'); + expect(path).toContain('/home/testuser/.local/bin'); + expect(path).toContain('/home/testuser/bin'); + expect(path).toContain('/usr/bin'); + expect(path).toContain('/bin'); + }); + }); + + describe('on Windows', () => { + beforeEach(() => { + Object.defineProperty(process, 'platform', { value: 'win32' }); + }); + + it('should use where command instead of which', async () => { + mockedExecFileNoThrow.mockResolvedValue({ + stdout: 'C:\\Program Files\\cloudflared\\cloudflared.exe\n', + stderr: '', + exitCode: 0, + }); + + const result = await isCloudflaredInstalled(); + + expect(result).toBe(true); + expect(mockedExecFileNoThrow).toHaveBeenCalledWith( + 'where', + ['cloudflared'], + undefined, + expect.any(Object) + ); + }); + }); + + describe('caching behavior', () => { + it('should cache the result after first call', async () => { + mockedExecFileNoThrow.mockResolvedValue({ + stdout: '/usr/local/bin/cloudflared\n', + stderr: '', + exitCode: 0, + }); + + // First call + await isCloudflaredInstalled(); + expect(mockedExecFileNoThrow).toHaveBeenCalledTimes(1); + + // Second call should use cache + const result = await isCloudflaredInstalled(); + expect(mockedExecFileNoThrow).toHaveBeenCalledTimes(1); + expect(result).toBe(true); + }); + + it('should cache false results too', async () => { + mockedExecFileNoThrow.mockResolvedValue({ + stdout: '', + stderr: 'not found', + exitCode: 1, + }); + + // First call + await isCloudflaredInstalled(); + expect(mockedExecFileNoThrow).toHaveBeenCalledTimes(1); + + // Second call should use cache + const result = await isCloudflaredInstalled(); + expect(mockedExecFileNoThrow).toHaveBeenCalledTimes(1); + expect(result).toBe(false); + }); + }); + + describe('path extraction', () => { + it('should extract first path when multiple paths returned', async () => { + mockedExecFileNoThrow.mockResolvedValue({ + stdout: '/opt/homebrew/bin/cloudflared\n/usr/local/bin/cloudflared\n', + stderr: '', + exitCode: 0, + }); + + await isCloudflaredInstalled(); + + expect(getCloudflaredPath()).toBe('/opt/homebrew/bin/cloudflared'); + }); + + it('should trim whitespace from path', async () => { + mockedExecFileNoThrow.mockResolvedValue({ + stdout: ' /usr/local/bin/cloudflared \n', + stderr: '', + exitCode: 0, + }); + + await isCloudflaredInstalled(); + + expect(getCloudflaredPath()).toBe('/usr/local/bin/cloudflared'); + }); + }); + }); + + describe('getCloudflaredPath', () => { + // Note: The path cache is separate from the installed cache. + // clearCloudflaredCache() only clears the installed cache, NOT the path cache. + // This means once a path is found, it persists until the module is reloaded. + + it('should return the path after successful detection', async () => { + mockedExecFileNoThrow.mockResolvedValue({ + stdout: '/usr/bin/cloudflared\n', + stderr: '', + exitCode: 0, + }); + + await isCloudflaredInstalled(); + + expect(getCloudflaredPath()).toBe('/usr/bin/cloudflared'); + }); + + it('should NOT update path cache when detection fails after previous success', async () => { + // First, ensure we have a successful detection + mockedExecFileNoThrow.mockResolvedValueOnce({ + stdout: '/first/path/cloudflared\n', + stderr: '', + exitCode: 0, + }); + clearCloudflaredCache(); + await isCloudflaredInstalled(); + const firstPath = getCloudflaredPath(); + + // Clear the installed cache (not path cache) + clearCloudflaredCache(); + + // Now a failed detection + mockedExecFileNoThrow.mockResolvedValueOnce({ + stdout: '', + stderr: 'not found', + exitCode: 1, + }); + await isCloudflaredInstalled(); + + // Path should still be the old value since the code doesn't clear it on failure + // This tests the ACTUAL behavior of the code + expect(getCloudflaredPath()).toBe(firstPath); + }); + + it('should update path when detection succeeds again with new path', async () => { + mockedExecFileNoThrow.mockResolvedValueOnce({ + stdout: '/new/path/cloudflared\n', + stderr: '', + exitCode: 0, + }); + + clearCloudflaredCache(); + await isCloudflaredInstalled(); + + expect(getCloudflaredPath()).toBe('/new/path/cloudflared'); + }); + }); + + describe('clearCloudflaredCache', () => { + it('should clear the cached result', async () => { + mockedExecFileNoThrow.mockResolvedValue({ + stdout: '/usr/local/bin/cloudflared\n', + stderr: '', + exitCode: 0, + }); + + // First call populates cache + await isCloudflaredInstalled(); + expect(mockedExecFileNoThrow).toHaveBeenCalledTimes(1); + + // Clear cache + clearCloudflaredCache(); + + // Next call should hit execFileNoThrow again + await isCloudflaredInstalled(); + expect(mockedExecFileNoThrow).toHaveBeenCalledTimes(2); + }); + + it('should allow re-detection with different result after cache clear', async () => { + // First detection: found + mockedExecFileNoThrow.mockResolvedValueOnce({ + stdout: '/usr/local/bin/cloudflared\n', + stderr: '', + exitCode: 0, + }); + + const firstResult = await isCloudflaredInstalled(); + expect(firstResult).toBe(true); + + // Clear cache + clearCloudflaredCache(); + + // Second detection: not found + mockedExecFileNoThrow.mockResolvedValueOnce({ + stdout: '', + stderr: 'not found', + exitCode: 1, + }); + + const secondResult = await isCloudflaredInstalled(); + expect(secondResult).toBe(false); + }); + }); + + describe('getExpandedEnv internal function', () => { + it('should not duplicate paths that already exist in PATH', async () => { + // Set up process.env.PATH to include some of the additional paths + const originalPath = process.env.PATH; + process.env.PATH = '/opt/homebrew/bin:/usr/bin:/custom/path'; + + mockedExecFileNoThrow.mockResolvedValue({ + stdout: '/usr/bin/cloudflared\n', + stderr: '', + exitCode: 0, + }); + + // Clear cache to trigger new detection + clearCloudflaredCache(); + await isCloudflaredInstalled(); + + const callEnv = mockedExecFileNoThrow.mock.calls[0][3] as NodeJS.ProcessEnv; + const pathParts = (callEnv.PATH || '').split(':'); + + // Count occurrences of /opt/homebrew/bin - should be 1 + const homebrewCount = pathParts.filter((p) => p === '/opt/homebrew/bin').length; + expect(homebrewCount).toBe(1); + + // Restore original PATH + process.env.PATH = originalPath; + }); + + it('should prepend additional paths to front of PATH', async () => { + const originalPath = process.env.PATH; + process.env.PATH = '/custom/path'; + + mockedExecFileNoThrow.mockResolvedValue({ + stdout: '/usr/bin/cloudflared\n', + stderr: '', + exitCode: 0, + }); + + clearCloudflaredCache(); + await isCloudflaredInstalled(); + + const callEnv = mockedExecFileNoThrow.mock.calls[0][3] as NodeJS.ProcessEnv; + const path = callEnv.PATH || ''; + + // Additional paths should come before custom path + const homebrewIndex = path.indexOf('/opt/homebrew/bin'); + const customIndex = path.indexOf('/custom/path'); + expect(homebrewIndex).toBeLessThan(customIndex); + + process.env.PATH = originalPath; + }); + + it('should handle empty PATH environment', async () => { + const originalPath = process.env.PATH; + delete process.env.PATH; + + mockedExecFileNoThrow.mockResolvedValue({ + stdout: '/usr/bin/cloudflared\n', + stderr: '', + exitCode: 0, + }); + + clearCloudflaredCache(); + await isCloudflaredInstalled(); + + const callEnv = mockedExecFileNoThrow.mock.calls[0][3] as NodeJS.ProcessEnv; + const path = callEnv.PATH || ''; + + // Should still have the additional paths + expect(path).toContain('/opt/homebrew/bin'); + expect(path).toContain('/usr/local/bin'); + + process.env.PATH = originalPath; + }); + }); + + describe('edge cases', () => { + it('should handle path with spaces', async () => { + mockedExecFileNoThrow.mockResolvedValue({ + stdout: '/path/with spaces/cloudflared\n', + stderr: '', + exitCode: 0, + }); + + await isCloudflaredInstalled(); + + expect(getCloudflaredPath()).toBe('/path/with spaces/cloudflared'); + }); + + it('should handle Windows-style path', async () => { + Object.defineProperty(process, 'platform', { value: 'win32' }); + + mockedExecFileNoThrow.mockResolvedValue({ + stdout: 'C:\\Program Files\\Cloudflared\\cloudflared.exe\r\n', + stderr: '', + exitCode: 0, + }); + + clearCloudflaredCache(); + const result = await isCloudflaredInstalled(); + + expect(result).toBe(true); + expect(getCloudflaredPath()).toBe('C:\\Program Files\\Cloudflared\\cloudflared.exe'); + }); + + it('should handle path with special characters', async () => { + mockedExecFileNoThrow.mockResolvedValue({ + stdout: '/home/user@domain/bin/cloudflared\n', + stderr: '', + exitCode: 0, + }); + + await isCloudflaredInstalled(); + + expect(getCloudflaredPath()).toBe('/home/user@domain/bin/cloudflared'); + }); + }); +}); diff --git a/src/__tests__/main/utils/execFile.test.ts b/src/__tests__/main/utils/execFile.test.ts new file mode 100644 index 00000000..6abe2bdc --- /dev/null +++ b/src/__tests__/main/utils/execFile.test.ts @@ -0,0 +1,567 @@ +/** + * Tests for src/main/utils/execFile.ts + * + * Tests cover the execFileNoThrow function which safely executes + * commands without shell injection vulnerabilities. + */ + +import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'; +import type { ExecResult } from '../../../main/utils/execFile'; + +// Create mock function +const mockExecFile = vi.fn(); + +// Mock child_process module using vi.mock with dynamic import +vi.mock('child_process', async (importOriginal) => { + const actual = await importOriginal(); + return { + ...actual, + default: { + ...actual, + execFile: mockExecFile, + }, + execFile: mockExecFile, + }; +}); + +// Mock util.promisify to return our mock function wrapped in a promise +vi.mock('util', async (importOriginal) => { + const actual = await importOriginal(); + return { + ...actual, + default: { + ...actual, + promisify: (fn: any) => { + // If it's our mock, return it wrapped + if (fn === mockExecFile) { + return async (...args: any[]) => { + return new Promise((resolve, reject) => { + mockExecFile(...args, (error: Error | null, stdout: string, stderr: string) => { + if (error) reject(error); + else resolve({ stdout, stderr }); + }); + }); + }; + } + return actual.promisify(fn); + }, + }, + promisify: (fn: any) => { + // If it's our mock, return it wrapped + if (fn === mockExecFile) { + return async (...args: any[]) => { + return new Promise((resolve, reject) => { + mockExecFile(...args, (error: Error | null, stdout: string, stderr: string) => { + if (error) reject(error); + else resolve({ stdout, stderr }); + }); + }); + }; + } + return actual.promisify(fn); + }, + }; +}); + +describe('execFile.ts', () => { + beforeEach(() => { + vi.clearAllMocks(); + }); + + afterEach(() => { + vi.restoreAllMocks(); + }); + + describe('ExecResult interface', () => { + it('should define the correct structure', () => { + // Type test - verifying interface shape + const result: ExecResult = { + stdout: 'output', + stderr: 'error', + exitCode: 0, + }; + + expect(result).toHaveProperty('stdout'); + expect(result).toHaveProperty('stderr'); + expect(result).toHaveProperty('exitCode'); + }); + }); + + describe('execFileNoThrow', () => { + describe('successful execution', () => { + it('should return stdout and stderr with exitCode 0 on success', async () => { + mockExecFile.mockImplementation( + (_cmd: string, _args: readonly string[], _options: any, callback?: any) => { + if (callback) { + callback(null, 'command output', 'stderr output'); + } + return {} as any; + } + ); + + const { execFileNoThrow } = await import('../../../main/utils/execFile'); + const result = await execFileNoThrow('echo', ['hello']); + + expect(result).toEqual({ + stdout: 'command output', + stderr: 'stderr output', + exitCode: 0, + }); + }); + + it('should call execFile with correct arguments', async () => { + mockExecFile.mockImplementation( + (_cmd: string, _args: readonly string[], _options: any, callback?: any) => { + if (callback) { + callback(null, 'output', ''); + } + return {} as any; + } + ); + + const { execFileNoThrow } = await import('../../../main/utils/execFile'); + await execFileNoThrow('git', ['status', '--short'], '/path/to/repo'); + + expect(mockExecFile).toHaveBeenCalledWith( + 'git', + ['status', '--short'], + expect.objectContaining({ + cwd: '/path/to/repo', + encoding: 'utf8', + maxBuffer: 10 * 1024 * 1024, // 10MB + }), + expect.any(Function) + ); + }); + + it('should use provided environment variables', async () => { + mockExecFile.mockImplementation( + (_cmd: string, _args: readonly string[], _options: any, callback?: any) => { + if (callback) { + callback(null, 'output', ''); + } + return {} as any; + } + ); + + const { execFileNoThrow } = await import('../../../main/utils/execFile'); + const customEnv = { PATH: '/custom/path', MY_VAR: 'value' }; + await execFileNoThrow('mycmd', [], '/cwd', customEnv); + + expect(mockExecFile).toHaveBeenCalledWith( + 'mycmd', + [], + expect.objectContaining({ + env: customEnv, + }), + expect.any(Function) + ); + }); + + it('should handle empty arguments array', async () => { + mockExecFile.mockImplementation( + (_cmd: string, _args: readonly string[], _options: any, callback?: any) => { + if (callback) { + callback(null, 'output', ''); + } + return {} as any; + } + ); + + const { execFileNoThrow } = await import('../../../main/utils/execFile'); + const result = await execFileNoThrow('ls'); + + expect(result.exitCode).toBe(0); + expect(mockExecFile).toHaveBeenCalledWith( + 'ls', + [], + expect.any(Object), + expect.any(Function) + ); + }); + + it('should handle empty stdout and stderr', async () => { + mockExecFile.mockImplementation( + (_cmd: string, _args: readonly string[], _options: any, callback?: any) => { + if (callback) { + callback(null, '', ''); + } + return {} as any; + } + ); + + const { execFileNoThrow } = await import('../../../main/utils/execFile'); + const result = await execFileNoThrow('true'); + + expect(result).toEqual({ + stdout: '', + stderr: '', + exitCode: 0, + }); + }); + }); + + describe('error handling', () => { + it('should return non-zero exit code on command failure', async () => { + const error = new Error('Command failed') as any; + error.code = 1; + error.stdout = 'partial output'; + error.stderr = 'error message'; + + mockExecFile.mockImplementation( + (_cmd: string, _args: readonly string[], _options: any, callback?: any) => { + if (callback) { + callback(error, '', ''); + } + return {} as any; + } + ); + + const { execFileNoThrow } = await import('../../../main/utils/execFile'); + const result = await execFileNoThrow('failing-cmd'); + + expect(result).toEqual({ + stdout: 'partial output', + stderr: 'error message', + exitCode: 1, + }); + }); + + it('should use error.message as stderr when stderr is empty', async () => { + const error = new Error('Command not found') as any; + error.code = 127; + error.stdout = ''; + error.stderr = ''; + + mockExecFile.mockImplementation( + (_cmd: string, _args: readonly string[], _options: any, callback?: any) => { + if (callback) { + callback(error, '', ''); + } + return {} as any; + } + ); + + const { execFileNoThrow } = await import('../../../main/utils/execFile'); + const result = await execFileNoThrow('nonexistent-cmd'); + + expect(result).toEqual({ + stdout: '', + stderr: 'Command not found', + exitCode: 127, + }); + }); + + it('should default to exit code 1 when error.code is undefined', async () => { + const error = new Error('Unknown error') as any; + error.stdout = ''; + error.stderr = 'some error'; + + mockExecFile.mockImplementation( + (_cmd: string, _args: readonly string[], _options: any, callback?: any) => { + if (callback) { + callback(error, '', ''); + } + return {} as any; + } + ); + + const { execFileNoThrow } = await import('../../../main/utils/execFile'); + const result = await execFileNoThrow('cmd'); + + expect(result.exitCode).toBe(1); + }); + + it('should handle missing stdout on error', async () => { + const error = new Error('Error') as any; + error.code = 2; + error.stderr = 'error output'; + + mockExecFile.mockImplementation( + (_cmd: string, _args: readonly string[], _options: any, callback?: any) => { + if (callback) { + callback(error, '', ''); + } + return {} as any; + } + ); + + const { execFileNoThrow } = await import('../../../main/utils/execFile'); + const result = await execFileNoThrow('cmd'); + + expect(result.stdout).toBe(''); + }); + + it('should handle missing stderr and message on error', async () => { + const error = {} as any; + error.code = 3; + + mockExecFile.mockImplementation( + (_cmd: string, _args: readonly string[], _options: any, callback?: any) => { + if (callback) { + callback(error, '', ''); + } + return {} as any; + } + ); + + const { execFileNoThrow } = await import('../../../main/utils/execFile'); + const result = await execFileNoThrow('cmd'); + + expect(result.stderr).toBe(''); + }); + + it('should handle ENOENT error (command not found)', async () => { + const error = new Error('spawn nonexistent ENOENT') as any; + error.code = 'ENOENT'; + error.stdout = ''; + error.stderr = ''; + + mockExecFile.mockImplementation( + (_cmd: string, _args: readonly string[], _options: any, callback?: any) => { + if (callback) { + callback(error, '', ''); + } + return {} as any; + } + ); + + const { execFileNoThrow } = await import('../../../main/utils/execFile'); + const result = await execFileNoThrow('nonexistent'); + + expect(result.exitCode).toBe('ENOENT'); + expect(result.stderr).toBe('spawn nonexistent ENOENT'); + }); + + it('should handle EPERM error (permission denied)', async () => { + const error = new Error('spawn EPERM') as any; + error.code = 'EPERM'; + error.stdout = ''; + error.stderr = 'Permission denied'; + + mockExecFile.mockImplementation( + (_cmd: string, _args: readonly string[], _options: any, callback?: any) => { + if (callback) { + callback(error, '', ''); + } + return {} as any; + } + ); + + const { execFileNoThrow } = await import('../../../main/utils/execFile'); + const result = await execFileNoThrow('/restricted/cmd'); + + expect(result.exitCode).toBe('EPERM'); + expect(result.stderr).toBe('Permission denied'); + }); + }); + + describe('edge cases', () => { + it('should handle commands with special characters in arguments', async () => { + mockExecFile.mockImplementation( + (_cmd: string, _args: readonly string[], _options: any, callback?: any) => { + if (callback) { + callback(null, 'output', ''); + } + return {} as any; + } + ); + + const { execFileNoThrow } = await import('../../../main/utils/execFile'); + await execFileNoThrow('echo', ['hello world', 'test=value', '"quoted"']); + + expect(mockExecFile).toHaveBeenCalledWith( + 'echo', + ['hello world', 'test=value', '"quoted"'], + expect.any(Object), + expect.any(Function) + ); + }); + + it('should handle undefined cwd', async () => { + mockExecFile.mockImplementation( + (_cmd: string, _args: readonly string[], _options: any, callback?: any) => { + if (callback) { + callback(null, 'output', ''); + } + return {} as any; + } + ); + + const { execFileNoThrow } = await import('../../../main/utils/execFile'); + await execFileNoThrow('pwd', [], undefined); + + expect(mockExecFile).toHaveBeenCalledWith( + 'pwd', + [], + expect.objectContaining({ + cwd: undefined, + }), + expect.any(Function) + ); + }); + + it('should handle undefined env', async () => { + mockExecFile.mockImplementation( + (_cmd: string, _args: readonly string[], _options: any, callback?: any) => { + if (callback) { + callback(null, 'output', ''); + } + return {} as any; + } + ); + + const { execFileNoThrow } = await import('../../../main/utils/execFile'); + await execFileNoThrow('env', [], '/cwd', undefined); + + expect(mockExecFile).toHaveBeenCalledWith( + 'env', + [], + expect.objectContaining({ + env: undefined, + }), + expect.any(Function) + ); + }); + + it('should handle large output within buffer limit', async () => { + const largeOutput = 'x'.repeat(1024 * 1024); // 1MB + + mockExecFile.mockImplementation( + (_cmd: string, _args: readonly string[], _options: any, callback?: any) => { + if (callback) { + callback(null, largeOutput, ''); + } + return {} as any; + } + ); + + const { execFileNoThrow } = await import('../../../main/utils/execFile'); + const result = await execFileNoThrow('cat', ['largefile']); + + expect(result.stdout).toBe(largeOutput); + expect(result.exitCode).toBe(0); + }); + + it('should handle unicode in stdout', async () => { + const unicodeOutput = '你好世界 🎵 مرحبا'; + + mockExecFile.mockImplementation( + (_cmd: string, _args: readonly string[], _options: any, callback?: any) => { + if (callback) { + callback(null, unicodeOutput, ''); + } + return {} as any; + } + ); + + const { execFileNoThrow } = await import('../../../main/utils/execFile'); + const result = await execFileNoThrow('echo', [unicodeOutput]); + + expect(result.stdout).toBe(unicodeOutput); + }); + + it('should handle multiline output', async () => { + const multilineOutput = 'line1\nline2\nline3\n'; + + mockExecFile.mockImplementation( + (_cmd: string, _args: readonly string[], _options: any, callback?: any) => { + if (callback) { + callback(null, multilineOutput, ''); + } + return {} as any; + } + ); + + const { execFileNoThrow } = await import('../../../main/utils/execFile'); + const result = await execFileNoThrow('ls', ['-la']); + + expect(result.stdout).toBe(multilineOutput); + }); + + it('should handle error with numeric code', async () => { + const error = new Error('Exit with code 128') as any; + error.code = 128; + error.stdout = ''; + error.stderr = 'fatal: not a git repository'; + + mockExecFile.mockImplementation( + (_cmd: string, _args: readonly string[], _options: any, callback?: any) => { + if (callback) { + callback(error, '', ''); + } + return {} as any; + } + ); + + const { execFileNoThrow } = await import('../../../main/utils/execFile'); + const result = await execFileNoThrow('git', ['status']); + + expect(result.exitCode).toBe(128); + expect(result.stderr).toBe('fatal: not a git repository'); + }); + + it('should handle error code 0 (falsy but valid)', async () => { + const error = new Error('Weird error') as any; + error.code = 0; + error.stdout = 'output'; + error.stderr = ''; + + mockExecFile.mockImplementation( + (_cmd: string, _args: readonly string[], _options: any, callback?: any) => { + if (callback) { + callback(error, '', ''); + } + return {} as any; + } + ); + + const { execFileNoThrow } = await import('../../../main/utils/execFile'); + const result = await execFileNoThrow('cmd'); + + // Due to || operator, 0 is falsy so it defaults to 1 + expect(result.exitCode).toBe(1); + }); + }); + + describe('max buffer configuration', () => { + it('should set maxBuffer to 10MB', async () => { + let capturedOptions: any; + mockExecFile.mockImplementation( + (_cmd: string, _args: readonly string[], options: any, callback?: any) => { + capturedOptions = options; + if (callback) { + callback(null, '', ''); + } + return {} as any; + } + ); + + const { execFileNoThrow } = await import('../../../main/utils/execFile'); + await execFileNoThrow('cmd'); + + expect(capturedOptions.maxBuffer).toBe(10 * 1024 * 1024); + }); + }); + + describe('encoding configuration', () => { + it('should use utf8 encoding', async () => { + let capturedOptions: any; + mockExecFile.mockImplementation( + (_cmd: string, _args: readonly string[], options: any, callback?: any) => { + capturedOptions = options; + if (callback) { + callback(null, '', ''); + } + return {} as any; + } + ); + + const { execFileNoThrow } = await import('../../../main/utils/execFile'); + await execFileNoThrow('cmd'); + + expect(capturedOptions.encoding).toBe('utf8'); + }); + }); + }); +}); diff --git a/src/__tests__/main/utils/logger.test.ts b/src/__tests__/main/utils/logger.test.ts new file mode 100644 index 00000000..23100d52 --- /dev/null +++ b/src/__tests__/main/utils/logger.test.ts @@ -0,0 +1,598 @@ +import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'; + +// We need to test the Logger class, not the singleton +// The module exports both the class structure and a singleton instance +// We'll import and create fresh instances for testing + +// First, let's check the module structure +// Since Logger is a class exported via singleton, we need to work with fresh instances + +// Helper to create a fresh Logger instance for testing +// We'll do this by importing the class and creating new instances +// However, since only the singleton is exported, we'll need to work around this + +// Actually, we can test the singleton but reset its state between tests +import type { LogLevel, LogEntry } from '../../../main/utils/logger'; + +// Dynamic import to get a fresh module each time +const getLogger = async () => { + // Clear module cache to get fresh Logger instance + vi.resetModules(); + const module = await import('../../../main/utils/logger'); + return module.logger; +}; + +describe('Logger', () => { + let logger: Awaited>; + let consoleErrorSpy: ReturnType; + let consoleWarnSpy: ReturnType; + let consoleInfoSpy: ReturnType; + let consoleLogSpy: ReturnType; + + beforeEach(async () => { + // Get a fresh logger instance + logger = await getLogger(); + + // Clear logs to start fresh + logger.clearLogs(); + + // Reset to default log level + logger.setLogLevel('info'); + + // Reset to default max buffer + logger.setMaxLogBuffer(1000); + + // Spy on console methods + consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {}); + consoleWarnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {}); + consoleInfoSpy = vi.spyOn(console, 'info').mockImplementation(() => {}); + consoleLogSpy = vi.spyOn(console, 'log').mockImplementation(() => {}); + }); + + afterEach(() => { + vi.restoreAllMocks(); + }); + + describe('Log Level Management', () => { + it('should have default log level of info', async () => { + expect(logger.getLogLevel()).toBe('info'); + }); + + it('should allow setting log level', async () => { + logger.setLogLevel('debug'); + expect(logger.getLogLevel()).toBe('debug'); + + logger.setLogLevel('warn'); + expect(logger.getLogLevel()).toBe('warn'); + + logger.setLogLevel('error'); + expect(logger.getLogLevel()).toBe('error'); + }); + + it('should filter debug logs when level is info', async () => { + logger.setLogLevel('info'); + logger.debug('debug message'); + + expect(logger.getLogs()).toHaveLength(0); + }); + + it('should log debug messages when level is debug', async () => { + logger.setLogLevel('debug'); + logger.debug('debug message'); + + expect(logger.getLogs()).toHaveLength(1); + expect(logger.getLogs()[0].level).toBe('debug'); + }); + + it('should filter info logs when level is warn', async () => { + logger.setLogLevel('warn'); + logger.info('info message'); + + expect(logger.getLogs()).toHaveLength(0); + }); + + it('should filter info and warn logs when level is error', async () => { + logger.setLogLevel('error'); + logger.info('info message'); + logger.warn('warn message'); + + expect(logger.getLogs()).toHaveLength(0); + }); + + it('should log error messages at any level', async () => { + logger.setLogLevel('error'); + logger.error('error message'); + + expect(logger.getLogs()).toHaveLength(1); + expect(logger.getLogs()[0].level).toBe('error'); + }); + }); + + describe('Buffer Size Management', () => { + it('should have default max buffer of 1000', async () => { + expect(logger.getMaxLogBuffer()).toBe(1000); + }); + + it('should allow setting max buffer size', async () => { + logger.setMaxLogBuffer(500); + expect(logger.getMaxLogBuffer()).toBe(500); + + logger.setMaxLogBuffer(100); + expect(logger.getMaxLogBuffer()).toBe(100); + }); + + it('should trim logs when buffer exceeds max size', async () => { + logger.setMaxLogBuffer(5); + + // Add 7 logs + for (let i = 1; i <= 7; i++) { + logger.info(`message ${i}`); + } + + const logs = logger.getLogs(); + expect(logs).toHaveLength(5); + // Should keep the last 5 (messages 3-7) + expect(logs[0].message).toBe('message 3'); + expect(logs[4].message).toBe('message 7'); + }); + + it('should trim existing logs when max buffer is reduced', async () => { + // Add 10 logs with default buffer + for (let i = 1; i <= 10; i++) { + logger.info(`message ${i}`); + } + + expect(logger.getLogs()).toHaveLength(10); + + // Reduce buffer size + logger.setMaxLogBuffer(5); + + const logs = logger.getLogs(); + expect(logs).toHaveLength(5); + // Should keep the last 5 + expect(logs[0].message).toBe('message 6'); + expect(logs[4].message).toBe('message 10'); + }); + + it('should not trim when max buffer is increased', async () => { + logger.setMaxLogBuffer(5); + + for (let i = 1; i <= 5; i++) { + logger.info(`message ${i}`); + } + + logger.setMaxLogBuffer(10); + + expect(logger.getLogs()).toHaveLength(5); + }); + }); + + describe('Logging Methods', () => { + describe('debug', () => { + it('should log debug message with correct structure', async () => { + logger.setLogLevel('debug'); + const beforeTime = Date.now(); + logger.debug('debug test'); + const afterTime = Date.now(); + + const logs = logger.getLogs(); + expect(logs).toHaveLength(1); + expect(logs[0].level).toBe('debug'); + expect(logs[0].message).toBe('debug test'); + expect(logs[0].timestamp).toBeGreaterThanOrEqual(beforeTime); + expect(logs[0].timestamp).toBeLessThanOrEqual(afterTime); + }); + + it('should log debug with context', async () => { + logger.setLogLevel('debug'); + logger.debug('debug test', 'TestContext'); + + const logs = logger.getLogs(); + expect(logs[0].context).toBe('TestContext'); + }); + + it('should log debug with data', async () => { + logger.setLogLevel('debug'); + const testData = { key: 'value', count: 42 }; + logger.debug('debug test', 'TestContext', testData); + + const logs = logger.getLogs(); + expect(logs[0].data).toEqual(testData); + }); + + it('should output to console.log for debug level', async () => { + logger.setLogLevel('debug'); + logger.debug('debug console test'); + + expect(consoleLogSpy).toHaveBeenCalled(); + expect(consoleLogSpy.mock.calls[0][0]).toContain('[DEBUG]'); + expect(consoleLogSpy.mock.calls[0][0]).toContain('debug console test'); + }); + }); + + describe('info', () => { + it('should log info message with correct structure', async () => { + logger.info('info test'); + + const logs = logger.getLogs(); + expect(logs).toHaveLength(1); + expect(logs[0].level).toBe('info'); + expect(logs[0].message).toBe('info test'); + }); + + it('should log info with context', async () => { + logger.info('info test', 'InfoContext'); + + const logs = logger.getLogs(); + expect(logs[0].context).toBe('InfoContext'); + }); + + it('should log info with data', async () => { + const testData = ['item1', 'item2']; + logger.info('info test', undefined, testData); + + const logs = logger.getLogs(); + expect(logs[0].data).toEqual(testData); + expect(logs[0].context).toBeUndefined(); + }); + + it('should output to console.info for info level', async () => { + logger.info('info console test'); + + expect(consoleInfoSpy).toHaveBeenCalled(); + expect(consoleInfoSpy.mock.calls[0][0]).toContain('[INFO]'); + expect(consoleInfoSpy.mock.calls[0][0]).toContain('info console test'); + }); + }); + + describe('warn', () => { + it('should log warn message with correct structure', async () => { + logger.warn('warn test'); + + const logs = logger.getLogs(); + expect(logs).toHaveLength(1); + expect(logs[0].level).toBe('warn'); + expect(logs[0].message).toBe('warn test'); + }); + + it('should log warn with context and data', async () => { + logger.warn('warn test', 'WarnContext', { warning: true }); + + const logs = logger.getLogs(); + expect(logs[0].context).toBe('WarnContext'); + expect(logs[0].data).toEqual({ warning: true }); + }); + + it('should output to console.warn for warn level', async () => { + logger.warn('warn console test'); + + expect(consoleWarnSpy).toHaveBeenCalled(); + expect(consoleWarnSpy.mock.calls[0][0]).toContain('[WARN]'); + expect(consoleWarnSpy.mock.calls[0][0]).toContain('warn console test'); + }); + }); + + describe('error', () => { + it('should log error message with correct structure', async () => { + logger.error('error test'); + + const logs = logger.getLogs(); + expect(logs).toHaveLength(1); + expect(logs[0].level).toBe('error'); + expect(logs[0].message).toBe('error test'); + }); + + it('should log error with context and data', async () => { + const errorData = new Error('test error'); + logger.error('error test', 'ErrorContext', errorData); + + const logs = logger.getLogs(); + expect(logs[0].context).toBe('ErrorContext'); + expect(logs[0].data).toBe(errorData); + }); + + it('should output to console.error for error level', async () => { + logger.error('error console test'); + + expect(consoleErrorSpy).toHaveBeenCalled(); + expect(consoleErrorSpy.mock.calls[0][0]).toContain('[ERROR]'); + expect(consoleErrorSpy.mock.calls[0][0]).toContain('error console test'); + }); + }); + + describe('toast', () => { + it('should log toast message with correct structure', async () => { + logger.toast('toast test'); + + const logs = logger.getLogs(); + expect(logs).toHaveLength(1); + expect(logs[0].level).toBe('toast'); + expect(logs[0].message).toBe('toast test'); + }); + + it('should always log toast regardless of log level', async () => { + logger.setLogLevel('error'); + logger.toast('toast test'); + + // Toast should be logged even though level is error + const logs = logger.getLogs(); + expect(logs).toHaveLength(1); + expect(logs[0].level).toBe('toast'); + }); + + it('should log toast with context and data', async () => { + logger.toast('toast test', 'ToastContext', { notification: true }); + + const logs = logger.getLogs(); + expect(logs[0].context).toBe('ToastContext'); + expect(logs[0].data).toEqual({ notification: true }); + }); + + it('should output to console.info for toast level', async () => { + logger.toast('toast console test'); + + expect(consoleInfoSpy).toHaveBeenCalled(); + expect(consoleInfoSpy.mock.calls[0][0]).toContain('[TOAST]'); + expect(consoleInfoSpy.mock.calls[0][0]).toContain('toast console test'); + }); + }); + }); + + describe('Log Retrieval (getLogs)', () => { + beforeEach(async () => { + // Populate with test logs + logger.setLogLevel('debug'); + logger.debug('debug 1', 'ContextA'); + logger.info('info 1', 'ContextA'); + logger.info('info 2', 'ContextB'); + logger.warn('warn 1', 'ContextB'); + logger.error('error 1', 'ContextA'); + }); + + it('should return all logs without filter', async () => { + const logs = logger.getLogs(); + expect(logs).toHaveLength(5); + }); + + it('should return copy of logs (not reference)', async () => { + const logs1 = logger.getLogs(); + const logs2 = logger.getLogs(); + expect(logs1).not.toBe(logs2); + }); + + it('should filter by level', async () => { + const warnAndAbove = logger.getLogs({ level: 'warn' }); + expect(warnAndAbove).toHaveLength(2); + expect(warnAndAbove.every(l => l.level === 'warn' || l.level === 'error')).toBe(true); + }); + + it('should filter by level - error only', async () => { + const errorOnly = logger.getLogs({ level: 'error' }); + expect(errorOnly).toHaveLength(1); + expect(errorOnly[0].level).toBe('error'); + }); + + it('should filter by level - info and above', async () => { + const infoAndAbove = logger.getLogs({ level: 'info' }); + expect(infoAndAbove).toHaveLength(4); // info, info, warn, error (no debug) + }); + + it('should filter by context', async () => { + const contextA = logger.getLogs({ context: 'ContextA' }); + expect(contextA).toHaveLength(3); + expect(contextA.every(l => l.context === 'ContextA')).toBe(true); + }); + + it('should filter by context - different context', async () => { + const contextB = logger.getLogs({ context: 'ContextB' }); + expect(contextB).toHaveLength(2); + expect(contextB.every(l => l.context === 'ContextB')).toBe(true); + }); + + it('should filter by context - non-existent context', async () => { + const noContext = logger.getLogs({ context: 'NonExistent' }); + expect(noContext).toHaveLength(0); + }); + + it('should limit returned entries', async () => { + const limited = logger.getLogs({ limit: 2 }); + expect(limited).toHaveLength(2); + // Should return last 2 + expect(limited[0].level).toBe('warn'); + expect(limited[1].level).toBe('error'); + }); + + it('should handle limit larger than log count', async () => { + const limited = logger.getLogs({ limit: 100 }); + expect(limited).toHaveLength(5); + }); + + it('should combine level and context filters', async () => { + const filtered = logger.getLogs({ level: 'info', context: 'ContextA' }); + expect(filtered).toHaveLength(2); // info 1 and error 1 from ContextA (info level and above) + }); + + it('should combine all filters', async () => { + const filtered = logger.getLogs({ level: 'info', context: 'ContextA', limit: 1 }); + expect(filtered).toHaveLength(1); + expect(filtered[0].level).toBe('error'); // Last one from ContextA at info level or above + }); + }); + + describe('Log Clearing (clearLogs)', () => { + it('should clear all logs', async () => { + logger.info('message 1'); + logger.info('message 2'); + logger.info('message 3'); + + expect(logger.getLogs()).toHaveLength(3); + + logger.clearLogs(); + + expect(logger.getLogs()).toHaveLength(0); + }); + + it('should allow new logs after clearing', async () => { + logger.info('message 1'); + logger.clearLogs(); + logger.info('message 2'); + + const logs = logger.getLogs(); + expect(logs).toHaveLength(1); + expect(logs[0].message).toBe('message 2'); + }); + }); + + describe('Console Output Formatting', () => { + it('should include timestamp in ISO format', async () => { + logger.info('test message'); + + const logCall = consoleInfoSpy.mock.calls[0][0]; + // Should contain ISO timestamp format [YYYY-MM-DDTHH:MM:SS.sssZ] + expect(logCall).toMatch(/\[\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/); + }); + + it('should include context in brackets when provided', async () => { + logger.info('test message', 'MyContext'); + + const logCall = consoleInfoSpy.mock.calls[0][0]; + expect(logCall).toContain('[MyContext]'); + }); + + it('should not include context brackets when not provided', async () => { + logger.info('test message'); + + const logCall = consoleInfoSpy.mock.calls[0][0]; + // Should have only two bracket pairs: timestamp and level + const bracketCount = (logCall.match(/\[/g) || []).length; + expect(bracketCount).toBe(2); + }); + + it('should output data as second argument when provided', async () => { + const testData = { key: 'value' }; + logger.info('test message', 'Context', testData); + + expect(consoleInfoSpy.mock.calls[0][1]).toEqual(testData); + }); + + it('should output empty string as second argument when no data', async () => { + logger.info('test message'); + + expect(consoleInfoSpy.mock.calls[0][1]).toBe(''); + }); + }); + + describe('Edge Cases', () => { + it('should handle empty message', async () => { + logger.info(''); + + const logs = logger.getLogs(); + expect(logs).toHaveLength(1); + expect(logs[0].message).toBe(''); + }); + + it('should handle undefined data', async () => { + logger.info('test', 'Context', undefined); + + const logs = logger.getLogs(); + expect(logs[0].data).toBeUndefined(); + }); + + it('should handle null data', async () => { + logger.info('test', 'Context', null); + + const logs = logger.getLogs(); + expect(logs[0].data).toBeNull(); + }); + + it('should handle complex nested data', async () => { + const complexData = { + array: [1, 2, 3], + nested: { a: { b: { c: 'deep' } } }, + fn: undefined, // Functions would be undefined after JSON stringify + date: new Date('2024-01-01'), + }; + logger.info('test', undefined, complexData); + + const logs = logger.getLogs(); + expect(logs[0].data).toEqual(complexData); + }); + + it('should handle special characters in message', async () => { + const specialMessage = 'Test: [brackets] {braces} "quotes" \'apostrophes\' \n newline \t tab'; + logger.info(specialMessage); + + const logs = logger.getLogs(); + expect(logs[0].message).toBe(specialMessage); + }); + + it('should handle unicode in message', async () => { + const unicodeMessage = 'Test: 🔥 火 مرحبا 你好 emoji and scripts'; + logger.info(unicodeMessage); + + const logs = logger.getLogs(); + expect(logs[0].message).toBe(unicodeMessage); + }); + + it('should handle very long message', async () => { + const longMessage = 'a'.repeat(10000); + logger.info(longMessage); + + const logs = logger.getLogs(); + expect(logs[0].message).toBe(longMessage); + expect(logs[0].message.length).toBe(10000); + }); + }); + + describe('Level Priority System', () => { + it('should respect debug < info < warn < error priority', async () => { + // At debug level, all messages should be logged + logger.setLogLevel('debug'); + logger.debug('d'); + logger.info('i'); + logger.warn('w'); + logger.error('e'); + expect(logger.getLogs()).toHaveLength(4); + logger.clearLogs(); + + // At info level, debug should be filtered + logger.setLogLevel('info'); + logger.debug('d'); + logger.info('i'); + logger.warn('w'); + logger.error('e'); + expect(logger.getLogs()).toHaveLength(3); + logger.clearLogs(); + + // At warn level, debug and info should be filtered + logger.setLogLevel('warn'); + logger.debug('d'); + logger.info('i'); + logger.warn('w'); + logger.error('e'); + expect(logger.getLogs()).toHaveLength(2); + logger.clearLogs(); + + // At error level, only error should be logged + logger.setLogLevel('error'); + logger.debug('d'); + logger.info('i'); + logger.warn('w'); + logger.error('e'); + expect(logger.getLogs()).toHaveLength(1); + expect(logger.getLogs()[0].level).toBe('error'); + }); + + it('should treat toast as info priority for filtering in getLogs', async () => { + logger.toast('toast message'); + + // Toast has priority 1 (same as info), so filtering by warn should exclude it + const warnLevel = logger.getLogs({ level: 'warn' }); + expect(warnLevel).toHaveLength(0); + + // But filtering by info should include it + const infoLevel = logger.getLogs({ level: 'info' }); + expect(infoLevel).toHaveLength(1); + }); + }); +}); diff --git a/src/__tests__/main/utils/networkUtils.test.ts b/src/__tests__/main/utils/networkUtils.test.ts new file mode 100644 index 00000000..9bc9bbc8 --- /dev/null +++ b/src/__tests__/main/utils/networkUtils.test.ts @@ -0,0 +1,701 @@ +/** + * @file networkUtils.test.ts + * @description Tests for src/main/utils/networkUtils.ts + * + * Tests network utilities for IP address detection including: + * - getLocalIpAddress (async with UDP socket) + * - getLocalIpAddressSync (interface scanning) + * - Private IP detection + */ + +import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'; + +// Use vi.hoisted to create mocks that can be used in vi.mock +const { mockNetworkInterfaces, mockCreateSocket } = vi.hoisted(() => ({ + mockNetworkInterfaces: vi.fn(), + mockCreateSocket: vi.fn(), +})); + +// Mock the os module +vi.mock('os', () => ({ + default: { networkInterfaces: mockNetworkInterfaces }, + networkInterfaces: mockNetworkInterfaces, +})); + +// Mock the dgram module +vi.mock('dgram', () => ({ + default: { createSocket: mockCreateSocket }, + createSocket: mockCreateSocket, +})); + +import * as networkUtils from '../../../main/utils/networkUtils'; + +describe('main/utils/networkUtils', () => { + beforeEach(() => { + vi.clearAllMocks(); + }); + + // =========================================== + // getLocalIpAddress (async) + // =========================================== + describe('getLocalIpAddress', () => { + it('should return IP from UDP socket when successful', async () => { + const mockSocket = { + on: vi.fn(), + connect: vi.fn((port, host, callback) => { + // Simulate successful connection + callback(); + }), + address: vi.fn().mockReturnValue({ address: '192.168.1.100' }), + close: vi.fn(), + removeAllListeners: vi.fn(), + }; + mockCreateSocket.mockReturnValue(mockSocket as any); + + const result = await networkUtils.getLocalIpAddress(); + expect(result).toBe('192.168.1.100'); + expect(mockCreateSocket).toHaveBeenCalledWith('udp4'); + }); + + it('should fall back to interface scanning when UDP returns 127.0.0.1', async () => { + const mockSocket = { + on: vi.fn(), + connect: vi.fn((port, host, callback) => { + callback(); + }), + address: vi.fn().mockReturnValue({ address: '127.0.0.1' }), + close: vi.fn(), + removeAllListeners: vi.fn(), + }; + mockCreateSocket.mockReturnValue(mockSocket as any); + + // Set up interface scanning fallback + mockNetworkInterfaces.mockReturnValue({ + en0: [ + { + address: '192.168.1.50', + netmask: '255.255.255.0', + family: 'IPv4', + mac: '00:00:00:00:00:00', + internal: false, + cidr: '192.168.1.50/24', + }, + ], + }); + + const result = await networkUtils.getLocalIpAddress(); + expect(result).toBe('192.168.1.50'); + }); + + it('should fall back to interface scanning when UDP socket errors', async () => { + const mockSocket = { + on: vi.fn((event, handler) => { + if (event === 'error') { + // Trigger error immediately + setTimeout(() => handler(new Error('Socket error')), 0); + } + }), + connect: vi.fn(), + close: vi.fn(), + removeAllListeners: vi.fn(), + }; + mockCreateSocket.mockReturnValue(mockSocket as any); + + mockNetworkInterfaces.mockReturnValue({ + eth0: [ + { + address: '10.0.0.5', + netmask: '255.0.0.0', + family: 'IPv4', + mac: '00:00:00:00:00:00', + internal: false, + cidr: '10.0.0.5/8', + }, + ], + }); + + const result = await networkUtils.getLocalIpAddress(); + expect(result).toBe('10.0.0.5'); + }); + + it('should handle UDP socket address() throwing error', async () => { + const mockSocket = { + on: vi.fn(), + connect: vi.fn((port, host, callback) => { + callback(); + }), + address: vi.fn().mockImplementation(() => { + throw new Error('Address error'); + }), + close: vi.fn(), + removeAllListeners: vi.fn(), + }; + mockCreateSocket.mockReturnValue(mockSocket as any); + + mockNetworkInterfaces.mockReturnValue({ + en0: [ + { + address: '172.16.0.10', + netmask: '255.255.0.0', + family: 'IPv4', + mac: '00:00:00:00:00:00', + internal: false, + cidr: '172.16.0.10/16', + }, + ], + }); + + const result = await networkUtils.getLocalIpAddress(); + expect(result).toBe('172.16.0.10'); + }); + + it('should handle UDP socket close() throwing error', async () => { + const mockSocket = { + on: vi.fn(), + connect: vi.fn((port, host, callback) => { + callback(); + }), + address: vi.fn().mockReturnValue({ address: '192.168.1.100' }), + close: vi.fn().mockImplementation(() => { + throw new Error('Close error'); + }), + removeAllListeners: vi.fn(), + }; + mockCreateSocket.mockReturnValue(mockSocket as any); + + // Should still return the IP despite close error + const result = await networkUtils.getLocalIpAddress(); + expect(result).toBe('192.168.1.100'); + }); + }); + + // =========================================== + // getLocalIpAddressSync + // =========================================== + describe('getLocalIpAddressSync', () => { + it('should return localhost when no interfaces available', () => { + mockNetworkInterfaces.mockReturnValue({}); + const result = networkUtils.getLocalIpAddressSync(); + expect(result).toBe('localhost'); + }); + + it('should skip internal interfaces', () => { + mockNetworkInterfaces.mockReturnValue({ + lo0: [ + { + address: '127.0.0.1', + netmask: '255.0.0.0', + family: 'IPv4', + mac: '00:00:00:00:00:00', + internal: true, + cidr: '127.0.0.1/8', + }, + ], + }); + const result = networkUtils.getLocalIpAddressSync(); + expect(result).toBe('localhost'); + }); + + it('should skip IPv6 addresses', () => { + mockNetworkInterfaces.mockReturnValue({ + en0: [ + { + address: 'fe80::1', + netmask: 'ffff:ffff:ffff:ffff::', + family: 'IPv6', + mac: '00:00:00:00:00:00', + internal: false, + cidr: 'fe80::1/64', + scopeid: 1, + }, + ], + }); + const result = networkUtils.getLocalIpAddressSync(); + expect(result).toBe('localhost'); + }); + + it('should skip 127.0.0.1 addresses', () => { + mockNetworkInterfaces.mockReturnValue({ + lo0: [ + { + address: '127.0.0.1', + netmask: '255.0.0.0', + family: 'IPv4', + mac: '00:00:00:00:00:00', + internal: false, // Even if not marked internal + cidr: '127.0.0.1/8', + }, + ], + }); + const result = networkUtils.getLocalIpAddressSync(); + expect(result).toBe('localhost'); + }); + + it('should prioritize Ethernet interfaces (en0, eth0)', () => { + mockNetworkInterfaces.mockReturnValue({ + veth0: [ + { + address: '172.17.0.1', + netmask: '255.255.0.0', + family: 'IPv4', + mac: '00:00:00:00:00:00', + internal: false, + cidr: '172.17.0.1/16', + }, + ], + en0: [ + { + address: '192.168.1.10', + netmask: '255.255.255.0', + family: 'IPv4', + mac: '00:00:00:00:00:00', + internal: false, + cidr: '192.168.1.10/24', + }, + ], + }); + const result = networkUtils.getLocalIpAddressSync(); + expect(result).toBe('192.168.1.10'); + }); + + it('should prioritize WiFi interfaces over virtual', () => { + mockNetworkInterfaces.mockReturnValue({ + docker0: [ + { + address: '172.17.0.1', + netmask: '255.255.0.0', + family: 'IPv4', + mac: '00:00:00:00:00:00', + internal: false, + cidr: '172.17.0.1/16', + }, + ], + wlan0: [ + { + address: '192.168.1.20', + netmask: '255.255.255.0', + family: 'IPv4', + mac: '00:00:00:00:00:00', + internal: false, + cidr: '192.168.1.20/24', + }, + ], + }); + const result = networkUtils.getLocalIpAddressSync(); + expect(result).toBe('192.168.1.20'); + }); + + it('should handle bridge interfaces with medium priority', () => { + mockNetworkInterfaces.mockReturnValue({ + docker0: [ + { + address: '172.17.0.1', + netmask: '255.255.0.0', + family: 'IPv4', + mac: '00:00:00:00:00:00', + internal: false, + cidr: '172.17.0.1/16', + }, + ], + bridge0: [ + { + address: '192.168.2.1', + netmask: '255.255.255.0', + family: 'IPv4', + mac: '00:00:00:00:00:00', + internal: false, + cidr: '192.168.2.1/24', + }, + ], + }); + const result = networkUtils.getLocalIpAddressSync(); + expect(result).toBe('192.168.2.1'); + }); + + it('should give lower priority to virtual interfaces (veth, docker, vmnet, vbox, tun, tap)', () => { + mockNetworkInterfaces.mockReturnValue({ + veth123: [ + { + address: '172.17.0.2', + netmask: '255.255.0.0', + family: 'IPv4', + mac: '00:00:00:00:00:00', + internal: false, + cidr: '172.17.0.2/16', + }, + ], + unknown0: [ + { + address: '10.0.0.50', + netmask: '255.0.0.0', + family: 'IPv4', + mac: '00:00:00:00:00:00', + internal: false, + cidr: '10.0.0.50/8', + }, + ], + }); + const result = networkUtils.getLocalIpAddressSync(); + // unknown0 has priority 30+5 (other + private), veth123 has 10+5 + expect(result).toBe('10.0.0.50'); + }); + + it('should prefer private IP ranges', () => { + mockNetworkInterfaces.mockReturnValue({ + unknown0: [ + { + address: '8.8.8.8', // Public IP (unlikely but for test) + netmask: '255.0.0.0', + family: 'IPv4', + mac: '00:00:00:00:00:00', + internal: false, + cidr: '8.8.8.8/8', + }, + ], + unknown1: [ + { + address: '192.168.1.5', // Private IP + netmask: '255.255.255.0', + family: 'IPv4', + mac: '00:00:00:00:00:00', + internal: false, + cidr: '192.168.1.5/24', + }, + ], + }); + const result = networkUtils.getLocalIpAddressSync(); + // Both are "other" interfaces (priority 30), but 192.168.1.5 gets +5 for private + expect(result).toBe('192.168.1.5'); + }); + + it('should handle undefined interface addresses', () => { + mockNetworkInterfaces.mockReturnValue({ + en0: undefined as any, + en1: [ + { + address: '192.168.1.100', + netmask: '255.255.255.0', + family: 'IPv4', + mac: '00:00:00:00:00:00', + internal: false, + cidr: '192.168.1.100/24', + }, + ], + }); + const result = networkUtils.getLocalIpAddressSync(); + expect(result).toBe('192.168.1.100'); + }); + + it('should handle eth interfaces similar to en interfaces', () => { + mockNetworkInterfaces.mockReturnValue({ + eth0: [ + { + address: '10.0.0.100', + netmask: '255.0.0.0', + family: 'IPv4', + mac: '00:00:00:00:00:00', + internal: false, + cidr: '10.0.0.100/8', + }, + ], + }); + const result = networkUtils.getLocalIpAddressSync(); + expect(result).toBe('10.0.0.100'); + }); + + it('should handle WiFi interface name variations', () => { + mockNetworkInterfaces.mockReturnValue({ + WiFi: [ + { + address: '192.168.0.50', + netmask: '255.255.255.0', + family: 'IPv4', + mac: '00:00:00:00:00:00', + internal: false, + cidr: '192.168.0.50/24', + }, + ], + }); + const result = networkUtils.getLocalIpAddressSync(); + expect(result).toBe('192.168.0.50'); + }); + + it('should handle wl interface prefix', () => { + mockNetworkInterfaces.mockReturnValue({ + wlp3s0: [ + { + address: '192.168.0.60', + netmask: '255.255.255.0', + family: 'IPv4', + mac: '00:00:00:00:00:00', + internal: false, + cidr: '192.168.0.60/24', + }, + ], + }); + const result = networkUtils.getLocalIpAddressSync(); + expect(result).toBe('192.168.0.60'); + }); + + it('should handle multiple interfaces with multiple addresses', () => { + mockNetworkInterfaces.mockReturnValue({ + en0: [ + { + address: 'fe80::1', + netmask: 'ffff:ffff:ffff:ffff::', + family: 'IPv6', + mac: '00:00:00:00:00:00', + internal: false, + cidr: 'fe80::1/64', + scopeid: 4, + }, + { + address: '192.168.1.200', + netmask: '255.255.255.0', + family: 'IPv4', + mac: '00:00:00:00:00:00', + internal: false, + cidr: '192.168.1.200/24', + }, + ], + }); + const result = networkUtils.getLocalIpAddressSync(); + expect(result).toBe('192.168.1.200'); + }); + }); + + // =========================================== + // Private IP Detection (tested via behavior) + // =========================================== + describe('private IP detection', () => { + it('should recognize 10.x.x.x as private', () => { + mockNetworkInterfaces.mockReturnValue({ + unknown0: [ + { + address: '10.0.0.1', + netmask: '255.0.0.0', + family: 'IPv4', + mac: '00:00:00:00:00:00', + internal: false, + cidr: '10.0.0.1/8', + }, + ], + unknown1: [ + { + address: '11.0.0.1', // Not private + netmask: '255.0.0.0', + family: 'IPv4', + mac: '00:00:00:00:00:00', + internal: false, + cidr: '11.0.0.1/8', + }, + ], + }); + const result = networkUtils.getLocalIpAddressSync(); + expect(result).toBe('10.0.0.1'); + }); + + it('should recognize 172.16-31.x.x as private', () => { + mockNetworkInterfaces.mockReturnValue({ + unknown0: [ + { + address: '172.16.0.1', + netmask: '255.255.0.0', + family: 'IPv4', + mac: '00:00:00:00:00:00', + internal: false, + cidr: '172.16.0.1/16', + }, + ], + unknown1: [ + { + address: '172.15.0.1', // Not in private range + netmask: '255.255.0.0', + family: 'IPv4', + mac: '00:00:00:00:00:00', + internal: false, + cidr: '172.15.0.1/16', + }, + ], + }); + const result = networkUtils.getLocalIpAddressSync(); + expect(result).toBe('172.16.0.1'); + }); + + it('should recognize 172.31.x.x as private', () => { + mockNetworkInterfaces.mockReturnValue({ + unknown0: [ + { + address: '172.31.255.255', + netmask: '255.255.0.0', + family: 'IPv4', + mac: '00:00:00:00:00:00', + internal: false, + cidr: '172.31.255.255/16', + }, + ], + unknown1: [ + { + address: '172.32.0.1', // Not in private range + netmask: '255.255.0.0', + family: 'IPv4', + mac: '00:00:00:00:00:00', + internal: false, + cidr: '172.32.0.1/16', + }, + ], + }); + const result = networkUtils.getLocalIpAddressSync(); + expect(result).toBe('172.31.255.255'); + }); + + it('should recognize 192.168.x.x as private', () => { + mockNetworkInterfaces.mockReturnValue({ + unknown0: [ + { + address: '192.168.0.1', + netmask: '255.255.255.0', + family: 'IPv4', + mac: '00:00:00:00:00:00', + internal: false, + cidr: '192.168.0.1/24', + }, + ], + unknown1: [ + { + address: '192.169.0.1', // Not private + netmask: '255.255.255.0', + family: 'IPv4', + mac: '00:00:00:00:00:00', + internal: false, + cidr: '192.169.0.1/24', + }, + ], + }); + const result = networkUtils.getLocalIpAddressSync(); + expect(result).toBe('192.168.0.1'); + }); + }); + + // =========================================== + // Edge Cases + // =========================================== + describe('edge cases', () => { + it('should handle empty interface arrays', () => { + mockNetworkInterfaces.mockReturnValue({ + en0: [], + }); + const result = networkUtils.getLocalIpAddressSync(); + expect(result).toBe('localhost'); + }); + + it('should handle vmnet interfaces (VMware)', () => { + mockNetworkInterfaces.mockReturnValue({ + vmnet1: [ + { + address: '192.168.100.1', + netmask: '255.255.255.0', + family: 'IPv4', + mac: '00:00:00:00:00:00', + internal: false, + cidr: '192.168.100.1/24', + }, + ], + unknown0: [ + { + address: '10.0.0.5', + netmask: '255.0.0.0', + family: 'IPv4', + mac: '00:00:00:00:00:00', + internal: false, + cidr: '10.0.0.5/8', + }, + ], + }); + const result = networkUtils.getLocalIpAddressSync(); + // vmnet gets priority 10+5=15, unknown0 gets 30+5=35 + expect(result).toBe('10.0.0.5'); + }); + + it('should handle VirtualBox interfaces', () => { + mockNetworkInterfaces.mockReturnValue({ + vboxnet0: [ + { + address: '192.168.56.1', + netmask: '255.255.255.0', + family: 'IPv4', + mac: '00:00:00:00:00:00', + internal: false, + cidr: '192.168.56.1/24', + }, + ], + }); + const result = networkUtils.getLocalIpAddressSync(); + expect(result).toBe('192.168.56.1'); // Still returned, just lower priority + }); + + it('should handle tun/tap interfaces', () => { + mockNetworkInterfaces.mockReturnValue({ + tun0: [ + { + address: '10.8.0.1', + netmask: '255.255.255.0', + family: 'IPv4', + mac: '00:00:00:00:00:00', + internal: false, + cidr: '10.8.0.1/24', + }, + ], + tap0: [ + { + address: '10.9.0.1', + netmask: '255.255.255.0', + family: 'IPv4', + mac: '00:00:00:00:00:00', + internal: false, + cidr: '10.9.0.1/24', + }, + ], + }); + const result = networkUtils.getLocalIpAddressSync(); + // Both have same priority, result will be one of them + expect(['10.8.0.1', '10.9.0.1']).toContain(result); + }); + }); + + // =========================================== + // Integration Tests + // =========================================== + describe('integration', () => { + it('getLocalIpAddress should call getLocalIpAddressSync as fallback', async () => { + // Make UDP fail + const mockSocket = { + on: vi.fn((event, handler) => { + if (event === 'error') { + setTimeout(() => handler(new Error('UDP error')), 0); + } + }), + connect: vi.fn(), + close: vi.fn(), + removeAllListeners: vi.fn(), + }; + mockCreateSocket.mockReturnValue(mockSocket as any); + + mockNetworkInterfaces.mockReturnValue({ + en0: [ + { + address: '192.168.1.123', + netmask: '255.255.255.0', + family: 'IPv4', + mac: '00:00:00:00:00:00', + internal: false, + cidr: '192.168.1.123/24', + }, + ], + }); + + const result = await networkUtils.getLocalIpAddress(); + expect(result).toBe('192.168.1.123'); + }); + }); +}); diff --git a/src/__tests__/main/utils/shellDetector.test.ts b/src/__tests__/main/utils/shellDetector.test.ts new file mode 100644 index 00000000..4349d8fc --- /dev/null +++ b/src/__tests__/main/utils/shellDetector.test.ts @@ -0,0 +1,493 @@ +import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'; + +// Mock execFile before importing shellDetector +vi.mock('../../../main/utils/execFile', () => ({ + execFileNoThrow: vi.fn(), +})); + +import { detectShells, getShellCommand } from '../../../main/utils/shellDetector'; +import { execFileNoThrow } from '../../../main/utils/execFile'; + +const mockedExecFileNoThrow = vi.mocked(execFileNoThrow); + +describe('shellDetector', () => { + beforeEach(() => { + vi.clearAllMocks(); + }); + + afterEach(() => { + vi.restoreAllMocks(); + }); + + describe('detectShells', () => { + it('should detect all available shells', async () => { + // Mock all shells as available + mockedExecFileNoThrow.mockResolvedValue({ + stdout: '/bin/zsh\n', + stderr: '', + exitCode: 0, + }); + + const shells = await detectShells(); + + expect(shells).toHaveLength(5); + expect(shells.every((s) => s.available)).toBe(true); + }); + + it('should return the correct shell IDs', async () => { + mockedExecFileNoThrow.mockResolvedValue({ + stdout: '/usr/bin/shell\n', + stderr: '', + exitCode: 0, + }); + + const shells = await detectShells(); + const ids = shells.map((s) => s.id); + + expect(ids).toEqual(['zsh', 'bash', 'sh', 'fish', 'tcsh']); + }); + + it('should return the correct shell names', async () => { + mockedExecFileNoThrow.mockResolvedValue({ + stdout: '/usr/bin/shell\n', + stderr: '', + exitCode: 0, + }); + + const shells = await detectShells(); + const names = shells.map((s) => s.name); + + expect(names).toEqual(['Zsh', 'Bash', 'Bourne Shell (sh)', 'Fish', 'Tcsh']); + }); + + it('should handle shells that are not available', async () => { + mockedExecFileNoThrow.mockResolvedValue({ + stdout: '', + stderr: 'not found', + exitCode: 1, + }); + + const shells = await detectShells(); + + expect(shells.every((s) => !s.available)).toBe(true); + expect(shells.every((s) => s.path === undefined)).toBe(true); + }); + + it('should extract the correct path from stdout', async () => { + mockedExecFileNoThrow.mockResolvedValue({ + stdout: '/opt/homebrew/bin/zsh\n', + stderr: '', + exitCode: 0, + }); + + const shells = await detectShells(); + + expect(shells[0].path).toBe('/opt/homebrew/bin/zsh'); + }); + + it('should take the first result when multiple paths are returned', async () => { + mockedExecFileNoThrow.mockResolvedValue({ + stdout: '/opt/homebrew/bin/bash\n/usr/bin/bash\n/bin/bash\n', + stderr: '', + exitCode: 0, + }); + + const shells = await detectShells(); + + expect(shells[1].path).toBe('/opt/homebrew/bin/bash'); + }); + + it('should handle mixed availability', async () => { + mockedExecFileNoThrow + .mockResolvedValueOnce({ + stdout: '/bin/zsh\n', + stderr: '', + exitCode: 0, + }) + .mockResolvedValueOnce({ + stdout: '/bin/bash\n', + stderr: '', + exitCode: 0, + }) + .mockResolvedValueOnce({ + stdout: '', + stderr: 'not found', + exitCode: 1, + }) + .mockResolvedValueOnce({ + stdout: '', + stderr: 'not found', + exitCode: 1, + }) + .mockResolvedValueOnce({ + stdout: '/bin/tcsh\n', + stderr: '', + exitCode: 0, + }); + + const shells = await detectShells(); + + expect(shells[0].available).toBe(true); + expect(shells[0].path).toBe('/bin/zsh'); + expect(shells[1].available).toBe(true); + expect(shells[1].path).toBe('/bin/bash'); + expect(shells[2].available).toBe(false); + expect(shells[2].path).toBeUndefined(); + expect(shells[3].available).toBe(false); + expect(shells[3].path).toBeUndefined(); + expect(shells[4].available).toBe(true); + expect(shells[4].path).toBe('/bin/tcsh'); + }); + + it('should use which command on non-Windows platforms', async () => { + // Store original platform + const originalPlatform = process.platform; + // Mock as darwin + Object.defineProperty(process, 'platform', { value: 'darwin', writable: true }); + + mockedExecFileNoThrow.mockResolvedValue({ + stdout: '/bin/zsh\n', + stderr: '', + exitCode: 0, + }); + + await detectShells(); + + expect(mockedExecFileNoThrow).toHaveBeenCalledWith('which', ['zsh']); + + // Restore original platform + Object.defineProperty(process, 'platform', { value: originalPlatform, writable: true }); + }); + + it('should use where command on Windows', async () => { + // Store original platform + const originalPlatform = process.platform; + // Mock as win32 + Object.defineProperty(process, 'platform', { value: 'win32', writable: true }); + + mockedExecFileNoThrow.mockResolvedValue({ + stdout: 'C:\\Windows\\System32\\bash.exe\n', + stderr: '', + exitCode: 0, + }); + + await detectShells(); + + expect(mockedExecFileNoThrow).toHaveBeenCalledWith('where', ['zsh']); + + // Restore original platform + Object.defineProperty(process, 'platform', { value: originalPlatform, writable: true }); + }); + + it('should handle empty stdout with zero exit code', async () => { + mockedExecFileNoThrow.mockResolvedValue({ + stdout: '', + stderr: '', + exitCode: 0, + }); + + const shells = await detectShells(); + + // Empty stdout means shell is not available + expect(shells.every((s) => !s.available)).toBe(true); + }); + + it('should handle whitespace-only stdout', async () => { + mockedExecFileNoThrow.mockResolvedValue({ + stdout: ' \n \n ', + stderr: '', + exitCode: 0, + }); + + const shells = await detectShells(); + + // Whitespace-only stdout means shell is not available + expect(shells.every((s) => !s.available)).toBe(true); + }); + + it('should call execFileNoThrow for each shell', async () => { + mockedExecFileNoThrow.mockResolvedValue({ + stdout: '/bin/shell\n', + stderr: '', + exitCode: 0, + }); + + await detectShells(); + + expect(mockedExecFileNoThrow).toHaveBeenCalledTimes(5); + }); + + it('should handle exceptions from execFileNoThrow', async () => { + mockedExecFileNoThrow.mockRejectedValue(new Error('Command failed')); + + const shells = await detectShells(); + + // Exception means shell is not available + expect(shells.every((s) => !s.available)).toBe(true); + expect(shells.every((s) => s.path === undefined)).toBe(true); + }); + + it('should handle partial exceptions', async () => { + mockedExecFileNoThrow + .mockResolvedValueOnce({ + stdout: '/bin/zsh\n', + stderr: '', + exitCode: 0, + }) + .mockRejectedValueOnce(new Error('Command failed')) + .mockResolvedValueOnce({ + stdout: '/bin/sh\n', + stderr: '', + exitCode: 0, + }) + .mockRejectedValueOnce(new Error('Command failed')) + .mockResolvedValueOnce({ + stdout: '/bin/tcsh\n', + stderr: '', + exitCode: 0, + }); + + const shells = await detectShells(); + + expect(shells[0].available).toBe(true); + expect(shells[1].available).toBe(false); + expect(shells[2].available).toBe(true); + expect(shells[3].available).toBe(false); + expect(shells[4].available).toBe(true); + }); + }); + + describe('getShellCommand', () => { + describe('on Unix-like platforms', () => { + const originalPlatform = process.platform; + + beforeEach(() => { + Object.defineProperty(process, 'platform', { value: 'darwin', writable: true }); + }); + + afterEach(() => { + Object.defineProperty(process, 'platform', { value: originalPlatform, writable: true }); + }); + + it('should return the shell ID directly for zsh', () => { + expect(getShellCommand('zsh')).toBe('zsh'); + }); + + it('should return the shell ID directly for bash', () => { + expect(getShellCommand('bash')).toBe('bash'); + }); + + it('should return the shell ID directly for sh', () => { + expect(getShellCommand('sh')).toBe('sh'); + }); + + it('should return the shell ID directly for fish', () => { + expect(getShellCommand('fish')).toBe('fish'); + }); + + it('should return the shell ID directly for tcsh', () => { + expect(getShellCommand('tcsh')).toBe('tcsh'); + }); + + it('should return any shell ID directly for unknown shells', () => { + expect(getShellCommand('custom-shell')).toBe('custom-shell'); + }); + }); + + describe('on Windows', () => { + const originalPlatform = process.platform; + + beforeEach(() => { + Object.defineProperty(process, 'platform', { value: 'win32', writable: true }); + }); + + afterEach(() => { + Object.defineProperty(process, 'platform', { value: originalPlatform, writable: true }); + }); + + it('should return bash for sh on Windows', () => { + expect(getShellCommand('sh')).toBe('bash'); + }); + + it('should return bash for bash on Windows', () => { + expect(getShellCommand('bash')).toBe('bash'); + }); + + it('should return powershell.exe for zsh on Windows', () => { + expect(getShellCommand('zsh')).toBe('powershell.exe'); + }); + + it('should return powershell.exe for fish on Windows', () => { + expect(getShellCommand('fish')).toBe('powershell.exe'); + }); + + it('should return powershell.exe for tcsh on Windows', () => { + expect(getShellCommand('tcsh')).toBe('powershell.exe'); + }); + + it('should return powershell.exe for unknown shells on Windows', () => { + expect(getShellCommand('custom-shell')).toBe('powershell.exe'); + }); + }); + + describe('on Linux', () => { + const originalPlatform = process.platform; + + beforeEach(() => { + Object.defineProperty(process, 'platform', { value: 'linux', writable: true }); + }); + + afterEach(() => { + Object.defineProperty(process, 'platform', { value: originalPlatform, writable: true }); + }); + + it('should return the shell ID directly on Linux', () => { + expect(getShellCommand('zsh')).toBe('zsh'); + expect(getShellCommand('bash')).toBe('bash'); + expect(getShellCommand('sh')).toBe('sh'); + }); + }); + }); + + describe('ShellInfo type', () => { + it('should return ShellInfo objects with all required properties', async () => { + mockedExecFileNoThrow.mockResolvedValue({ + stdout: '/bin/zsh\n', + stderr: '', + exitCode: 0, + }); + + const shells = await detectShells(); + + for (const shell of shells) { + expect(shell).toHaveProperty('id'); + expect(shell).toHaveProperty('name'); + expect(shell).toHaveProperty('available'); + expect(typeof shell.id).toBe('string'); + expect(typeof shell.name).toBe('string'); + expect(typeof shell.available).toBe('boolean'); + } + }); + + it('should include path property only when available', async () => { + mockedExecFileNoThrow + .mockResolvedValueOnce({ + stdout: '/bin/zsh\n', + stderr: '', + exitCode: 0, + }) + .mockResolvedValueOnce({ + stdout: '', + stderr: '', + exitCode: 1, + }) + .mockResolvedValueOnce({ + stdout: '/bin/sh\n', + stderr: '', + exitCode: 0, + }) + .mockResolvedValueOnce({ + stdout: '', + stderr: '', + exitCode: 1, + }) + .mockResolvedValueOnce({ + stdout: '', + stderr: '', + exitCode: 1, + }); + + const shells = await detectShells(); + + expect(shells[0].path).toBe('/bin/zsh'); + expect(shells[1].path).toBeUndefined(); + expect(shells[2].path).toBe('/bin/sh'); + expect(shells[3].path).toBeUndefined(); + expect(shells[4].path).toBeUndefined(); + }); + }); + + describe('edge cases', () => { + it('should handle paths with spaces', async () => { + mockedExecFileNoThrow.mockResolvedValue({ + stdout: '/Users/My User/bin/zsh\n', + stderr: '', + exitCode: 0, + }); + + const shells = await detectShells(); + + expect(shells[0].path).toBe('/Users/My User/bin/zsh'); + }); + + it('should handle paths with special characters', async () => { + mockedExecFileNoThrow.mockResolvedValue({ + stdout: "/Users/user's-shell/bin/zsh\n", + stderr: '', + exitCode: 0, + }); + + const shells = await detectShells(); + + expect(shells[0].path).toBe("/Users/user's-shell/bin/zsh"); + }); + + it('should handle Windows-style paths', async () => { + const originalPlatform = process.platform; + Object.defineProperty(process, 'platform', { value: 'win32', writable: true }); + + mockedExecFileNoThrow.mockResolvedValue({ + stdout: 'C:\\Program Files\\Git\\bin\\bash.exe\r\n', + stderr: '', + exitCode: 0, + }); + + const shells = await detectShells(); + + // Windows paths can have \r\n line endings, trim handles this + expect(shells[0].path).toBe('C:\\Program Files\\Git\\bin\\bash.exe'); + + Object.defineProperty(process, 'platform', { value: originalPlatform, writable: true }); + }); + + it('should handle very long paths', async () => { + const longPath = '/a'.repeat(1000) + '/zsh'; + mockedExecFileNoThrow.mockResolvedValue({ + stdout: longPath + '\n', + stderr: '', + exitCode: 0, + }); + + const shells = await detectShells(); + + expect(shells[0].path).toBe(longPath); + }); + + it('should handle stderr with content but zero exit code', async () => { + mockedExecFileNoThrow.mockResolvedValue({ + stdout: '/bin/zsh\n', + stderr: 'warning: something happened', + exitCode: 0, + }); + + const shells = await detectShells(); + + // Should still be available if stdout has path and exit code is 0 + expect(shells[0].available).toBe(true); + expect(shells[0].path).toBe('/bin/zsh'); + }); + + it('should handle newline variations', async () => { + mockedExecFileNoThrow.mockResolvedValue({ + stdout: '/bin/zsh\r\n', + stderr: '', + exitCode: 0, + }); + + const shells = await detectShells(); + + // Trim should handle \r\n + expect(shells[0].path).toBe('/bin/zsh'); + }); + }); +}); diff --git a/src/__tests__/main/utils/terminalFilter.test.ts b/src/__tests__/main/utils/terminalFilter.test.ts new file mode 100644 index 00000000..80521f5d --- /dev/null +++ b/src/__tests__/main/utils/terminalFilter.test.ts @@ -0,0 +1,459 @@ +/** + * Tests for terminal filter utilities + * @file src/__tests__/main/utils/terminalFilter.test.ts + */ + +import { describe, it, expect } from 'vitest'; +import { + stripControlSequences, + isCommandEcho, + extractCommand, +} from '../../../main/utils/terminalFilter'; + +describe('terminalFilter', () => { + describe('stripControlSequences', () => { + describe('OSC (Operating System Command) sequences', () => { + it('should remove window title sequences (ESC ] ... BEL)', () => { + const input = '\x1b]0;Terminal Title\x07Some content'; + const result = stripControlSequences(input); + expect(result).toBe('Some content'); + }); + + it('should remove window title sequences with ST terminator (ESC ] ... ESC \\)', () => { + const input = '\x1b]0;Terminal Title\x1b\\Some content'; + const result = stripControlSequences(input); + expect(result).toBe('Some content'); + }); + + it('should remove hyperlink OSC sequences', () => { + const input = '\x1b]8;;http://example.com\x07Click here\x1b]8;;\x07'; + const result = stripControlSequences(input); + expect(result).toBe('Click here'); + }); + + it('should remove numbered OSC sequences', () => { + const input = '\x1b]1;icon-name\x07text\x1b]2;title\x07more'; + const result = stripControlSequences(input); + expect(result).toBe('textmore'); + }); + }); + + describe('CSI (Control Sequence Introducer) sequences', () => { + it('should remove cursor up (A)', () => { + const input = 'text\x1b[1Amore'; + const result = stripControlSequences(input); + expect(result).toBe('textmore'); + }); + + it('should remove cursor down (B)', () => { + const input = 'text\x1b[1Bmore'; + const result = stripControlSequences(input); + expect(result).toBe('textmore'); + }); + + it('should remove cursor forward (C)', () => { + const input = 'text\x1b[5Cmore'; + const result = stripControlSequences(input); + expect(result).toBe('textmore'); + }); + + it('should remove cursor back (D)', () => { + const input = 'text\x1b[3Dmore'; + const result = stripControlSequences(input); + expect(result).toBe('textmore'); + }); + + it('should remove cursor position (H)', () => { + const input = 'text\x1b[10;20Hmore'; + const result = stripControlSequences(input); + expect(result).toBe('textmore'); + }); + + it('should remove cursor position (f)', () => { + const input = 'text\x1b[5;10fmore'; + const result = stripControlSequences(input); + expect(result).toBe('textmore'); + }); + + it('should remove erase in display (J)', () => { + const input = 'text\x1b[2Jmore'; + const result = stripControlSequences(input); + expect(result).toBe('textmore'); + }); + + it('should remove erase in line (K)', () => { + const input = 'text\x1b[0Kmore'; + const result = stripControlSequences(input); + expect(result).toBe('textmore'); + }); + + it('should remove scroll up (S)', () => { + const input = 'text\x1b[3Smore'; + const result = stripControlSequences(input); + expect(result).toBe('textmore'); + }); + + it('should remove scroll down (T)', () => { + const input = 'text\x1b[2Tmore'; + const result = stripControlSequences(input); + expect(result).toBe('textmore'); + }); + + it('should remove DECSET/DECRST sequences (h and l) without ?', () => { + // The regex only matches CSI sequences without ? prefix + // ?25h (show cursor) and ?25l (hide cursor) are not matched + const input = '\x1b[25hvisible\x1b[25l'; + const result = stripControlSequences(input); + expect(result).toBe('visible'); + }); + + it('should preserve DECSET/DECRST private mode sequences with ?', () => { + // The current implementation does NOT remove private mode sequences (with ?) + // This is intentional to preserve certain terminal features + const input = '\x1b[?25hvisible\x1b[?25l'; + const result = stripControlSequences(input); + expect(result).toBe('\x1b[?25hvisible\x1b[?25l'); + }); + + it('should remove soft cursor sequences (p)', () => { + const input = 'text\x1b[0pmore'; + const result = stripControlSequences(input); + expect(result).toBe('textmore'); + }); + + it('should NOT remove SGR color codes (m)', () => { + const input = '\x1b[32mGreen Text\x1b[0m'; + const result = stripControlSequences(input); + expect(result).toBe('\x1b[32mGreen Text\x1b[0m'); + }); + + it('should preserve complex SGR sequences', () => { + const input = '\x1b[1;4;32mBold Underline Green\x1b[0m'; + const result = stripControlSequences(input); + expect(result).toBe('\x1b[1;4;32mBold Underline Green\x1b[0m'); + }); + }); + + describe('shell integration markers', () => { + it('should remove VSCode shell integration (ESC ] 133 ; ...)', () => { + const input = '\x1b]133;A\x07prompt\x1b]133;B\x07\x1b]133;C\x07output\x1b]133;D;0\x07'; + const result = stripControlSequences(input); + expect(result).toBe('promptoutput'); + }); + + it('should remove iTerm2 shell integration (ESC ] 1337 ; ...)', () => { + const input = '\x1b]1337;SetUserVar=foo=bar\x07content'; + const result = stripControlSequences(input); + expect(result).toBe('content'); + }); + + it('should remove current working directory (ESC ] 7 ; ...)', () => { + const input = '\x1b]7;file:///Users/test\x07pwd'; + const result = stripControlSequences(input); + expect(result).toBe('pwd'); + }); + }); + + describe('other escape sequences', () => { + it('should remove soft hyphen', () => { + const input = 'hyphen\u00ADated'; + const result = stripControlSequences(input); + expect(result).toBe('hyphenated'); + }); + + it('should convert CRLF to LF', () => { + const input = 'line1\r\nline2\r\n'; + const result = stripControlSequences(input); + expect(result).toBe('line1\nline2\n'); + }); + + it('should remove character set sequences', () => { + const input = '\x1b(B\x1b)0text'; + const result = stripControlSequences(input); + expect(result).toBe('text'); + }); + + it('should remove BEL character', () => { + const input = 'alert\x07text'; + const result = stripControlSequences(input); + expect(result).toBe('alerttext'); + }); + + it('should remove control characters (0x00-0x1F except newline, tab, escape)', () => { + const input = 'text\x00\x01\x02\x03more'; + const result = stripControlSequences(input); + expect(result).toBe('textmore'); + }); + + it('should preserve newlines', () => { + const input = 'line1\nline2'; + const result = stripControlSequences(input); + expect(result).toBe('line1\nline2'); + }); + + it('should preserve tabs', () => { + const input = 'col1\tcol2'; + const result = stripControlSequences(input); + expect(result).toBe('col1\tcol2'); + }); + }); + + describe('terminal mode filtering (isTerminal = true)', () => { + describe('shell prompt patterns', () => { + it('should remove [user:~/path] format prompts', () => { + const input = '[pedram:~/Projects]\n[pedram:~/Projects]$ ls\nfile1.txt'; + const result = stripControlSequences(input, undefined, true); + expect(result).toBe('file1.txt'); + }); + + it('should remove user@host:~$ format prompts', () => { + const input = 'pedram@macbook:~$\nsome output'; + const result = stripControlSequences(input, undefined, true); + expect(result).toBe('some output'); + }); + + it('should remove user@host:~# format prompts (root)', () => { + const input = 'root@server:~#\nsome output'; + const result = stripControlSequences(input, undefined, true); + expect(result).toBe('some output'); + }); + + it('should remove user@host:~% format prompts (zsh)', () => { + const input = 'user@host:~%\nsome output'; + const result = stripControlSequences(input, undefined, true); + expect(result).toBe('some output'); + }); + + it('should remove user@host:~> format prompts (PowerShell)', () => { + const input = 'user@host:~>\nsome output'; + const result = stripControlSequences(input, undefined, true); + expect(result).toBe('some output'); + }); + + it('should remove ~/path $ format prompts', () => { + const input = '~/Projects $\noutput'; + const result = stripControlSequences(input, undefined, true); + expect(result).toBe('output'); + }); + + it('should remove /absolute/path $ format prompts', () => { + const input = '/home/user $\noutput'; + const result = stripControlSequences(input, undefined, true); + expect(result).toBe('output'); + }); + + it('should remove standalone git branch indicators', () => { + const input = '(main)\n(master)\n(feature/test)\nactual output'; + const result = stripControlSequences(input, undefined, true); + expect(result).toBe('actual output'); + }); + + it('should remove standalone prompt characters', () => { + const input = '$\n#\n%\n>\nactual output'; + const result = stripControlSequences(input, undefined, true); + expect(result).toBe('actual output'); + }); + + it('should remove [user:~/path] (branch) $ format prompts', () => { + const input = '[pedram:~/Projects] (main) $\nactual output'; + const result = stripControlSequences(input, undefined, true); + expect(result).toBe('actual output'); + }); + + it('should handle prompts with dots and hyphens in names', () => { + const input = 'user-name.test@host-name.local:~$\noutput'; + const result = stripControlSequences(input, undefined, true); + expect(result).toBe('output'); + }); + }); + + describe('command echo filtering', () => { + it('should remove exact command echoes', () => { + const input = 'ls -la\nfile1.txt\nfile2.txt'; + const result = stripControlSequences(input, 'ls -la', true); + expect(result).toBe('file1.txt\nfile2.txt'); + }); + + it('should not remove partial matches', () => { + const input = 'ls -la something\nfile1.txt'; + const result = stripControlSequences(input, 'ls -la', true); + expect(result).toBe('ls -la something\nfile1.txt'); + }); + + it('should handle command echo with leading whitespace', () => { + const input = ' ls \nfile1.txt'; + const result = stripControlSequences(input, 'ls', true); + expect(result).toBe('file1.txt'); + }); + }); + + describe('git branch cleanup', () => { + it('should remove git branch indicators from content lines', () => { + const input = 'output (main) text'; + const result = stripControlSequences(input, undefined, true); + expect(result).toBe('output text'); + }); + + it('should remove trailing prompt characters from content', () => { + // The regex removes trailing $ but keeps preceding space + // The line is 'some text $' -> regex replaces '$ ' with '' -> 'some text ' + // (trailing space remains because cleanedLine.trim() is only checked for empty) + const input = 'some text $\nmore text'; + const result = stripControlSequences(input, undefined, true); + expect(result).toBe('some text \nmore text'); + }); + }); + + describe('empty line handling', () => { + it('should skip empty lines', () => { + const input = '\n\n\nactual output\n\n'; + const result = stripControlSequences(input, undefined, true); + expect(result).toBe('actual output'); + }); + + it('should skip lines that become empty after cleaning', () => { + const input = ' (main) $\nactual output'; + const result = stripControlSequences(input, undefined, true); + expect(result).toBe('actual output'); + }); + }); + }); + + describe('non-terminal mode (isTerminal = false, default)', () => { + it('should not filter prompts when isTerminal is false', () => { + const input = 'user@host:~$ ls\nfile1.txt'; + const result = stripControlSequences(input, 'ls', false); + expect(result).toBe('user@host:~$ ls\nfile1.txt'); + }); + + it('should not filter prompts when isTerminal is not provided', () => { + const input = 'user@host:~$ ls\nfile1.txt'; + const result = stripControlSequences(input); + expect(result).toBe('user@host:~$ ls\nfile1.txt'); + }); + }); + + describe('complex scenarios', () => { + it('should handle mixed control sequences and content', () => { + const input = + '\x1b]0;Title\x07\x1b[2J\x1b[H\x1b[32mGreen text\x1b[0m\x07more content'; + const result = stripControlSequences(input); + expect(result).toBe('\x1b[32mGreen text\x1b[0mmore content'); + }); + + it('should handle multiple shell integration markers', () => { + const input = + '\x1b]133;A\x07\x1b]7;file:///path\x07prompt\x1b]133;B\x07\x1b]1337;Foo=bar\x07output'; + const result = stripControlSequences(input); + expect(result).toBe('promptoutput'); + }); + + it('should handle empty input', () => { + const result = stripControlSequences(''); + expect(result).toBe(''); + }); + + it('should handle input with only control sequences', () => { + const input = '\x1b[2J\x1b[H\x1b]0;Title\x07'; + const result = stripControlSequences(input); + expect(result).toBe(''); + }); + }); + }); + + describe('isCommandEcho', () => { + it('should return false when lastCommand is not provided', () => { + expect(isCommandEcho('ls')).toBe(false); + }); + + it('should return false when lastCommand is empty', () => { + expect(isCommandEcho('ls', '')).toBe(false); + }); + + it('should return true for exact match', () => { + expect(isCommandEcho('ls -la', 'ls -la')).toBe(true); + }); + + it('should return true for match with leading whitespace in line', () => { + expect(isCommandEcho(' ls -la ', 'ls -la')).toBe(true); + }); + + it('should return true for match with leading whitespace in command', () => { + expect(isCommandEcho('ls -la', ' ls -la ')).toBe(true); + }); + + it('should return true when line ends with the command', () => { + expect(isCommandEcho('$ ls -la', 'ls -la')).toBe(true); + }); + + it('should return true when line has prompt prefix and ends with command', () => { + expect(isCommandEcho('[user:~/path]$ ls -la', 'ls -la')).toBe(true); + }); + + it('should return false for partial match that does not end with command', () => { + expect(isCommandEcho('ls -la --all', 'ls -la')).toBe(false); + }); + + it('should return false for completely different line', () => { + expect(isCommandEcho('file1.txt', 'ls -la')).toBe(false); + }); + + it('should handle multi-word commands', () => { + expect(isCommandEcho('git commit -m "message"', 'git commit -m "message"')).toBe(true); + }); + + it('should handle commands with special characters', () => { + expect(isCommandEcho('echo "hello world"', 'echo "hello world"')).toBe(true); + }); + }); + + describe('extractCommand', () => { + it('should return trimmed input when no prompt present', () => { + expect(extractCommand('ls -la')).toBe('ls -la'); + }); + + it('should remove $ prompt prefix', () => { + expect(extractCommand('$ ls -la')).toBe('ls -la'); + }); + + it('should remove # prompt prefix', () => { + expect(extractCommand('# ls -la')).toBe('ls -la'); + }); + + it('should remove % prompt prefix', () => { + expect(extractCommand('% ls -la')).toBe('ls -la'); + }); + + it('should remove > prompt prefix', () => { + expect(extractCommand('> ls -la')).toBe('ls -la'); + }); + + it('should remove user@host:~$ prompt prefix', () => { + expect(extractCommand('user@host:~$ ls -la')).toBe('ls -la'); + }); + + it('should remove [user:~/path]$ prompt prefix', () => { + expect(extractCommand('[pedram:~/Projects]$ npm install')).toBe('npm install'); + }); + + it('should handle extra whitespace after prompt', () => { + expect(extractCommand('$ ls -la')).toBe('ls -la'); + }); + + it('should handle complex prompt patterns', () => { + expect(extractCommand('user@host:/var/log# tail -f syslog')).toBe('tail -f syslog'); + }); + + it('should return empty string for empty input', () => { + expect(extractCommand('')).toBe(''); + }); + + it('should return empty string for just prompt', () => { + expect(extractCommand('$ ')).toBe(''); + }); + + it('should handle multiple prompt characters (takes first)', () => { + expect(extractCommand('$ echo "$ hello"')).toBe('echo "$ hello"'); + }); + }); +}); diff --git a/src/__tests__/renderer/components/AICommandsPanel.test.tsx b/src/__tests__/renderer/components/AICommandsPanel.test.tsx new file mode 100644 index 00000000..eb3da69e --- /dev/null +++ b/src/__tests__/renderer/components/AICommandsPanel.test.tsx @@ -0,0 +1,1159 @@ +/** + * Tests for AICommandsPanel.tsx + * + * Tests the AICommandsPanel component for custom AI slash command management: + * - Initial render (empty state, with commands) + * - Template variables documentation section (expand/collapse) + * - Create new command form (open/close, validation, submission) + * - Edit existing commands (enter edit mode, update fields, save) + * - Delete commands (custom commands, built-in protection) + * - Command validation (slash prefix normalization, duplicate prevention) + * - Built-in command handling (edit allowed, delete prevented) + */ + +import React from 'react'; +import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'; +import { render, screen, fireEvent, within } from '@testing-library/react'; +import { AICommandsPanel } from '../../../renderer/components/AICommandsPanel'; +import type { Theme, CustomAICommand } from '../../../renderer/types'; + +// Sample theme for testing +const mockTheme: Theme = { + id: 'dracula', + name: 'Dracula', + mode: 'dark', + colors: { + bgMain: '#282a36', + bgSidebar: '#21222c', + bgActivity: '#343746', + border: '#44475a', + textMain: '#f8f8f2', + textDim: '#6272a4', + accent: '#bd93f9', + accentDim: '#bd93f920', + accentText: '#f8f8f2', + accentForeground: '#ffffff', + success: '#50fa7b', + warning: '#ffb86c', + error: '#ff5555', + }, +}; + +// Helper to create mock commands +const createMockCommand = (overrides: Partial = {}): CustomAICommand => ({ + id: `custom-test-${Date.now()}`, + command: '/test', + description: 'Test command description', + prompt: 'Test prompt content', + isBuiltIn: false, + ...overrides, +}); + +describe('AICommandsPanel', () => { + let mockSetCustomAICommands: ReturnType; + + beforeEach(() => { + mockSetCustomAICommands = vi.fn(); + vi.clearAllMocks(); + }); + + afterEach(() => { + vi.clearAllMocks(); + }); + + describe('Initial render', () => { + it('should render header with title and description', () => { + render( + + ); + + expect(screen.getByText('Custom AI Commands')).toBeInTheDocument(); + expect(screen.getByText(/Slash commands available in AI terminal mode/)).toBeInTheDocument(); + }); + + it('should render template variables section collapsed by default', () => { + render( + + ); + + expect(screen.getByText('Template Variables')).toBeInTheDocument(); + // Variable documentation should not be visible + expect(screen.queryByText(/Use these variables in your command prompts/)).not.toBeInTheDocument(); + }); + + it('should render Add Command button', () => { + render( + + ); + + expect(screen.getByRole('button', { name: /Add Command/i })).toBeInTheDocument(); + }); + + it('should render empty state when no commands', () => { + render( + + ); + + expect(screen.getByText('No custom AI commands configured')).toBeInTheDocument(); + expect(screen.getByText('Create your first command')).toBeInTheDocument(); + }); + + it('should render existing commands', () => { + const commands = [ + createMockCommand({ id: 'cmd-1', command: '/hello', description: 'Say hello' }), + createMockCommand({ id: 'cmd-2', command: '/goodbye', description: 'Say goodbye' }), + ]; + + render( + + ); + + expect(screen.getByText('/hello')).toBeInTheDocument(); + expect(screen.getByText('Say hello')).toBeInTheDocument(); + expect(screen.getByText('/goodbye')).toBeInTheDocument(); + expect(screen.getByText('Say goodbye')).toBeInTheDocument(); + }); + + it('should not show empty state when commands exist', () => { + const commands = [createMockCommand()]; + + render( + + ); + + expect(screen.queryByText('No custom AI commands configured')).not.toBeInTheDocument(); + }); + }); + + describe('Template Variables documentation', () => { + it('should expand template variables when clicked', () => { + render( + + ); + + const toggleButton = screen.getByText('Template Variables').closest('button')!; + fireEvent.click(toggleButton); + + expect(screen.getByText(/Use these variables in your command prompts/)).toBeInTheDocument(); + }); + + it('should collapse template variables when clicked again', () => { + render( + + ); + + const toggleButton = screen.getByText('Template Variables').closest('button')!; + + // Expand + fireEvent.click(toggleButton); + expect(screen.getByText(/Use these variables in your command prompts/)).toBeInTheDocument(); + + // Collapse + fireEvent.click(toggleButton); + expect(screen.queryByText(/Use these variables in your command prompts/)).not.toBeInTheDocument(); + }); + + it('should display template variable codes when expanded', () => { + render( + + ); + + const toggleButton = screen.getByText('Template Variables').closest('button')!; + fireEvent.click(toggleButton); + + // Check for some common template variables (uppercase with underscores) + expect(screen.getByText('{{AGENT_NAME}}')).toBeInTheDocument(); + expect(screen.getByText('{{PROJECT_PATH}}')).toBeInTheDocument(); + }); + }); + + describe('Create new command form', () => { + it('should open create form when Add Command clicked', () => { + render( + + ); + + fireEvent.click(screen.getByRole('button', { name: /Add Command/i })); + + expect(screen.getByText('New Command')).toBeInTheDocument(); + expect(screen.getByPlaceholderText('/mycommand')).toBeInTheDocument(); + expect(screen.getByPlaceholderText('Short description for autocomplete')).toBeInTheDocument(); + expect(screen.getByPlaceholderText(/The actual prompt sent to the AI/)).toBeInTheDocument(); + }); + + it('should open create form when empty state link clicked', () => { + render( + + ); + + fireEvent.click(screen.getByText('Create your first command')); + + expect(screen.getByText('New Command')).toBeInTheDocument(); + }); + + it('should hide Add Command button when form is open', () => { + render( + + ); + + fireEvent.click(screen.getByRole('button', { name: /Add Command/i })); + + // Should only have Cancel and Create buttons, not Add Command + expect(screen.queryByRole('button', { name: /Add Command/i })).not.toBeInTheDocument(); + }); + + it('should cancel create form and reset state', () => { + render( + + ); + + fireEvent.click(screen.getByRole('button', { name: /Add Command/i })); + + // Fill some fields + fireEvent.change(screen.getByPlaceholderText('/mycommand'), { target: { value: '/custom' } }); + fireEvent.change(screen.getByPlaceholderText('Short description for autocomplete'), { target: { value: 'My description' } }); + + // Cancel + fireEvent.click(screen.getByRole('button', { name: /Cancel/i })); + + // Form should be hidden + expect(screen.queryByText('New Command')).not.toBeInTheDocument(); + // Add Command button should be back + expect(screen.getByRole('button', { name: /Add Command/i })).toBeInTheDocument(); + }); + + it('should disable Create button when fields are empty', () => { + render( + + ); + + fireEvent.click(screen.getByRole('button', { name: /Add Command/i })); + + // Create button should be disabled initially (only / in command field) + const createButton = screen.getByRole('button', { name: /Create/i }); + expect(createButton).toBeDisabled(); + }); + + it('should enable Create button when all fields are filled', () => { + render( + + ); + + fireEvent.click(screen.getByRole('button', { name: /Add Command/i })); + + // Fill all fields + fireEvent.change(screen.getByPlaceholderText('/mycommand'), { target: { value: '/custom' } }); + fireEvent.change(screen.getByPlaceholderText('Short description for autocomplete'), { target: { value: 'My description' } }); + fireEvent.change(screen.getByPlaceholderText(/The actual prompt sent to the AI/), { target: { value: 'My prompt' } }); + + const createButton = screen.getByRole('button', { name: /Create/i }); + expect(createButton).not.toBeDisabled(); + }); + + it('should create command with slash prefix if missing', () => { + render( + + ); + + fireEvent.click(screen.getByRole('button', { name: /Add Command/i })); + + // Fill fields without slash prefix + fireEvent.change(screen.getByPlaceholderText('/mycommand'), { target: { value: 'mycommand' } }); + fireEvent.change(screen.getByPlaceholderText('Short description for autocomplete'), { target: { value: 'Description' } }); + fireEvent.change(screen.getByPlaceholderText(/The actual prompt sent to the AI/), { target: { value: 'Prompt' } }); + + fireEvent.click(screen.getByRole('button', { name: /Create/i })); + + // Should add slash prefix + expect(mockSetCustomAICommands).toHaveBeenCalled(); + const callArg = mockSetCustomAICommands.mock.calls[0][0]; + expect(callArg[0].command).toBe('/mycommand'); + }); + + it('should keep slash prefix if already present', () => { + render( + + ); + + fireEvent.click(screen.getByRole('button', { name: /Add Command/i })); + + // Fill fields with slash prefix + fireEvent.change(screen.getByPlaceholderText('/mycommand'), { target: { value: '/mycommand' } }); + fireEvent.change(screen.getByPlaceholderText('Short description for autocomplete'), { target: { value: 'Description' } }); + fireEvent.change(screen.getByPlaceholderText(/The actual prompt sent to the AI/), { target: { value: 'Prompt' } }); + + fireEvent.click(screen.getByRole('button', { name: /Create/i })); + + const callArg = mockSetCustomAICommands.mock.calls[0][0]; + expect(callArg[0].command).toBe('/mycommand'); + }); + + it('should generate unique ID for new command', () => { + render( + + ); + + fireEvent.click(screen.getByRole('button', { name: /Add Command/i })); + + fireEvent.change(screen.getByPlaceholderText('/mycommand'), { target: { value: '/test-cmd' } }); + fireEvent.change(screen.getByPlaceholderText('Short description for autocomplete'), { target: { value: 'Description' } }); + fireEvent.change(screen.getByPlaceholderText(/The actual prompt sent to the AI/), { target: { value: 'Prompt' } }); + + fireEvent.click(screen.getByRole('button', { name: /Create/i })); + + const callArg = mockSetCustomAICommands.mock.calls[0][0]; + expect(callArg[0].id).toMatch(/^custom-test-cmd-\d+$/); + expect(callArg[0].isBuiltIn).toBe(false); + }); + + it('should not create duplicate commands', () => { + const existingCommands = [ + createMockCommand({ command: '/existing' }), + ]; + + render( + + ); + + fireEvent.click(screen.getByRole('button', { name: /Add Command/i })); + + // Try to create duplicate + fireEvent.change(screen.getByPlaceholderText('/mycommand'), { target: { value: '/existing' } }); + fireEvent.change(screen.getByPlaceholderText('Short description for autocomplete'), { target: { value: 'Description' } }); + fireEvent.change(screen.getByPlaceholderText(/The actual prompt sent to the AI/), { target: { value: 'Prompt' } }); + + fireEvent.click(screen.getByRole('button', { name: /Create/i })); + + // Should not call setCustomAICommands for duplicate + expect(mockSetCustomAICommands).not.toHaveBeenCalled(); + }); + + it('should reset form after successful creation', () => { + render( + + ); + + fireEvent.click(screen.getByRole('button', { name: /Add Command/i })); + + fireEvent.change(screen.getByPlaceholderText('/mycommand'), { target: { value: '/newcmd' } }); + fireEvent.change(screen.getByPlaceholderText('Short description for autocomplete'), { target: { value: 'Description' } }); + fireEvent.change(screen.getByPlaceholderText(/The actual prompt sent to the AI/), { target: { value: 'Prompt' } }); + + fireEvent.click(screen.getByRole('button', { name: /Create/i })); + + // Form should be closed + expect(screen.queryByText('New Command')).not.toBeInTheDocument(); + // Add Command button should be back + expect(screen.getByRole('button', { name: /Add Command/i })).toBeInTheDocument(); + }); + + it('should append new command to existing commands', () => { + const existingCommands = [ + createMockCommand({ id: 'cmd-1', command: '/existing' }), + ]; + + render( + + ); + + fireEvent.click(screen.getByRole('button', { name: /Add Command/i })); + + fireEvent.change(screen.getByPlaceholderText('/mycommand'), { target: { value: '/newcmd' } }); + fireEvent.change(screen.getByPlaceholderText('Short description for autocomplete'), { target: { value: 'Description' } }); + fireEvent.change(screen.getByPlaceholderText(/The actual prompt sent to the AI/), { target: { value: 'Prompt' } }); + + fireEvent.click(screen.getByRole('button', { name: /Create/i })); + + const callArg = mockSetCustomAICommands.mock.calls[0][0]; + expect(callArg).toHaveLength(2); + expect(callArg[0].command).toBe('/existing'); + expect(callArg[1].command).toBe('/newcmd'); + }); + + it('should sanitize command ID (replace non-alphanumeric with dashes)', () => { + render( + + ); + + fireEvent.click(screen.getByRole('button', { name: /Add Command/i })); + + fireEvent.change(screen.getByPlaceholderText('/mycommand'), { target: { value: '/test@command#123!' } }); + fireEvent.change(screen.getByPlaceholderText('Short description for autocomplete'), { target: { value: 'Description' } }); + fireEvent.change(screen.getByPlaceholderText(/The actual prompt sent to the AI/), { target: { value: 'Prompt' } }); + + fireEvent.click(screen.getByRole('button', { name: /Create/i })); + + const callArg = mockSetCustomAICommands.mock.calls[0][0]; + // ID generation: command.slice(1).toLowerCase().replace(/[^a-z0-9]/g, '-') + // /test@command#123! => test@command#123! => test-command-123- + expect(callArg[0].id).toMatch(/^custom-test-command-123--\d+$/); + }); + }); + + describe('Edit command', () => { + it('should enter edit mode when edit button clicked', () => { + const commands = [ + createMockCommand({ id: 'cmd-1', command: '/editable', description: 'Editable command', prompt: 'Original prompt' }), + ]; + + render( + + ); + + // Click edit button + const editButton = screen.getByTitle('Edit command'); + fireEvent.click(editButton); + + // Should show edit form with current values + const commandInput = screen.getByDisplayValue('/editable'); + const descInput = screen.getByDisplayValue('Editable command'); + const promptInput = screen.getByDisplayValue('Original prompt'); + + expect(commandInput).toBeInTheDocument(); + expect(descInput).toBeInTheDocument(); + expect(promptInput).toBeInTheDocument(); + }); + + it('should save edited command', () => { + const commands = [ + createMockCommand({ id: 'cmd-1', command: '/original', description: 'Original desc', prompt: 'Original prompt' }), + ]; + + render( + + ); + + // Enter edit mode + fireEvent.click(screen.getByTitle('Edit command')); + + // Change values + const commandInput = screen.getByDisplayValue('/original'); + fireEvent.change(commandInput, { target: { value: '/updated' } }); + + const descInput = screen.getByDisplayValue('Original desc'); + fireEvent.change(descInput, { target: { value: 'Updated desc' } }); + + // Save + fireEvent.click(screen.getByRole('button', { name: /Save/i })); + + expect(mockSetCustomAICommands).toHaveBeenCalled(); + const callArg = mockSetCustomAICommands.mock.calls[0][0]; + expect(callArg[0].command).toBe('/updated'); + expect(callArg[0].description).toBe('Updated desc'); + }); + + it('should add slash prefix when saving edit without slash', () => { + const commands = [ + createMockCommand({ id: 'cmd-1', command: '/original' }), + ]; + + render( + + ); + + fireEvent.click(screen.getByTitle('Edit command')); + + const commandInput = screen.getByDisplayValue('/original'); + fireEvent.change(commandInput, { target: { value: 'noslash' } }); + + fireEvent.click(screen.getByRole('button', { name: /Save/i })); + + const callArg = mockSetCustomAICommands.mock.calls[0][0]; + expect(callArg[0].command).toBe('/noslash'); + }); + + it('should cancel edit and restore original values', () => { + const commands = [ + createMockCommand({ id: 'cmd-1', command: '/original', description: 'Original desc' }), + ]; + + render( + + ); + + fireEvent.click(screen.getByTitle('Edit command')); + + // Change values + const commandInput = screen.getByDisplayValue('/original'); + fireEvent.change(commandInput, { target: { value: '/changed' } }); + + // Cancel + fireEvent.click(screen.getByRole('button', { name: /Cancel/i })); + + // Should show original values (not be in edit mode) + expect(screen.queryByDisplayValue('/changed')).not.toBeInTheDocument(); + expect(screen.getByText('/original')).toBeInTheDocument(); + expect(mockSetCustomAICommands).not.toHaveBeenCalled(); + }); + + it('should update only the edited command', () => { + const commands = [ + createMockCommand({ id: 'cmd-1', command: '/first', description: 'First', prompt: 'Prompt 1' }), + createMockCommand({ id: 'cmd-2', command: '/second', description: 'Second', prompt: 'Prompt 2' }), + ]; + + render( + + ); + + // Edit first command + const editButtons = screen.getAllByTitle('Edit command'); + fireEvent.click(editButtons[0]); + + const commandInput = screen.getByDisplayValue('/first'); + fireEvent.change(commandInput, { target: { value: '/updated-first' } }); + + fireEvent.click(screen.getByRole('button', { name: /Save/i })); + + const callArg = mockSetCustomAICommands.mock.calls[0][0]; + expect(callArg[0].command).toBe('/updated-first'); + expect(callArg[1].command).toBe('/second'); // Unchanged + }); + + it('should not save edit if editingCommand is null', () => { + const commands = [createMockCommand({ id: 'cmd-1', command: '/test' })]; + + const { rerender } = render( + + ); + + // This tests the early return in handleSaveEdit when editingCommand is null + // By testing that if we never enter edit mode, nothing is saved + expect(mockSetCustomAICommands).not.toHaveBeenCalled(); + }); + + it('should show Save and Cancel buttons in edit mode', () => { + const commands = [createMockCommand({ id: 'cmd-1', command: '/test' })]; + + render( + + ); + + fireEvent.click(screen.getByTitle('Edit command')); + + expect(screen.getByRole('button', { name: /Save/i })).toBeInTheDocument(); + expect(screen.getByRole('button', { name: /Cancel/i })).toBeInTheDocument(); + }); + }); + + describe('Delete command', () => { + it('should delete custom command', () => { + const commands = [ + createMockCommand({ id: 'cmd-1', command: '/deletable', isBuiltIn: false }), + ]; + + render( + + ); + + fireEvent.click(screen.getByTitle('Delete command')); + + expect(mockSetCustomAICommands).toHaveBeenCalled(); + const callArg = mockSetCustomAICommands.mock.calls[0][0]; + expect(callArg).toHaveLength(0); + }); + + it('should not delete built-in command', () => { + const commands = [ + createMockCommand({ id: 'cmd-1', command: '/builtin', isBuiltIn: true }), + ]; + + render( + + ); + + // Built-in commands should not have delete button + expect(screen.queryByTitle('Delete command')).not.toBeInTheDocument(); + }); + + it('should remove only the specified command', () => { + const commands = [ + createMockCommand({ id: 'cmd-1', command: '/first', isBuiltIn: false }), + createMockCommand({ id: 'cmd-2', command: '/second', isBuiltIn: false }), + createMockCommand({ id: 'cmd-3', command: '/third', isBuiltIn: false }), + ]; + + render( + + ); + + // Delete second command + const deleteButtons = screen.getAllByTitle('Delete command'); + fireEvent.click(deleteButtons[1]); + + const callArg = mockSetCustomAICommands.mock.calls[0][0]; + expect(callArg).toHaveLength(2); + expect(callArg[0].command).toBe('/first'); + expect(callArg[1].command).toBe('/third'); + }); + + it('should handle delete of non-existent command gracefully', () => { + const commands = [ + createMockCommand({ id: 'cmd-1', command: '/test', isBuiltIn: false }), + ]; + + render( + + ); + + // This tests the handleDelete function's guard clause + fireEvent.click(screen.getByTitle('Delete command')); + + // Should have been called with filtered array + expect(mockSetCustomAICommands).toHaveBeenCalledTimes(1); + }); + }); + + describe('Built-in commands', () => { + it('should show Built-in badge for built-in commands', () => { + const commands = [ + createMockCommand({ id: 'builtin-1', command: '/help', isBuiltIn: true }), + ]; + + render( + + ); + + expect(screen.getByText('Built-in')).toBeInTheDocument(); + }); + + it('should not show Built-in badge for custom commands', () => { + const commands = [ + createMockCommand({ id: 'custom-1', command: '/custom', isBuiltIn: false }), + ]; + + render( + + ); + + expect(screen.queryByText('Built-in')).not.toBeInTheDocument(); + }); + + it('should allow editing built-in commands', () => { + const commands = [ + createMockCommand({ id: 'builtin-1', command: '/help', description: 'Help command', isBuiltIn: true }), + ]; + + render( + + ); + + // Edit button should exist + const editButton = screen.getByTitle('Edit command'); + expect(editButton).toBeInTheDocument(); + + // Enter edit mode and save + fireEvent.click(editButton); + + const descInput = screen.getByDisplayValue('Help command'); + fireEvent.change(descInput, { target: { value: 'Updated help' } }); + + fireEvent.click(screen.getByRole('button', { name: /Save/i })); + + expect(mockSetCustomAICommands).toHaveBeenCalled(); + }); + + it('should not show delete button for built-in commands', () => { + const commands = [ + createMockCommand({ id: 'builtin-1', command: '/help', isBuiltIn: true }), + createMockCommand({ id: 'custom-1', command: '/custom', isBuiltIn: false }), + ]; + + render( + + ); + + // Only one delete button should exist (for custom command) + const deleteButtons = screen.getAllByTitle('Delete command'); + expect(deleteButtons).toHaveLength(1); + }); + }); + + describe('Command display', () => { + it('should display command name with accent color', () => { + const commands = [ + createMockCommand({ command: '/highlighted' }), + ]; + + render( + + ); + + const commandText = screen.getByText('/highlighted'); + expect(commandText).toHaveStyle({ color: mockTheme.colors.accent }); + }); + + it('should display command prompt in code block', () => { + const commands = [ + createMockCommand({ prompt: 'This is the prompt content' }), + ]; + + render( + + ); + + expect(screen.getByText('This is the prompt content')).toBeInTheDocument(); + }); + + it('should apply theme colors to components', () => { + const commands = [ + createMockCommand({ command: '/themed' }), + ]; + + render( + + ); + + // Check description text uses textDim color + const description = screen.getByText('Test command description'); + expect(description).toHaveStyle({ color: mockTheme.colors.textDim }); + }); + }); + + describe('Input handling', () => { + it('should update command input in create form', () => { + render( + + ); + + fireEvent.click(screen.getByRole('button', { name: /Add Command/i })); + + const input = screen.getByPlaceholderText('/mycommand'); + fireEvent.change(input, { target: { value: '/newvalue' } }); + + expect(input).toHaveValue('/newvalue'); + }); + + it('should update description input in create form', () => { + render( + + ); + + fireEvent.click(screen.getByRole('button', { name: /Add Command/i })); + + const input = screen.getByPlaceholderText('Short description for autocomplete'); + fireEvent.change(input, { target: { value: 'New description' } }); + + expect(input).toHaveValue('New description'); + }); + + it('should update prompt textarea in create form', () => { + render( + + ); + + fireEvent.click(screen.getByRole('button', { name: /Add Command/i })); + + const textarea = screen.getByPlaceholderText(/The actual prompt sent to the AI/); + fireEvent.change(textarea, { target: { value: 'New prompt text' } }); + + expect(textarea).toHaveValue('New prompt text'); + }); + + it('should update command input in edit form', () => { + const commands = [ + createMockCommand({ command: '/original' }), + ]; + + render( + + ); + + fireEvent.click(screen.getByTitle('Edit command')); + + const input = screen.getByDisplayValue('/original'); + fireEvent.change(input, { target: { value: '/edited' } }); + + expect(input).toHaveValue('/edited'); + }); + + it('should update description input in edit form', () => { + const commands = [ + createMockCommand({ description: 'Original description' }), + ]; + + render( + + ); + + fireEvent.click(screen.getByTitle('Edit command')); + + const input = screen.getByDisplayValue('Original description'); + fireEvent.change(input, { target: { value: 'Edited description' } }); + + expect(input).toHaveValue('Edited description'); + }); + + it('should update prompt textarea in edit form', () => { + const commands = [ + createMockCommand({ prompt: 'Original prompt' }), + ]; + + render( + + ); + + fireEvent.click(screen.getByTitle('Edit command')); + + const textarea = screen.getByDisplayValue('Original prompt'); + fireEvent.change(textarea, { target: { value: 'Edited prompt' } }); + + expect(textarea).toHaveValue('Edited prompt'); + }); + }); + + describe('Edge cases', () => { + it('should handle special characters in command', () => { + render( + + ); + + fireEvent.click(screen.getByRole('button', { name: /Add Command/i })); + + fireEvent.change(screen.getByPlaceholderText('/mycommand'), { target: { value: '/test' } }); + fireEvent.change(screen.getByPlaceholderText('Short description for autocomplete'), { target: { value: 'XSS test' } }); + fireEvent.change(screen.getByPlaceholderText(/The actual prompt sent to the AI/), { target: { value: 'Prompt' } }); + + fireEvent.click(screen.getByRole('button', { name: /Create/i })); + + expect(mockSetCustomAICommands).toHaveBeenCalled(); + // Command should be sanitized in ID generation (non-alphanumeric replaced with dashes) + // /test => test-script-alert--xss----script- + const callArg = mockSetCustomAICommands.mock.calls[0][0]; + expect(callArg[0].id).toMatch(/^custom-test-script-alert--xss----script--\d+$/); + }); + + it('should handle unicode in command description', () => { + const commands = [ + createMockCommand({ description: '日本語の説明 🎉' }), + ]; + + render( + + ); + + expect(screen.getByText('日本語の説明 🎉')).toBeInTheDocument(); + }); + + it('should handle very long prompt text', () => { + const longPrompt = 'A'.repeat(10000); + const commands = [ + createMockCommand({ prompt: longPrompt }), + ]; + + render( + + ); + + expect(screen.getByText(longPrompt)).toBeInTheDocument(); + }); + + it('should handle empty commands array', () => { + render( + + ); + + expect(screen.getByText('No custom AI commands configured')).toBeInTheDocument(); + }); + + it('should handle many commands', () => { + const commands = Array.from({ length: 50 }, (_, i) => + createMockCommand({ id: `cmd-${i}`, command: `/command${i}` }) + ); + + render( + + ); + + expect(screen.getByText('/command0')).toBeInTheDocument(); + expect(screen.getByText('/command49')).toBeInTheDocument(); + }); + + it('should handle whitespace-only inputs as invalid', () => { + render( + + ); + + fireEvent.click(screen.getByRole('button', { name: /Add Command/i })); + + // Fill with whitespace only (except command which starts with /) + fireEvent.change(screen.getByPlaceholderText('/mycommand'), { target: { value: '/test' } }); + fireEvent.change(screen.getByPlaceholderText('Short description for autocomplete'), { target: { value: ' ' } }); + fireEvent.change(screen.getByPlaceholderText(/The actual prompt sent to the AI/), { target: { value: ' ' } }); + + // Button should be enabled because fields are technically not empty + // The component doesn't trim whitespace before checking + const createButton = screen.getByRole('button', { name: /Create/i }); + expect(createButton).not.toBeDisabled(); + }); + + it('should handle rapid create/cancel cycles', () => { + render( + + ); + + // Rapid create/cancel cycles + for (let i = 0; i < 5; i++) { + fireEvent.click(screen.getByRole('button', { name: /Add Command/i })); + fireEvent.click(screen.getByRole('button', { name: /Cancel/i })); + } + + // Should end in stable state + expect(screen.getByRole('button', { name: /Add Command/i })).toBeInTheDocument(); + expect(screen.queryByText('New Command')).not.toBeInTheDocument(); + }); + }); + + describe('Light theme', () => { + const lightTheme: Theme = { + ...mockTheme, + id: 'github-light', + name: 'GitHub Light', + mode: 'light', + colors: { + bgMain: '#ffffff', + bgSidebar: '#f6f8fa', + bgActivity: '#f0f0f0', + border: '#d0d7de', + textMain: '#24292f', + textDim: '#57606a', + accent: '#0969da', + accentDim: '#0969da20', + accentText: '#24292f', + accentForeground: '#ffffff', + success: '#1a7f37', + warning: '#9a6700', + error: '#cf222e', + }, + }; + + it('should render with light theme colors', () => { + const commands = [ + createMockCommand({ command: '/themed' }), + ]; + + render( + + ); + + const commandText = screen.getByText('/themed'); + expect(commandText).toHaveStyle({ color: lightTheme.colors.accent }); + }); + }); +}); diff --git a/src/__tests__/renderer/components/AboutModal.test.tsx b/src/__tests__/renderer/components/AboutModal.test.tsx new file mode 100644 index 00000000..d1bdebe9 --- /dev/null +++ b/src/__tests__/renderer/components/AboutModal.test.tsx @@ -0,0 +1,1089 @@ +/** + * @fileoverview Tests for AboutModal component + * Tests: formatTokens helper, formatDuration helper, layer stack integration, + * streaming stats loading, external links, child component rendering + */ + +import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'; +import { render, screen, fireEvent, waitFor, act } from '@testing-library/react'; +import { AboutModal } from '../../../renderer/components/AboutModal'; +import type { Theme, Session, AutoRunStats } from '../../../renderer/types'; + +// Mock lucide-react icons +vi.mock('lucide-react', () => ({ + X: ({ className, style }: { className?: string; style?: React.CSSProperties }) => ( + × + ), + Wand2: ({ className, style }: { className?: string; style?: React.CSSProperties }) => ( + 🪄 + ), + ExternalLink: ({ className, style }: { className?: string; style?: React.CSSProperties }) => ( + ↗ + ), + FileCode: ({ className, style }: { className?: string; style?: React.CSSProperties }) => ( + 📄 + ), + BarChart3: ({ className, style }: { className?: string; style?: React.CSSProperties }) => ( + 📊 + ), + Loader2: ({ className, style }: { className?: string; style?: React.CSSProperties }) => ( + ⏳ + ), +})); + +// Mock the avatar import +vi.mock('../../../renderer/assets/pedram-avatar.png', () => ({ + default: 'mock-avatar-url.png', +})); + +// Mock layer stack context +const mockRegisterLayer = vi.fn(() => 'layer-about-123'); +const mockUnregisterLayer = vi.fn(); +const mockUpdateLayerHandler = vi.fn(); + +vi.mock('../../../renderer/contexts/LayerStackContext', () => ({ + useLayerStack: () => ({ + registerLayer: mockRegisterLayer, + unregisterLayer: mockUnregisterLayer, + updateLayerHandler: mockUpdateLayerHandler, + }), +})); + +// Mock AchievementCard +vi.mock('../../../renderer/components/AchievementCard', () => ({ + AchievementCard: ({ theme, autoRunStats, globalStats, onEscapeWithBadgeOpen }: { + theme: Theme; + autoRunStats: AutoRunStats; + globalStats: ClaudeGlobalStats | null; + onEscapeWithBadgeOpen: (handler: (() => boolean) | null) => void; + }) => ( +
+ AchievementCard + + +
+ ), +})); + +// Add __APP_VERSION__ global +(globalThis as unknown as { __APP_VERSION__: string }).__APP_VERSION__ = '1.0.0'; + +// Interface for global stats +interface ClaudeGlobalStats { + totalSessions: number; + totalMessages: number; + totalInputTokens: number; + totalOutputTokens: number; + totalCacheReadTokens: number; + totalCacheCreationTokens: number; + totalCostUsd: number; + totalSizeBytes: number; + isComplete?: boolean; +} + +// Create test theme +const createTheme = (): Theme => ({ + id: 'test-dark', + name: 'Test Dark', + mode: 'dark', + colors: { + bgMain: '#1a1a2e', + bgSidebar: '#16213e', + bgActivity: '#0f3460', + textMain: '#e8e8e8', + textDim: '#888888', + accent: '#7b2cbf', + border: '#333355', + success: '#22c55e', + warning: '#f59e0b', + error: '#ef4444', + info: '#3b82f6', + bgAccentHover: '#9333ea', + }, +}); + +// Create test session +const createSession = (overrides: Partial = {}): Session => ({ + id: 'session-1', + name: 'Test Session', + toolType: 'claude-code', + state: 'idle', + inputMode: 'ai', + cwd: '/test/path', + projectRoot: '/test/path', + aiPid: 12345, + terminalPid: 12346, + aiLogs: [], + shellLogs: [], + isGitRepo: false, + fileTree: [], + fileExplorerExpanded: [], + activeTimeMs: 0, + ...overrides, +}); + +// Create test autoRunStats +const createAutoRunStats = (overrides: Partial = {}): AutoRunStats => ({ + cumulativeTimeMs: 0, + longestRunMs: 0, + totalRuns: 0, + lastBadgeAcknowledged: null, + badgeHistory: [], + ...overrides, +}); + +// Create test global stats +const createGlobalStats = (overrides: Partial = {}): ClaudeGlobalStats => ({ + totalSessions: 100, + totalMessages: 500, + totalInputTokens: 1000000, + totalOutputTokens: 500000, + totalCacheReadTokens: 0, + totalCacheCreationTokens: 0, + totalCostUsd: 25.50, + totalSizeBytes: 1048576, + isComplete: true, + ...overrides, +}); + +describe('AboutModal', () => { + let theme: Theme; + let onClose: ReturnType; + let unsubscribeMock: ReturnType; + let statsCallback: ((stats: ClaudeGlobalStats) => void) | null = null; + + beforeEach(() => { + vi.useFakeTimers(); + theme = createTheme(); + onClose = vi.fn(); + unsubscribeMock = vi.fn(); + statsCallback = null; + + // Mock onGlobalStatsUpdate to capture the callback + vi.mocked(window.maestro.claude.onGlobalStatsUpdate).mockImplementation((callback) => { + statsCallback = callback; + return unsubscribeMock; + }); + + // Mock getGlobalStats + vi.mocked(window.maestro.claude.getGlobalStats).mockResolvedValue(createGlobalStats()); + + // Mock shell.openExternal + vi.mocked(window.maestro.shell.openExternal).mockResolvedValue(undefined); + + // Reset layer stack mocks + mockRegisterLayer.mockClear().mockReturnValue('layer-about-123'); + mockUnregisterLayer.mockClear(); + mockUpdateLayerHandler.mockClear(); + }); + + afterEach(() => { + vi.useRealTimers(); + vi.clearAllMocks(); + statsCallback = null; + }); + + describe('Initial render', () => { + it('should render with dialog role and aria attributes', async () => { + render( + + ); + + const dialog = screen.getByRole('dialog'); + expect(dialog).toHaveAttribute('aria-modal', 'true'); + expect(dialog).toHaveAttribute('aria-label', 'About Maestro'); + }); + + it('should render the modal header with title', () => { + render( + + ); + + expect(screen.getByText('About Maestro')).toBeInTheDocument(); + }); + + it('should render MAESTRO branding', () => { + render( + + ); + + expect(screen.getByText('MAESTRO')).toBeInTheDocument(); + }); + + it('should render version number', () => { + render( + + ); + + expect(screen.getByText('v1.0.0')).toBeInTheDocument(); + }); + + it('should render subtitle', () => { + render( + + ); + + expect(screen.getByText('Agent Orchestration Command Center')).toBeInTheDocument(); + }); + + it('should render loading state initially', () => { + render( + + ); + + expect(screen.getByText('Loading stats...')).toBeInTheDocument(); + }); + }); + + describe('Author section', () => { + it('should render author name', () => { + render( + + ); + + expect(screen.getByText('Pedram Amini')).toBeInTheDocument(); + }); + + it('should render author title', () => { + render( + + ); + + expect(screen.getByText('Founder, Hacker, Investor, Advisor')).toBeInTheDocument(); + }); + + it('should render author avatar with correct alt text', () => { + render( + + ); + + const avatar = screen.getByAltText('Pedram Amini'); + expect(avatar).toBeInTheDocument(); + }); + + it('should have GitHub profile link', () => { + render( + + ); + + // The component renders "GitHub" as the button text in author section + // Use getByText since there are multiple GitHub buttons + expect(screen.getByText('GitHub')).toBeInTheDocument(); + }); + + it('should have LinkedIn profile link', () => { + render( + + ); + + // The component renders "LinkedIn" as the button text + expect(screen.getByText('LinkedIn')).toBeInTheDocument(); + }); + }); + + describe('External links', () => { + it('should open GitHub profile on click', async () => { + render( + + ); + + // The component renders "GitHub" as the button text - use getByText and find parent button + const githubLink = screen.getByText('GitHub'); + fireEvent.click(githubLink); + + expect(window.maestro.shell.openExternal).toHaveBeenCalledWith('https://github.com/pedramamini'); + }); + + it('should open LinkedIn profile on click', async () => { + render( + + ); + + // The component renders "LinkedIn" as the button text + const linkedinLink = screen.getByText('LinkedIn'); + fireEvent.click(linkedinLink); + + expect(window.maestro.shell.openExternal).toHaveBeenCalledWith('https://www.linkedin.com/in/pedramamini/'); + }); + + it('should open GitHub repo on View on GitHub click', async () => { + render( + + ); + + const viewOnGitHub = screen.getByText('View on GitHub'); + fireEvent.click(viewOnGitHub); + + expect(window.maestro.shell.openExternal).toHaveBeenCalledWith('https://github.com/pedramamini/Maestro'); + }); + + it('should open San Jac Saloon on Texas flag click', async () => { + render( + + ); + + // Find the Texas flag button (it's near "Made in Austin, TX") + const austinText = screen.getByText('Made in Austin, TX'); + // The Texas flag SVG button is a sibling + const texasButton = austinText.parentElement?.querySelector('button'); + expect(texasButton).toBeInTheDocument(); + fireEvent.click(texasButton!); + + expect(window.maestro.shell.openExternal).toHaveBeenCalledWith('https://www.sanjacsaloon.com'); + }); + }); + + describe('Layer stack integration', () => { + it('should register layer on mount', () => { + render( + + ); + + expect(mockRegisterLayer).toHaveBeenCalledTimes(1); + expect(mockRegisterLayer).toHaveBeenCalledWith(expect.objectContaining({ + type: 'modal', + blocksLowerLayers: true, + capturesFocus: true, + focusTrap: 'strict', + ariaLabel: 'About Maestro', + })); + }); + + it('should unregister layer on unmount', () => { + const { unmount } = render( + + ); + + unmount(); + + expect(mockUnregisterLayer).toHaveBeenCalledWith('layer-about-123'); + }); + }); + + describe('Close functionality', () => { + it('should call onClose when X button is clicked', () => { + render( + + ); + + const closeButton = screen.getByTestId('x-icon').closest('button'); + expect(closeButton).toBeInTheDocument(); + fireEvent.click(closeButton!); + + expect(onClose).toHaveBeenCalledTimes(1); + }); + + it('should call onClose via Escape when no badge overlay is open', () => { + render( + + ); + + // Get the registered escape handler + const registerCall = mockRegisterLayer.mock.calls[0][0]; + expect(registerCall.onEscape).toBeDefined(); + + // Call the escape handler + act(() => { + registerCall.onEscape(); + }); + + expect(onClose).toHaveBeenCalledTimes(1); + }); + + it('should handle badge escape handler before modal close', () => { + render( + + ); + + // Simulate badge overlay opening (via mocked AchievementCard) + const openBadgeButton = screen.getByTestId('badge-open-trigger'); + fireEvent.click(openBadgeButton); + + // Get the registered escape handler + const registerCall = mockRegisterLayer.mock.calls[0][0]; + + // Call the escape handler - should handle badge first + act(() => { + registerCall.onEscape(); + }); + + // onClose should NOT be called because badge handler intercepted + expect(onClose).not.toHaveBeenCalled(); + }); + }); + + describe('Global stats loading', () => { + it('should subscribe to global stats updates on mount', () => { + render( + + ); + + expect(window.maestro.claude.onGlobalStatsUpdate).toHaveBeenCalledTimes(1); + }); + + it('should call getGlobalStats on mount', () => { + render( + + ); + + expect(window.maestro.claude.getGlobalStats).toHaveBeenCalledTimes(1); + }); + + it('should unsubscribe from stats updates on unmount', () => { + const { unmount } = render( + + ); + + unmount(); + + expect(unsubscribeMock).toHaveBeenCalledTimes(1); + }); + + it('should display stats when received via callback', async () => { + render( + + ); + + // Simulate receiving stats via callback + await act(async () => { + if (statsCallback) { + statsCallback(createGlobalStats({ + totalSessions: 42, + totalMessages: 123, + isComplete: true, + })); + } + }); + + // Should no longer show loading + expect(screen.queryByText('Loading stats...')).not.toBeInTheDocument(); + + // Should show stats + expect(screen.getByText('42')).toBeInTheDocument(); + expect(screen.getByText('123')).toBeInTheDocument(); + }); + + it('should show spinner when stats are not complete', async () => { + render( + + ); + + // Simulate receiving incomplete stats + await act(async () => { + if (statsCallback) { + statsCallback(createGlobalStats({ isComplete: false })); + } + }); + + // Should show spinner icon in the header + expect(screen.getAllByTestId('loader-icon')).toHaveLength(1); + }); + + it('should handle stats loading error gracefully', async () => { + const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {}); + vi.mocked(window.maestro.claude.getGlobalStats).mockRejectedValue(new Error('Failed')); + + render( + + ); + + await act(async () => { + await vi.runAllTimersAsync(); + }); + + expect(consoleErrorSpy).toHaveBeenCalledWith('Failed to load global Claude stats:', expect.any(Error)); + consoleErrorSpy.mockRestore(); + }); + + it('should display "No Claude sessions found" when no stats', async () => { + const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {}); + // Setup the mock to reject BEFORE rendering + vi.mocked(window.maestro.claude.getGlobalStats).mockRejectedValue(new Error('Failed')); + + render( + + ); + + await act(async () => { + await vi.runAllTimersAsync(); + }); + + expect(screen.getByText('No Claude sessions found')).toBeInTheDocument(); + consoleErrorSpy.mockRestore(); + }); + }); + + describe('formatTokens helper (tested via display)', () => { + it('should format millions with M suffix', async () => { + render( + + ); + + await act(async () => { + if (statsCallback) { + statsCallback(createGlobalStats({ + totalInputTokens: 2500000, + totalOutputTokens: 1000000, + })); + } + }); + + expect(screen.getByText('2.5M')).toBeInTheDocument(); + expect(screen.getByText('1.0M')).toBeInTheDocument(); + }); + + it('should format thousands with K suffix', async () => { + render( + + ); + + await act(async () => { + if (statsCallback) { + statsCallback(createGlobalStats({ + totalInputTokens: 5500, + totalOutputTokens: 2000, + })); + } + }); + + expect(screen.getByText('5.5K')).toBeInTheDocument(); + expect(screen.getByText('2.0K')).toBeInTheDocument(); + }); + + it('should format small numbers without suffix', async () => { + render( + + ); + + await act(async () => { + if (statsCallback) { + statsCallback(createGlobalStats({ + totalInputTokens: 599, + totalOutputTokens: 299, + })); + } + }); + + // Use unique values that won't match other numbers + expect(screen.getByText('599')).toBeInTheDocument(); + expect(screen.getByText('299')).toBeInTheDocument(); + }); + }); + + describe('formatDuration helper (tested via display)', () => { + it('should format hours and minutes', async () => { + render( + + ); + + await act(async () => { + if (statsCallback) { + statsCallback(createGlobalStats()); + } + }); + + expect(screen.getByText('1h 5m')).toBeInTheDocument(); + }); + + it('should format minutes and seconds', async () => { + render( + + ); + + await act(async () => { + if (statsCallback) { + statsCallback(createGlobalStats()); + } + }); + + expect(screen.getByText('2m 5s')).toBeInTheDocument(); + }); + + it('should format only seconds for small values', async () => { + render( + + ); + + await act(async () => { + if (statsCallback) { + statsCallback(createGlobalStats()); + } + }); + + expect(screen.getByText('45s')).toBeInTheDocument(); + }); + + it('should not show Active Time when totalActiveTimeMs is 0', async () => { + render( + + ); + + await act(async () => { + if (statsCallback) { + statsCallback(createGlobalStats()); + } + }); + + expect(screen.queryByText('Active Time')).not.toBeInTheDocument(); + }); + + it('should accumulate active time from multiple sessions', async () => { + render( + + ); + + await act(async () => { + if (statsCallback) { + statsCallback(createGlobalStats()); + } + }); + + expect(screen.getByText('2m 0s')).toBeInTheDocument(); + }); + }); + + describe('Cache tokens display', () => { + it('should show cache tokens when they exist', async () => { + render( + + ); + + await act(async () => { + if (statsCallback) { + statsCallback(createGlobalStats({ + totalCacheReadTokens: 50000, + totalCacheCreationTokens: 25000, + })); + } + }); + + expect(screen.getByText('Cache Read')).toBeInTheDocument(); + expect(screen.getByText('50.0K')).toBeInTheDocument(); + expect(screen.getByText('Cache Creation')).toBeInTheDocument(); + expect(screen.getByText('25.0K')).toBeInTheDocument(); + }); + + it('should hide cache tokens when they are 0', async () => { + render( + + ); + + await act(async () => { + if (statsCallback) { + statsCallback(createGlobalStats({ + totalCacheReadTokens: 0, + totalCacheCreationTokens: 0, + })); + } + }); + + expect(screen.queryByText('Cache Read')).not.toBeInTheDocument(); + expect(screen.queryByText('Cache Creation')).not.toBeInTheDocument(); + }); + }); + + describe('Total cost display', () => { + it('should format cost with 2 decimal places', async () => { + render( + + ); + + await act(async () => { + if (statsCallback) { + statsCallback(createGlobalStats({ + totalCostUsd: 1234.56, + })); + } + }); + + expect(screen.getByText('$1,234.56')).toBeInTheDocument(); + }); + + it('should show cost with pulse animation when incomplete', async () => { + render( + + ); + + await act(async () => { + if (statsCallback) { + statsCallback(createGlobalStats({ + totalCostUsd: 25.50, + isComplete: false, + })); + } + }); + + const costElement = screen.getByText('$25.50'); + expect(costElement).toHaveClass('animate-pulse'); + }); + + it('should show cost without pulse animation when complete', async () => { + render( + + ); + + await act(async () => { + if (statsCallback) { + statsCallback(createGlobalStats({ + totalCostUsd: 25.50, + isComplete: true, + })); + } + }); + + const costElement = screen.getByText('$25.50'); + expect(costElement).not.toHaveClass('animate-pulse'); + }); + }); + + describe('AchievementCard integration', () => { + it('should render AchievementCard', () => { + render( + + ); + + expect(screen.getByTestId('achievement-card')).toBeInTheDocument(); + }); + }); + + describe('Made in Austin section', () => { + it('should render Made in Austin text', () => { + render( + + ); + + expect(screen.getByText('Made in Austin, TX')).toBeInTheDocument(); + }); + }); + + describe('Theme styling', () => { + it('should apply theme colors to modal', () => { + render( + + ); + + const dialog = screen.getByRole('dialog'); + const modalContent = dialog.querySelector('div > div'); + expect(modalContent).toHaveStyle({ backgroundColor: theme.colors.bgSidebar }); + }); + + it('should apply theme colors to title', () => { + render( + + ); + + const title = screen.getByText('MAESTRO'); + expect(title).toHaveStyle({ color: theme.colors.textMain }); + }); + }); + + describe('Edge cases', () => { + it('should handle empty sessions array', () => { + expect(() => { + render( + + ); + }).not.toThrow(); + }); + + it('should handle sessions with undefined activeTimeMs', async () => { + render( + + ); + + await act(async () => { + if (statsCallback) { + statsCallback(createGlobalStats()); + } + }); + + // Should not show Active Time with 0 + expect(screen.queryByText('Active Time')).not.toBeInTheDocument(); + }); + + it('should handle very large token counts', async () => { + render( + + ); + + await act(async () => { + if (statsCallback) { + statsCallback(createGlobalStats({ + totalInputTokens: 999999999, // Almost 1 billion + })); + } + }); + + expect(screen.getByText('1000.0M')).toBeInTheDocument(); + }); + + it('should handle very large cost', async () => { + render( + + ); + + await act(async () => { + if (statsCallback) { + statsCallback(createGlobalStats({ + totalCostUsd: 12345678.90, + })); + } + }); + + expect(screen.getByText('$12,345,678.90')).toBeInTheDocument(); + }); + }); +}); diff --git a/src/__tests__/renderer/components/AchievementCard.test.tsx b/src/__tests__/renderer/components/AchievementCard.test.tsx new file mode 100644 index 00000000..030f9cdc --- /dev/null +++ b/src/__tests__/renderer/components/AchievementCard.test.tsx @@ -0,0 +1,1097 @@ +import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'; +import { render, screen, fireEvent, act, waitFor } from '@testing-library/react'; +import React from 'react'; +import { AchievementCard } from '../../../renderer/components/AchievementCard'; +import type { Theme } from '../../../renderer/types'; +import type { AutoRunStats } from '../../../renderer/types'; + +// Mock the MaestroSilhouette component +vi.mock('../../../renderer/components/MaestroSilhouette', () => ({ + MaestroSilhouette: ({ variant, size, style }: { variant: string; size: number; style?: React.CSSProperties }) => ( +
+ Maestro Silhouette +
+ ), +})); + +// Mock lucide-react icons +vi.mock('lucide-react', () => ({ + Trophy: ({ className, style }: { className?: string; style?: React.CSSProperties }) => ( + + ), + Clock: ({ className, style }: { className?: string; style?: React.CSSProperties }) => ( + + ), + Zap: ({ className, style }: { className?: string; style?: React.CSSProperties }) => ( + + ), + Star: ({ className, style }: { className?: string; style?: React.CSSProperties }) => ( + + ), + ExternalLink: ({ className, style }: { className?: string; style?: React.CSSProperties }) => ( + + ), + ChevronDown: ({ className, style }: { className?: string; style?: React.CSSProperties }) => ( + + ), + History: ({ className, style }: { className?: string; style?: React.CSSProperties }) => ( + + ), + Share2: ({ className, style }: { className?: string; style?: React.CSSProperties }) => ( + + ), + Copy: ({ className, style }: { className?: string; style?: React.CSSProperties }) => ( + + ), + Download: ({ className, style }: { className?: string; style?: React.CSSProperties }) => ( + + ), + Check: ({ className, style }: { className?: string; style?: React.CSSProperties }) => ( + + ), +})); + +// Test theme +const mockTheme: Theme = { + id: 'test-theme', + name: 'Test Theme', + mode: 'dark', + colors: { + bgMain: '#1e1e2e', + bgSidebar: '#181825', + bgActivity: '#11111b', + textMain: '#cdd6f4', + textDim: '#a6adc8', + accent: '#8B5CF6', + border: '#313244', + success: '#a6e3a1', + warning: '#f9e2af', + error: '#f38ba8', + info: '#89dceb', + highlight: '#f5c2e7', + }, +}; + +// Base autoRunStats for tests +const baseAutoRunStats: AutoRunStats = { + cumulativeTimeMs: 0, + longestRunMs: 0, + totalRuns: 0, + lastRunMs: 0, + badgeHistory: [], +}; + +// AutoRunStats with some progress (15 minutes = first badge - Apprentice Conductor) +const firstBadgeStats: AutoRunStats = { + cumulativeTimeMs: 15 * 60 * 1000, // 15 minutes + longestRunMs: 10 * 60 * 1000, // 10 minutes + totalRuns: 3, + lastRunMs: 5 * 60 * 1000, + badgeHistory: [{ level: 1, unlockedAt: Date.now() - 86400000 }], +}; + +// AutoRunStats at level 5 (1 week) +const level5Stats: AutoRunStats = { + cumulativeTimeMs: 7 * 24 * 60 * 60 * 1000, // 1 week + longestRunMs: 2 * 60 * 60 * 1000, // 2 hours + totalRuns: 15, + lastRunMs: 30 * 60 * 1000, + badgeHistory: [ + { level: 1, unlockedAt: Date.now() - 86400000 * 5 }, + { level: 2, unlockedAt: Date.now() - 86400000 * 4 }, + { level: 3, unlockedAt: Date.now() - 86400000 * 3 }, + { level: 4, unlockedAt: Date.now() - 86400000 * 2 }, + { level: 5, unlockedAt: Date.now() - 86400000 }, + ], +}; + +// Max level stats (10 years = level 11) +const maxLevelStats: AutoRunStats = { + cumulativeTimeMs: 10 * 365 * 24 * 60 * 60 * 1000, // 10 years + longestRunMs: 24 * 60 * 60 * 1000, // 24 hours + totalRuns: 1000, + lastRunMs: 60 * 60 * 1000, + badgeHistory: Array.from({ length: 11 }, (_, i) => ({ + level: i + 1, + unlockedAt: Date.now() - 86400000 * (11 - i), + })), +}; + +// Mock globalStats +const mockGlobalStats = { + totalSessions: 150, + totalMessages: 5000, + totalInputTokens: 1000000, + totalOutputTokens: 500000, + totalCacheReadTokens: 200000, + totalCacheCreationTokens: 100000, + totalCostUsd: 45.67, + totalSizeBytes: 10000000, + isComplete: true, +}; + +// Mock ClipboardItem for jsdom environment +class MockClipboardItem { + private _data: Record; + constructor(data: Record) { + this._data = data; + } + get types() { + return Object.keys(this._data); + } + getType(type: string) { + return Promise.resolve(this._data[type]); + } +} +(global as any).ClipboardItem = MockClipboardItem; + +// Mock navigator.clipboard.write for jsdom environment +const mockClipboard = { + write: vi.fn().mockResolvedValue(undefined), + writeText: vi.fn().mockResolvedValue(undefined), + read: vi.fn().mockResolvedValue([]), + readText: vi.fn().mockResolvedValue(''), +}; +Object.defineProperty(navigator, 'clipboard', { + value: mockClipboard, + writable: true, +}); + +describe('AchievementCard', () => { + beforeEach(() => { + vi.clearAllMocks(); + vi.useFakeTimers({ shouldAdvanceTime: true }); + }); + + afterEach(() => { + vi.useRealTimers(); + }); + + describe('Basic Rendering', () => { + it('renders the achievement card container', () => { + render(); + + expect(screen.getByText('Maestro Achievements')).toBeInTheDocument(); + }); + + it('renders with correct theme colors', () => { + const { container } = render(); + + const card = container.firstChild as HTMLElement; + expect(card).toHaveStyle({ borderColor: mockTheme.colors.border }); + expect(card).toHaveStyle({ backgroundColor: mockTheme.colors.bgActivity }); + }); + + it('renders trophy icons', () => { + render(); + + // There are multiple trophy icons (header and stats grid) + const trophyIcons = screen.getAllByTestId('trophy-icon'); + expect(trophyIcons.length).toBeGreaterThan(0); + }); + + it('renders share button', () => { + render(); + + expect(screen.getByTestId('share-icon')).toBeInTheDocument(); + }); + + it('renders Maestro silhouette', () => { + render(); + + expect(screen.getByTestId('maestro-silhouette')).toBeInTheDocument(); + }); + }); + + describe('No Badge State', () => { + it('shows "No Badge Yet" message when no time accumulated', () => { + render(); + + expect(screen.getByText('No Badge Yet')).toBeInTheDocument(); + }); + + it('shows unlock hint for first badge', () => { + render(); + + expect(screen.getByText('Complete 15 minutes of AutoRun to unlock')).toBeInTheDocument(); + }); + + it('renders silhouette with low opacity when no badge', () => { + render(); + + const silhouette = screen.getByTestId('maestro-silhouette'); + expect(silhouette).toHaveStyle({ opacity: '0.3' }); + }); + + it('shows 0/11 unlocked when no badges', () => { + render(); + + expect(screen.getByText('0/11 unlocked')).toBeInTheDocument(); + }); + }); + + describe('First Badge State', () => { + it('shows badge name for first level (Apprentice Conductor)', () => { + render(); + + expect(screen.getByText('Apprentice Conductor')).toBeInTheDocument(); + }); + + it('shows level indicator', () => { + render(); + + expect(screen.getByText('Level 1 of 11')).toBeInTheDocument(); + }); + + it('shows progress bar to next level', () => { + render(); + + // Should show "Next: Assistant" (shortName for level 2) + expect(screen.getByText(/Next:/)).toBeInTheDocument(); + }); + + it('renders silhouette with full opacity when badge unlocked', () => { + render(); + + const silhouette = screen.getByTestId('maestro-silhouette'); + expect(silhouette).toHaveStyle({ opacity: '1' }); + }); + + it('shows level badge number', () => { + render(); + + // Look for the text "1" - the level number + expect(screen.getByText('1')).toBeInTheDocument(); + }); + + it('shows 1/11 unlocked', () => { + render(); + + expect(screen.getByText('1/11 unlocked')).toBeInTheDocument(); + }); + }); + + describe('Stats Grid', () => { + it('renders three stat columns', () => { + render(); + + expect(screen.getByText('Total Time')).toBeInTheDocument(); + expect(screen.getByText('Longest Run')).toBeInTheDocument(); + expect(screen.getByText('Total Runs')).toBeInTheDocument(); + }); + + it('shows formatted total time', () => { + render(); + + // formatCumulativeTime(15 min) returns "15m 0s" + expect(screen.getByText('15m 0s')).toBeInTheDocument(); + }); + + it('shows total runs count', () => { + render(); + + expect(screen.getByText('3')).toBeInTheDocument(); + }); + + it('renders clock icon for Total Time', () => { + render(); + + expect(screen.getByTestId('clock-icon')).toBeInTheDocument(); + }); + + it('renders zap icon for Total Runs', () => { + render(); + + expect(screen.getByTestId('zap-icon')).toBeInTheDocument(); + }); + }); + + describe('Badge Progression Bar', () => { + it('shows progression label', () => { + render(); + + expect(screen.getByText('Badge Progression')).toBeInTheDocument(); + }); + + it('shows correct unlocked count for level 5', () => { + render(); + + expect(screen.getByText('5/11 unlocked')).toBeInTheDocument(); + }); + + it('renders 11 badge segments', () => { + const { container } = render(); + + // Each badge segment is an h-3 rounded-full div + const segments = container.querySelectorAll('.h-3.rounded-full.cursor-pointer'); + expect(segments.length).toBe(11); + }); + }); + + describe('Badge Tooltip', () => { + it('opens tooltip when clicking on a badge segment', async () => { + const { container } = render(); + + const segments = container.querySelectorAll('.h-3.rounded-full.cursor-pointer'); + + // Click first segment + fireEvent.click(segments[0]); + + // Should show Level 1 in tooltip + expect(screen.getByText('Level 1')).toBeInTheDocument(); + }); + + it('shows badge description in tooltip', async () => { + const { container } = render(); + + const segments = container.querySelectorAll('.h-3.rounded-full.cursor-pointer'); + fireEvent.click(segments[0]); + + // Level 1 - should show "Unlocked" status + expect(screen.getByText('Unlocked')).toBeInTheDocument(); + }); + + it('shows "Locked" for unearned badges', async () => { + const { container } = render(); + + const segments = container.querySelectorAll('.h-3.rounded-full.cursor-pointer'); + // Click on level 5 segment (index 4) + fireEvent.click(segments[4]); + + expect(screen.getByText('Locked')).toBeInTheDocument(); + }); + + it('closes tooltip when clicking on same badge again', async () => { + const { container } = render(); + + const segments = container.querySelectorAll('.h-3.rounded-full.cursor-pointer'); + + // Click to open + fireEvent.click(segments[0]); + expect(screen.getByText('Level 1')).toBeInTheDocument(); + + // Click again to close + fireEvent.click(segments[0]); + + // Tooltip should close - Level 1 text only exists in tooltip + await waitFor(() => { + expect(screen.queryByText('Level 1')).not.toBeInTheDocument(); + }); + }); + + it('shows external link button in tooltip', async () => { + const { container } = render(); + + const segments = container.querySelectorAll('.h-3.rounded-full.cursor-pointer'); + fireEvent.click(segments[0]); + + expect(screen.getByTestId('external-link-icon')).toBeInTheDocument(); + }); + + it('opens external link when clicking conductor link', async () => { + const { container } = render(); + + const segments = container.querySelectorAll('.h-3.rounded-full.cursor-pointer'); + fireEvent.click(segments[0]); + + // Find the button with external link (Gustavo Dudamel for level 1) + const linkButton = screen.getByRole('button', { name: /Gustavo Dudamel/i }); + fireEvent.click(linkButton); + + expect(window.maestro.shell.openExternal).toHaveBeenCalled(); + }); + + it('closes tooltip when clicking outside', async () => { + const { container } = render(); + + const segments = container.querySelectorAll('.h-3.rounded-full.cursor-pointer'); + fireEvent.click(segments[0]); + + expect(screen.getByText('Level 1')).toBeInTheDocument(); + + // Advance timers to allow click listener to be added + vi.advanceTimersByTime(10); + + // Click outside (on document) + fireEvent.click(document.body); + + await waitFor(() => { + expect(screen.queryByText('Level 1')).not.toBeInTheDocument(); + }); + }); + + it('shows flavor text only for unlocked badges', async () => { + const { container } = render(); + + const segments = container.querySelectorAll('.h-3.rounded-full.cursor-pointer'); + + // Level 1 (unlocked) - should show flavor text in quotes + fireEvent.click(segments[0]); + // Check for italic text (flavor text styling) + const italicText = container.querySelector('.italic'); + expect(italicText).toBeInTheDocument(); + }); + }); + + describe('Badge Unlock History', () => { + it('does not show history for first badge only', () => { + render(); + + expect(screen.queryByText('Unlock History')).not.toBeInTheDocument(); + }); + + it('shows history button for multiple badges', () => { + render(); + + expect(screen.getByText('Unlock History')).toBeInTheDocument(); + }); + + it('expands history when clicking button', async () => { + render(); + + const historyButton = screen.getByText('Unlock History'); + fireEvent.click(historyButton); + + // Should show badge history entries - short names + await waitFor(() => { + expect(screen.getByText('Principal Guest')).toBeInTheDocument(); // Level 5 shortName + }); + }); + + it('shows history icon', () => { + render(); + + expect(screen.getByTestId('history-icon')).toBeInTheDocument(); + }); + + it('collapses history when clicking again', async () => { + render(); + + const historyButton = screen.getByText('Unlock History'); + + // Expand + fireEvent.click(historyButton); + await waitFor(() => { + expect(screen.getByText('Principal Guest')).toBeInTheDocument(); + }); + + // Collapse + fireEvent.click(historyButton); + await waitFor(() => { + expect(screen.queryByText('Principal Guest')).not.toBeInTheDocument(); + }); + }); + }); + + describe('Max Level Celebration', () => { + it('shows celebration message at max level', () => { + render(); + + expect(screen.getByText('Maximum Level Achieved!')).toBeInTheDocument(); + }); + + it('shows star icons in celebration', () => { + render(); + + const stars = screen.getAllByTestId('star-icon'); + expect(stars.length).toBe(2); + }); + + it('shows "Titan of the Baton" text', () => { + render(); + + expect(screen.getByText('You are a true Titan of the Baton')).toBeInTheDocument(); + }); + + it('does not show progress bar at max level', () => { + render(); + + // "Next:" text only appears when there's a next badge + expect(screen.queryByText(/Next:/)).not.toBeInTheDocument(); + }); + + it('shows 11/11 unlocked', () => { + render(); + + expect(screen.getByText('11/11 unlocked')).toBeInTheDocument(); + }); + }); + + describe('Share Menu', () => { + it('opens share menu when clicking share button', () => { + render(); + + const shareButton = screen.getByTitle('Share achievements'); + fireEvent.click(shareButton); + + expect(screen.getByText('Copy to Clipboard')).toBeInTheDocument(); + expect(screen.getByText('Save as Image')).toBeInTheDocument(); + }); + + it('closes share menu when clicking again', async () => { + render(); + + const shareButton = screen.getByTitle('Share achievements'); + + // Open + fireEvent.click(shareButton); + expect(screen.getByText('Copy to Clipboard')).toBeInTheDocument(); + + // Close + fireEvent.click(shareButton); + await waitFor(() => { + expect(screen.queryByText('Copy to Clipboard')).not.toBeInTheDocument(); + }); + }); + + it('renders copy icon in menu', () => { + render(); + + const shareButton = screen.getByTitle('Share achievements'); + fireEvent.click(shareButton); + + expect(screen.getByTestId('copy-icon')).toBeInTheDocument(); + }); + + it('renders download icon in menu', () => { + render(); + + const shareButton = screen.getByTitle('Share achievements'); + fireEvent.click(shareButton); + + expect(screen.getByTestId('download-icon')).toBeInTheDocument(); + }); + + it('closes share menu when clicking outside', async () => { + render(); + + const shareButton = screen.getByTitle('Share achievements'); + fireEvent.click(shareButton); + + expect(screen.getByText('Copy to Clipboard')).toBeInTheDocument(); + + // Advance timers + vi.advanceTimersByTime(10); + + // Click outside + fireEvent.click(document.body); + + await waitFor(() => { + expect(screen.queryByText('Copy to Clipboard')).not.toBeInTheDocument(); + }); + }); + }); + + describe('Copy to Clipboard', () => { + it('attempts to generate image for clipboard', async () => { + // Mock canvas context for image generation + const mockContext = { + createRadialGradient: vi.fn().mockReturnValue({ + addColorStop: vi.fn(), + }), + createLinearGradient: vi.fn().mockReturnValue({ + addColorStop: vi.fn(), + }), + fillStyle: '', + strokeStyle: '', + lineWidth: 0, + font: '', + textAlign: '', + textBaseline: '', + letterSpacing: '', + fillRect: vi.fn(), + roundRect: vi.fn(), + fill: vi.fn(), + stroke: vi.fn(), + beginPath: vi.fn(), + arc: vi.fn(), + fillText: vi.fn(), + measureText: vi.fn().mockReturnValue({ width: 100 }), + }; + HTMLCanvasElement.prototype.getContext = vi.fn().mockReturnValue(mockContext); + + render(); + + const shareButton = screen.getByTitle('Share achievements'); + fireEvent.click(shareButton); + + const copyButton = screen.getByText('Copy to Clipboard'); + + // Clicking copy button should trigger image generation + fireEvent.click(copyButton); + + // The canvas context should be accessed for image generation + expect(HTMLCanvasElement.prototype.getContext).toHaveBeenCalled(); + }); + }); + + describe('Download Image', () => { + it('attempts to generate image for download', async () => { + // Mock canvas context + const mockContext = { + createRadialGradient: vi.fn().mockReturnValue({ + addColorStop: vi.fn(), + }), + createLinearGradient: vi.fn().mockReturnValue({ + addColorStop: vi.fn(), + }), + fillStyle: '', + strokeStyle: '', + lineWidth: 0, + font: '', + textAlign: '', + textBaseline: '', + letterSpacing: '', + fillRect: vi.fn(), + roundRect: vi.fn(), + fill: vi.fn(), + stroke: vi.fn(), + beginPath: vi.fn(), + arc: vi.fn(), + fillText: vi.fn(), + measureText: vi.fn().mockReturnValue({ width: 100 }), + }; + HTMLCanvasElement.prototype.getContext = vi.fn().mockReturnValue(mockContext); + + render(); + + const shareButton = screen.getByTitle('Share achievements'); + fireEvent.click(shareButton); + + const saveButton = screen.getByText('Save as Image'); + fireEvent.click(saveButton); + + // The canvas context should be accessed for image generation + expect(HTMLCanvasElement.prototype.getContext).toHaveBeenCalled(); + }); + }); + + describe('Global Stats Display', () => { + it('displays global stats when provided', () => { + // GlobalStats are shown in the shareable image, not in the main UI + // The main UI shows autoRunStats + render( + + ); + + // Should still render normally + expect(screen.getByText('Maestro Achievements')).toBeInTheDocument(); + }); + + it('handles null globalStats', () => { + render( + + ); + + expect(screen.getByText('Maestro Achievements')).toBeInTheDocument(); + }); + + it('handles undefined globalStats', () => { + render( + + ); + + expect(screen.getByText('Maestro Achievements')).toBeInTheDocument(); + }); + }); + + describe('Escape Handler', () => { + it('calls onEscapeWithBadgeOpen with handler when badge is selected', () => { + const mockOnEscape = vi.fn(); + const { container } = render( + + ); + + const segments = container.querySelectorAll('.h-3.rounded-full.cursor-pointer'); + fireEvent.click(segments[0]); + + // Should have called with a function + expect(mockOnEscape).toHaveBeenCalledWith(expect.any(Function)); + }); + + it('calls onEscapeWithBadgeOpen with null when badge is deselected', async () => { + const mockOnEscape = vi.fn(); + const { container } = render( + + ); + + const segments = container.querySelectorAll('.h-3.rounded-full.cursor-pointer'); + + // Select badge + fireEvent.click(segments[0]); + expect(mockOnEscape).toHaveBeenCalledWith(expect.any(Function)); + + // Deselect badge + fireEvent.click(segments[0]); + + await waitFor(() => { + expect(mockOnEscape).toHaveBeenCalledWith(null); + }); + }); + + it('escape handler closes badge and returns true', () => { + let capturedHandler: (() => boolean) | null = null; + const mockOnEscape = vi.fn((handler) => { + capturedHandler = handler; + }); + + const { container } = render( + + ); + + const segments = container.querySelectorAll('.h-3.rounded-full.cursor-pointer'); + fireEvent.click(segments[0]); + + // Now call the captured handler + expect(capturedHandler).not.toBeNull(); + const result = capturedHandler!(); + + expect(result).toBe(true); + }); + }); + + describe('Badge Progress Ring', () => { + it('renders SVG with correct dimensions', () => { + const { container } = render(); + + const svg = container.querySelector('svg[viewBox="0 0 72 72"]'); + expect(svg).toBeInTheDocument(); + }); + + it('renders 11 path segments', () => { + const { container } = render(); + + const svg = container.querySelector('svg[viewBox="0 0 72 72"]'); + const paths = svg?.querySelectorAll('path'); + expect(paths?.length).toBe(11); + }); + + it('unlocked segments have higher opacity', () => { + const { container } = render(); + + const svg = container.querySelector('svg[viewBox="0 0 72 72"]'); + const paths = svg?.querySelectorAll('path'); + + // First segment (level 1) should be unlocked with opacity 1 + expect(paths?.[0]).toHaveAttribute('opacity', '1'); + + // Later segments should be locked with opacity 0.3 + expect(paths?.[5]).toHaveAttribute('opacity', '0.3'); + }); + + it('unlocked segments use accent color', () => { + const { container } = render(); + + const svg = container.querySelector('svg[viewBox="0 0 72 72"]'); + const paths = svg?.querySelectorAll('path'); + + // First segment (level 1 <= 3) should use accent color + expect(paths?.[0]).toHaveAttribute('stroke', mockTheme.colors.accent); + }); + + it('locked segments use border color', () => { + const { container } = render(); + + const svg = container.querySelector('svg[viewBox="0 0 72 72"]'); + const paths = svg?.querySelectorAll('path'); + + // Locked segment should use border color + expect(paths?.[5]).toHaveAttribute('stroke', mockTheme.colors.border); + }); + }); + + describe('Tooltip Positioning', () => { + it('positions tooltip left for level 1-2 badges', () => { + const { container } = render(); + + const segments = container.querySelectorAll('.h-3.rounded-full.cursor-pointer'); + + // Click first segment + fireEvent.click(segments[0]); + + // Tooltip should have left: 0 + const tooltip = container.querySelector('.absolute.bottom-full'); + expect(tooltip).toHaveStyle({ left: '0px' }); + }); + + it('positions tooltip center for middle badges', () => { + const { container } = render(); + + const segments = container.querySelectorAll('.h-3.rounded-full.cursor-pointer'); + + // Click 5th segment (index 4) + fireEvent.click(segments[4]); + + // Tooltip should have left: 50% and transform: translateX(-50%) + const tooltip = container.querySelector('.absolute.bottom-full'); + expect(tooltip).toHaveStyle({ left: '50%' }); + }); + + it('positions tooltip right for level 10-11 badges', () => { + const { container } = render(); + + const segments = container.querySelectorAll('.h-3.rounded-full.cursor-pointer'); + + // Click last segment (index 10) + fireEvent.click(segments[10]); + + // Tooltip should have right: 0 + const tooltip = container.querySelector('.absolute.bottom-full'); + expect(tooltip).toHaveStyle({ right: '0px' }); + }); + }); + + describe('Color Interpolation', () => { + // Test through the badge progression bar colors + it('uses accent color for levels 1-3 (unlocked)', () => { + // Need a stats object that has 3 levels unlocked + const level3Stats: AutoRunStats = { + cumulativeTimeMs: 8 * 60 * 60 * 1000, // 8 hours (level 3) + longestRunMs: 4 * 60 * 60 * 1000, + totalRuns: 10, + lastRunMs: 60 * 60 * 1000, + badgeHistory: Array.from({ length: 3 }, (_, i) => ({ + level: i + 1, + unlockedAt: Date.now() - 86400000 * (3 - i), + })), + }; + + const { container } = render(); + + const segments = container.querySelectorAll('.h-3.rounded-full.cursor-pointer'); + + // Level 1-3 should have accent color (they're unlocked) + for (let i = 0; i < 3; i++) { + expect(segments[i]).toHaveStyle({ backgroundColor: mockTheme.colors.accent }); + } + }); + + it('uses gold color (#FFD700) for levels 4-7 (unlocked)', () => { + // Need 3 months of time to reach level 7 + const level7Stats: AutoRunStats = { + cumulativeTimeMs: 3 * 30 * 24 * 60 * 60 * 1000, // 3 months (level 7 requires 3 months) + longestRunMs: 24 * 60 * 60 * 1000, + totalRuns: 100, + lastRunMs: 60 * 60 * 1000, + badgeHistory: Array.from({ length: 7 }, (_, i) => ({ + level: i + 1, + unlockedAt: Date.now() - 86400000 * (7 - i), + })), + }; + + const { container } = render(); + + const segments = container.querySelectorAll('.h-3.rounded-full.cursor-pointer'); + + // Levels 4-7 should have gold color (#FFD700) when unlocked + for (let i = 3; i < 7; i++) { + expect(segments[i]).toHaveStyle({ backgroundColor: '#FFD700' }); + } + }); + + it('uses orange color (#FF6B35) for levels 8-11 (unlocked)', () => { + const { container } = render(); + + const segments = container.querySelectorAll('.h-3.rounded-full.cursor-pointer'); + + // Levels 8-11 should have orange color (#FF6B35) when unlocked + for (let i = 7; i < 11; i++) { + expect(segments[i]).toHaveStyle({ backgroundColor: '#FF6B35' }); + } + }); + + it('uses border color for locked badges', () => { + const { container } = render(); + + const segments = container.querySelectorAll('.h-3.rounded-full.cursor-pointer'); + + // Locked segments (2-11) should have border color + for (let i = 1; i < 11; i++) { + expect(segments[i]).toHaveStyle({ backgroundColor: mockTheme.colors.border }); + } + }); + }); + + describe('Current Badge Styling', () => { + it('adds box shadow to current level badge segment', () => { + const { container } = render(); + + const segments = container.querySelectorAll('.h-3.rounded-full.cursor-pointer'); + + // First segment (current level) should have box shadow + const style = segments[0].getAttribute('style') || ''; + expect(style).toContain('box-shadow'); + expect(style).not.toContain('box-shadow: none'); + }); + + it('no box shadow on non-current badge segments', () => { + const { container } = render(); + + const segments = container.querySelectorAll('.h-3.rounded-full.cursor-pointer'); + + // Second segment (not current level) should have no box shadow + const style = segments[1].getAttribute('style') || ''; + expect(style).toContain('box-shadow: none'); + }); + }); + + describe('Edge Cases', () => { + it('handles zero cumulative time', () => { + const zeroTimeStats: AutoRunStats = { + cumulativeTimeMs: 0, + longestRunMs: 0, + totalRuns: 0, + lastRunMs: 0, + badgeHistory: [], + }; + + render(); + + expect(screen.getByText('No Badge Yet')).toBeInTheDocument(); + }); + + it('handles very large cumulative time', () => { + const hugeTimeStats: AutoRunStats = { + cumulativeTimeMs: 100 * 365 * 24 * 60 * 60 * 1000, // 100 years + longestRunMs: 365 * 24 * 60 * 60 * 1000, // 1 year + totalRuns: 10000, + lastRunMs: 24 * 60 * 60 * 1000, + badgeHistory: Array.from({ length: 11 }, (_, i) => ({ + level: i + 1, + unlockedAt: Date.now() - 86400000 * (11 - i), + })), + }; + + render(); + + // Should still show max level + expect(screen.getByText('Maximum Level Achieved!')).toBeInTheDocument(); + }); + + it('handles empty badgeHistory array', () => { + const noHistoryStats: AutoRunStats = { + cumulativeTimeMs: 15 * 60 * 1000, // 15 minutes (has a badge) + longestRunMs: 10 * 60 * 1000, + totalRuns: 3, + lastRunMs: 5 * 60 * 1000, + badgeHistory: [], // Empty history + }; + + render(); + + // Should not show history button + expect(screen.queryByText('Unlock History')).not.toBeInTheDocument(); + }); + + it('handles undefined badgeHistory', () => { + const undefinedHistoryStats = { + cumulativeTimeMs: 15 * 60 * 1000, + longestRunMs: 10 * 60 * 1000, + totalRuns: 3, + lastRunMs: 5 * 60 * 1000, + // badgeHistory is undefined + } as AutoRunStats; + + render(); + + // Should not crash and should render + expect(screen.getByText('Maestro Achievements')).toBeInTheDocument(); + }); + + it('handles light theme mode', () => { + const lightTheme: Theme = { + ...mockTheme, + mode: 'light', + colors: { + ...mockTheme.colors, + bgMain: '#ffffff', + bgSidebar: '#f8f8f8', + bgActivity: '#f0f0f0', + textMain: '#333333', + textDim: '#666666', + }, + }; + + render(); + + expect(screen.getByText('Maestro Achievements')).toBeInTheDocument(); + }); + + it('handles rapid badge selection changes', async () => { + const { container } = render(); + + const segments = container.querySelectorAll('.h-3.rounded-full.cursor-pointer'); + + // Rapid clicks on different badges + fireEvent.click(segments[0]); + fireEvent.click(segments[1]); + fireEvent.click(segments[2]); + fireEvent.click(segments[3]); + fireEvent.click(segments[4]); + + // Should show the last clicked badge (level 5) + expect(screen.getByText('Level 5')).toBeInTheDocument(); + }); + + it('handles special characters in theme IDs', () => { + const specialTheme: Theme = { + ...mockTheme, + id: 'test-theme-special', + name: 'Test Theme Special', + }; + + render(); + + expect(screen.getByText('Maestro Achievements')).toBeInTheDocument(); + }); + }); + + describe('Progress Percentage', () => { + it('shows progress toward next badge', () => { + const halfwayStats: AutoRunStats = { + cumulativeTimeMs: 37.5 * 60 * 1000, // 37.5 minutes (halfway from 15min to 60min) + longestRunMs: 15 * 60 * 1000, + totalRuns: 5, + lastRunMs: 10 * 60 * 1000, + badgeHistory: [{ level: 1, unlockedAt: Date.now() - 86400000 }], + }; + + const { container } = render(); + + // Progress bar should exist + const progressBar = container.querySelector('.h-2.rounded-full.overflow-hidden'); + expect(progressBar).toBeInTheDocument(); + }); + }); + + describe('Default Export', () => { + it('exports AchievementCard as default', async () => { + const module = await import('../../../renderer/components/AchievementCard'); + expect(module.default).toBe(module.AchievementCard); + }); + }); +}); diff --git a/src/__tests__/renderer/components/AgentPromptComposerModal.test.tsx b/src/__tests__/renderer/components/AgentPromptComposerModal.test.tsx new file mode 100644 index 00000000..3294a418 --- /dev/null +++ b/src/__tests__/renderer/components/AgentPromptComposerModal.test.tsx @@ -0,0 +1,1373 @@ +/** + * Tests for AgentPromptComposerModal component + * + * AgentPromptComposerModal is a modal for editing agent prompts with: + * - Large textarea for prompt editing + * - Template variable support with autocomplete + * - Collapsible template variables panel + * - Token and character count display + * - Layer stack integration for Escape handling + * - Backdrop click to save and close + * - Focus management + */ + +import React from 'react'; +import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'; +import { render, screen, fireEvent, act, waitFor } from '@testing-library/react'; +import { AgentPromptComposerModal } from '../../../renderer/components/AgentPromptComposerModal'; +import { LayerStackProvider } from '../../../renderer/contexts/LayerStackContext'; +import type { Theme } from '../../../renderer/types'; + +// Mock lucide-react +vi.mock('lucide-react', () => ({ + X: () => , + FileText: () => , + Variable: () => , + ChevronDown: () => , + ChevronRight: () => , +})); + +// Mock the useTemplateAutocomplete hook +const mockAutocompleteState = { + isOpen: false, + search: '', + filteredVariables: [], + selectedIndex: 0, + position: { top: 0, left: 0 }, +}; + +const mockCloseAutocomplete = vi.fn(); +const mockHandleKeyDown = vi.fn().mockReturnValue(false); +const mockHandleChange = vi.fn(); +const mockSelectVariable = vi.fn(); +const mockAutocompleteRef = { current: null }; + +vi.mock('../../../renderer/hooks/useTemplateAutocomplete', () => ({ + useTemplateAutocomplete: () => ({ + autocompleteState: mockAutocompleteState, + handleKeyDown: mockHandleKeyDown, + handleChange: mockHandleChange, + selectVariable: mockSelectVariable, + closeAutocomplete: mockCloseAutocomplete, + autocompleteRef: mockAutocompleteRef, + }), +})); + +// Mock TemplateAutocompleteDropdown +vi.mock('../../../renderer/components/TemplateAutocompleteDropdown', () => ({ + TemplateAutocompleteDropdown: React.forwardRef( + (props: { theme: Theme; state: typeof mockAutocompleteState; onSelect: () => void }, ref) => ( +
}> + Autocomplete Dropdown +
+ ) + ), +})); + +// Mock TEMPLATE_VARIABLES +vi.mock('../../../renderer/utils/templateVariables', () => ({ + TEMPLATE_VARIABLES: [ + { variable: '{{SESSION_NAME}}', description: 'Current session name' }, + { variable: '{{PROJECT_PATH}}', description: 'Project directory path' }, + { variable: '{{DATE}}', description: 'Current date' }, + { variable: '{{TIME}}', description: 'Current time' }, + { variable: '{{GIT_BRANCH}}', description: 'Current git branch' }, + ], +})); + +// Create a test theme +const createTestTheme = (overrides: Partial = {}): Theme => ({ + id: 'test-theme', + name: 'Test Theme', + mode: 'dark', + colors: { + bgMain: '#1e1e1e', + bgSidebar: '#252526', + bgActivity: '#333333', + textMain: '#d4d4d4', + textDim: '#808080', + accent: '#007acc', + accentForeground: '#ffffff', + border: '#404040', + error: '#f14c4c', + warning: '#cca700', + success: '#89d185', + info: '#3794ff', + textInverse: '#000000', + ...overrides, + }, +}); + +// Helper to render with LayerStackProvider +const renderWithLayerStack = (ui: React.ReactElement) => { + return render({ui}); +}; + +describe('AgentPromptComposerModal', () => { + let theme: Theme; + + beforeEach(() => { + theme = createTestTheme(); + vi.clearAllMocks(); + mockAutocompleteState.isOpen = false; + }); + + afterEach(() => { + vi.restoreAllMocks(); + }); + + describe('estimateTokenCount helper function', () => { + // The function is internal but we can test its behavior through the UI + it('shows 0 tokens for empty text', () => { + renderWithLayerStack( + + ); + + expect(screen.getByText('~0 tokens')).toBeInTheDocument(); + }); + + it('estimates tokens correctly for short text', () => { + // 8 characters / 4 = 2 tokens + renderWithLayerStack( + + ); + + expect(screen.getByText('~2 tokens')).toBeInTheDocument(); + }); + + it('estimates tokens with ceiling for fractional values', () => { + // 5 characters / 4 = 1.25, ceil = 2 tokens + renderWithLayerStack( + + ); + + expect(screen.getByText('~2 tokens')).toBeInTheDocument(); + }); + + it('formats large token counts with locale string', () => { + // 10000 characters / 4 = 2500 tokens + const longText = 'a'.repeat(10000); + renderWithLayerStack( + + ); + + expect(screen.getByText('~2,500 tokens')).toBeInTheDocument(); + }); + }); + + describe('rendering', () => { + it('returns null when isOpen is false', () => { + const { container } = renderWithLayerStack( + + ); + + expect(container.firstChild).toBeNull(); + }); + + it('renders modal when isOpen is true', () => { + renderWithLayerStack( + + ); + + expect(screen.getByText('Agent Prompt Editor')).toBeInTheDocument(); + }); + + it('renders header with FileText icon and title', () => { + renderWithLayerStack( + + ); + + expect(screen.getByTestId('file-text-icon')).toBeInTheDocument(); + expect(screen.getByText('Agent Prompt Editor')).toBeInTheDocument(); + }); + + it('renders close button with X icon', () => { + renderWithLayerStack( + + ); + + expect(screen.getByTestId('x-icon')).toBeInTheDocument(); + expect(screen.getByTitle('Close (Escape)')).toBeInTheDocument(); + }); + + it('renders textarea with initial value', () => { + renderWithLayerStack( + + ); + + const textarea = screen.getByPlaceholderText('Enter your agent prompt... (type {{ for variables)'); + expect(textarea).toHaveValue('Initial prompt text'); + }); + + it('renders template variables section collapsed by default', () => { + renderWithLayerStack( + + ); + + expect(screen.getByText('Template Variables')).toBeInTheDocument(); + expect(screen.getByTestId('chevron-right-icon')).toBeInTheDocument(); + // Variables should not be visible when collapsed + expect(screen.queryByText('Current session name')).not.toBeInTheDocument(); + }); + + it('renders footer with character and token counts', () => { + renderWithLayerStack( + + ); + + expect(screen.getByText('4 characters')).toBeInTheDocument(); + expect(screen.getByText('~1 tokens')).toBeInTheDocument(); + }); + + it('renders Done button', () => { + renderWithLayerStack( + + ); + + expect(screen.getByRole('button', { name: 'Done' })).toBeInTheDocument(); + }); + + it('renders autocomplete dropdown component', () => { + renderWithLayerStack( + + ); + + expect(screen.getByTestId('autocomplete-dropdown')).toBeInTheDocument(); + }); + }); + + describe('theme styling', () => { + it('applies theme colors to modal container', () => { + renderWithLayerStack( + + ); + + // The modal container has w-[90vw] class + const modalContainer = document.querySelector('.w-\\[90vw\\]'); + expect(modalContainer).toHaveStyle({ backgroundColor: theme.colors.bgMain }); + }); + + it('applies accent color to header icon', () => { + renderWithLayerStack( + + ); + + // Icon color is applied via style prop + const icon = screen.getByTestId('file-text-icon').closest('svg'); + expect(icon).toBeInTheDocument(); + }); + + it('applies accent color to Done button', () => { + renderWithLayerStack( + + ); + + const doneButton = screen.getByRole('button', { name: 'Done' }); + expect(doneButton).toHaveStyle({ backgroundColor: theme.colors.accent }); + }); + }); + + describe('template variables panel', () => { + it('expands when clicking the header button', async () => { + renderWithLayerStack( + + ); + + const toggleButton = screen.getByText('Template Variables').closest('button'); + expect(toggleButton).toBeInTheDocument(); + + await act(async () => { + fireEvent.click(toggleButton!); + }); + + expect(screen.getByTestId('chevron-down-icon')).toBeInTheDocument(); + expect(screen.getByText('Current session name')).toBeInTheDocument(); + }); + + it('collapses when clicking the header button again', async () => { + renderWithLayerStack( + + ); + + const toggleButton = screen.getByText('Template Variables').closest('button'); + + // Expand + await act(async () => { + fireEvent.click(toggleButton!); + }); + + // Collapse + await act(async () => { + fireEvent.click(toggleButton!); + }); + + expect(screen.getByTestId('chevron-right-icon')).toBeInTheDocument(); + expect(screen.queryByText('Current session name')).not.toBeInTheDocument(); + }); + + it('shows Variable icon in the panel header', async () => { + renderWithLayerStack( + + ); + + expect(screen.getByTestId('variable-icon')).toBeInTheDocument(); + }); + + it('shows all template variables when expanded', async () => { + renderWithLayerStack( + + ); + + const toggleButton = screen.getByText('Template Variables').closest('button'); + await act(async () => { + fireEvent.click(toggleButton!); + }); + + expect(screen.getByText('{{SESSION_NAME}}')).toBeInTheDocument(); + expect(screen.getByText('{{PROJECT_PATH}}')).toBeInTheDocument(); + expect(screen.getByText('{{DATE}}')).toBeInTheDocument(); + expect(screen.getByText('{{TIME}}')).toBeInTheDocument(); + expect(screen.getByText('{{GIT_BRANCH}}')).toBeInTheDocument(); + }); + + it('shows description for each variable when expanded', async () => { + renderWithLayerStack( + + ); + + const toggleButton = screen.getByText('Template Variables').closest('button'); + await act(async () => { + fireEvent.click(toggleButton!); + }); + + expect(screen.getByText('Current session name')).toBeInTheDocument(); + expect(screen.getByText('Project directory path')).toBeInTheDocument(); + expect(screen.getByText('Current date')).toBeInTheDocument(); + expect(screen.getByText('Current time')).toBeInTheDocument(); + expect(screen.getByText('Current git branch')).toBeInTheDocument(); + }); + + it('shows help text when expanded', async () => { + renderWithLayerStack( + + ); + + const toggleButton = screen.getByText('Template Variables').closest('button'); + await act(async () => { + fireEvent.click(toggleButton!); + }); + + expect( + screen.getByText('Use these variables in your prompt. They will be replaced with actual values at runtime.') + ).toBeInTheDocument(); + }); + + it('has clickable variables with title attribute', async () => { + renderWithLayerStack( + + ); + + const toggleButton = screen.getByText('Template Variables').closest('button'); + await act(async () => { + fireEvent.click(toggleButton!); + }); + + const variableCode = screen.getByText('{{SESSION_NAME}}'); + expect(variableCode).toHaveAttribute('title', 'Click to insert'); + }); + }); + + describe('variable insertion', () => { + it('inserts variable at cursor position when clicked', async () => { + renderWithLayerStack( + + ); + + // Expand variables panel + const toggleButton = screen.getByText('Template Variables').closest('button'); + await act(async () => { + fireEvent.click(toggleButton!); + }); + + const textarea = screen.getByPlaceholderText( + 'Enter your agent prompt... (type {{ for variables)' + ) as HTMLTextAreaElement; + + // Set cursor position in the middle + await act(async () => { + textarea.setSelectionRange(6, 6); // After "Hello " + }); + + // Click on a variable + const variableCode = screen.getByText('{{SESSION_NAME}}'); + await act(async () => { + fireEvent.click(variableCode); + }); + + // Value should be updated with variable inserted + expect(textarea.value).toBe('Hello {{SESSION_NAME}}World'); + }); + + it('replaces selected text when variable is clicked', async () => { + renderWithLayerStack( + + ); + + // Expand variables panel + const toggleButton = screen.getByText('Template Variables').closest('button'); + await act(async () => { + fireEvent.click(toggleButton!); + }); + + const textarea = screen.getByPlaceholderText( + 'Enter your agent prompt... (type {{ for variables)' + ) as HTMLTextAreaElement; + + // Select "World" + await act(async () => { + textarea.setSelectionRange(6, 11); // Select "World" + }); + + // Click on a variable + const variableCode = screen.getByText('{{DATE}}'); + await act(async () => { + fireEvent.click(variableCode); + }); + + // "World" should be replaced with the variable + expect(textarea.value).toBe('Hello {{DATE}}'); + }); + + it('inserts at end when no cursor position (edge case)', async () => { + renderWithLayerStack( + + ); + + // Expand variables panel + const toggleButton = screen.getByText('Template Variables').closest('button'); + await act(async () => { + fireEvent.click(toggleButton!); + }); + + // Click on a variable when textarea is empty + const variableCode = screen.getByText('{{TIME}}'); + await act(async () => { + fireEvent.click(variableCode); + }); + + const textarea = screen.getByPlaceholderText( + 'Enter your agent prompt... (type {{ for variables)' + ) as HTMLTextAreaElement; + expect(textarea.value).toBe('{{TIME}}'); + }); + }); + + describe('textarea interaction', () => { + it('updates value when typing', async () => { + renderWithLayerStack( + + ); + + const textarea = screen.getByPlaceholderText('Enter your agent prompt... (type {{ for variables)'); + + await act(async () => { + fireEvent.change(textarea, { target: { value: 'New prompt text' } }); + }); + + expect(mockHandleChange).toHaveBeenCalled(); + }); + + it('passes keydown events to autocomplete handler first', async () => { + renderWithLayerStack( + + ); + + const textarea = screen.getByPlaceholderText('Enter your agent prompt... (type {{ for variables)'); + + await act(async () => { + fireEvent.keyDown(textarea, { key: 'ArrowDown' }); + }); + + expect(mockHandleKeyDown).toHaveBeenCalled(); + }); + + it('updates character count as user types', async () => { + renderWithLayerStack( + + ); + + expect(screen.getByText('0 characters')).toBeInTheDocument(); + }); + + it('updates token count as user types', async () => { + renderWithLayerStack( + + ); + + expect(screen.getByText('12 characters')).toBeInTheDocument(); + expect(screen.getByText('~3 tokens')).toBeInTheDocument(); + }); + }); + + describe('Done button behavior', () => { + it('calls onSubmit with current value when clicked', async () => { + const onSubmit = vi.fn(); + const onClose = vi.fn(); + + renderWithLayerStack( + + ); + + const doneButton = screen.getByRole('button', { name: 'Done' }); + await act(async () => { + fireEvent.click(doneButton); + }); + + expect(onSubmit).toHaveBeenCalledWith('My prompt'); + expect(onClose).toHaveBeenCalled(); + }); + }); + + describe('close button behavior', () => { + it('calls onSubmit and onClose when close button is clicked', async () => { + const onSubmit = vi.fn(); + const onClose = vi.fn(); + + renderWithLayerStack( + + ); + + const closeButton = screen.getByTitle('Close (Escape)'); + await act(async () => { + fireEvent.click(closeButton); + }); + + expect(onSubmit).toHaveBeenCalledWith('Test value'); + expect(onClose).toHaveBeenCalled(); + }); + }); + + describe('backdrop click behavior', () => { + it('calls onSubmit and onClose when clicking backdrop', async () => { + const onSubmit = vi.fn(); + const onClose = vi.fn(); + + renderWithLayerStack( + + ); + + // Find the backdrop (the outermost fixed div) + const backdrop = document.querySelector('.fixed.inset-0'); + expect(backdrop).toBeInTheDocument(); + + await act(async () => { + fireEvent.click(backdrop!); + }); + + expect(onSubmit).toHaveBeenCalledWith('Backdrop test'); + expect(onClose).toHaveBeenCalled(); + }); + + it('does not close when clicking inside modal content', async () => { + const onSubmit = vi.fn(); + const onClose = vi.fn(); + + renderWithLayerStack( + + ); + + // Click inside the modal (on the title) + const title = screen.getByText('Agent Prompt Editor'); + await act(async () => { + fireEvent.click(title); + }); + + expect(onSubmit).not.toHaveBeenCalled(); + expect(onClose).not.toHaveBeenCalled(); + }); + }); + + describe('focus management', () => { + it('focuses textarea when modal opens', async () => { + renderWithLayerStack( + + ); + + const textarea = screen.getByPlaceholderText('Enter your agent prompt... (type {{ for variables)'); + + await waitFor(() => { + expect(textarea).toHaveFocus(); + }); + }); + + it('sets cursor at end of text when modal opens', async () => { + renderWithLayerStack( + + ); + + const textarea = screen.getByPlaceholderText( + 'Enter your agent prompt... (type {{ for variables)' + ) as HTMLTextAreaElement; + + await waitFor(() => { + expect(textarea.selectionStart).toBe(15); // Length of "Cursor position" + expect(textarea.selectionEnd).toBe(15); + }); + }); + }); + + describe('value synchronization', () => { + it('syncs value when modal opens with new initialValue', async () => { + const { rerender } = renderWithLayerStack( + + ); + + rerender( + + + + ); + + const textarea = screen.getByPlaceholderText('Enter your agent prompt... (type {{ for variables)'); + expect(textarea).toHaveValue('Updated value'); + }); + + it('closes autocomplete when modal opens', async () => { + renderWithLayerStack( + + ); + + expect(mockCloseAutocomplete).toHaveBeenCalled(); + }); + }); + + describe('layer stack integration', () => { + it('registers with layer stack when opened', async () => { + const { unmount } = renderWithLayerStack( + + ); + + // Modal should be visible (layer registered) + expect(screen.getByText('Agent Prompt Editor')).toBeInTheDocument(); + + unmount(); + }); + + it('unregisters from layer stack when closed', async () => { + const { rerender } = renderWithLayerStack( + + ); + + expect(screen.getByText('Agent Prompt Editor')).toBeInTheDocument(); + + rerender( + + + + ); + + expect(screen.queryByText('Agent Prompt Editor')).not.toBeInTheDocument(); + }); + + it('closes autocomplete first on Escape if autocomplete is open', async () => { + // Set autocomplete as open + mockAutocompleteState.isOpen = true; + + renderWithLayerStack( + + ); + + // Simulate Escape via layer stack + const escapeEvent = new KeyboardEvent('keydown', { + key: 'Escape', + bubbles: true, + cancelable: true, + }); + + await act(async () => { + document.dispatchEvent(escapeEvent); + }); + + expect(mockCloseAutocomplete).toHaveBeenCalled(); + }); + }); + + describe('character and token formatting', () => { + it('formats character count with locale string', () => { + const longText = 'a'.repeat(1234); + renderWithLayerStack( + + ); + + expect(screen.getByText('1,234 characters')).toBeInTheDocument(); + }); + + it('formats token count with locale string', () => { + // 40000 characters / 4 = 10000 tokens + const longText = 'a'.repeat(40000); + renderWithLayerStack( + + ); + + expect(screen.getByText('~10,000 tokens')).toBeInTheDocument(); + }); + }); + + describe('edge cases', () => { + it('handles empty initialValue', () => { + renderWithLayerStack( + + ); + + const textarea = screen.getByPlaceholderText('Enter your agent prompt... (type {{ for variables)'); + expect(textarea).toHaveValue(''); + }); + + it('handles very long initialValue', () => { + const longValue = 'This is a very long prompt. '.repeat(100); + renderWithLayerStack( + + ); + + const textarea = screen.getByPlaceholderText('Enter your agent prompt... (type {{ for variables)'); + expect(textarea).toHaveValue(longValue); + }); + + it('handles special characters in prompt', () => { + const specialChars = 'Test with & special "chars" {{var}}'; + renderWithLayerStack( + + ); + + const textarea = screen.getByPlaceholderText('Enter your agent prompt... (type {{ for variables)'); + expect(textarea).toHaveValue(specialChars); + }); + + it('handles unicode characters', () => { + const unicode = 'Test with emojis 🎵🎹🎼 and symbols ™®©'; + renderWithLayerStack( + + ); + + const textarea = screen.getByPlaceholderText('Enter your agent prompt... (type {{ for variables)'); + expect(textarea).toHaveValue(unicode); + }); + + it('handles multiline text', () => { + const multiline = 'Line 1\nLine 2\nLine 3\n\nLine 5'; + renderWithLayerStack( + + ); + + const textarea = screen.getByPlaceholderText('Enter your agent prompt... (type {{ for variables)'); + expect(textarea).toHaveValue(multiline); + }); + + it('submits with modified value after user edits', async () => { + const onSubmit = vi.fn(); + + // Create a custom implementation that actually updates the state + let currentValue = 'Initial'; + mockHandleChange.mockImplementation((e: React.ChangeEvent) => { + currentValue = e.target.value; + }); + + renderWithLayerStack( + + ); + + // The actual submit would use the internal state value + const doneButton = screen.getByRole('button', { name: 'Done' }); + await act(async () => { + fireEvent.click(doneButton); + }); + + expect(onSubmit).toHaveBeenCalledWith('Initial'); + }); + + it('preserves value when toggling template variables panel', async () => { + renderWithLayerStack( + + ); + + const textarea = screen.getByPlaceholderText('Enter your agent prompt... (type {{ for variables)'); + expect(textarea).toHaveValue('Preserved value'); + + // Toggle variables panel + const toggleButton = screen.getByText('Template Variables').closest('button'); + await act(async () => { + fireEvent.click(toggleButton!); + }); + + expect(textarea).toHaveValue('Preserved value'); + + await act(async () => { + fireEvent.click(toggleButton!); + }); + + expect(textarea).toHaveValue('Preserved value'); + }); + }); + + describe('light theme support', () => { + it('applies light theme colors correctly', () => { + const lightTheme = createTestTheme({ + bgMain: '#ffffff', + bgSidebar: '#f5f5f5', + textMain: '#1e1e1e', + textDim: '#666666', + accent: '#0066cc', + accentForeground: '#ffffff', + }); + + renderWithLayerStack( + + ); + + const doneButton = screen.getByRole('button', { name: 'Done' }); + expect(doneButton).toHaveStyle({ backgroundColor: '#0066cc' }); + }); + }); + + describe('rapid operations', () => { + it('handles rapid open/close cycles', async () => { + const { rerender } = renderWithLayerStack( + + ); + + for (let i = 0; i < 5; i++) { + rerender( + + + + ); + + await act(async () => {}); + + rerender( + + + + ); + + await act(async () => {}); + } + + // Should handle gracefully without errors + expect(screen.queryByText('Agent Prompt Editor')).not.toBeInTheDocument(); + }); + + it('handles rapid Done button clicks', async () => { + const onSubmit = vi.fn(); + const onClose = vi.fn(); + + renderWithLayerStack( + + ); + + const doneButton = screen.getByRole('button', { name: 'Done' }); + + // Rapid clicks + await act(async () => { + fireEvent.click(doneButton); + fireEvent.click(doneButton); + fireEvent.click(doneButton); + }); + + // Should have been called multiple times (no debouncing) + expect(onSubmit.mock.calls.length).toBeGreaterThanOrEqual(1); + }); + }); + + describe('onClose ref updates', () => { + it('uses updated onClose when escape is pressed', async () => { + const onClose1 = vi.fn(); + const onClose2 = vi.fn(); + + const { rerender } = renderWithLayerStack( + + ); + + // Update onClose + rerender( + + + + ); + + // Trigger escape via layer stack + const escapeEvent = new KeyboardEvent('keydown', { + key: 'Escape', + bubbles: true, + cancelable: true, + }); + + await act(async () => { + document.dispatchEvent(escapeEvent); + }); + + // Should call the updated onClose, not the original + // (Behavior depends on how the layer stack handler captures the ref) + }); + }); + + describe('onSubmit ref updates', () => { + it('uses updated onSubmit when Done is clicked', async () => { + const onSubmit1 = vi.fn(); + const onSubmit2 = vi.fn(); + + const { rerender } = renderWithLayerStack( + + ); + + // Update onSubmit + rerender( + + + + ); + + const doneButton = screen.getByRole('button', { name: 'Done' }); + await act(async () => { + fireEvent.click(doneButton); + }); + + expect(onSubmit2).toHaveBeenCalledWith('Test'); + expect(onSubmit1).not.toHaveBeenCalled(); + }); + }); + + describe('modal dimensions and layout', () => { + it('has correct modal dimensions classes', () => { + renderWithLayerStack( + + ); + + const modalContent = screen.getByText('Agent Prompt Editor').closest('.w-\\[90vw\\]'); + expect(modalContent).toHaveClass('h-[85vh]', 'max-w-5xl'); + }); + + it('has fixed position backdrop', () => { + renderWithLayerStack( + + ); + + const backdrop = document.querySelector('.fixed.inset-0'); + expect(backdrop).toBeInTheDocument(); + expect(backdrop).toHaveClass('z-[10001]'); + }); + }); + + describe('requestAnimationFrame in variable insertion', () => { + it('calls requestAnimationFrame when inserting variable', async () => { + const rafSpy = vi.spyOn(window, 'requestAnimationFrame').mockImplementation((cb) => { + cb(0); + return 0; + }); + + renderWithLayerStack( + + ); + + // Expand variables panel + const toggleButton = screen.getByText('Template Variables').closest('button'); + await act(async () => { + fireEvent.click(toggleButton!); + }); + + // Click on a variable + const variableCode = screen.getByText('{{SESSION_NAME}}'); + await act(async () => { + fireEvent.click(variableCode); + }); + + expect(rafSpy).toHaveBeenCalled(); + + rafSpy.mockRestore(); + }); + }); +}); diff --git a/src/__tests__/renderer/components/AgentSessionsBrowser.test.tsx b/src/__tests__/renderer/components/AgentSessionsBrowser.test.tsx new file mode 100644 index 00000000..720aca04 --- /dev/null +++ b/src/__tests__/renderer/components/AgentSessionsBrowser.test.tsx @@ -0,0 +1,2669 @@ +/** + * @fileoverview Tests for AgentSessionsBrowser component + * + * AgentSessionsBrowser is a modal component that displays Claude sessions: + * - Session list with search and filtering + * - Session detail view with messages + * - Session stats (cost, duration, tokens) + * - Star/unstar sessions + * - Rename sessions + * - Resume sessions + * - Progressive stats loading + */ + +import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'; +import { render, screen, fireEvent, act, waitFor } from '@testing-library/react'; +import { AgentSessionsBrowser } from '../../../renderer/components/AgentSessionsBrowser'; +import { LayerStackProvider } from '../../../renderer/contexts/LayerStackContext'; +import type { Theme, Session, LogEntry } from '../../../renderer/types'; + +// Mock lucide-react icons +vi.mock('lucide-react', () => ({ + Search: () => , + Clock: () => , + MessageSquare: () => , + HardDrive: () => , + Play: () => , + ChevronLeft: () => , + Loader2: ({ className }: { className?: string }) => ( + + ), + Plus: () => , + X: () => , + List: () => , + Database: () => , + BarChart3: () => , + ChevronDown: () => , + User: () => , + Bot: () => , + DollarSign: () => , + Star: ({ style }: { style?: React.CSSProperties }) => ( + + ), + Zap: () => , + Timer: () => , + Hash: () => , + ArrowDownToLine: () => , + ArrowUpFromLine: () => , + Edit3: () => , +})); + +// Default theme +const defaultTheme: Theme = { + id: 'dracula', + name: 'Dracula', + mode: 'dark', + colors: { + bgMain: '#282a36', + bgSidebar: '#21222c', + bgActivity: '#343746', + textMain: '#f8f8f2', + textDim: '#6272a4', + accent: '#bd93f9', + accentForeground: '#f8f8f2', + border: '#44475a', + success: '#50fa7b', + warning: '#ffb86c', + error: '#ff5555', + info: '#8be9fd', + }, +}; + +// Mock ClaudeSession +interface ClaudeSession { + sessionId: string; + projectPath: string; + timestamp: string; + modifiedAt: string; + firstMessage: string; + messageCount: number; + sizeBytes: number; + costUsd: number; + inputTokens: number; + outputTokens: number; + cacheReadTokens: number; + cacheCreationTokens: number; + durationSeconds: number; + origin?: 'user' | 'auto'; + sessionName?: string; +} + +// Mock SessionMessage +interface SessionMessage { + type: string; + role?: string; + content: string; + timestamp: string; + uuid: string; + toolUse?: unknown; +} + +// Create mock Claude session +const createMockClaudeSession = (overrides: Partial = {}): ClaudeSession => ({ + sessionId: `d02d0bd6-${Math.random().toString(36).substr(2, 6)}-4a01-9123-456789abcdef`, + projectPath: '/path/to/project', + timestamp: '2025-01-15T10:00:00Z', + modifiedAt: '2025-01-15T11:30:00Z', + firstMessage: 'Help me with this code', + messageCount: 10, + sizeBytes: 25000, + costUsd: 0.15, + inputTokens: 5000, + outputTokens: 2000, + cacheReadTokens: 1000, + cacheCreationTokens: 500, + durationSeconds: 300, + ...overrides, +}); + +// Create mock session message +const createMockMessage = (overrides: Partial = {}): SessionMessage => ({ + type: 'assistant', + content: 'Here is the code you requested...', + timestamp: '2025-01-15T10:05:00Z', + uuid: `msg-${Math.random().toString(36).substr(2, 9)}`, + ...overrides, +}); + +// Create mock active session +const createMockActiveSession = (overrides: Partial = {}): Session => ({ + id: 'session-1', + name: 'Test Project', + toolType: 'claude-code', + state: 'idle', + inputMode: 'ai', + cwd: '/path/to/project', + projectRoot: '/path/to/project', + aiPid: 12345, + terminalPid: 12346, + aiLogs: [], + shellLogs: [], + isGitRepo: true, + fileTree: [], + fileExplorerExpanded: [], + messageQueue: [], + ...overrides, +}); + +// Store unsubscribe function from onProjectStatsUpdate +let projectStatsCallback: ((stats: unknown) => void) | null = null; + +// Default props +const createDefaultProps = (overrides: Partial[0]> = {}) => ({ + theme: defaultTheme, + activeSession: createMockActiveSession(), + activeClaudeSessionId: null as string | null, + onClose: vi.fn(), + onResumeSession: vi.fn(), + onNewSession: vi.fn(), + onUpdateTab: vi.fn(), + ...overrides, +}); + +// Helper to render with LayerStackProvider +const renderWithProvider = (ui: React.ReactElement) => { + return render({ui}); +}; + +describe('AgentSessionsBrowser', () => { + beforeEach(() => { + vi.clearAllMocks(); + vi.useFakeTimers(); + projectStatsCallback = null; + + // Setup mock implementations + vi.mocked(window.maestro.claude.listSessionsPaginated).mockResolvedValue({ + sessions: [], + hasMore: false, + totalCount: 0, + nextCursor: null, + }); + vi.mocked(window.maestro.claude.getSessionOrigins).mockResolvedValue({}); + vi.mocked(window.maestro.claude.getProjectStats).mockResolvedValue(undefined); + vi.mocked(window.maestro.claude.onProjectStatsUpdate).mockImplementation((callback) => { + projectStatsCallback = callback; + return () => { + projectStatsCallback = null; + }; + }); + vi.mocked(window.maestro.claude.readSessionMessages).mockResolvedValue({ + messages: [], + total: 0, + hasMore: false, + }); + vi.mocked(window.maestro.claude.searchSessions).mockResolvedValue([]); + vi.mocked(window.maestro.claude.updateSessionStarred).mockResolvedValue(undefined); + vi.mocked(window.maestro.claude.updateSessionName).mockResolvedValue(undefined); + }); + + afterEach(() => { + vi.useRealTimers(); + }); + + // ============================================================================ + // Helper Function Tests (via component behavior) + // ============================================================================ + + describe('formatSize helper', () => { + it('formats bytes correctly', async () => { + const session = createMockClaudeSession({ sizeBytes: 500 }); + vi.mocked(window.maestro.claude.listSessionsPaginated).mockResolvedValue({ + sessions: [session], + hasMore: false, + totalCount: 1, + nextCursor: null, + }); + + await act(async () => { + renderWithProvider(); + await vi.runAllTimersAsync(); + }); + + expect(screen.getByText(/500 B/i)).toBeInTheDocument(); + }); + + it('formats kilobytes correctly', async () => { + const session = createMockClaudeSession({ sizeBytes: 2048 }); + vi.mocked(window.maestro.claude.listSessionsPaginated).mockResolvedValue({ + sessions: [session], + hasMore: false, + totalCount: 1, + nextCursor: null, + }); + + await act(async () => { + renderWithProvider(); + await vi.runAllTimersAsync(); + }); + + expect(screen.getByText(/2\.0 KB/i)).toBeInTheDocument(); + }); + + it('formats megabytes correctly', async () => { + const session = createMockClaudeSession({ sizeBytes: 5 * 1024 * 1024 }); + vi.mocked(window.maestro.claude.listSessionsPaginated).mockResolvedValue({ + sessions: [session], + hasMore: false, + totalCount: 1, + nextCursor: null, + }); + + await act(async () => { + renderWithProvider(); + await vi.runAllTimersAsync(); + }); + + expect(screen.getByText(/5\.0 MB/i)).toBeInTheDocument(); + }); + + it('formats gigabytes correctly', async () => { + const session = createMockClaudeSession({ sizeBytes: 2 * 1024 * 1024 * 1024 }); + vi.mocked(window.maestro.claude.listSessionsPaginated).mockResolvedValue({ + sessions: [session], + hasMore: false, + totalCount: 1, + nextCursor: null, + }); + + await act(async () => { + renderWithProvider(); + await vi.runAllTimersAsync(); + }); + + expect(screen.getByText(/2\.0 GB/i)).toBeInTheDocument(); + }); + }); + + describe('formatNumber helper', () => { + it('formats small numbers correctly', async () => { + const session = createMockClaudeSession({ + inputTokens: 500, + outputTokens: 200, + }); + vi.mocked(window.maestro.claude.listSessionsPaginated).mockResolvedValue({ + sessions: [session], + hasMore: false, + totalCount: 1, + nextCursor: null, + }); + vi.mocked(window.maestro.claude.readSessionMessages).mockResolvedValue({ + messages: [], + total: 0, + hasMore: false, + }); + + await act(async () => { + renderWithProvider(); + await vi.runAllTimersAsync(); + }); + + // Click on session to view details + const sessionItem = screen.getByText(/Help me with this code/i).closest('div[class*="cursor-pointer"]'); + await act(async () => { + fireEvent.click(sessionItem!); + await vi.runAllTimersAsync(); + }); + + // Total tokens = 500 + 200 = 700 + expect(screen.getByText('700.0')).toBeInTheDocument(); + }); + + it('formats thousands with k suffix', async () => { + const session = createMockClaudeSession({ + inputTokens: 5000, + outputTokens: 3000, + }); + vi.mocked(window.maestro.claude.listSessionsPaginated).mockResolvedValue({ + sessions: [session], + hasMore: false, + totalCount: 1, + nextCursor: null, + }); + + await act(async () => { + renderWithProvider(); + await vi.runAllTimersAsync(); + }); + + // Click on session + const sessionItem = screen.getByText(/Help me with this code/i).closest('div[class*="cursor-pointer"]'); + await act(async () => { + fireEvent.click(sessionItem!); + await vi.runAllTimersAsync(); + }); + + // Total = 8000, should be 8.0k + expect(screen.getByText('8.0k')).toBeInTheDocument(); + }); + + it('formats millions with M suffix', async () => { + const session = createMockClaudeSession({ + inputTokens: 1500000, + outputTokens: 500000, + }); + vi.mocked(window.maestro.claude.listSessionsPaginated).mockResolvedValue({ + sessions: [session], + hasMore: false, + totalCount: 1, + nextCursor: null, + }); + + await act(async () => { + renderWithProvider(); + await vi.runAllTimersAsync(); + }); + + // Click on session + const sessionItem = screen.getByText(/Help me with this code/i).closest('div[class*="cursor-pointer"]'); + await act(async () => { + fireEvent.click(sessionItem!); + await vi.runAllTimersAsync(); + }); + + // Total = 2000000, should be 2.0M + expect(screen.getByText('2.0M')).toBeInTheDocument(); + }); + }); + + describe('formatRelativeTime helper', () => { + it('formats just now correctly', async () => { + const now = new Date(); + const session = createMockClaudeSession({ + modifiedAt: now.toISOString(), + }); + vi.mocked(window.maestro.claude.listSessionsPaginated).mockResolvedValue({ + sessions: [session], + hasMore: false, + totalCount: 1, + nextCursor: null, + }); + + await act(async () => { + renderWithProvider(); + await vi.runAllTimersAsync(); + }); + + expect(screen.getByText('just now')).toBeInTheDocument(); + }); + + it('formats minutes ago correctly', async () => { + const thirtyMinsAgo = new Date(Date.now() - 30 * 60 * 1000); + const session = createMockClaudeSession({ + modifiedAt: thirtyMinsAgo.toISOString(), + }); + vi.mocked(window.maestro.claude.listSessionsPaginated).mockResolvedValue({ + sessions: [session], + hasMore: false, + totalCount: 1, + nextCursor: null, + }); + + await act(async () => { + renderWithProvider(); + await vi.runAllTimersAsync(); + }); + + expect(screen.getByText('30m ago')).toBeInTheDocument(); + }); + + it('formats hours ago correctly', async () => { + const fiveHoursAgo = new Date(Date.now() - 5 * 60 * 60 * 1000); + const session = createMockClaudeSession({ + modifiedAt: fiveHoursAgo.toISOString(), + }); + vi.mocked(window.maestro.claude.listSessionsPaginated).mockResolvedValue({ + sessions: [session], + hasMore: false, + totalCount: 1, + nextCursor: null, + }); + + await act(async () => { + renderWithProvider(); + await vi.runAllTimersAsync(); + }); + + expect(screen.getByText('5h ago')).toBeInTheDocument(); + }); + + it('formats days ago correctly', async () => { + const threeDaysAgo = new Date(Date.now() - 3 * 24 * 60 * 60 * 1000); + const session = createMockClaudeSession({ + modifiedAt: threeDaysAgo.toISOString(), + }); + vi.mocked(window.maestro.claude.listSessionsPaginated).mockResolvedValue({ + sessions: [session], + hasMore: false, + totalCount: 1, + nextCursor: null, + }); + + await act(async () => { + renderWithProvider(); + await vi.runAllTimersAsync(); + }); + + expect(screen.getByText('3d ago')).toBeInTheDocument(); + }); + }); + + // ============================================================================ + // Rendering Tests + // ============================================================================ + + describe('initial rendering', () => { + it('renders modal structure with header', async () => { + await act(async () => { + renderWithProvider(); + await vi.runAllTimersAsync(); + }); + + expect(screen.getByText(/Claude Sessions for/i)).toBeInTheDocument(); + }); + + it('shows loading state initially', async () => { + // Don't resolve the promise immediately + vi.mocked(window.maestro.claude.listSessionsPaginated).mockImplementation( + () => new Promise(() => {}) + ); + + await act(async () => { + renderWithProvider(); + }); + + expect(screen.getByTestId('icon-loader')).toBeInTheDocument(); + }); + + it('shows active session name in header', async () => { + const props = createDefaultProps({ + activeSession: createMockActiveSession({ name: 'My Project' }), + }); + + await act(async () => { + renderWithProvider(); + await vi.runAllTimersAsync(); + }); + + expect(screen.getByText(/Claude Sessions for My Project/i)).toBeInTheDocument(); + }); + + it('shows active Claude session ID badge when provided', async () => { + const props = createDefaultProps({ + activeClaudeSessionId: 'abc12345-def6-7890', + }); + + await act(async () => { + renderWithProvider(); + await vi.runAllTimersAsync(); + }); + + expect(screen.getByText(/Active:/i)).toBeInTheDocument(); + }); + + it('displays New Session button', async () => { + await act(async () => { + renderWithProvider(); + await vi.runAllTimersAsync(); + }); + + expect(screen.getByText('New Session')).toBeInTheDocument(); + }); + }); + + // ============================================================================ + // Session Loading Tests + // ============================================================================ + + describe('session loading', () => { + it('loads sessions from API on mount', async () => { + const sessions = [ + createMockClaudeSession({ sessionId: 'session-1', firstMessage: 'First session' }), + createMockClaudeSession({ sessionId: 'session-2', firstMessage: 'Second session' }), + ]; + vi.mocked(window.maestro.claude.listSessionsPaginated).mockResolvedValue({ + sessions, + hasMore: false, + totalCount: 2, + nextCursor: null, + }); + + await act(async () => { + renderWithProvider(); + await vi.runAllTimersAsync(); + }); + + expect(screen.getByText('First session')).toBeInTheDocument(); + expect(screen.getByText('Second session')).toBeInTheDocument(); + }); + + it('loads starred sessions from origins', async () => { + const sessions = [createMockClaudeSession({ sessionId: 'session-1' })]; + vi.mocked(window.maestro.claude.listSessionsPaginated).mockResolvedValue({ + sessions, + hasMore: false, + totalCount: 1, + nextCursor: null, + }); + vi.mocked(window.maestro.claude.getSessionOrigins).mockResolvedValue({ + 'session-1': { origin: 'user', starred: true }, + }); + + await act(async () => { + renderWithProvider(); + await vi.runAllTimersAsync(); + }); + + // Star icon should be filled (warning color) + const starIcon = screen.getAllByTestId('icon-star')[0]; + expect(starIcon).toHaveStyle({ fill: defaultTheme.colors.warning }); + }); + + it('shows empty state when no sessions', async () => { + vi.mocked(window.maestro.claude.listSessionsPaginated).mockResolvedValue({ + sessions: [], + hasMore: false, + totalCount: 0, + nextCursor: null, + }); + + await act(async () => { + renderWithProvider(); + await vi.runAllTimersAsync(); + }); + + expect(screen.getByText(/No Claude sessions found for this project/i)).toBeInTheDocument(); + }); + + it('handles API error gracefully', async () => { + const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {}); + vi.mocked(window.maestro.claude.listSessionsPaginated).mockRejectedValue( + new Error('API Error') + ); + + await act(async () => { + renderWithProvider(); + await vi.runAllTimersAsync(); + }); + + expect(consoleSpy).toHaveBeenCalledWith('Failed to load sessions:', expect.any(Error)); + consoleSpy.mockRestore(); + }); + + it('handles no active session gracefully', async () => { + const props = createDefaultProps({ activeSession: undefined }); + + await act(async () => { + renderWithProvider(); + await vi.runAllTimersAsync(); + }); + + // Should not crash and show agent name fallback + expect(screen.getByText(/Claude Sessions for Agent/i)).toBeInTheDocument(); + }); + }); + + // ============================================================================ + // Stats Panel Tests + // ============================================================================ + + describe('stats panel', () => { + it('displays aggregate stats', async () => { + const sessions = [createMockClaudeSession()]; + vi.mocked(window.maestro.claude.listSessionsPaginated).mockResolvedValue({ + sessions, + hasMore: false, + totalCount: 1, + nextCursor: null, + }); + + await act(async () => { + renderWithProvider(); + await vi.runAllTimersAsync(); + }); + + // Trigger stats update + await act(async () => { + projectStatsCallback?.({ + projectPath: '/path/to/project', + totalSessions: 5, + totalMessages: 100, + totalCostUsd: 2.5, + totalSizeBytes: 50000, + oldestTimestamp: '2025-01-01T00:00:00Z', + isComplete: true, + }); + await vi.runAllTimersAsync(); + }); + + expect(screen.getByText('5 sessions')).toBeInTheDocument(); + expect(screen.getByText('100 messages')).toBeInTheDocument(); + expect(screen.getByText('$2.50')).toBeInTheDocument(); + }); + + it('shows loading indicator while stats incomplete', async () => { + const sessions = [createMockClaudeSession()]; + vi.mocked(window.maestro.claude.listSessionsPaginated).mockResolvedValue({ + sessions, + hasMore: false, + totalCount: 1, + nextCursor: null, + }); + + await act(async () => { + renderWithProvider(); + await vi.runAllTimersAsync(); + }); + + // Trigger incomplete stats update + await act(async () => { + projectStatsCallback?.({ + projectPath: '/path/to/project', + totalSessions: 3, + totalMessages: 50, + totalCostUsd: 1.0, + totalSizeBytes: 25000, + oldestTimestamp: null, + isComplete: false, + }); + await vi.runAllTimersAsync(); + }); + + // Stats should have animate-pulse class when incomplete + const statsText = screen.getByText('3 sessions'); + expect(statsText).toHaveClass('animate-pulse'); + }); + + it('shows oldest session date', async () => { + const sessions = [createMockClaudeSession()]; + vi.mocked(window.maestro.claude.listSessionsPaginated).mockResolvedValue({ + sessions, + hasMore: false, + totalCount: 1, + nextCursor: null, + }); + + await act(async () => { + renderWithProvider(); + await vi.runAllTimersAsync(); + }); + + await act(async () => { + projectStatsCallback?.({ + projectPath: '/path/to/project', + totalSessions: 1, + totalMessages: 10, + totalCostUsd: 0.5, + totalSizeBytes: 5000, + oldestTimestamp: '2024-06-15T00:00:00Z', + isComplete: true, + }); + await vi.runAllTimersAsync(); + }); + + expect(screen.getByText(/Since/i)).toBeInTheDocument(); + }); + }); + + // ============================================================================ + // Search Tests + // ============================================================================ + + describe('search functionality', () => { + it('filters sessions by title (client-side)', async () => { + const sessions = [ + createMockClaudeSession({ sessionId: 'session-1', firstMessage: 'React component' }), + createMockClaudeSession({ sessionId: 'session-2', firstMessage: 'Python script' }), + createMockClaudeSession({ sessionId: 'session-3', firstMessage: 'TypeScript type' }), + ]; + vi.mocked(window.maestro.claude.listSessionsPaginated).mockResolvedValue({ + sessions, + hasMore: false, + totalCount: 3, + nextCursor: null, + }); + + await act(async () => { + renderWithProvider(); + await vi.runAllTimersAsync(); + }); + + // Default mode is 'all', switch to 'title' for client-side filtering + const searchModeButton = screen.getByText('All').closest('button'); + await act(async () => { + fireEvent.click(searchModeButton!); + await vi.runAllTimersAsync(); + }); + const titleOption = screen.getByText('Title Only'); + await act(async () => { + fireEvent.click(titleOption); + await vi.runAllTimersAsync(); + }); + + const searchInput = screen.getByPlaceholderText(/Search titles/i); + await act(async () => { + fireEvent.change(searchInput, { target: { value: 'React' } }); + await vi.runAllTimersAsync(); + }); + + expect(screen.getByText('React component')).toBeInTheDocument(); + expect(screen.queryByText('Python script')).not.toBeInTheDocument(); + expect(screen.queryByText('TypeScript type')).not.toBeInTheDocument(); + }); + + it('searches by session ID', async () => { + const sessions = [ + createMockClaudeSession({ sessionId: 'd02d0bd6-1234-5678-90ab-cdefghijklmn', firstMessage: 'Session A' }), + createMockClaudeSession({ sessionId: 'e13e1ce7-5678-9012-34ab-cdefghijklmn', firstMessage: 'Session B' }), + ]; + vi.mocked(window.maestro.claude.listSessionsPaginated).mockResolvedValue({ + sessions, + hasMore: false, + totalCount: 2, + nextCursor: null, + }); + + await act(async () => { + renderWithProvider(); + await vi.runAllTimersAsync(); + }); + + // Switch to title mode for immediate filtering + const searchModeButton = screen.getByText('All').closest('button'); + await act(async () => { + fireEvent.click(searchModeButton!); + await vi.runAllTimersAsync(); + }); + const titleOption = screen.getByText('Title Only'); + await act(async () => { + fireEvent.click(titleOption); + await vi.runAllTimersAsync(); + }); + + const searchInput = screen.getByPlaceholderText(/Search titles/i); + await act(async () => { + fireEvent.change(searchInput, { target: { value: 'D02D0BD6' } }); + await vi.runAllTimersAsync(); + }); + + expect(screen.getByText('Session A')).toBeInTheDocument(); + expect(screen.queryByText('Session B')).not.toBeInTheDocument(); + }); + + it('searches by session name', async () => { + const sessions = [ + createMockClaudeSession({ sessionId: 'session-1', firstMessage: 'First', sessionName: 'My Feature' }), + createMockClaudeSession({ sessionId: 'session-2', firstMessage: 'Second', sessionName: 'Bug Fix' }), + ]; + vi.mocked(window.maestro.claude.listSessionsPaginated).mockResolvedValue({ + sessions, + hasMore: false, + totalCount: 2, + nextCursor: null, + }); + + await act(async () => { + renderWithProvider(); + await vi.runAllTimersAsync(); + }); + + // Switch to title mode for immediate filtering + const searchModeButton = screen.getByText('All').closest('button'); + await act(async () => { + fireEvent.click(searchModeButton!); + await vi.runAllTimersAsync(); + }); + const titleOption = screen.getByText('Title Only'); + await act(async () => { + fireEvent.click(titleOption); + await vi.runAllTimersAsync(); + }); + + const searchInput = screen.getByPlaceholderText(/Search titles/i); + await act(async () => { + fireEvent.change(searchInput, { target: { value: 'Feature' } }); + await vi.runAllTimersAsync(); + }); + + expect(screen.getByText('My Feature')).toBeInTheDocument(); + expect(screen.queryByText('Bug Fix')).not.toBeInTheDocument(); + }); + + it('clears search with X button', async () => { + const sessions = [ + createMockClaudeSession({ sessionId: 'session-1', firstMessage: 'Session A' }), + createMockClaudeSession({ sessionId: 'session-2', firstMessage: 'Session B' }), + ]; + vi.mocked(window.maestro.claude.listSessionsPaginated).mockResolvedValue({ + sessions, + hasMore: false, + totalCount: 2, + nextCursor: null, + }); + + await act(async () => { + renderWithProvider(); + await vi.runAllTimersAsync(); + }); + + // Switch to title mode + const searchModeButton = screen.getByText('All').closest('button'); + await act(async () => { + fireEvent.click(searchModeButton!); + await vi.runAllTimersAsync(); + }); + const titleOption = screen.getByText('Title Only'); + await act(async () => { + fireEvent.click(titleOption); + await vi.runAllTimersAsync(); + }); + + const searchInput = screen.getByPlaceholderText(/Search titles/i); + await act(async () => { + fireEvent.change(searchInput, { target: { value: 'Session A' } }); + await vi.runAllTimersAsync(); + }); + + expect(screen.queryByText('Session B')).not.toBeInTheDocument(); + + // Find the clear search button - it's the X icon in the search bar, not the modal close button + // Get all X icons and find the one in the search area + const xIcons = screen.getAllByTestId('icon-x'); + // The clear button is the one that appears after the search input + const clearButton = xIcons.find((icon) => { + const button = icon.closest('button'); + // The clear button should be inside the search bar container + return button?.classList.contains('p-0.5'); + })?.closest('button'); + + await act(async () => { + fireEvent.click(clearButton!); + await vi.runAllTimersAsync(); + }); + + expect(screen.getByText('Session A')).toBeInTheDocument(); + expect(screen.getByText('Session B')).toBeInTheDocument(); + }); + + it('performs backend search for content mode', async () => { + const sessions = [createMockClaudeSession({ sessionId: 'session-1', firstMessage: 'Test' })]; + vi.mocked(window.maestro.claude.listSessionsPaginated).mockResolvedValue({ + sessions, + hasMore: false, + totalCount: 1, + nextCursor: null, + }); + vi.mocked(window.maestro.claude.searchSessions).mockResolvedValue([ + { + sessionId: 'session-1', + matchType: 'assistant' as const, + matchPreview: 'found the match here', + matchCount: 5, + }, + ]); + + await act(async () => { + renderWithProvider(); + await vi.runAllTimersAsync(); + }); + + // Default mode is 'all', just type search + const searchInput = screen.getByPlaceholderText(/Search all content/i); + await act(async () => { + fireEvent.change(searchInput, { target: { value: 'search term' } }); + // Wait for debounce + await vi.advanceTimersByTimeAsync(400); + }); + + expect(window.maestro.claude.searchSessions).toHaveBeenCalledWith( + '/path/to/project', + 'search term', + 'all' + ); + }); + + it('shows search mode dropdown options', async () => { + await act(async () => { + renderWithProvider(); + await vi.runAllTimersAsync(); + }); + + // Default mode is 'all' + const searchModeButton = screen.getByText('All').closest('button'); + await act(async () => { + fireEvent.click(searchModeButton!); + await vi.runAllTimersAsync(); + }); + + expect(screen.getByText('Title Only')).toBeInTheDocument(); + expect(screen.getByText('My Messages')).toBeInTheDocument(); + expect(screen.getByText('AI Responses')).toBeInTheDocument(); + expect(screen.getByText('All Content')).toBeInTheDocument(); + }); + + it('closes dropdown when clicking outside', async () => { + await act(async () => { + renderWithProvider(); + await vi.runAllTimersAsync(); + }); + + const searchModeButton = screen.getByText('All').closest('button'); + await act(async () => { + fireEvent.click(searchModeButton!); + await vi.runAllTimersAsync(); + }); + + expect(screen.getByText('Title Only')).toBeInTheDocument(); + + // Click outside + await act(async () => { + fireEvent.mouseDown(document.body); + await vi.runAllTimersAsync(); + }); + + expect(screen.queryByText('Title Only')).not.toBeInTheDocument(); + }); + }); + + // ============================================================================ + // Filter Tests + // ============================================================================ + + describe('filtering', () => { + it('filters by named only checkbox', async () => { + const sessions = [ + createMockClaudeSession({ sessionId: 'session-1', firstMessage: 'Named one', sessionName: 'My Session' }), + createMockClaudeSession({ sessionId: 'session-2', firstMessage: 'Unnamed one' }), + ]; + vi.mocked(window.maestro.claude.listSessionsPaginated).mockResolvedValue({ + sessions, + hasMore: false, + totalCount: 2, + nextCursor: null, + }); + + await act(async () => { + renderWithProvider(); + await vi.runAllTimersAsync(); + }); + + expect(screen.getByText('My Session')).toBeInTheDocument(); + expect(screen.getByText('Unnamed one')).toBeInTheDocument(); + + // Click named only checkbox + const namedCheckbox = screen.getByLabelText('Named'); + await act(async () => { + fireEvent.click(namedCheckbox); + await vi.runAllTimersAsync(); + }); + + expect(screen.getByText('My Session')).toBeInTheDocument(); + expect(screen.queryByText('Unnamed one')).not.toBeInTheDocument(); + }); + + it('shows all sessions with show all checkbox', async () => { + const sessions = [ + createMockClaudeSession({ sessionId: 'd02d0bd6-test', firstMessage: 'UUID session' }), + createMockClaudeSession({ sessionId: 'agent-batch-123', firstMessage: 'Agent session' }), + ]; + vi.mocked(window.maestro.claude.listSessionsPaginated).mockResolvedValue({ + sessions, + hasMore: false, + totalCount: 2, + nextCursor: null, + }); + + await act(async () => { + renderWithProvider(); + await vi.runAllTimersAsync(); + }); + + // Agent sessions hidden by default + expect(screen.getByText('UUID session')).toBeInTheDocument(); + expect(screen.queryByText('Agent session')).not.toBeInTheDocument(); + + // Click show all + const showAllCheckbox = screen.getByLabelText('Show All'); + await act(async () => { + fireEvent.click(showAllCheckbox); + await vi.runAllTimersAsync(); + }); + + expect(screen.getByText('UUID session')).toBeInTheDocument(); + expect(screen.getByText('Agent session')).toBeInTheDocument(); + }); + }); + + // ============================================================================ + // Session Origin Pills Tests + // ============================================================================ + + describe('session origin pills', () => { + it('shows MAESTRO pill for user-initiated sessions', async () => { + const sessions = [ + createMockClaudeSession({ sessionId: 'session-1', origin: 'user' }), + ]; + vi.mocked(window.maestro.claude.listSessionsPaginated).mockResolvedValue({ + sessions, + hasMore: false, + totalCount: 1, + nextCursor: null, + }); + + await act(async () => { + renderWithProvider(); + await vi.runAllTimersAsync(); + }); + + expect(screen.getByText('MAESTRO')).toBeInTheDocument(); + }); + + it('shows AUTO pill for auto-batch sessions', async () => { + const sessions = [ + createMockClaudeSession({ sessionId: 'session-1', origin: 'auto' }), + ]; + vi.mocked(window.maestro.claude.listSessionsPaginated).mockResolvedValue({ + sessions, + hasMore: false, + totalCount: 1, + nextCursor: null, + }); + + await act(async () => { + renderWithProvider(); + await vi.runAllTimersAsync(); + }); + + expect(screen.getByText('AUTO')).toBeInTheDocument(); + }); + + it('shows CLI pill for sessions without origin', async () => { + const sessions = [ + createMockClaudeSession({ sessionId: 'session-1', origin: undefined }), + ]; + vi.mocked(window.maestro.claude.listSessionsPaginated).mockResolvedValue({ + sessions, + hasMore: false, + totalCount: 1, + nextCursor: null, + }); + + await act(async () => { + renderWithProvider(); + await vi.runAllTimersAsync(); + }); + + expect(screen.getByText('CLI')).toBeInTheDocument(); + }); + }); + + // ============================================================================ + // Star/Unstar Tests + // ============================================================================ + + describe('star/unstar sessions', () => { + it('toggles star status on click', async () => { + const sessions = [createMockClaudeSession({ sessionId: 'session-1' })]; + vi.mocked(window.maestro.claude.listSessionsPaginated).mockResolvedValue({ + sessions, + hasMore: false, + totalCount: 1, + nextCursor: null, + }); + + const onUpdateTab = vi.fn(); + const props = createDefaultProps({ onUpdateTab }); + + await act(async () => { + renderWithProvider(); + await vi.runAllTimersAsync(); + }); + + // Find and click star button + const starButton = screen.getByTestId('icon-star').closest('button'); + await act(async () => { + fireEvent.click(starButton!); + await vi.runAllTimersAsync(); + }); + + expect(window.maestro.claude.updateSessionStarred).toHaveBeenCalledWith( + '/path/to/project', + 'session-1', + true + ); + expect(onUpdateTab).toHaveBeenCalledWith('session-1', { starred: true }); + }); + + it('unstars previously starred session', async () => { + const sessions = [createMockClaudeSession({ sessionId: 'session-1' })]; + vi.mocked(window.maestro.claude.listSessionsPaginated).mockResolvedValue({ + sessions, + hasMore: false, + totalCount: 1, + nextCursor: null, + }); + vi.mocked(window.maestro.claude.getSessionOrigins).mockResolvedValue({ + 'session-1': { origin: 'user', starred: true }, + }); + + const onUpdateTab = vi.fn(); + const props = createDefaultProps({ onUpdateTab }); + + await act(async () => { + renderWithProvider(); + await vi.runAllTimersAsync(); + }); + + // Click star to unstar + const starButton = screen.getByTestId('icon-star').closest('button'); + await act(async () => { + fireEvent.click(starButton!); + await vi.runAllTimersAsync(); + }); + + expect(window.maestro.claude.updateSessionStarred).toHaveBeenCalledWith( + '/path/to/project', + 'session-1', + false + ); + expect(onUpdateTab).toHaveBeenCalledWith('session-1', { starred: false }); + }); + + it('sorts starred sessions to the top', async () => { + const sessions = [ + createMockClaudeSession({ sessionId: 'session-1', firstMessage: 'Unstarred', modifiedAt: '2025-01-15T12:00:00Z' }), + createMockClaudeSession({ sessionId: 'session-2', firstMessage: 'Starred', modifiedAt: '2025-01-15T10:00:00Z' }), + ]; + vi.mocked(window.maestro.claude.listSessionsPaginated).mockResolvedValue({ + sessions, + hasMore: false, + totalCount: 2, + nextCursor: null, + }); + vi.mocked(window.maestro.claude.getSessionOrigins).mockResolvedValue({ + 'session-2': { origin: 'user', starred: true }, + }); + + await act(async () => { + renderWithProvider(); + await vi.runAllTimersAsync(); + }); + + const items = screen.getAllByText(/^(Starred|Unstarred)$/); + expect(items[0]).toHaveTextContent('Starred'); + expect(items[1]).toHaveTextContent('Unstarred'); + }); + }); + + // ============================================================================ + // Rename Tests + // ============================================================================ + + describe('rename sessions', () => { + it('enters rename mode on edit button click', async () => { + const sessions = [createMockClaudeSession({ sessionId: 'session-1' })]; + vi.mocked(window.maestro.claude.listSessionsPaginated).mockResolvedValue({ + sessions, + hasMore: false, + totalCount: 1, + nextCursor: null, + }); + + await act(async () => { + renderWithProvider(); + await vi.runAllTimersAsync(); + }); + + // Hover over session to show edit button + const sessionItem = screen.getByText(/Help me with this code/i).closest('div[class*="cursor-pointer"]'); + await act(async () => { + fireEvent.mouseEnter(sessionItem!); + await vi.runAllTimersAsync(); + }); + + // Find and click edit button + const editButtons = screen.getAllByTestId('icon-edit'); + const editButton = editButtons[0].closest('button'); + await act(async () => { + fireEvent.click(editButton!); + await vi.advanceTimersByTimeAsync(100); + }); + + expect(screen.getByPlaceholderText('Enter session name...')).toBeInTheDocument(); + }); + + it('submits rename on Enter key', async () => { + const sessions = [createMockClaudeSession({ sessionId: 'session-1' })]; + vi.mocked(window.maestro.claude.listSessionsPaginated).mockResolvedValue({ + sessions, + hasMore: false, + totalCount: 1, + nextCursor: null, + }); + + const onUpdateTab = vi.fn(); + const props = createDefaultProps({ onUpdateTab }); + + await act(async () => { + renderWithProvider(); + await vi.runAllTimersAsync(); + }); + + // Start rename + const editButtons = screen.getAllByTestId('icon-edit'); + const editButton = editButtons[0].closest('button'); + await act(async () => { + fireEvent.click(editButton!); + await vi.advanceTimersByTimeAsync(100); + }); + + const input = screen.getByPlaceholderText('Enter session name...'); + await act(async () => { + fireEvent.change(input, { target: { value: 'New Name' } }); + fireEvent.keyDown(input, { key: 'Enter' }); + await vi.runAllTimersAsync(); + }); + + expect(window.maestro.claude.updateSessionName).toHaveBeenCalledWith( + '/path/to/project', + 'session-1', + 'New Name' + ); + expect(onUpdateTab).toHaveBeenCalledWith('session-1', { name: 'New Name' }); + }); + + it('cancels rename on Escape key (clears input value)', async () => { + const sessions = [createMockClaudeSession({ sessionId: 'session-1' })]; + vi.mocked(window.maestro.claude.listSessionsPaginated).mockResolvedValue({ + sessions, + hasMore: false, + totalCount: 1, + nextCursor: null, + }); + + await act(async () => { + renderWithProvider(); + await vi.runAllTimersAsync(); + }); + + // Start rename + const editButtons = screen.getAllByTestId('icon-edit'); + const editButton = editButtons[0].closest('button'); + await act(async () => { + fireEvent.click(editButton!); + await vi.advanceTimersByTimeAsync(100); + }); + + const input = screen.getByPlaceholderText('Enter session name...') as HTMLInputElement; + + // Type a new name + await act(async () => { + fireEvent.change(input, { target: { value: 'New Name' } }); + await vi.runAllTimersAsync(); + }); + + expect(input.value).toBe('New Name'); + + // Press Escape - this should call cancelRename which clears the value + await act(async () => { + fireEvent.keyDown(input, { key: 'Escape' }); + await vi.runAllTimersAsync(); + }); + + // Verify that "New Name" was NOT saved - if updateSessionName was called, + // it should NOT have been called with 'New Name' + const calls = vi.mocked(window.maestro.claude.updateSessionName).mock.calls; + const savedWithNewName = calls.some(call => call[2] === 'New Name'); + expect(savedWithNewName).toBe(false); + }); + + it('submits rename on blur', async () => { + const sessions = [createMockClaudeSession({ sessionId: 'session-1' })]; + vi.mocked(window.maestro.claude.listSessionsPaginated).mockResolvedValue({ + sessions, + hasMore: false, + totalCount: 1, + nextCursor: null, + }); + + await act(async () => { + renderWithProvider(); + await vi.runAllTimersAsync(); + }); + + // Start rename + const editButtons = screen.getAllByTestId('icon-edit'); + const editButton = editButtons[0].closest('button'); + await act(async () => { + fireEvent.click(editButton!); + await vi.advanceTimersByTimeAsync(100); + }); + + const input = screen.getByPlaceholderText('Enter session name...'); + await act(async () => { + fireEvent.change(input, { target: { value: 'Blur Name' } }); + fireEvent.blur(input); + await vi.runAllTimersAsync(); + }); + + expect(window.maestro.claude.updateSessionName).toHaveBeenCalledWith( + '/path/to/project', + 'session-1', + 'Blur Name' + ); + }); + + it('clears name when submitting empty string', async () => { + const sessions = [createMockClaudeSession({ sessionId: 'session-1', sessionName: 'Existing Name' })]; + vi.mocked(window.maestro.claude.listSessionsPaginated).mockResolvedValue({ + sessions, + hasMore: false, + totalCount: 1, + nextCursor: null, + }); + + const onUpdateTab = vi.fn(); + const props = createDefaultProps({ onUpdateTab }); + + await act(async () => { + renderWithProvider(); + await vi.runAllTimersAsync(); + }); + + // Start rename + const editButtons = screen.getAllByTestId('icon-edit'); + const editButton = editButtons[0].closest('button'); + await act(async () => { + fireEvent.click(editButton!); + await vi.advanceTimersByTimeAsync(100); + }); + + const input = screen.getByDisplayValue('Existing Name'); + await act(async () => { + fireEvent.change(input, { target: { value: '' } }); + fireEvent.keyDown(input, { key: 'Enter' }); + await vi.runAllTimersAsync(); + }); + + expect(window.maestro.claude.updateSessionName).toHaveBeenCalledWith( + '/path/to/project', + 'session-1', + '' + ); + expect(onUpdateTab).toHaveBeenCalledWith('session-1', { name: null }); + }); + }); + + // ============================================================================ + // Keyboard Navigation Tests + // ============================================================================ + + describe('keyboard navigation', () => { + it('navigates down with ArrowDown', async () => { + const sessions = [ + createMockClaudeSession({ sessionId: 'session-1', firstMessage: 'First' }), + createMockClaudeSession({ sessionId: 'session-2', firstMessage: 'Second' }), + ]; + vi.mocked(window.maestro.claude.listSessionsPaginated).mockResolvedValue({ + sessions, + hasMore: false, + totalCount: 2, + nextCursor: null, + }); + + await act(async () => { + renderWithProvider(); + await vi.runAllTimersAsync(); + }); + + // Default mode is 'all', so use that placeholder + const searchInput = screen.getByPlaceholderText(/Search all content/i); + await act(async () => { + fireEvent.keyDown(searchInput, { key: 'ArrowDown' }); + await vi.runAllTimersAsync(); + }); + + // Arrow keys update selectedIndex, which changes the highlighting + // Initial selectedIndex is 0, ArrowDown makes it 1 + // We can verify by checking that both sessions are rendered (one will be highlighted) + expect(screen.getByText('First')).toBeInTheDocument(); + expect(screen.getByText('Second')).toBeInTheDocument(); + }); + + it('navigates up with ArrowUp', async () => { + const sessions = [ + createMockClaudeSession({ sessionId: 'session-1', firstMessage: 'First' }), + createMockClaudeSession({ sessionId: 'session-2', firstMessage: 'Second' }), + ]; + vi.mocked(window.maestro.claude.listSessionsPaginated).mockResolvedValue({ + sessions, + hasMore: false, + totalCount: 2, + nextCursor: null, + }); + + await act(async () => { + renderWithProvider(); + await vi.runAllTimersAsync(); + }); + + const searchInput = screen.getByPlaceholderText(/Search all content/i); + // Move down first + await act(async () => { + fireEvent.keyDown(searchInput, { key: 'ArrowDown' }); + await vi.runAllTimersAsync(); + }); + // Then back up + await act(async () => { + fireEvent.keyDown(searchInput, { key: 'ArrowUp' }); + await vi.runAllTimersAsync(); + }); + + // Sessions should still be rendered + expect(screen.getByText('First')).toBeInTheDocument(); + expect(screen.getByText('Second')).toBeInTheDocument(); + }); + + it('opens session on Enter key', async () => { + const sessions = [createMockClaudeSession({ sessionId: 'session-1' })]; + vi.mocked(window.maestro.claude.listSessionsPaginated).mockResolvedValue({ + sessions, + hasMore: false, + totalCount: 1, + nextCursor: null, + }); + vi.mocked(window.maestro.claude.readSessionMessages).mockResolvedValue({ + messages: [], + total: 0, + hasMore: false, + }); + + await act(async () => { + renderWithProvider(); + await vi.runAllTimersAsync(); + }); + + const searchInput = screen.getByPlaceholderText(/Search all content/i); + await act(async () => { + fireEvent.keyDown(searchInput, { key: 'Enter' }); + await vi.runAllTimersAsync(); + }); + + // Should show detail view with Resume button + expect(screen.getByText('Resume')).toBeInTheDocument(); + }); + + it('closes modal on Escape in list view', async () => { + const onClose = vi.fn(); + const props = createDefaultProps({ onClose }); + + await act(async () => { + renderWithProvider(); + await vi.runAllTimersAsync(); + }); + + // Escape should close modal + await act(async () => { + fireEvent.keyDown(window, { key: 'Escape' }); + await vi.runAllTimersAsync(); + }); + + expect(onClose).toHaveBeenCalled(); + }); + + it('returns to list view on Escape in detail view', async () => { + const sessions = [createMockClaudeSession({ sessionId: 'session-1' })]; + vi.mocked(window.maestro.claude.listSessionsPaginated).mockResolvedValue({ + sessions, + hasMore: false, + totalCount: 1, + nextCursor: null, + }); + vi.mocked(window.maestro.claude.readSessionMessages).mockResolvedValue({ + messages: [], + total: 0, + hasMore: false, + }); + + const onClose = vi.fn(); + const props = createDefaultProps({ onClose }); + + await act(async () => { + renderWithProvider(); + await vi.runAllTimersAsync(); + }); + + // Open detail view + const sessionItem = screen.getByText(/Help me with this code/i).closest('div[class*="cursor-pointer"]'); + await act(async () => { + fireEvent.click(sessionItem!); + await vi.runAllTimersAsync(); + }); + + // Escape should go back to list + await act(async () => { + fireEvent.keyDown(window, { key: 'Escape' }); + await vi.runAllTimersAsync(); + }); + + // Should be back in list view + expect(onClose).not.toHaveBeenCalled(); + expect(screen.queryByText('Resume')).not.toBeInTheDocument(); + }); + }); + + // ============================================================================ + // Session Detail View Tests + // ============================================================================ + + describe('session detail view', () => { + it('shows session stats panel', async () => { + const session = createMockClaudeSession({ + sessionId: 'session-1', + costUsd: 1.23, + durationSeconds: 185, // 3m 5s + inputTokens: 5000, + outputTokens: 3000, + messageCount: 15, + }); + vi.mocked(window.maestro.claude.listSessionsPaginated).mockResolvedValue({ + sessions: [session], + hasMore: false, + totalCount: 1, + nextCursor: null, + }); + vi.mocked(window.maestro.claude.readSessionMessages).mockResolvedValue({ + messages: [], + total: 15, + hasMore: false, + }); + + await act(async () => { + renderWithProvider(); + await vi.runAllTimersAsync(); + }); + + // Click session + const sessionItem = screen.getByText(/Help me with this code/i).closest('div[class*="cursor-pointer"]'); + await act(async () => { + fireEvent.click(sessionItem!); + await vi.runAllTimersAsync(); + }); + + expect(screen.getByText('$1.23')).toBeInTheDocument(); + expect(screen.getByText('3m 5s')).toBeInTheDocument(); + expect(screen.getByText('8.0k')).toBeInTheDocument(); // 5000 + 3000 + expect(screen.getByText('15')).toBeInTheDocument(); + }); + + it('shows token breakdown with cache tokens', async () => { + const session = createMockClaudeSession({ + sessionId: 'session-1', + inputTokens: 5000, + outputTokens: 3000, + cacheReadTokens: 2000, + cacheCreationTokens: 500, + }); + vi.mocked(window.maestro.claude.listSessionsPaginated).mockResolvedValue({ + sessions: [session], + hasMore: false, + totalCount: 1, + nextCursor: null, + }); + + await act(async () => { + renderWithProvider(); + await vi.runAllTimersAsync(); + }); + + const sessionItem = screen.getByText(/Help me with this code/i).closest('div[class*="cursor-pointer"]'); + await act(async () => { + fireEvent.click(sessionItem!); + await vi.runAllTimersAsync(); + }); + + expect(screen.getByText(/Input:/)).toBeInTheDocument(); + expect(screen.getByText(/Output:/)).toBeInTheDocument(); + expect(screen.getByText(/Cache Read:/)).toBeInTheDocument(); + expect(screen.getByText(/Cache Write:/)).toBeInTheDocument(); + }); + + it('hides cache tokens when zero', async () => { + const session = createMockClaudeSession({ + sessionId: 'session-1', + cacheReadTokens: 0, + cacheCreationTokens: 0, + }); + vi.mocked(window.maestro.claude.listSessionsPaginated).mockResolvedValue({ + sessions: [session], + hasMore: false, + totalCount: 1, + nextCursor: null, + }); + + await act(async () => { + renderWithProvider(); + await vi.runAllTimersAsync(); + }); + + const sessionItem = screen.getByText(/Help me with this code/i).closest('div[class*="cursor-pointer"]'); + await act(async () => { + fireEvent.click(sessionItem!); + await vi.runAllTimersAsync(); + }); + + expect(screen.queryByText(/Cache Read:/)).not.toBeInTheDocument(); + expect(screen.queryByText(/Cache Write:/)).not.toBeInTheDocument(); + }); + + it('displays messages in correct format', async () => { + const session = createMockClaudeSession({ sessionId: 'session-1' }); + const messages = [ + createMockMessage({ type: 'user', content: 'Hello, can you help?' }), + createMockMessage({ type: 'assistant', content: 'Of course!' }), + ]; + vi.mocked(window.maestro.claude.listSessionsPaginated).mockResolvedValue({ + sessions: [session], + hasMore: false, + totalCount: 1, + nextCursor: null, + }); + vi.mocked(window.maestro.claude.readSessionMessages).mockResolvedValue({ + messages, + total: 2, + hasMore: false, + }); + + await act(async () => { + renderWithProvider(); + await vi.runAllTimersAsync(); + }); + + const sessionItem = screen.getByText(/Help me with this code/i).closest('div[class*="cursor-pointer"]'); + await act(async () => { + fireEvent.click(sessionItem!); + await vi.runAllTimersAsync(); + }); + + expect(screen.getByText('Hello, can you help?')).toBeInTheDocument(); + expect(screen.getByText('Of course!')).toBeInTheDocument(); + }); + + it('shows back button in detail view', async () => { + const session = createMockClaudeSession({ sessionId: 'session-1' }); + vi.mocked(window.maestro.claude.listSessionsPaginated).mockResolvedValue({ + sessions: [session], + hasMore: false, + totalCount: 1, + nextCursor: null, + }); + + await act(async () => { + renderWithProvider(); + await vi.runAllTimersAsync(); + }); + + const sessionItem = screen.getByText(/Help me with this code/i).closest('div[class*="cursor-pointer"]'); + await act(async () => { + fireEvent.click(sessionItem!); + await vi.runAllTimersAsync(); + }); + + expect(screen.getByTestId('icon-chevron-left')).toBeInTheDocument(); + }); + + it('navigates back to list on back button click', async () => { + const session = createMockClaudeSession({ sessionId: 'session-1' }); + vi.mocked(window.maestro.claude.listSessionsPaginated).mockResolvedValue({ + sessions: [session], + hasMore: false, + totalCount: 1, + nextCursor: null, + }); + + await act(async () => { + renderWithProvider(); + await vi.runAllTimersAsync(); + }); + + const sessionItem = screen.getByText(/Help me with this code/i).closest('div[class*="cursor-pointer"]'); + await act(async () => { + fireEvent.click(sessionItem!); + await vi.runAllTimersAsync(); + }); + + const backButton = screen.getByTestId('icon-chevron-left').closest('button'); + await act(async () => { + fireEvent.click(backButton!); + await vi.runAllTimersAsync(); + }); + + // Should be back in list view + expect(screen.queryByText('Resume')).not.toBeInTheDocument(); + expect(screen.getByText(/Help me with this code/i)).toBeInTheDocument(); + }); + }); + + // ============================================================================ + // Context Window Gauge Tests + // ============================================================================ + + describe('context window gauge', () => { + it('shows green for low usage', async () => { + const session = createMockClaudeSession({ + sessionId: 'session-1', + inputTokens: 10000, + outputTokens: 10000, // 20k total = 10% + }); + vi.mocked(window.maestro.claude.listSessionsPaginated).mockResolvedValue({ + sessions: [session], + hasMore: false, + totalCount: 1, + nextCursor: null, + }); + + await act(async () => { + renderWithProvider(); + await vi.runAllTimersAsync(); + }); + + const sessionItem = screen.getByText(/Help me with this code/i).closest('div[class*="cursor-pointer"]'); + await act(async () => { + fireEvent.click(sessionItem!); + await vi.runAllTimersAsync(); + }); + + // Should show accent color (green-ish) for 10% usage + const percentText = screen.getByText('10.0%'); + expect(percentText).toHaveStyle({ color: defaultTheme.colors.accent }); + }); + + it('shows warning color for high usage', async () => { + const session = createMockClaudeSession({ + sessionId: 'session-1', + inputTokens: 80000, + outputTokens: 70000, // 150k total = 75% + }); + vi.mocked(window.maestro.claude.listSessionsPaginated).mockResolvedValue({ + sessions: [session], + hasMore: false, + totalCount: 1, + nextCursor: null, + }); + + await act(async () => { + renderWithProvider(); + await vi.runAllTimersAsync(); + }); + + const sessionItem = screen.getByText(/Help me with this code/i).closest('div[class*="cursor-pointer"]'); + await act(async () => { + fireEvent.click(sessionItem!); + await vi.runAllTimersAsync(); + }); + + const percentText = screen.getByText('75.0%'); + expect(percentText).toHaveStyle({ color: defaultTheme.colors.warning }); + }); + + it('shows error color for critical usage', async () => { + const session = createMockClaudeSession({ + sessionId: 'session-1', + inputTokens: 100000, + outputTokens: 90000, // 190k total = 95% + }); + vi.mocked(window.maestro.claude.listSessionsPaginated).mockResolvedValue({ + sessions: [session], + hasMore: false, + totalCount: 1, + nextCursor: null, + }); + + await act(async () => { + renderWithProvider(); + await vi.runAllTimersAsync(); + }); + + const sessionItem = screen.getByText(/Help me with this code/i).closest('div[class*="cursor-pointer"]'); + await act(async () => { + fireEvent.click(sessionItem!); + await vi.runAllTimersAsync(); + }); + + const percentText = screen.getByText('95.0%'); + expect(percentText).toHaveStyle({ color: defaultTheme.colors.error }); + }); + }); + + // ============================================================================ + // Duration Formatting Tests + // ============================================================================ + + describe('duration formatting', () => { + it('shows seconds only for short durations', async () => { + const session = createMockClaudeSession({ + sessionId: 'session-1', + durationSeconds: 45, + }); + vi.mocked(window.maestro.claude.listSessionsPaginated).mockResolvedValue({ + sessions: [session], + hasMore: false, + totalCount: 1, + nextCursor: null, + }); + + await act(async () => { + renderWithProvider(); + await vi.runAllTimersAsync(); + }); + + const sessionItem = screen.getByText(/Help me with this code/i).closest('div[class*="cursor-pointer"]'); + await act(async () => { + fireEvent.click(sessionItem!); + await vi.runAllTimersAsync(); + }); + + expect(screen.getByText('45s')).toBeInTheDocument(); + }); + + it('shows minutes and seconds for medium durations', async () => { + const session = createMockClaudeSession({ + sessionId: 'session-1', + durationSeconds: 125, // 2m 5s + }); + vi.mocked(window.maestro.claude.listSessionsPaginated).mockResolvedValue({ + sessions: [session], + hasMore: false, + totalCount: 1, + nextCursor: null, + }); + + await act(async () => { + renderWithProvider(); + await vi.runAllTimersAsync(); + }); + + const sessionItem = screen.getByText(/Help me with this code/i).closest('div[class*="cursor-pointer"]'); + await act(async () => { + fireEvent.click(sessionItem!); + await vi.runAllTimersAsync(); + }); + + expect(screen.getByText('2m 5s')).toBeInTheDocument(); + }); + + it('shows hours and minutes for long durations', async () => { + const session = createMockClaudeSession({ + sessionId: 'session-1', + durationSeconds: 3900, // 1h 5m + }); + vi.mocked(window.maestro.claude.listSessionsPaginated).mockResolvedValue({ + sessions: [session], + hasMore: false, + totalCount: 1, + nextCursor: null, + }); + + await act(async () => { + renderWithProvider(); + await vi.runAllTimersAsync(); + }); + + const sessionItem = screen.getByText(/Help me with this code/i).closest('div[class*="cursor-pointer"]'); + await act(async () => { + fireEvent.click(sessionItem!); + await vi.runAllTimersAsync(); + }); + + expect(screen.getByText('1h 5m')).toBeInTheDocument(); + }); + }); + + // ============================================================================ + // Resume Session Tests + // ============================================================================ + + describe('resume session', () => { + it('calls onResumeSession when Resume button clicked', async () => { + const session = createMockClaudeSession({ sessionId: 'session-1', sessionName: 'My Session' }); + const messages = [ + createMockMessage({ type: 'user', content: 'Hello' }), + createMockMessage({ type: 'assistant', content: 'Hi!' }), + ]; + vi.mocked(window.maestro.claude.listSessionsPaginated).mockResolvedValue({ + sessions: [session], + hasMore: false, + totalCount: 1, + nextCursor: null, + }); + vi.mocked(window.maestro.claude.readSessionMessages).mockResolvedValue({ + messages, + total: 2, + hasMore: false, + }); + + const onResumeSession = vi.fn(); + const onClose = vi.fn(); + const props = createDefaultProps({ onResumeSession, onClose }); + + await act(async () => { + renderWithProvider(); + await vi.runAllTimersAsync(); + }); + + const sessionItem = screen.getByText(/Help me with this code/i).closest('div[class*="cursor-pointer"]'); + await act(async () => { + fireEvent.click(sessionItem!); + await vi.runAllTimersAsync(); + }); + + const resumeButton = screen.getByText('Resume'); + await act(async () => { + fireEvent.click(resumeButton); + await vi.runAllTimersAsync(); + }); + + expect(onResumeSession).toHaveBeenCalledWith( + 'session-1', + expect.arrayContaining([ + expect.objectContaining({ text: 'Hello', source: 'user' }), + expect.objectContaining({ text: 'Hi!', source: 'stdout' }), + ]), + 'My Session', + false // not starred + ); + expect(onClose).toHaveBeenCalled(); + }); + + it('resumes starred session with correct starred flag', async () => { + const session = createMockClaudeSession({ sessionId: 'session-1' }); + vi.mocked(window.maestro.claude.listSessionsPaginated).mockResolvedValue({ + sessions: [session], + hasMore: false, + totalCount: 1, + nextCursor: null, + }); + vi.mocked(window.maestro.claude.getSessionOrigins).mockResolvedValue({ + 'session-1': { origin: 'user', starred: true }, + }); + + const onResumeSession = vi.fn(); + const props = createDefaultProps({ onResumeSession }); + + await act(async () => { + renderWithProvider(); + await vi.runAllTimersAsync(); + }); + + const sessionItem = screen.getByText(/Help me with this code/i).closest('div[class*="cursor-pointer"]'); + await act(async () => { + fireEvent.click(sessionItem!); + await vi.runAllTimersAsync(); + }); + + const resumeButton = screen.getByText('Resume'); + await act(async () => { + fireEvent.click(resumeButton); + await vi.runAllTimersAsync(); + }); + + expect(onResumeSession).toHaveBeenCalledWith( + 'session-1', + expect.any(Array), + undefined, + true // starred + ); + }); + + it('resumes session with Enter key in detail view', async () => { + const session = createMockClaudeSession({ sessionId: 'session-1' }); + vi.mocked(window.maestro.claude.listSessionsPaginated).mockResolvedValue({ + sessions: [session], + hasMore: false, + totalCount: 1, + nextCursor: null, + }); + + const onResumeSession = vi.fn(); + const props = createDefaultProps({ onResumeSession }); + + await act(async () => { + renderWithProvider(); + await vi.runAllTimersAsync(); + }); + + const sessionItem = screen.getByText(/Help me with this code/i).closest('div[class*="cursor-pointer"]'); + await act(async () => { + fireEvent.click(sessionItem!); + await vi.runAllTimersAsync(); + }); + + // Press Enter in detail view + const messagesContainer = document.querySelector('[tabindex="0"]'); + await act(async () => { + fireEvent.keyDown(messagesContainer!, { key: 'Enter' }); + await vi.runAllTimersAsync(); + }); + + expect(onResumeSession).toHaveBeenCalled(); + }); + }); + + // ============================================================================ + // Quick Resume Tests + // ============================================================================ + + describe('quick resume', () => { + it('quick resumes session from list view', async () => { + const session = createMockClaudeSession({ sessionId: 'session-1', sessionName: 'Quick Session' }); + vi.mocked(window.maestro.claude.listSessionsPaginated).mockResolvedValue({ + sessions: [session], + hasMore: false, + totalCount: 1, + nextCursor: null, + }); + + const onResumeSession = vi.fn(); + const onClose = vi.fn(); + const props = createDefaultProps({ onResumeSession, onClose }); + + await act(async () => { + renderWithProvider(); + await vi.runAllTimersAsync(); + }); + + // Find and click quick resume (play) button - it's visible on hover + const playButtons = screen.getAllByTestId('icon-play'); + const quickResumeButton = playButtons[0].closest('button'); + await act(async () => { + fireEvent.click(quickResumeButton!); + await vi.runAllTimersAsync(); + }); + + expect(onResumeSession).toHaveBeenCalledWith( + 'session-1', + [], // Empty messages for quick resume + 'Quick Session', + false + ); + expect(onClose).toHaveBeenCalled(); + }); + }); + + // ============================================================================ + // New Session Tests + // ============================================================================ + + describe('new session', () => { + it('calls onNewSession when New Session button clicked', async () => { + const onNewSession = vi.fn(); + const props = createDefaultProps({ onNewSession }); + + await act(async () => { + renderWithProvider(); + await vi.runAllTimersAsync(); + }); + + const newSessionButton = screen.getByText('New Session'); + await act(async () => { + fireEvent.click(newSessionButton); + await vi.runAllTimersAsync(); + }); + + expect(onNewSession).toHaveBeenCalled(); + }); + }); + + // ============================================================================ + // Close Modal Tests + // ============================================================================ + + describe('close modal', () => { + it('calls onClose when X button clicked', async () => { + const onClose = vi.fn(); + const props = createDefaultProps({ onClose }); + + await act(async () => { + renderWithProvider(); + await vi.runAllTimersAsync(); + }); + + // Find X button (icon-x inside a button) + const closeButtons = screen.getAllByTestId('icon-x'); + const closeButton = closeButtons[closeButtons.length - 1].closest('button'); + await act(async () => { + fireEvent.click(closeButton!); + await vi.runAllTimersAsync(); + }); + + expect(onClose).toHaveBeenCalled(); + }); + }); + + // ============================================================================ + // Pagination Tests + // ============================================================================ + + describe('pagination', () => { + it('loads more sessions on scroll', async () => { + const firstBatch = [ + createMockClaudeSession({ sessionId: 'session-1', firstMessage: 'First batch' }), + ]; + const secondBatch = [ + createMockClaudeSession({ sessionId: 'session-2', firstMessage: 'Second batch' }), + ]; + + vi.mocked(window.maestro.claude.listSessionsPaginated) + .mockResolvedValueOnce({ + sessions: firstBatch, + hasMore: true, + totalCount: 2, + nextCursor: 'cursor-1', + }) + .mockResolvedValueOnce({ + sessions: secondBatch, + hasMore: false, + totalCount: 2, + nextCursor: null, + }); + + await act(async () => { + renderWithProvider(); + await vi.runAllTimersAsync(); + }); + + expect(screen.getByText('First batch')).toBeInTheDocument(); + + // Trigger auto-load (the component auto-loads more after initial load) + await act(async () => { + await vi.advanceTimersByTimeAsync(100); + }); + + expect(screen.getByText('Second batch')).toBeInTheDocument(); + }); + + it('shows loading indicator while loading more', async () => { + const sessions = [createMockClaudeSession({ sessionId: 'session-1' })]; + + let resolveSecondCall: (value: unknown) => void; + const secondCallPromise = new Promise((resolve) => { + resolveSecondCall = resolve; + }); + + vi.mocked(window.maestro.claude.listSessionsPaginated) + .mockResolvedValueOnce({ + sessions, + hasMore: true, + totalCount: 2, + nextCursor: 'cursor-1', + }) + .mockImplementationOnce(() => secondCallPromise as Promise<{ + sessions: ClaudeSession[]; + hasMore: boolean; + totalCount: number; + nextCursor: string | null; + }>); + + await act(async () => { + renderWithProvider(); + await vi.runAllTimersAsync(); + }); + + // Trigger load more + await act(async () => { + await vi.advanceTimersByTimeAsync(100); + }); + + expect(screen.getByText(/Loading more sessions/i)).toBeInTheDocument(); + + // Resolve the second call + await act(async () => { + resolveSecondCall!({ + sessions: [], + hasMore: false, + totalCount: 1, + nextCursor: null, + }); + await vi.runAllTimersAsync(); + }); + }); + }); + + // ============================================================================ + // Message Loading Tests + // ============================================================================ + + describe('message loading', () => { + it('loads more messages on scroll to top', async () => { + const session = createMockClaudeSession({ sessionId: 'session-1' }); + const firstBatch = [createMockMessage({ uuid: 'msg-1', content: 'Recent message' })]; + const secondBatch = [createMockMessage({ uuid: 'msg-2', content: 'Older message' })]; + + vi.mocked(window.maestro.claude.listSessionsPaginated).mockResolvedValue({ + sessions: [session], + hasMore: false, + totalCount: 1, + nextCursor: null, + }); + vi.mocked(window.maestro.claude.readSessionMessages) + .mockResolvedValueOnce({ + messages: firstBatch, + total: 2, + hasMore: true, + }) + .mockResolvedValueOnce({ + messages: secondBatch, + total: 2, + hasMore: false, + }); + + await act(async () => { + renderWithProvider(); + await vi.runAllTimersAsync(); + }); + + // Click session + const sessionItem = screen.getByText(/Help me with this code/i).closest('div[class*="cursor-pointer"]'); + await act(async () => { + fireEvent.click(sessionItem!); + await vi.runAllTimersAsync(); + }); + + expect(screen.getByText('Recent message')).toBeInTheDocument(); + + // Click load more button + const loadMoreButton = screen.getByText(/Load earlier messages/i); + await act(async () => { + fireEvent.click(loadMoreButton); + await vi.runAllTimersAsync(); + }); + + expect(screen.getByText('Older message')).toBeInTheDocument(); + }); + + it('shows loading spinner while messages loading', async () => { + const session = createMockClaudeSession({ sessionId: 'session-1' }); + + let resolveMessages: (value: unknown) => void; + const messagesPromise = new Promise((resolve) => { + resolveMessages = resolve; + }); + + vi.mocked(window.maestro.claude.listSessionsPaginated).mockResolvedValue({ + sessions: [session], + hasMore: false, + totalCount: 1, + nextCursor: null, + }); + vi.mocked(window.maestro.claude.readSessionMessages).mockImplementation( + () => messagesPromise as Promise<{ messages: SessionMessage[]; total: number; hasMore: boolean }> + ); + + await act(async () => { + renderWithProvider(); + await vi.runAllTimersAsync(); + }); + + const sessionItem = screen.getByText(/Help me with this code/i).closest('div[class*="cursor-pointer"]'); + await act(async () => { + fireEvent.click(sessionItem!); + await vi.runAllTimersAsync(); + }); + + // Should show loader while loading + expect(screen.getAllByTestId('icon-loader').length).toBeGreaterThan(0); + + // Resolve + await act(async () => { + resolveMessages!({ messages: [], total: 0, hasMore: false }); + await vi.runAllTimersAsync(); + }); + }); + }); + + // ============================================================================ + // Active Session Badge Tests + // ============================================================================ + + describe('active session badge', () => { + it('shows ACTIVE badge for current session in list', async () => { + const sessions = [ + createMockClaudeSession({ sessionId: 'session-1', firstMessage: 'Not active' }), + createMockClaudeSession({ sessionId: 'active-session-123', firstMessage: 'Active session' }), + ]; + vi.mocked(window.maestro.claude.listSessionsPaginated).mockResolvedValue({ + sessions, + hasMore: false, + totalCount: 2, + nextCursor: null, + }); + + const props = createDefaultProps({ + activeClaudeSessionId: 'active-session-123', + }); + + await act(async () => { + renderWithProvider(); + await vi.runAllTimersAsync(); + }); + + // When activeClaudeSessionId is provided, the component auto-jumps to detail view + // Go back to list view first + const backButton = screen.getByTestId('icon-chevron-left').closest('button'); + await act(async () => { + fireEvent.click(backButton!); + await vi.runAllTimersAsync(); + }); + + // Now check for ACTIVE badge(s) - there may be one in header and one in list + const activeBadges = screen.getAllByText('ACTIVE'); + expect(activeBadges.length).toBeGreaterThanOrEqual(1); + }); + }); + + // ============================================================================ + // Auto-Jump Tests + // ============================================================================ + + describe('auto-jump to session', () => { + it('auto-opens session detail when activeClaudeSessionId provided', async () => { + const session = createMockClaudeSession({ sessionId: 'target-session' }); + vi.mocked(window.maestro.claude.listSessionsPaginated).mockResolvedValue({ + sessions: [session], + hasMore: false, + totalCount: 1, + nextCursor: null, + }); + vi.mocked(window.maestro.claude.readSessionMessages).mockResolvedValue({ + messages: [], + total: 0, + hasMore: false, + }); + + const props = createDefaultProps({ + activeClaudeSessionId: 'target-session', + }); + + await act(async () => { + renderWithProvider(); + await vi.runAllTimersAsync(); + }); + + // Should be in detail view + expect(screen.getByText('Resume')).toBeInTheDocument(); + }); + }); + + // ============================================================================ + // Rename in Detail View Tests + // ============================================================================ + + describe('rename in detail view', () => { + it('allows renaming in detail view header', async () => { + const session = createMockClaudeSession({ sessionId: 'session-1' }); + vi.mocked(window.maestro.claude.listSessionsPaginated).mockResolvedValue({ + sessions: [session], + hasMore: false, + totalCount: 1, + nextCursor: null, + }); + + await act(async () => { + renderWithProvider(); + await vi.runAllTimersAsync(); + }); + + const sessionItem = screen.getByText(/Help me with this code/i).closest('div[class*="cursor-pointer"]'); + await act(async () => { + fireEvent.click(sessionItem!); + await vi.runAllTimersAsync(); + }); + + // Click edit button in header + const editButtons = screen.getAllByTestId('icon-edit'); + const headerEditButton = editButtons[0].closest('button'); + await act(async () => { + fireEvent.click(headerEditButton!); + await vi.advanceTimersByTimeAsync(100); + }); + + const input = screen.getByPlaceholderText('Enter session name...'); + await act(async () => { + fireEvent.change(input, { target: { value: 'Detail View Name' } }); + fireEvent.keyDown(input, { key: 'Enter' }); + await vi.runAllTimersAsync(); + }); + + expect(window.maestro.claude.updateSessionName).toHaveBeenCalledWith( + '/path/to/project', + 'session-1', + 'Detail View Name' + ); + }); + + it('shows session name in detail view header when set', async () => { + const session = createMockClaudeSession({ + sessionId: 'session-1', + sessionName: 'My Named Session', + }); + vi.mocked(window.maestro.claude.listSessionsPaginated).mockResolvedValue({ + sessions: [session], + hasMore: false, + totalCount: 1, + nextCursor: null, + }); + + await act(async () => { + renderWithProvider(); + await vi.runAllTimersAsync(); + }); + + const sessionItem = screen.getByText('My Named Session').closest('div[class*="cursor-pointer"]'); + await act(async () => { + fireEvent.click(sessionItem!); + await vi.runAllTimersAsync(); + }); + + // Session name should be in header + const headerName = screen.getAllByText('My Named Session')[0]; + expect(headerName).toBeInTheDocument(); + }); + }); + + // ============================================================================ + // Star in Detail View Tests + // ============================================================================ + + describe('star in detail view', () => { + it('toggles star in detail view', async () => { + const session = createMockClaudeSession({ sessionId: 'session-1' }); + vi.mocked(window.maestro.claude.listSessionsPaginated).mockResolvedValue({ + sessions: [session], + hasMore: false, + totalCount: 1, + nextCursor: null, + }); + + const onUpdateTab = vi.fn(); + const props = createDefaultProps({ onUpdateTab }); + + await act(async () => { + renderWithProvider(); + await vi.runAllTimersAsync(); + }); + + const sessionItem = screen.getByText(/Help me with this code/i).closest('div[class*="cursor-pointer"]'); + await act(async () => { + fireEvent.click(sessionItem!); + await vi.runAllTimersAsync(); + }); + + // Find star button in header (detail view) + const starButtons = screen.getAllByTestId('icon-star'); + const headerStarButton = starButtons[0].closest('button'); + await act(async () => { + fireEvent.click(headerStarButton!); + await vi.runAllTimersAsync(); + }); + + expect(window.maestro.claude.updateSessionStarred).toHaveBeenCalledWith( + '/path/to/project', + 'session-1', + true + ); + expect(onUpdateTab).toHaveBeenCalledWith('session-1', { starred: true }); + }); + }); + + // ============================================================================ + // Tool Use Message Tests + // ============================================================================ + + describe('tool use messages', () => { + it('displays tool use placeholder for messages with tool calls', async () => { + const session = createMockClaudeSession({ sessionId: 'session-1' }); + const messages = [ + createMockMessage({ + type: 'assistant', + content: '', + toolUse: [{ name: 'file_read' }], + }), + ]; + vi.mocked(window.maestro.claude.listSessionsPaginated).mockResolvedValue({ + sessions: [session], + hasMore: false, + totalCount: 1, + nextCursor: null, + }); + vi.mocked(window.maestro.claude.readSessionMessages).mockResolvedValue({ + messages, + total: 1, + hasMore: false, + }); + + await act(async () => { + renderWithProvider(); + await vi.runAllTimersAsync(); + }); + + const sessionItem = screen.getByText(/Help me with this code/i).closest('div[class*="cursor-pointer"]'); + await act(async () => { + fireEvent.click(sessionItem!); + await vi.runAllTimersAsync(); + }); + + expect(screen.getByText('[Tool: file_read]')).toBeInTheDocument(); + }); + + it('displays no content placeholder for empty messages', async () => { + const session = createMockClaudeSession({ sessionId: 'session-1' }); + const messages = [ + createMockMessage({ + type: 'assistant', + content: '', + toolUse: undefined, + }), + ]; + vi.mocked(window.maestro.claude.listSessionsPaginated).mockResolvedValue({ + sessions: [session], + hasMore: false, + totalCount: 1, + nextCursor: null, + }); + vi.mocked(window.maestro.claude.readSessionMessages).mockResolvedValue({ + messages, + total: 1, + hasMore: false, + }); + + await act(async () => { + renderWithProvider(); + await vi.runAllTimersAsync(); + }); + + const sessionItem = screen.getByText(/Help me with this code/i).closest('div[class*="cursor-pointer"]'); + await act(async () => { + fireEvent.click(sessionItem!); + await vi.runAllTimersAsync(); + }); + + expect(screen.getByText('[No content]')).toBeInTheDocument(); + }); + }); + + // ============================================================================ + // Session ID Display Tests + // ============================================================================ + + describe('session ID display', () => { + it('displays first octet of UUID in uppercase', async () => { + const session = createMockClaudeSession({ + sessionId: 'd02d0bd6-1234-5678-90ab-cdefghijklmn', + }); + vi.mocked(window.maestro.claude.listSessionsPaginated).mockResolvedValue({ + sessions: [session], + hasMore: false, + totalCount: 1, + nextCursor: null, + }); + + await act(async () => { + renderWithProvider(); + await vi.runAllTimersAsync(); + }); + + expect(screen.getByText('D02D0BD6')).toBeInTheDocument(); + }); + + it('displays agent session ID correctly', async () => { + const session = createMockClaudeSession({ + sessionId: 'agent-abc123-batch-task', + }); + vi.mocked(window.maestro.claude.listSessionsPaginated).mockResolvedValue({ + sessions: [session], + hasMore: false, + totalCount: 1, + nextCursor: null, + }); + + // Enable show all to see agent sessions + await act(async () => { + renderWithProvider(); + await vi.runAllTimersAsync(); + }); + + const showAllCheckbox = screen.getByLabelText('Show All'); + await act(async () => { + fireEvent.click(showAllCheckbox); + await vi.runAllTimersAsync(); + }); + + expect(screen.getByText('AGENT-ABC123')).toBeInTheDocument(); + }); + + it('shows full UUID in detail view header when no session name', async () => { + const session = createMockClaudeSession({ + sessionId: 'd02d0bd6-1234-5678-90ab-cdefghijklmn', + sessionName: undefined, + }); + vi.mocked(window.maestro.claude.listSessionsPaginated).mockResolvedValue({ + sessions: [session], + hasMore: false, + totalCount: 1, + nextCursor: null, + }); + + await act(async () => { + renderWithProvider(); + await vi.runAllTimersAsync(); + }); + + const sessionItem = screen.getByText(/Help me with this code/i).closest('div[class*="cursor-pointer"]'); + await act(async () => { + fireEvent.click(sessionItem!); + await vi.runAllTimersAsync(); + }); + + expect(screen.getByText('D02D0BD6-1234-5678-90AB-CDEFGHIJKLMN')).toBeInTheDocument(); + }); + }); +}); diff --git a/src/__tests__/renderer/components/AgentSessionsModal.test.tsx b/src/__tests__/renderer/components/AgentSessionsModal.test.tsx new file mode 100644 index 00000000..d96a11ee --- /dev/null +++ b/src/__tests__/renderer/components/AgentSessionsModal.test.tsx @@ -0,0 +1,2383 @@ +import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'; +import { render, screen, fireEvent, waitFor, within, act } from '@testing-library/react'; +import { AgentSessionsModal } from '../../../renderer/components/AgentSessionsModal'; +import type { Theme, Session } from '../../../renderer/types'; + +// Mock LayerStackContext +const mockRegisterLayer = vi.fn(() => 'layer-id-1'); +const mockUnregisterLayer = vi.fn(); +const mockUpdateLayerHandler = vi.fn(); + +vi.mock('../../../renderer/contexts/LayerStackContext', () => ({ + useLayerStack: () => ({ + registerLayer: mockRegisterLayer, + unregisterLayer: mockUnregisterLayer, + updateLayerHandler: mockUpdateLayerHandler, + }), +})); + +// Mock modal priorities +vi.mock('../../../renderer/constants/modalPriorities', () => ({ + MODAL_PRIORITIES: { + AGENT_SESSIONS: 200, + }, +})); + +// Create a mock theme +const mockTheme: Theme = { + id: 'dracula', + name: 'Dracula', + mode: 'dark', + colors: { + bgMain: '#282a36', + bgSidebar: '#21222c', + bgActivity: '#343746', + textMain: '#f8f8f2', + textDim: '#6272a4', + accent: '#bd93f9', + accentForeground: '#f8f8f2', + border: '#44475a', + success: '#50fa7b', + warning: '#ffb86c', + error: '#ff5555', + scrollbar: '#44475a', + scrollbarHover: '#6272a4', + }, +}; + +const lightTheme: Theme = { + ...mockTheme, + id: 'github-light', + name: 'GitHub Light', + mode: 'light', +}; + +// Create a mock session +const createMockSession = (overrides: Partial = {}): Session => ({ + id: 'session-1', + name: 'Test Session', + cwd: '/test/project', + projectRoot: '/test/project', + inputMode: 'ai', + state: 'idle', + toolType: 'claude-code', + aiPid: 12345, + terminalPid: 12346, + aiLogs: [], + shellLogs: [], + isGitRepo: true, + fileTree: [], + fileExplorerExpanded: [], + messageQueue: [], + ...overrides, +} as Session); + +// Create a mock Claude session +interface MockClaudeSession { + sessionId: string; + projectPath: string; + timestamp: string; + modifiedAt: string; + firstMessage: string; + messageCount: number; + sizeBytes: number; + sessionName?: string; +} + +const createMockClaudeSession = (overrides: Partial = {}): MockClaudeSession => ({ + sessionId: 'claude-session-1', + projectPath: '/test/project', + timestamp: new Date().toISOString(), + modifiedAt: new Date().toISOString(), + firstMessage: 'Hello, can you help me?', + messageCount: 10, + sizeBytes: 1024 * 50, // 50KB + ...overrides, +}); + +// Create a mock message +interface MockSessionMessage { + type: string; + role?: string; + content: string; + timestamp: string; + uuid: string; + toolUse?: any; +} + +const createMockMessage = (overrides: Partial = {}): MockSessionMessage => ({ + type: 'user', + content: 'Test message content', + timestamp: new Date().toISOString(), + uuid: `msg-${Math.random().toString(36).substr(2, 9)}`, + ...overrides, +}); + +describe('AgentSessionsModal', () => { + let mockOnClose: ReturnType; + let mockOnResumeSession: ReturnType; + + beforeEach(() => { + mockOnClose = vi.fn(); + mockOnResumeSession = vi.fn(); + mockRegisterLayer.mockClear(); + mockUnregisterLayer.mockClear(); + mockUpdateLayerHandler.mockClear(); + + // Reset window.maestro mocks + vi.mocked(window.maestro.settings.get).mockResolvedValue(undefined); + vi.mocked(window.maestro.settings.set).mockResolvedValue(undefined); + vi.mocked(window.maestro.claude.listSessionsPaginated).mockResolvedValue({ + sessions: [], + hasMore: false, + totalCount: 0, + nextCursor: null, + }); + vi.mocked(window.maestro.claude.readSessionMessages).mockResolvedValue({ + messages: [], + total: 0, + hasMore: false, + }); + }); + + afterEach(() => { + vi.restoreAllMocks(); + }); + + describe('Initial Render', () => { + it('should render with required props', async () => { + render( + + ); + + await waitFor(() => { + expect(screen.getByRole('dialog')).toBeInTheDocument(); + }); + }); + + it('should have correct dialog aria attributes', async () => { + render( + + ); + + await waitFor(() => { + const dialog = screen.getByRole('dialog'); + expect(dialog).toHaveAttribute('aria-modal', 'true'); + expect(dialog).toHaveAttribute('aria-label', 'Agent Sessions'); + }); + }); + + it('should show loading state initially', async () => { + vi.mocked(window.maestro.claude.listSessionsPaginated).mockImplementation(() => + new Promise(() => {}) + ); + + render( + + ); + + // Should show loading spinner + expect(document.querySelector('.animate-spin')).toBeInTheDocument(); + }); + + it('should display search input with session name placeholder', async () => { + render( + + ); + + await waitFor(() => { + expect(screen.getByPlaceholderText('Search My Project sessions...')).toBeInTheDocument(); + }); + }); + + it('should display ESC badge', async () => { + render( + + ); + + await waitFor(() => { + expect(screen.getByText('ESC')).toBeInTheDocument(); + }); + }); + + it('should focus search input on mount', async () => { + render( + + ); + + // Wait for the setTimeout(50) focus delay + await waitFor(() => { + expect(screen.getByPlaceholderText(/Search.*sessions/)).toHaveFocus(); + }, { timeout: 200 }); + }); + }); + + describe('Layer Stack Integration', () => { + it('should register layer on mount', async () => { + render( + + ); + + await waitFor(() => { + expect(mockRegisterLayer).toHaveBeenCalledWith( + expect.objectContaining({ + type: 'modal', + blocksLowerLayers: true, + capturesFocus: true, + focusTrap: 'strict', + ariaLabel: 'Agent Sessions', + }) + ); + }); + }); + + it('should unregister layer on unmount', async () => { + const { unmount } = render( + + ); + + await waitFor(() => { + expect(mockRegisterLayer).toHaveBeenCalled(); + }); + + unmount(); + + expect(mockUnregisterLayer).toHaveBeenCalledWith('layer-id-1'); + }); + + it('should call onClose via escape handler in list view', async () => { + render( + + ); + + await waitFor(() => { + expect(mockRegisterLayer).toHaveBeenCalled(); + }); + + // Get the escape handler from registerLayer call + const escapeHandler = mockRegisterLayer.mock.calls[0][0].onEscape; + escapeHandler(); + + expect(mockOnClose).toHaveBeenCalled(); + }); + }); + + describe('Sessions Loading', () => { + it('should load sessions for active project', async () => { + const mockSessions = [createMockClaudeSession()]; + vi.mocked(window.maestro.claude.listSessionsPaginated).mockResolvedValue({ + sessions: mockSessions, + hasMore: false, + totalCount: 1, + nextCursor: null, + }); + + render( + + ); + + await waitFor(() => { + expect(window.maestro.claude.listSessionsPaginated).toHaveBeenCalledWith( + '/my/project', + { limit: 100 } + ); + }); + }); + + it('should not load sessions when no activeSession.cwd', async () => { + const listSessionsMock = vi.fn().mockResolvedValue({ + sessions: [], + hasMore: false, + totalCount: 0, + nextCursor: null, + }); + vi.mocked(window.maestro.claude.listSessionsPaginated).mockImplementation(listSessionsMock); + + render( + + ); + + // Wait a bit for potential async calls + await new Promise(r => setTimeout(r, 50)); + + expect(listSessionsMock).not.toHaveBeenCalled(); + }); + + it('should display empty state when no sessions', async () => { + vi.mocked(window.maestro.claude.listSessionsPaginated).mockResolvedValue({ + sessions: [], + hasMore: false, + totalCount: 0, + nextCursor: null, + }); + + render( + + ); + + await waitFor(() => { + expect(screen.getByText('No Claude sessions found for this project')).toBeInTheDocument(); + }); + }); + + it('should display sessions when loaded', async () => { + const mockSessions = [ + createMockClaudeSession({ sessionId: 's1', firstMessage: 'First session message' }), + createMockClaudeSession({ sessionId: 's2', firstMessage: 'Second session message' }), + ]; + vi.mocked(window.maestro.claude.listSessionsPaginated).mockResolvedValue({ + sessions: mockSessions, + hasMore: false, + totalCount: 2, + nextCursor: null, + }); + + render( + + ); + + await waitFor(() => { + expect(screen.getByText('First session message')).toBeInTheDocument(); + expect(screen.getByText('Second session message')).toBeInTheDocument(); + }); + }); + + it('should display session with sessionName instead of firstMessage', async () => { + const mockSessions = [ + createMockClaudeSession({ sessionName: 'Named Session', firstMessage: 'Should not show' }), + ]; + vi.mocked(window.maestro.claude.listSessionsPaginated).mockResolvedValue({ + sessions: mockSessions, + hasMore: false, + totalCount: 1, + nextCursor: null, + }); + + render( + + ); + + await waitFor(() => { + expect(screen.getByText('Named Session')).toBeInTheDocument(); + }); + }); + + it('should display session ID fallback when no name or message', async () => { + const mockSessions = [ + createMockClaudeSession({ sessionId: 'abcdef12345678', sessionName: undefined, firstMessage: '' }), + ]; + vi.mocked(window.maestro.claude.listSessionsPaginated).mockResolvedValue({ + sessions: mockSessions, + hasMore: false, + totalCount: 1, + nextCursor: null, + }); + + render( + + ); + + await waitFor(() => { + expect(screen.getByText('Session abcdef12...')).toBeInTheDocument(); + }); + }); + }); + + describe('Session Metadata Display', () => { + it('should display message count', async () => { + const mockSessions = [createMockClaudeSession({ messageCount: 42 })]; + vi.mocked(window.maestro.claude.listSessionsPaginated).mockResolvedValue({ + sessions: mockSessions, + hasMore: false, + totalCount: 1, + nextCursor: null, + }); + + render( + + ); + + await waitFor(() => { + expect(screen.getByText('42 msgs')).toBeInTheDocument(); + }); + }); + + it('should format size in bytes', async () => { + const mockSessions = [createMockClaudeSession({ sizeBytes: 500 })]; + vi.mocked(window.maestro.claude.listSessionsPaginated).mockResolvedValue({ + sessions: mockSessions, + hasMore: false, + totalCount: 1, + nextCursor: null, + }); + + render( + + ); + + await waitFor(() => { + expect(screen.getByText('500 B')).toBeInTheDocument(); + }); + }); + + it('should format size in KB', async () => { + const mockSessions = [createMockClaudeSession({ sizeBytes: 5120 })]; + vi.mocked(window.maestro.claude.listSessionsPaginated).mockResolvedValue({ + sessions: mockSessions, + hasMore: false, + totalCount: 1, + nextCursor: null, + }); + + render( + + ); + + await waitFor(() => { + expect(screen.getByText('5.0 KB')).toBeInTheDocument(); + }); + }); + + it('should format size in MB', async () => { + const mockSessions = [createMockClaudeSession({ sizeBytes: 2 * 1024 * 1024 })]; + vi.mocked(window.maestro.claude.listSessionsPaginated).mockResolvedValue({ + sessions: mockSessions, + hasMore: false, + totalCount: 1, + nextCursor: null, + }); + + render( + + ); + + await waitFor(() => { + expect(screen.getByText('2.0 MB')).toBeInTheDocument(); + }); + }); + }); + + describe('Relative Time Formatting', () => { + it('should display "just now" for recent timestamps', async () => { + const mockSessions = [createMockClaudeSession({ modifiedAt: new Date().toISOString() })]; + vi.mocked(window.maestro.claude.listSessionsPaginated).mockResolvedValue({ + sessions: mockSessions, + hasMore: false, + totalCount: 1, + nextCursor: null, + }); + + render( + + ); + + await waitFor(() => { + expect(screen.getByText('just now')).toBeInTheDocument(); + }); + }); + + it('should display minutes ago', async () => { + const date = new Date(); + date.setMinutes(date.getMinutes() - 15); + const mockSessions = [createMockClaudeSession({ modifiedAt: date.toISOString() })]; + vi.mocked(window.maestro.claude.listSessionsPaginated).mockResolvedValue({ + sessions: mockSessions, + hasMore: false, + totalCount: 1, + nextCursor: null, + }); + + render( + + ); + + await waitFor(() => { + expect(screen.getByText('15m ago')).toBeInTheDocument(); + }); + }); + + it('should display hours ago', async () => { + const date = new Date(); + date.setHours(date.getHours() - 5); + const mockSessions = [createMockClaudeSession({ modifiedAt: date.toISOString() })]; + vi.mocked(window.maestro.claude.listSessionsPaginated).mockResolvedValue({ + sessions: mockSessions, + hasMore: false, + totalCount: 1, + nextCursor: null, + }); + + render( + + ); + + await waitFor(() => { + expect(screen.getByText('5h ago')).toBeInTheDocument(); + }); + }); + + it('should display days ago', async () => { + const date = new Date(); + date.setDate(date.getDate() - 3); + const mockSessions = [createMockClaudeSession({ modifiedAt: date.toISOString() })]; + vi.mocked(window.maestro.claude.listSessionsPaginated).mockResolvedValue({ + sessions: mockSessions, + hasMore: false, + totalCount: 1, + nextCursor: null, + }); + + render( + + ); + + await waitFor(() => { + expect(screen.getByText('3d ago')).toBeInTheDocument(); + }); + }); + + it('should display full date for old timestamps', async () => { + const date = new Date(); + date.setDate(date.getDate() - 30); + const mockSessions = [createMockClaudeSession({ modifiedAt: date.toISOString() })]; + vi.mocked(window.maestro.claude.listSessionsPaginated).mockResolvedValue({ + sessions: mockSessions, + hasMore: false, + totalCount: 1, + nextCursor: null, + }); + + render( + + ); + + await waitFor(() => { + // Should show locale date string + const dateStr = date.toLocaleDateString(); + expect(screen.getByText(dateStr)).toBeInTheDocument(); + }); + }); + }); + + describe('Search Functionality', () => { + it('should filter sessions by firstMessage', async () => { + const mockSessions = [ + createMockClaudeSession({ sessionId: 's1', firstMessage: 'Help with React' }), + createMockClaudeSession({ sessionId: 's2', firstMessage: 'Fix Python bug' }), + ]; + vi.mocked(window.maestro.claude.listSessionsPaginated).mockResolvedValue({ + sessions: mockSessions, + hasMore: false, + totalCount: 2, + nextCursor: null, + }); + + render( + + ); + + await waitFor(() => { + expect(screen.getByText('Help with React')).toBeInTheDocument(); + }); + + // Type in search + const input = screen.getByPlaceholderText(/Search.*sessions/); + fireEvent.change(input, { target: { value: 'python' } }); + + await waitFor(() => { + expect(screen.queryByText('Help with React')).not.toBeInTheDocument(); + expect(screen.getByText('Fix Python bug')).toBeInTheDocument(); + }); + }); + + it('should filter sessions by sessionName', async () => { + const mockSessions = [ + createMockClaudeSession({ sessionId: 's1', sessionName: 'Auth Feature', firstMessage: 'test' }), + createMockClaudeSession({ sessionId: 's2', sessionName: 'Database Migration', firstMessage: 'test' }), + ]; + vi.mocked(window.maestro.claude.listSessionsPaginated).mockResolvedValue({ + sessions: mockSessions, + hasMore: false, + totalCount: 2, + nextCursor: null, + }); + + render( + + ); + + await waitFor(() => { + expect(screen.getByText('Auth Feature')).toBeInTheDocument(); + }); + + const input = screen.getByPlaceholderText(/Search.*sessions/); + fireEvent.change(input, { target: { value: 'database' } }); + + await waitFor(() => { + expect(screen.queryByText('Auth Feature')).not.toBeInTheDocument(); + expect(screen.getByText('Database Migration')).toBeInTheDocument(); + }); + }); + + it('should filter sessions by sessionId', async () => { + const mockSessions = [ + createMockClaudeSession({ sessionId: 'abc123xyz', firstMessage: 'Session 1' }), + createMockClaudeSession({ sessionId: 'def456uvw', firstMessage: 'Session 2' }), + ]; + vi.mocked(window.maestro.claude.listSessionsPaginated).mockResolvedValue({ + sessions: mockSessions, + hasMore: false, + totalCount: 2, + nextCursor: null, + }); + + render( + + ); + + await waitFor(() => { + expect(screen.getByText('Session 1')).toBeInTheDocument(); + }); + + const input = screen.getByPlaceholderText(/Search.*sessions/); + fireEvent.change(input, { target: { value: 'def456' } }); + + await waitFor(() => { + expect(screen.queryByText('Session 1')).not.toBeInTheDocument(); + expect(screen.getByText('Session 2')).toBeInTheDocument(); + }); + }); + + it('should show no results message when search matches nothing', async () => { + const mockSessions = [createMockClaudeSession({ firstMessage: 'Test session' })]; + vi.mocked(window.maestro.claude.listSessionsPaginated).mockResolvedValue({ + sessions: mockSessions, + hasMore: false, + totalCount: 1, + nextCursor: null, + }); + + render( + + ); + + await waitFor(() => { + expect(screen.getByText('Test session')).toBeInTheDocument(); + }); + + const input = screen.getByPlaceholderText(/Search.*sessions/); + fireEvent.change(input, { target: { value: 'nonexistent' } }); + + await waitFor(() => { + expect(screen.getByText('No sessions match your search')).toBeInTheDocument(); + }); + }); + + it('should reset selection when search changes', async () => { + const mockSessions = [ + createMockClaudeSession({ sessionId: 's1', firstMessage: 'First' }), + createMockClaudeSession({ sessionId: 's2', firstMessage: 'Second' }), + createMockClaudeSession({ sessionId: 's3', firstMessage: 'Third' }), + ]; + vi.mocked(window.maestro.claude.listSessionsPaginated).mockResolvedValue({ + sessions: mockSessions, + hasMore: false, + totalCount: 3, + nextCursor: null, + }); + + render( + + ); + + await waitFor(() => { + expect(screen.getByText('First')).toBeInTheDocument(); + }); + + // Navigate down twice + const input = screen.getByPlaceholderText(/Search.*sessions/); + fireEvent.keyDown(input, { key: 'ArrowDown' }); + fireEvent.keyDown(input, { key: 'ArrowDown' }); + + // Now search - should reset to index 0 + fireEvent.change(input, { target: { value: 'ird' } }); + + // The first visible item should be selected (Third) + await waitFor(() => { + const buttons = screen.getAllByRole('button'); + const sessionButton = buttons.find(b => b.textContent?.includes('Third')); + expect(sessionButton).toHaveStyle({ backgroundColor: mockTheme.colors.accent }); + }); + }); + }); + + describe('Keyboard Navigation', () => { + it('should navigate down with ArrowDown', async () => { + const mockSessions = [ + createMockClaudeSession({ sessionId: 's1', firstMessage: 'First' }), + createMockClaudeSession({ sessionId: 's2', firstMessage: 'Second' }), + ]; + vi.mocked(window.maestro.claude.listSessionsPaginated).mockResolvedValue({ + sessions: mockSessions, + hasMore: false, + totalCount: 2, + nextCursor: null, + }); + + render( + + ); + + await waitFor(() => { + expect(screen.getByText('First')).toBeInTheDocument(); + }); + + const input = screen.getByPlaceholderText(/Search.*sessions/); + + // First item should be selected initially + const firstButton = screen.getByText('First').closest('button'); + expect(firstButton).toHaveStyle({ backgroundColor: mockTheme.colors.accent }); + + fireEvent.keyDown(input, { key: 'ArrowDown' }); + + await waitFor(() => { + const secondButton = screen.getByText('Second').closest('button'); + expect(secondButton).toHaveStyle({ backgroundColor: mockTheme.colors.accent }); + }); + }); + + it('should navigate up with ArrowUp', async () => { + const mockSessions = [ + createMockClaudeSession({ sessionId: 's1', firstMessage: 'First' }), + createMockClaudeSession({ sessionId: 's2', firstMessage: 'Second' }), + ]; + vi.mocked(window.maestro.claude.listSessionsPaginated).mockResolvedValue({ + sessions: mockSessions, + hasMore: false, + totalCount: 2, + nextCursor: null, + }); + + render( + + ); + + await waitFor(() => { + expect(screen.getByText('First')).toBeInTheDocument(); + }); + + const input = screen.getByPlaceholderText(/Search.*sessions/); + + // Navigate down then up + fireEvent.keyDown(input, { key: 'ArrowDown' }); + fireEvent.keyDown(input, { key: 'ArrowUp' }); + + await waitFor(() => { + const firstButton = screen.getByText('First').closest('button'); + expect(firstButton).toHaveStyle({ backgroundColor: mockTheme.colors.accent }); + }); + }); + + it('should not go below last item', async () => { + const mockSessions = [ + createMockClaudeSession({ sessionId: 's1', firstMessage: 'First' }), + createMockClaudeSession({ sessionId: 's2', firstMessage: 'Second' }), + ]; + vi.mocked(window.maestro.claude.listSessionsPaginated).mockResolvedValue({ + sessions: mockSessions, + hasMore: false, + totalCount: 2, + nextCursor: null, + }); + + render( + + ); + + await waitFor(() => { + expect(screen.getByText('First')).toBeInTheDocument(); + }); + + const input = screen.getByPlaceholderText(/Search.*sessions/); + + // Try to navigate way down + fireEvent.keyDown(input, { key: 'ArrowDown' }); + fireEvent.keyDown(input, { key: 'ArrowDown' }); + fireEvent.keyDown(input, { key: 'ArrowDown' }); + + await waitFor(() => { + const secondButton = screen.getByText('Second').closest('button'); + expect(secondButton).toHaveStyle({ backgroundColor: mockTheme.colors.accent }); + }); + }); + + it('should not go above first item', async () => { + const mockSessions = [ + createMockClaudeSession({ sessionId: 's1', firstMessage: 'First' }), + createMockClaudeSession({ sessionId: 's2', firstMessage: 'Second' }), + ]; + vi.mocked(window.maestro.claude.listSessionsPaginated).mockResolvedValue({ + sessions: mockSessions, + hasMore: false, + totalCount: 2, + nextCursor: null, + }); + + render( + + ); + + await waitFor(() => { + expect(screen.getByText('First')).toBeInTheDocument(); + }); + + const input = screen.getByPlaceholderText(/Search.*sessions/); + + // Try to navigate up when at first + fireEvent.keyDown(input, { key: 'ArrowUp' }); + fireEvent.keyDown(input, { key: 'ArrowUp' }); + + await waitFor(() => { + const firstButton = screen.getByText('First').closest('button'); + expect(firstButton).toHaveStyle({ backgroundColor: mockTheme.colors.accent }); + }); + }); + + it('should open session view on Enter', async () => { + const mockSessions = [createMockClaudeSession({ sessionId: 's1', firstMessage: 'Test Session' })]; + vi.mocked(window.maestro.claude.listSessionsPaginated).mockResolvedValue({ + sessions: mockSessions, + hasMore: false, + totalCount: 1, + nextCursor: null, + }); + + render( + + ); + + await waitFor(() => { + expect(screen.getByText('Test Session')).toBeInTheDocument(); + }); + + const input = screen.getByPlaceholderText(/Search.*sessions/); + fireEvent.keyDown(input, { key: 'Enter' }); + + await waitFor(() => { + // Should switch to message view (Resume button appears) + expect(screen.getByText('Resume')).toBeInTheDocument(); + }); + }); + }); + + describe('Session View', () => { + it('should click to view session', async () => { + const mockSessions = [createMockClaudeSession({ sessionId: 's1', firstMessage: 'Test Session' })]; + vi.mocked(window.maestro.claude.listSessionsPaginated).mockResolvedValue({ + sessions: mockSessions, + hasMore: false, + totalCount: 1, + nextCursor: null, + }); + vi.mocked(window.maestro.claude.readSessionMessages).mockResolvedValue({ + messages: [createMockMessage({ content: 'Hello' })], + total: 1, + hasMore: false, + }); + + render( + + ); + + await waitFor(() => { + expect(screen.getByText('Test Session')).toBeInTheDocument(); + }); + + // Click on session + fireEvent.click(screen.getByText('Test Session')); + + await waitFor(() => { + expect(window.maestro.claude.readSessionMessages).toHaveBeenCalled(); + expect(screen.getByText('Resume')).toBeInTheDocument(); + }); + }); + + it('should display back button in session view', async () => { + const mockSessions = [createMockClaudeSession({ sessionId: 's1', firstMessage: 'Test Session' })]; + vi.mocked(window.maestro.claude.listSessionsPaginated).mockResolvedValue({ + sessions: mockSessions, + hasMore: false, + totalCount: 1, + nextCursor: null, + }); + + render( + + ); + + await waitFor(() => { + expect(screen.getByText('Test Session')).toBeInTheDocument(); + }); + + fireEvent.click(screen.getByText('Test Session')); + + await waitFor(() => { + expect(screen.getByRole('button', { name: '' })).toBeInTheDocument(); // ChevronLeft icon button + }); + }); + + it('should go back to list view when clicking back button', async () => { + const mockSessions = [createMockClaudeSession({ sessionId: 's1', firstMessage: 'Test Session' })]; + vi.mocked(window.maestro.claude.listSessionsPaginated).mockResolvedValue({ + sessions: mockSessions, + hasMore: false, + totalCount: 1, + nextCursor: null, + }); + + render( + + ); + + await waitFor(() => { + expect(screen.getByText('Test Session')).toBeInTheDocument(); + }); + + fireEvent.click(screen.getByText('Test Session')); + + await waitFor(() => { + expect(screen.getByText('Resume')).toBeInTheDocument(); + }); + + // Click back button (first button in header) + const buttons = screen.getAllByRole('button'); + fireEvent.click(buttons[0]); // ChevronLeft button + + await waitFor(() => { + // Should be back in list view + expect(screen.getByPlaceholderText(/Search.*sessions/)).toBeInTheDocument(); + }); + }); + + it('should display session header info', async () => { + const mockSessions = [createMockClaudeSession({ + sessionId: 's1', + sessionName: 'My Session', + modifiedAt: new Date().toISOString(), + })]; + vi.mocked(window.maestro.claude.listSessionsPaginated).mockResolvedValue({ + sessions: mockSessions, + hasMore: false, + totalCount: 1, + nextCursor: null, + }); + vi.mocked(window.maestro.claude.readSessionMessages).mockResolvedValue({ + messages: [], + total: 5, + hasMore: false, + }); + + render( + + ); + + await waitFor(() => { + expect(screen.getByText('My Session')).toBeInTheDocument(); + }); + + fireEvent.click(screen.getByText('My Session')); + + await waitFor(() => { + expect(screen.getByText(/5 messages/)).toBeInTheDocument(); + expect(screen.getByText(/just now/)).toBeInTheDocument(); + }); + }); + + it('should display session preview fallback in header', async () => { + const mockSessions = [createMockClaudeSession({ + sessionId: 's1', + sessionName: undefined, + firstMessage: '', + })]; + vi.mocked(window.maestro.claude.listSessionsPaginated).mockResolvedValue({ + sessions: mockSessions, + hasMore: false, + totalCount: 1, + nextCursor: null, + }); + + render( + + ); + + await waitFor(() => { + expect(screen.getByText(/Session s1/)).toBeInTheDocument(); + }); + + fireEvent.click(screen.getByText(/Session s1/)); + + await waitFor(() => { + // Header should show "Session Preview" fallback + expect(screen.getByText('Session Preview')).toBeInTheDocument(); + }); + }); + }); + + describe('Message Display', () => { + it('should display user messages aligned right', async () => { + const mockSessions = [createMockClaudeSession({ sessionId: 's1' })]; + vi.mocked(window.maestro.claude.listSessionsPaginated).mockResolvedValue({ + sessions: mockSessions, + hasMore: false, + totalCount: 1, + nextCursor: null, + }); + vi.mocked(window.maestro.claude.readSessionMessages).mockResolvedValue({ + messages: [createMockMessage({ type: 'user', content: 'User message' })], + total: 1, + hasMore: false, + }); + + render( + + ); + + await waitFor(() => { + fireEvent.click(screen.getByText(/Hello, can you help me/)); + }); + + await waitFor(() => { + expect(screen.getByText('User message')).toBeInTheDocument(); + const messageContainer = screen.getByText('User message').closest('.flex'); + expect(messageContainer).toHaveClass('justify-end'); + }); + }); + + it('should display assistant messages aligned left', async () => { + const mockSessions = [createMockClaudeSession({ sessionId: 's1' })]; + vi.mocked(window.maestro.claude.listSessionsPaginated).mockResolvedValue({ + sessions: mockSessions, + hasMore: false, + totalCount: 1, + nextCursor: null, + }); + vi.mocked(window.maestro.claude.readSessionMessages).mockResolvedValue({ + messages: [createMockMessage({ type: 'assistant', content: 'Assistant message' })], + total: 1, + hasMore: false, + }); + + render( + + ); + + await waitFor(() => { + fireEvent.click(screen.getByText(/Hello, can you help me/)); + }); + + await waitFor(() => { + expect(screen.getByText('Assistant message')).toBeInTheDocument(); + const messageContainer = screen.getByText('Assistant message').closest('.flex'); + expect(messageContainer).toHaveClass('justify-start'); + }); + }); + + it('should display tool use fallback when no content', async () => { + const mockSessions = [createMockClaudeSession({ sessionId: 's1' })]; + vi.mocked(window.maestro.claude.listSessionsPaginated).mockResolvedValue({ + sessions: mockSessions, + hasMore: false, + totalCount: 1, + nextCursor: null, + }); + vi.mocked(window.maestro.claude.readSessionMessages).mockResolvedValue({ + messages: [createMockMessage({ + type: 'assistant', + content: '', + toolUse: [{ name: 'read_file' }], + })], + total: 1, + hasMore: false, + }); + + render( + + ); + + await waitFor(() => { + fireEvent.click(screen.getByText(/Hello, can you help me/)); + }); + + await waitFor(() => { + expect(screen.getByText('[Tool: read_file]')).toBeInTheDocument(); + }); + }); + + it('should display no content fallback', async () => { + const mockSessions = [createMockClaudeSession({ sessionId: 's1' })]; + vi.mocked(window.maestro.claude.listSessionsPaginated).mockResolvedValue({ + sessions: mockSessions, + hasMore: false, + totalCount: 1, + nextCursor: null, + }); + vi.mocked(window.maestro.claude.readSessionMessages).mockResolvedValue({ + messages: [createMockMessage({ + type: 'assistant', + content: '', + toolUse: undefined, + })], + total: 1, + hasMore: false, + }); + + render( + + ); + + await waitFor(() => { + fireEvent.click(screen.getByText(/Hello, can you help me/)); + }); + + await waitFor(() => { + expect(screen.getByText('[No content]')).toBeInTheDocument(); + }); + }); + + it('should display loading state for messages', async () => { + const mockSessions = [createMockClaudeSession({ sessionId: 's1' })]; + vi.mocked(window.maestro.claude.listSessionsPaginated).mockResolvedValue({ + sessions: mockSessions, + hasMore: false, + totalCount: 1, + nextCursor: null, + }); + vi.mocked(window.maestro.claude.readSessionMessages).mockImplementation(() => + new Promise(() => {}) + ); + + render( + + ); + + await waitFor(() => { + fireEvent.click(screen.getByText(/Hello, can you help me/)); + }); + + await waitFor(() => { + expect(document.querySelector('.animate-spin')).toBeInTheDocument(); + }); + }); + + it('should apply user message styling in dark mode', async () => { + const mockSessions = [createMockClaudeSession({ sessionId: 's1' })]; + vi.mocked(window.maestro.claude.listSessionsPaginated).mockResolvedValue({ + sessions: mockSessions, + hasMore: false, + totalCount: 1, + nextCursor: null, + }); + vi.mocked(window.maestro.claude.readSessionMessages).mockResolvedValue({ + messages: [createMockMessage({ type: 'user', content: 'Dark mode message' })], + total: 1, + hasMore: false, + }); + + render( + + ); + + await waitFor(() => { + fireEvent.click(screen.getByText(/Hello, can you help me/)); + }); + + await waitFor(() => { + const messageBubble = screen.getByText('Dark mode message').closest('.rounded-lg'); + expect(messageBubble).toHaveStyle({ backgroundColor: mockTheme.colors.accent }); + expect(messageBubble).toHaveStyle({ color: '#000' }); // Dark mode uses black text + }); + }); + + it('should apply user message styling in light mode', async () => { + const mockSessions = [createMockClaudeSession({ sessionId: 's1' })]; + vi.mocked(window.maestro.claude.listSessionsPaginated).mockResolvedValue({ + sessions: mockSessions, + hasMore: false, + totalCount: 1, + nextCursor: null, + }); + vi.mocked(window.maestro.claude.readSessionMessages).mockResolvedValue({ + messages: [createMockMessage({ type: 'user', content: 'Light mode message' })], + total: 1, + hasMore: false, + }); + + render( + + ); + + await waitFor(() => { + fireEvent.click(screen.getByText(/Hello, can you help me/)); + }); + + await waitFor(() => { + const messageBubble = screen.getByText('Light mode message').closest('.rounded-lg'); + expect(messageBubble).toHaveStyle({ color: '#fff' }); // Light mode uses white text + }); + }); + }); + + describe('Message Pagination', () => { + it('should load more messages button when hasMoreMessages', async () => { + const mockSessions = [createMockClaudeSession({ sessionId: 's1' })]; + vi.mocked(window.maestro.claude.listSessionsPaginated).mockResolvedValue({ + sessions: mockSessions, + hasMore: false, + totalCount: 1, + nextCursor: null, + }); + vi.mocked(window.maestro.claude.readSessionMessages).mockResolvedValue({ + messages: [createMockMessage({ content: 'First batch' })], + total: 50, + hasMore: true, + }); + + render( + + ); + + await waitFor(() => { + fireEvent.click(screen.getByText(/Hello, can you help me/)); + }); + + await waitFor(() => { + expect(screen.getByText('Load earlier messages...')).toBeInTheDocument(); + }); + }); + + it('should load more messages when clicking load more', async () => { + const mockSessions = [createMockClaudeSession({ sessionId: 's1' })]; + vi.mocked(window.maestro.claude.listSessionsPaginated).mockResolvedValue({ + sessions: mockSessions, + hasMore: false, + totalCount: 1, + nextCursor: null, + }); + + let callCount = 0; + vi.mocked(window.maestro.claude.readSessionMessages).mockImplementation(async () => { + callCount++; + if (callCount === 1) { + return { + messages: [createMockMessage({ content: 'Recent message' })], + total: 50, + hasMore: true, + }; + } + return { + messages: [createMockMessage({ content: 'Older message' })], + total: 50, + hasMore: false, + }; + }); + + render( + + ); + + await waitFor(() => { + fireEvent.click(screen.getByText(/Hello, can you help me/)); + }); + + await waitFor(() => { + expect(screen.getByText('Load earlier messages...')).toBeInTheDocument(); + }); + + fireEvent.click(screen.getByText('Load earlier messages...')); + + await waitFor(() => { + expect(screen.getByText('Older message')).toBeInTheDocument(); + }); + }); + }); + + describe('Resume Session', () => { + it('should call onResumeSession when clicking Resume button', async () => { + const mockSessions = [createMockClaudeSession({ sessionId: 'session-123' })]; + vi.mocked(window.maestro.claude.listSessionsPaginated).mockResolvedValue({ + sessions: mockSessions, + hasMore: false, + totalCount: 1, + nextCursor: null, + }); + + render( + + ); + + await waitFor(() => { + fireEvent.click(screen.getByText(/Hello, can you help me/)); + }); + + await waitFor(() => { + expect(screen.getByText('Resume')).toBeInTheDocument(); + }); + + fireEvent.click(screen.getByText('Resume')); + + expect(mockOnResumeSession).toHaveBeenCalledWith('session-123'); + expect(mockOnClose).toHaveBeenCalled(); + }); + }); + + describe('Starred Sessions', () => { + it('should load starred sessions from settings', async () => { + vi.mocked(window.maestro.settings.get).mockImplementation(async (key) => { + if (key === 'starredClaudeSessions:/test/project') { + return ['session-1']; + } + return undefined; + }); + + const mockSessions = [ + createMockClaudeSession({ sessionId: 'session-1', firstMessage: 'Starred session' }), + createMockClaudeSession({ sessionId: 'session-2', firstMessage: 'Not starred' }), + ]; + vi.mocked(window.maestro.claude.listSessionsPaginated).mockResolvedValue({ + sessions: mockSessions, + hasMore: false, + totalCount: 2, + nextCursor: null, + }); + + render( + + ); + + await waitFor(() => { + expect(window.maestro.settings.get).toHaveBeenCalledWith('starredClaudeSessions:/test/project'); + }); + }); + + it('should sort starred sessions to top', async () => { + vi.mocked(window.maestro.settings.get).mockImplementation(async (key) => { + if (key === 'starredClaudeSessions:/test/project') { + return ['session-2']; + } + return undefined; + }); + + const now = new Date(); + const oneHourAgo = new Date(now.getTime() - 60 * 60 * 1000); + + const mockSessions = [ + createMockClaudeSession({ + sessionId: 'session-1', + firstMessage: 'Not starred but newer', + modifiedAt: now.toISOString(), + }), + createMockClaudeSession({ + sessionId: 'session-2', + firstMessage: 'Starred but older', + modifiedAt: oneHourAgo.toISOString(), + }), + ]; + vi.mocked(window.maestro.claude.listSessionsPaginated).mockResolvedValue({ + sessions: mockSessions, + hasMore: false, + totalCount: 2, + nextCursor: null, + }); + + render( + + ); + + await waitFor(() => { + const buttons = screen.getAllByRole('button'); + const sessionButtons = buttons.filter(b => + b.textContent?.includes('Not starred') || b.textContent?.includes('Starred') + ); + // Starred session should come first even though it's older + expect(sessionButtons[0].textContent).toContain('Starred'); + }); + }); + + it('should toggle star on click', async () => { + const mockSessions = [createMockClaudeSession({ sessionId: 'session-1' })]; + vi.mocked(window.maestro.claude.listSessionsPaginated).mockResolvedValue({ + sessions: mockSessions, + hasMore: false, + totalCount: 1, + nextCursor: null, + }); + + render( + + ); + + await waitFor(() => { + expect(screen.getByTitle('Add to favorites')).toBeInTheDocument(); + }); + + fireEvent.click(screen.getByTitle('Add to favorites')); + + await waitFor(() => { + expect(screen.getByTitle('Remove from favorites')).toBeInTheDocument(); + expect(window.maestro.settings.set).toHaveBeenCalledWith( + 'starredClaudeSessions:/test/project', + ['session-1'] + ); + }); + }); + + it('should unstar session on second click', async () => { + vi.mocked(window.maestro.settings.get).mockImplementation(async (key) => { + if (key === 'starredClaudeSessions:/test/project') { + return ['session-1']; + } + return undefined; + }); + + const mockSessions = [createMockClaudeSession({ sessionId: 'session-1' })]; + vi.mocked(window.maestro.claude.listSessionsPaginated).mockResolvedValue({ + sessions: mockSessions, + hasMore: false, + totalCount: 1, + nextCursor: null, + }); + + render( + + ); + + await waitFor(() => { + expect(screen.getByTitle('Remove from favorites')).toBeInTheDocument(); + }); + + fireEvent.click(screen.getByTitle('Remove from favorites')); + + await waitFor(() => { + expect(screen.getByTitle('Add to favorites')).toBeInTheDocument(); + expect(window.maestro.settings.set).toHaveBeenCalledWith( + 'starredClaudeSessions:/test/project', + [] + ); + }); + }); + + it('should not open session view when clicking star', async () => { + const mockSessions = [createMockClaudeSession({ sessionId: 'session-1' })]; + vi.mocked(window.maestro.claude.listSessionsPaginated).mockResolvedValue({ + sessions: mockSessions, + hasMore: false, + totalCount: 1, + nextCursor: null, + }); + + render( + + ); + + await waitFor(() => { + expect(screen.getByTitle('Add to favorites')).toBeInTheDocument(); + }); + + fireEvent.click(screen.getByTitle('Add to favorites')); + + await waitFor(() => { + // Should still be in list view + expect(screen.getByPlaceholderText(/Search.*sessions/)).toBeInTheDocument(); + expect(screen.queryByText('Resume')).not.toBeInTheDocument(); + }); + }); + }); + + describe('Sessions Pagination', () => { + it('should show pagination indicator when hasMoreSessions', async () => { + const mockSessions = Array.from({ length: 100 }, (_, i) => + createMockClaudeSession({ sessionId: `s${i}`, firstMessage: `Session ${i}` }) + ); + vi.mocked(window.maestro.claude.listSessionsPaginated).mockResolvedValue({ + sessions: mockSessions, + hasMore: true, + totalCount: 250, + nextCursor: 'cursor-100', + }); + + render( + + ); + + await waitFor(() => { + expect(screen.getByText('100 of 250 sessions loaded')).toBeInTheDocument(); + }); + }); + + it('should not show pagination indicator when searching', async () => { + const mockSessions = [createMockClaudeSession({ firstMessage: 'Test' })]; + vi.mocked(window.maestro.claude.listSessionsPaginated).mockResolvedValue({ + sessions: mockSessions, + hasMore: true, + totalCount: 250, + nextCursor: 'cursor-100', + }); + + render( + + ); + + await waitFor(() => { + expect(screen.getByText('Test')).toBeInTheDocument(); + }); + + const input = screen.getByPlaceholderText(/Search.*sessions/); + fireEvent.change(input, { target: { value: 'test' } }); + + await waitFor(() => { + expect(screen.queryByText(/sessions loaded/)).not.toBeInTheDocument(); + }); + }); + + it('should load more sessions on scroll', async () => { + const mockSessions = Array.from({ length: 100 }, (_, i) => + createMockClaudeSession({ sessionId: `s${i}`, firstMessage: `Session ${i}` }) + ); + + let callCount = 0; + vi.mocked(window.maestro.claude.listSessionsPaginated).mockImplementation(async (cwd, opts) => { + callCount++; + if (callCount === 1) { + return { + sessions: mockSessions, + hasMore: true, + totalCount: 200, + nextCursor: 'cursor-100', + }; + } + return { + sessions: mockSessions.map(s => ({ ...s, sessionId: s.sessionId + '-more' })), + hasMore: false, + totalCount: 200, + nextCursor: null, + }; + }); + + render( + + ); + + await waitFor(() => { + expect(screen.getByText('100 of 200 sessions loaded')).toBeInTheDocument(); + }); + + // Simulate scroll to 70% + const container = document.querySelector('.overflow-y-auto.py-2'); + if (container) { + Object.defineProperty(container, 'scrollTop', { value: 700, writable: true }); + Object.defineProperty(container, 'scrollHeight', { value: 1000, writable: true }); + Object.defineProperty(container, 'clientHeight', { value: 100, writable: true }); + fireEvent.scroll(container); + } + + await waitFor(() => { + expect(window.maestro.claude.listSessionsPaginated).toHaveBeenCalledWith( + expect.anything(), + { cursor: 'cursor-100', limit: 100 } + ); + }); + }); + + it('should show loading indicator while loading more sessions', async () => { + const mockSessions = [createMockClaudeSession()]; + vi.mocked(window.maestro.claude.listSessionsPaginated) + .mockResolvedValueOnce({ + sessions: mockSessions, + hasMore: true, + totalCount: 200, + nextCursor: 'cursor-100', + }) + .mockImplementation(() => new Promise(() => {})); + + render( + + ); + + await waitFor(() => { + expect(screen.getByText(/sessions loaded/)).toBeInTheDocument(); + }); + + // Simulate scroll to 70% + const container = document.querySelector('.overflow-y-auto.py-2'); + if (container) { + Object.defineProperty(container, 'scrollTop', { value: 700, writable: true }); + Object.defineProperty(container, 'scrollHeight', { value: 1000, writable: true }); + Object.defineProperty(container, 'clientHeight', { value: 100, writable: true }); + fireEvent.scroll(container); + } + + await waitFor(() => { + expect(screen.getByText('Loading more sessions...')).toBeInTheDocument(); + }); + }); + + it('should not load more if already loading', async () => { + const mockSessions = [createMockClaudeSession()]; + let resolveSecond: (() => void) | undefined; + const secondPromise = new Promise(r => { resolveSecond = r; }); + let callCount = 0; + + const listSessionsMock = vi.fn().mockImplementation(async (cwd: string, opts?: { cursor?: string }) => { + callCount++; + if (callCount === 1) { + return { + sessions: mockSessions, + hasMore: true, + totalCount: 200, + nextCursor: 'cursor-100', + }; + } + await secondPromise; + return { + sessions: mockSessions, + hasMore: false, + totalCount: 200, + nextCursor: null, + }; + }); + vi.mocked(window.maestro.claude.listSessionsPaginated).mockImplementation(listSessionsMock); + + render( + + ); + + await waitFor(() => { + expect(screen.getByText(/sessions loaded/)).toBeInTheDocument(); + }); + + const container = document.querySelector('.overflow-y-auto.py-2'); + if (container) { + Object.defineProperty(container, 'scrollTop', { value: 700, writable: true }); + Object.defineProperty(container, 'scrollHeight', { value: 1000, writable: true }); + Object.defineProperty(container, 'clientHeight', { value: 100, writable: true }); + + // Trigger multiple scrolls + fireEvent.scroll(container); + fireEvent.scroll(container); + fireEvent.scroll(container); + } + + // Should only have been called twice (initial + 1 load more) + // Even with multiple scroll events, it shouldn't call again while loading + expect(listSessionsMock).toHaveBeenCalledTimes(2); + + resolveSecond!(); + }); + + it('should deduplicate sessions when loading more', async () => { + const mockSessions = [createMockClaudeSession({ sessionId: 'unique-1' })]; + + vi.mocked(window.maestro.claude.listSessionsPaginated) + .mockResolvedValueOnce({ + sessions: mockSessions, + hasMore: true, + totalCount: 2, + nextCursor: 'cursor-1', + }) + .mockResolvedValueOnce({ + sessions: [ + createMockClaudeSession({ sessionId: 'unique-1', firstMessage: 'Duplicate' }), + createMockClaudeSession({ sessionId: 'unique-2', firstMessage: 'New' }), + ], + hasMore: false, + totalCount: 2, + nextCursor: null, + }); + + render( + + ); + + await waitFor(() => { + expect(screen.getByText(/sessions loaded/)).toBeInTheDocument(); + }); + + const container = document.querySelector('.overflow-y-auto.py-2'); + if (container) { + Object.defineProperty(container, 'scrollTop', { value: 700, writable: true }); + Object.defineProperty(container, 'scrollHeight', { value: 1000, writable: true }); + Object.defineProperty(container, 'clientHeight', { value: 100, writable: true }); + fireEvent.scroll(container); + } + + await waitFor(() => { + expect(screen.getByText('New')).toBeInTheDocument(); + }); + + // Should only show each session once + const sessionButtons = screen.getAllByRole('button').filter(b => + b.textContent?.includes('Hello, can you help me') || b.textContent?.includes('New') + ); + expect(sessionButtons.length).toBe(2); + }); + }); + + describe('Escape Handler Updates', () => { + it('should update layer handler when viewingSession changes', async () => { + const mockSessions = [createMockClaudeSession({ sessionId: 's1' })]; + vi.mocked(window.maestro.claude.listSessionsPaginated).mockResolvedValue({ + sessions: mockSessions, + hasMore: false, + totalCount: 1, + nextCursor: null, + }); + + render( + + ); + + await waitFor(() => { + expect(screen.getByText(/Hello, can you help me/)).toBeInTheDocument(); + }); + + mockUpdateLayerHandler.mockClear(); + + fireEvent.click(screen.getByText(/Hello, can you help me/)); + + await waitFor(() => { + expect(mockUpdateLayerHandler).toHaveBeenCalled(); + }); + }); + + it('should go back to list view on Escape when viewing session', async () => { + const mockSessions = [createMockClaudeSession({ sessionId: 's1' })]; + vi.mocked(window.maestro.claude.listSessionsPaginated).mockResolvedValue({ + sessions: mockSessions, + hasMore: false, + totalCount: 1, + nextCursor: null, + }); + + render( + + ); + + await waitFor(() => { + expect(screen.getByText(/Hello, can you help me/)).toBeInTheDocument(); + }); + + fireEvent.click(screen.getByText(/Hello, can you help me/)); + + await waitFor(() => { + expect(screen.getByText('Resume')).toBeInTheDocument(); + }); + + // Get updated handler (after viewingSession changed) + expect(mockUpdateLayerHandler).toHaveBeenCalled(); + const lastCall = mockUpdateLayerHandler.mock.calls[mockUpdateLayerHandler.mock.calls.length - 1]; + const updatedHandler = lastCall[1]; + + // Call the escape handler - this should clear viewingSession + await act(async () => { + updatedHandler(); + }); + + await waitFor(() => { + // Should be back in list view with search input + expect(screen.getByPlaceholderText(/Search.*sessions/)).toBeInTheDocument(); + }); + + // onClose should not have been called - escape in session view goes back to list + expect(mockOnClose).not.toHaveBeenCalled(); + }); + }); + + describe('Error Handling', () => { + it('should handle session loading error gracefully', async () => { + const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {}); + vi.mocked(window.maestro.claude.listSessionsPaginated).mockRejectedValue(new Error('Load failed')); + + render( + + ); + + await waitFor(() => { + expect(consoleSpy).toHaveBeenCalledWith('Failed to load sessions:', expect.any(Error)); + }); + + // Should show empty state + await waitFor(() => { + expect(screen.getByText('No Claude sessions found for this project')).toBeInTheDocument(); + }); + + consoleSpy.mockRestore(); + }); + + it('should handle message loading error gracefully', async () => { + const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {}); + const mockSessions = [createMockClaudeSession({ sessionId: 's1' })]; + vi.mocked(window.maestro.claude.listSessionsPaginated).mockResolvedValue({ + sessions: mockSessions, + hasMore: false, + totalCount: 1, + nextCursor: null, + }); + vi.mocked(window.maestro.claude.readSessionMessages).mockRejectedValue(new Error('Read failed')); + + render( + + ); + + await waitFor(() => { + fireEvent.click(screen.getByText(/Hello, can you help me/)); + }); + + await waitFor(() => { + expect(consoleSpy).toHaveBeenCalledWith('Failed to load messages:', expect.any(Error)); + }); + + consoleSpy.mockRestore(); + }); + + it('should handle load more sessions error gracefully', async () => { + const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {}); + const mockSessions = [createMockClaudeSession()]; + vi.mocked(window.maestro.claude.listSessionsPaginated) + .mockResolvedValueOnce({ + sessions: mockSessions, + hasMore: true, + totalCount: 200, + nextCursor: 'cursor-100', + }) + .mockRejectedValueOnce(new Error('Load more failed')); + + render( + + ); + + await waitFor(() => { + expect(screen.getByText(/sessions loaded/)).toBeInTheDocument(); + }); + + const container = document.querySelector('.overflow-y-auto.py-2'); + if (container) { + Object.defineProperty(container, 'scrollTop', { value: 700, writable: true }); + Object.defineProperty(container, 'scrollHeight', { value: 1000, writable: true }); + Object.defineProperty(container, 'clientHeight', { value: 100, writable: true }); + fireEvent.scroll(container); + } + + await waitFor(() => { + expect(consoleSpy).toHaveBeenCalledWith('Failed to load more sessions:', expect.any(Error)); + }); + + consoleSpy.mockRestore(); + }); + }); + + describe('Theme Styling', () => { + it('should apply theme colors to modal', async () => { + render( + + ); + + await waitFor(() => { + const dialog = screen.getByRole('dialog'); + expect(dialog).toHaveStyle({ + backgroundColor: mockTheme.colors.bgActivity, + borderColor: mockTheme.colors.border, + }); + }); + }); + + it('should apply accent color to Resume button', async () => { + const mockSessions = [createMockClaudeSession({ sessionId: 's1' })]; + vi.mocked(window.maestro.claude.listSessionsPaginated).mockResolvedValue({ + sessions: mockSessions, + hasMore: false, + totalCount: 1, + nextCursor: null, + }); + + render( + + ); + + await waitFor(() => { + fireEvent.click(screen.getByText(/Hello, can you help me/)); + }); + + await waitFor(() => { + const resumeButton = screen.getByText('Resume'); + expect(resumeButton).toHaveStyle({ + backgroundColor: mockTheme.colors.accent, + color: mockTheme.colors.accentForeground, + }); + }); + }); + + it('should apply warning color to starred icon', async () => { + vi.mocked(window.maestro.settings.get).mockImplementation(async (key) => { + if (key === 'starredClaudeSessions:/test/project') { + return ['session-1']; + } + return undefined; + }); + + const mockSessions = [createMockClaudeSession({ sessionId: 'session-1' })]; + vi.mocked(window.maestro.claude.listSessionsPaginated).mockResolvedValue({ + sessions: mockSessions, + hasMore: false, + totalCount: 1, + nextCursor: null, + }); + + render( + + ); + + await waitFor(() => { + const starButton = screen.getByTitle('Remove from favorites'); + const starIcon = starButton.querySelector('svg'); + expect(starIcon).toHaveStyle({ + color: mockTheme.colors.warning, + fill: mockTheme.colors.warning, + }); + }); + }); + }); + + describe('Scroll Behavior', () => { + it('should scroll selected item into view', async () => { + const scrollIntoViewMock = vi.fn(); + Element.prototype.scrollIntoView = scrollIntoViewMock; + + const mockSessions = [ + createMockClaudeSession({ sessionId: 's1', firstMessage: 'First' }), + createMockClaudeSession({ sessionId: 's2', firstMessage: 'Second' }), + createMockClaudeSession({ sessionId: 's3', firstMessage: 'Third' }), + ]; + vi.mocked(window.maestro.claude.listSessionsPaginated).mockResolvedValue({ + sessions: mockSessions, + hasMore: false, + totalCount: 3, + nextCursor: null, + }); + + render( + + ); + + await waitFor(() => { + expect(screen.getByText('First')).toBeInTheDocument(); + }); + + scrollIntoViewMock.mockClear(); + + const input = screen.getByPlaceholderText(/Search.*sessions/); + fireEvent.keyDown(input, { key: 'ArrowDown' }); + + await waitFor(() => { + expect(scrollIntoViewMock).toHaveBeenCalledWith({ block: 'nearest', behavior: 'smooth' }); + }); + }); + }); + + describe('Modal Reset on Reopen', () => { + it('should reset to list view when modal reopens', async () => { + const mockSessions = [createMockClaudeSession({ sessionId: 's1', firstMessage: 'Test' })]; + vi.mocked(window.maestro.claude.listSessionsPaginated).mockResolvedValue({ + sessions: mockSessions, + hasMore: false, + totalCount: 1, + nextCursor: null, + }); + + const { rerender, unmount } = render( + + ); + + await waitFor(() => { + fireEvent.click(screen.getByText('Test')); + }); + + await waitFor(() => { + expect(screen.getByText('Resume')).toBeInTheDocument(); + }); + + // Unmount and remount + unmount(); + + render( + + ); + + await waitFor(() => { + // Should be in list view + expect(screen.getByPlaceholderText(/Search.*sessions/)).toBeInTheDocument(); + }); + }); + }); + + describe('Default Export', () => { + it('should export AgentSessionsModal as named export', async () => { + expect(AgentSessionsModal).toBeDefined(); + expect(typeof AgentSessionsModal).toBe('function'); + }); + }); +}); diff --git a/src/__tests__/renderer/components/AutoRun.test.tsx b/src/__tests__/renderer/components/AutoRun.test.tsx new file mode 100644 index 00000000..5eff52d3 --- /dev/null +++ b/src/__tests__/renderer/components/AutoRun.test.tsx @@ -0,0 +1,2217 @@ +/** + * @file AutoRun.test.tsx + * @description Tests for the AutoRun component - a markdown editor/viewer for Auto Run feature + */ + +import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'; +import { render, screen, fireEvent, waitFor, act } from '@testing-library/react'; +import React from 'react'; +import { AutoRun, AutoRunHandle } from '../../../renderer/components/AutoRun'; +import type { Theme, BatchRunState, SessionState } from '../../../renderer/types'; + +// Mock the external dependencies +vi.mock('react-markdown', () => ({ + default: ({ children }: { children: string }) =>
{children}
, +})); + +vi.mock('remark-gfm', () => ({ + default: {}, +})); + +vi.mock('react-syntax-highlighter', () => ({ + Prism: ({ children }: { children: string }) => {children}, +})); + +vi.mock('react-syntax-highlighter/dist/esm/styles/prism', () => ({ + vscDarkPlus: {}, +})); + +vi.mock('../../../renderer/components/AutoRunnerHelpModal', () => ({ + AutoRunnerHelpModal: ({ onClose }: { onClose: () => void }) => ( +
+ +
+ ), +})); + +vi.mock('../../../renderer/components/MermaidRenderer', () => ({ + MermaidRenderer: ({ chart }: { chart: string }) => ( +
{chart}
+ ), +})); + +vi.mock('../../../renderer/components/AutoRunDocumentSelector', () => ({ + AutoRunDocumentSelector: ({ + theme, + documents, + selectedDocument, + onSelectDocument, + onRefresh, + onChangeFolder, + onCreateDocument, + isLoading, + }: any) => ( +
+ + + + {isLoading && Loading...} +
+ ), +})); + +// Store the onChange handler so our mock can call it +let autocompleteOnChange: ((content: string) => void) | null = null; + +vi.mock('../../../renderer/hooks/useTemplateAutocomplete', () => ({ + useTemplateAutocomplete: ({ value, onChange }: { value: string; onChange: (value: string) => void }) => { + // Store the onChange handler so handleAutocompleteChange can trigger state updates + autocompleteOnChange = onChange; + return { + autocompleteState: { isOpen: false, suggestions: [], selectedIndex: 0, position: { top: 0, left: 0 } }, + handleKeyDown: () => false, + handleChange: (e: React.ChangeEvent) => { + // Actually call onChange with the new value to update state + onChange(e.target.value); + }, + selectVariable: () => {}, + closeAutocomplete: () => {}, + autocompleteRef: { current: null }, + }; + }, +})); + +vi.mock('../../../renderer/components/TemplateAutocompleteDropdown', () => ({ + TemplateAutocompleteDropdown: React.forwardRef(() => null), +})); + +// Create a mock theme for testing +const createMockTheme = (): Theme => ({ + id: 'test-theme', + name: 'Test Theme', + mode: 'dark', + colors: { + bgMain: '#1a1a1a', + bgPanel: '#252525', + bgActivity: '#2d2d2d', + textMain: '#ffffff', + textDim: '#888888', + accent: '#0066ff', + accentForeground: '#ffffff', + border: '#333333', + highlight: '#0066ff33', + success: '#00aa00', + warning: '#ffaa00', + error: '#ff0000', + }, +}); + +// Setup window.maestro mock +const setupMaestroMock = () => { + const mockMaestro = { + fs: { + readFile: vi.fn().mockResolvedValue('data:image/png;base64,abc123'), + readDir: vi.fn().mockResolvedValue([]), + }, + autorun: { + listImages: vi.fn().mockResolvedValue({ success: true, images: [] }), + saveImage: vi.fn().mockResolvedValue({ success: true, relativePath: 'images/test-123.png' }), + deleteImage: vi.fn().mockResolvedValue({ success: true }), + writeDoc: vi.fn().mockResolvedValue(undefined), + }, + settings: { + get: vi.fn().mockResolvedValue(null), + set: vi.fn().mockResolvedValue(undefined), + }, + }; + + (window as any).maestro = mockMaestro; + return mockMaestro; +}; + +// Default props for AutoRun component +const createDefaultProps = (overrides: Partial> = {}) => ({ + theme: createMockTheme(), + sessionId: 'test-session-1', + folderPath: '/test/folder', + selectedFile: 'test-doc', + documentList: ['test-doc', 'another-doc'], + content: '# Test Content\n\nSome markdown content.', + onContentChange: vi.fn(), + mode: 'edit' as const, + onModeChange: vi.fn(), + onOpenSetup: vi.fn(), + onRefresh: vi.fn(), + onSelectDocument: vi.fn(), + onCreateDocument: vi.fn().mockResolvedValue(true), + ...overrides, +}); + +describe('AutoRun', () => { + let mockMaestro: ReturnType; + + beforeEach(() => { + mockMaestro = setupMaestroMock(); + vi.useFakeTimers({ shouldAdvanceTime: true }); + }); + + afterEach(() => { + vi.clearAllMocks(); + vi.useRealTimers(); + }); + + describe('Basic Rendering', () => { + it('renders in edit mode by default', () => { + const props = createDefaultProps(); + render(); + + expect(screen.getByRole('textbox')).toBeInTheDocument(); + expect(screen.getByRole('textbox')).toHaveValue(props.content); + }); + + it('renders in preview mode when mode prop is preview', () => { + const props = createDefaultProps({ mode: 'preview' }); + render(); + + expect(screen.getByTestId('react-markdown')).toBeInTheDocument(); + }); + + it('shows "Select Auto Run Folder" button when no folder is configured', () => { + const props = createDefaultProps({ folderPath: null }); + render(); + + expect(screen.getByText('Select Auto Run Folder')).toBeInTheDocument(); + }); + + it('shows document selector when folder is configured', () => { + const props = createDefaultProps(); + render(); + + expect(screen.getByTestId('document-selector')).toBeInTheDocument(); + }); + + it('displays Edit and Preview toggle buttons', () => { + const props = createDefaultProps(); + render(); + + expect(screen.getByText('Edit')).toBeInTheDocument(); + expect(screen.getByText('Preview')).toBeInTheDocument(); + }); + + it('displays Run button when not locked', () => { + const props = createDefaultProps(); + render(); + + expect(screen.getByText('Run')).toBeInTheDocument(); + }); + + it('displays Stop button when batch run is active', () => { + const batchRunState: BatchRunState = { + isRunning: true, + isStopping: false, + currentTaskIndex: 0, + totalTasks: 5, + completedTasks: [], + failedTasks: [], + skippedTasks: [], + }; + const props = createDefaultProps({ batchRunState }); + render(); + + expect(screen.getByText('Stop')).toBeInTheDocument(); + }); + }); + + describe('Mode Toggling', () => { + it('calls onModeChange when clicking Edit button', async () => { + const props = createDefaultProps({ mode: 'preview' }); + render(); + + fireEvent.click(screen.getByText('Edit')); + expect(props.onModeChange).toHaveBeenCalledWith('edit'); + }); + + it('calls onModeChange when clicking Preview button', async () => { + const props = createDefaultProps({ mode: 'edit' }); + render(); + + fireEvent.click(screen.getByText('Preview')); + expect(props.onModeChange).toHaveBeenCalledWith('preview'); + }); + + it('disables Edit button when batch run is active', () => { + const batchRunState: BatchRunState = { + isRunning: true, + isStopping: false, + currentTaskIndex: 0, + totalTasks: 5, + completedTasks: [], + failedTasks: [], + skippedTasks: [], + }; + const props = createDefaultProps({ batchRunState }); + render(); + + expect(screen.getByText('Edit').closest('button')).toBeDisabled(); + }); + }); + + describe('Content Editing', () => { + it('updates local content when typing', async () => { + const props = createDefaultProps({ content: '' }); + render(); + + const textarea = screen.getByRole('textbox'); + fireEvent.change(textarea, { target: { value: 'New content' } }); + + expect(textarea).toHaveValue('New content'); + }); + + it('syncs content to parent on blur', async () => { + const props = createDefaultProps({ content: '' }); + render(); + + const textarea = screen.getByRole('textbox'); + fireEvent.focus(textarea); + fireEvent.change(textarea, { target: { value: 'New content' } }); + fireEvent.blur(textarea); + + expect(props.onContentChange).toHaveBeenCalledWith('New content'); + }); + + it('does not allow editing when locked', () => { + const batchRunState: BatchRunState = { + isRunning: true, + isStopping: false, + currentTaskIndex: 0, + totalTasks: 5, + completedTasks: [], + failedTasks: [], + skippedTasks: [], + }; + const props = createDefaultProps({ batchRunState }); + render(); + + const textarea = screen.getByRole('textbox'); + expect(textarea).toHaveAttribute('readonly'); + }); + }); + + describe('Auto-Save Functionality', () => { + it('auto-saves content after 5 seconds of inactivity', async () => { + const props = createDefaultProps({ content: 'Initial' }); + render(); + + const textarea = screen.getByRole('textbox'); + fireEvent.focus(textarea); + fireEvent.change(textarea, { target: { value: 'Updated content' } }); + + // Advance timers by 5 seconds + await act(async () => { + vi.advanceTimersByTime(5000); + }); + + expect(mockMaestro.autorun.writeDoc).toHaveBeenCalledWith( + '/test/folder', + 'test-doc.md', + 'Updated content' + ); + }); + + it('does not auto-save if content is empty', async () => { + const props = createDefaultProps({ content: 'Initial' }); + render(); + + const textarea = screen.getByRole('textbox'); + fireEvent.focus(textarea); + fireEvent.change(textarea, { target: { value: '' } }); + + await act(async () => { + vi.advanceTimersByTime(5000); + }); + + expect(mockMaestro.autorun.writeDoc).not.toHaveBeenCalled(); + }); + + it('does not auto-save if no folder is selected', async () => { + const props = createDefaultProps({ folderPath: null, content: 'Initial' }); + render(); + + await act(async () => { + vi.advanceTimersByTime(5000); + }); + + expect(mockMaestro.autorun.writeDoc).not.toHaveBeenCalled(); + }); + }); + + describe('Keyboard Shortcuts', () => { + it('toggles mode on Cmd+E', async () => { + const props = createDefaultProps({ mode: 'edit' }); + render(); + + const textarea = screen.getByRole('textbox'); + fireEvent.keyDown(textarea, { key: 'e', metaKey: true }); + + expect(props.onModeChange).toHaveBeenCalledWith('preview'); + }); + + it('inserts checkbox on Cmd+L at start of line', async () => { + const props = createDefaultProps({ content: '' }); + render(); + + const textarea = screen.getByRole('textbox') as HTMLTextAreaElement; + fireEvent.focus(textarea); + + // Set cursor position + textarea.selectionStart = 0; + textarea.selectionEnd = 0; + + fireEvent.keyDown(textarea, { key: 'l', metaKey: true }); + + // Wait for state update + await waitFor(() => { + expect(textarea.value).toBe('- [ ] '); + }); + }); + + it('inserts checkbox on new line with Cmd+L in middle of text', async () => { + const props = createDefaultProps({ content: 'Some text' }); + render(); + + const textarea = screen.getByRole('textbox') as HTMLTextAreaElement; + fireEvent.focus(textarea); + + // Set cursor position to middle + textarea.selectionStart = 5; + textarea.selectionEnd = 5; + + fireEvent.keyDown(textarea, { key: 'l', metaKey: true }); + + await waitFor(() => { + expect(textarea.value).toContain('\n- [ ] '); + }); + }); + }); + + describe('List Continuation', () => { + it('continues task list on Enter', async () => { + const props = createDefaultProps({ content: '- [ ] First task' }); + render(); + + const textarea = screen.getByRole('textbox') as HTMLTextAreaElement; + fireEvent.focus(textarea); + + // Position cursor at end of line + textarea.selectionStart = 16; + textarea.selectionEnd = 16; + + fireEvent.keyDown(textarea, { key: 'Enter' }); + + await waitFor(() => { + expect(textarea.value).toContain('- [ ] First task\n- [ ] '); + }); + }); + + it('continues unordered list with dash on Enter', async () => { + const props = createDefaultProps({ content: '- Item one' }); + render(); + + const textarea = screen.getByRole('textbox') as HTMLTextAreaElement; + fireEvent.focus(textarea); + + // Position cursor at end of line + textarea.selectionStart = 10; + textarea.selectionEnd = 10; + + fireEvent.keyDown(textarea, { key: 'Enter' }); + + await waitFor(() => { + expect(textarea.value).toContain('- Item one\n- '); + }); + }); + + it('continues ordered list and increments number on Enter', async () => { + const props = createDefaultProps({ content: '1. First item' }); + render(); + + const textarea = screen.getByRole('textbox') as HTMLTextAreaElement; + fireEvent.focus(textarea); + + // Position cursor at end of line + textarea.selectionStart = 13; + textarea.selectionEnd = 13; + + fireEvent.keyDown(textarea, { key: 'Enter' }); + + await waitFor(() => { + expect(textarea.value).toContain('1. First item\n2. '); + }); + }); + + it('preserves indentation in nested lists', async () => { + const props = createDefaultProps({ content: ' - Nested item' }); + render(); + + const textarea = screen.getByRole('textbox') as HTMLTextAreaElement; + fireEvent.focus(textarea); + + // Position cursor at end of line + textarea.selectionStart = 15; + textarea.selectionEnd = 15; + + fireEvent.keyDown(textarea, { key: 'Enter' }); + + await waitFor(() => { + expect(textarea.value).toContain(' - Nested item\n - '); + }); + }); + }); + + describe('Search Functionality', () => { + it('opens search on Cmd+F in edit mode', async () => { + const props = createDefaultProps({ mode: 'edit' }); + render(); + + const textarea = screen.getByRole('textbox'); + fireEvent.keyDown(textarea, { key: 'f', metaKey: true }); + + await waitFor(() => { + expect(screen.getByPlaceholderText(/Search/)).toBeInTheDocument(); + }); + }); + + it('closes search on Escape', async () => { + const props = createDefaultProps({ mode: 'edit' }); + render(); + + // Open search first + const textarea = screen.getByRole('textbox'); + fireEvent.keyDown(textarea, { key: 'f', metaKey: true }); + + await waitFor(() => { + expect(screen.getByPlaceholderText(/Search/)).toBeInTheDocument(); + }); + + // Close search + const searchInput = screen.getByPlaceholderText(/Search/); + fireEvent.keyDown(searchInput, { key: 'Escape' }); + + await waitFor(() => { + expect(screen.queryByPlaceholderText(/Search/)).not.toBeInTheDocument(); + }); + }); + + it('displays match count when searching', async () => { + const props = createDefaultProps({ content: 'test one test two test three' }); + render(); + + // Open search + const textarea = screen.getByRole('textbox'); + fireEvent.keyDown(textarea, { key: 'f', metaKey: true }); + + const searchInput = await screen.findByPlaceholderText(/Search/); + fireEvent.change(searchInput, { target: { value: 'test' } }); + + await waitFor(() => { + expect(screen.getByText('1/3')).toBeInTheDocument(); + }); + }); + + it('navigates to next match on Enter', async () => { + const props = createDefaultProps({ content: 'test one test two test three' }); + render(); + + // Open search + const textarea = screen.getByRole('textbox'); + fireEvent.keyDown(textarea, { key: 'f', metaKey: true }); + + const searchInput = await screen.findByPlaceholderText(/Search/); + fireEvent.change(searchInput, { target: { value: 'test' } }); + + await waitFor(() => { + expect(screen.getByText('1/3')).toBeInTheDocument(); + }); + + fireEvent.keyDown(searchInput, { key: 'Enter' }); + + await waitFor(() => { + expect(screen.getByText('2/3')).toBeInTheDocument(); + }); + }); + + it('navigates to previous match on Shift+Enter', async () => { + const props = createDefaultProps({ content: 'test one test two test three' }); + render(); + + // Open search and set query + const textarea = screen.getByRole('textbox'); + fireEvent.keyDown(textarea, { key: 'f', metaKey: true }); + + const searchInput = await screen.findByPlaceholderText(/Search/); + fireEvent.change(searchInput, { target: { value: 'test' } }); + + await waitFor(() => { + expect(screen.getByText('1/3')).toBeInTheDocument(); + }); + + // Go to prev (wraps to last match) + fireEvent.keyDown(searchInput, { key: 'Enter', shiftKey: true }); + + await waitFor(() => { + expect(screen.getByText('3/3')).toBeInTheDocument(); + }); + }); + + it('shows No matches when search has no results', async () => { + const props = createDefaultProps({ content: 'some content' }); + render(); + + // Open search + const textarea = screen.getByRole('textbox'); + fireEvent.keyDown(textarea, { key: 'f', metaKey: true }); + + const searchInput = await screen.findByPlaceholderText(/Search/); + fireEvent.change(searchInput, { target: { value: 'xyz' } }); + + await waitFor(() => { + expect(screen.getByText('No matches')).toBeInTheDocument(); + }); + }); + }); + + describe('Run/Stop Batch Processing', () => { + it('calls onOpenBatchRunner and syncs content when clicking Run', async () => { + const onOpenBatchRunner = vi.fn(); + const props = createDefaultProps({ onOpenBatchRunner, content: 'test' }); + render(); + + // Change content first + const textarea = screen.getByRole('textbox'); + fireEvent.focus(textarea); + fireEvent.change(textarea, { target: { value: 'new content' } }); + + fireEvent.click(screen.getByText('Run')); + + expect(props.onContentChange).toHaveBeenCalledWith('new content'); + expect(onOpenBatchRunner).toHaveBeenCalled(); + }); + + it('disables Run button when agent is busy', () => { + const props = createDefaultProps({ sessionState: 'busy' as SessionState }); + render(); + + expect(screen.getByText('Run').closest('button')).toBeDisabled(); + }); + + it('disables Run button when agent is connecting', () => { + const props = createDefaultProps({ sessionState: 'connecting' as SessionState }); + render(); + + expect(screen.getByText('Run').closest('button')).toBeDisabled(); + }); + + it('calls onStopBatchRun when clicking Stop', async () => { + const onStopBatchRun = vi.fn(); + const batchRunState: BatchRunState = { + isRunning: true, + isStopping: false, + currentTaskIndex: 0, + totalTasks: 5, + completedTasks: [], + failedTasks: [], + skippedTasks: [], + }; + const props = createDefaultProps({ batchRunState, onStopBatchRun }); + render(); + + fireEvent.click(screen.getByText('Stop')); + + expect(onStopBatchRun).toHaveBeenCalled(); + }); + + it('shows Stopping... when isStopping is true', () => { + const batchRunState: BatchRunState = { + isRunning: true, + isStopping: true, + currentTaskIndex: 0, + totalTasks: 5, + completedTasks: [], + failedTasks: [], + skippedTasks: [], + }; + const props = createDefaultProps({ batchRunState }); + render(); + + expect(screen.getByText('Stopping...')).toBeInTheDocument(); + }); + }); + + describe('Help Modal', () => { + it('opens help modal when clicking help button', async () => { + const props = createDefaultProps(); + render(); + + const helpButton = screen.getByTitle('Learn about Auto Runner'); + fireEvent.click(helpButton); + + expect(screen.getByTestId('help-modal')).toBeInTheDocument(); + }); + + it('closes help modal when onClose is called', async () => { + const props = createDefaultProps(); + render(); + + const helpButton = screen.getByTitle('Learn about Auto Runner'); + fireEvent.click(helpButton); + + expect(screen.getByTestId('help-modal')).toBeInTheDocument(); + + fireEvent.click(screen.getByText('Close')); + + await waitFor(() => { + expect(screen.queryByTestId('help-modal')).not.toBeInTheDocument(); + }); + }); + }); + + describe('Empty Folder State', () => { + it('shows empty state when folder has no documents', () => { + const props = createDefaultProps({ documentList: [], selectedFile: null }); + render(); + + expect(screen.getByText('No Documents Found')).toBeInTheDocument(); + expect(screen.getByText(/The selected folder doesn't contain any markdown/)).toBeInTheDocument(); + }); + + it('shows Refresh and Change Folder buttons in empty state', () => { + const props = createDefaultProps({ documentList: [], selectedFile: null }); + render(); + + // Use getAllByText since the refresh button exists in both document selector and empty state + expect(screen.getAllByText('Refresh').length).toBeGreaterThanOrEqual(1); + expect(screen.getByText('Change Folder')).toBeInTheDocument(); + }); + + it('calls onRefresh when clicking Refresh in empty state', async () => { + const props = createDefaultProps({ documentList: [], selectedFile: null }); + render(); + + // Get the Refresh button in the empty state (not in document selector) + const refreshButtons = screen.getAllByText('Refresh'); + // The second one is in the empty state UI + fireEvent.click(refreshButtons.length > 1 ? refreshButtons[1] : refreshButtons[0]); + + await waitFor(() => { + expect(props.onRefresh).toHaveBeenCalled(); + }); + }); + + it('calls onOpenSetup when clicking Change Folder in empty state', async () => { + const props = createDefaultProps({ documentList: [], selectedFile: null }); + render(); + + // Get the Change Folder button in the empty state + fireEvent.click(screen.getByText('Change Folder')); + + await waitFor(() => { + expect(props.onOpenSetup).toHaveBeenCalled(); + }); + }); + + it('shows loading indicator during refresh', async () => { + const props = createDefaultProps({ documentList: [], selectedFile: null, isLoadingDocuments: true }); + render(); + + // Loading state should not show empty state message + expect(screen.queryByText('No Documents Found')).not.toBeInTheDocument(); + }); + }); + + describe('Attachments', () => { + it('loads existing images on mount', async () => { + mockMaestro.autorun.listImages.mockResolvedValue({ + success: true, + images: [ + { filename: 'img1.png', relativePath: 'images/test-doc-123.png' }, + ], + }); + + const props = createDefaultProps(); + render(); + + await waitFor(() => { + expect(mockMaestro.autorun.listImages).toHaveBeenCalledWith('/test/folder', 'test-doc'); + }); + }); + + it('shows attachments section when there are images in edit mode', async () => { + mockMaestro.autorun.listImages.mockResolvedValue({ + success: true, + images: [ + { filename: 'img1.png', relativePath: 'images/test-doc-123.png' }, + ], + }); + + const props = createDefaultProps({ mode: 'edit' }); + render(); + + await waitFor(() => { + expect(screen.getByText(/Attached Images/)).toBeInTheDocument(); + }); + }); + + it('shows image upload button in edit mode', () => { + const props = createDefaultProps({ mode: 'edit' }); + render(); + + expect(screen.getByTitle('Add image (or paste from clipboard)')).toBeInTheDocument(); + }); + + it('hides image upload button in preview mode', () => { + const props = createDefaultProps({ mode: 'preview' }); + render(); + + expect(screen.queryByTitle('Add image (or paste from clipboard)')).not.toBeInTheDocument(); + }); + + it('hides image upload button when locked', () => { + const batchRunState: BatchRunState = { + isRunning: true, + isStopping: false, + currentTaskIndex: 0, + totalTasks: 5, + completedTasks: [], + failedTasks: [], + skippedTasks: [], + }; + const props = createDefaultProps({ batchRunState }); + render(); + + expect(screen.queryByTitle('Add image (or paste from clipboard)')).not.toBeInTheDocument(); + }); + }); + + describe('Image Paste Handling', () => { + // TODO: PENDING - NEEDS FIX - FileReader mocking is complex in jsdom + it.skip('handles image paste and inserts markdown reference', async () => { + // This test requires complex FileReader mocking that doesn't work well in jsdom + // The functionality is tested manually + }); + + it('does not handle paste when locked', async () => { + const batchRunState: BatchRunState = { + isRunning: true, + isStopping: false, + currentTaskIndex: 0, + totalTasks: 5, + completedTasks: [], + failedTasks: [], + skippedTasks: [], + }; + const props = createDefaultProps({ batchRunState }); + render(); + + const textarea = screen.getByRole('textbox'); + + const mockClipboardData = { + items: [ + { + type: 'image/png', + getAsFile: () => new File(['test'], 'test.png', { type: 'image/png' }), + }, + ], + }; + + fireEvent.paste(textarea, { clipboardData: mockClipboardData }); + + expect(mockMaestro.autorun.saveImage).not.toHaveBeenCalled(); + }); + }); + + describe('Imperative Handle (focus)', () => { + it('exposes focus method via ref', () => { + const ref = React.createRef(); + const props = createDefaultProps({ mode: 'edit' }); + render(); + + expect(ref.current).not.toBeNull(); + expect(typeof ref.current?.focus).toBe('function'); + }); + + it('focuses textarea when calling focus in edit mode', () => { + const ref = React.createRef(); + const props = createDefaultProps({ mode: 'edit' }); + render(); + + const textarea = screen.getByRole('textbox'); + ref.current?.focus(); + + expect(document.activeElement).toBe(textarea); + }); + }); + + describe('Session Switching', () => { + it('resets local content when session changes', () => { + const props = createDefaultProps({ content: 'Session 1 content' }); + const { rerender } = render(); + + const textarea = screen.getByRole('textbox'); + expect(textarea).toHaveValue('Session 1 content'); + + // Change session + rerender(); + + expect(textarea).toHaveValue('Session 2 content'); + }); + + it('syncs content when switching documents', () => { + const props = createDefaultProps({ content: 'Doc 1 content', selectedFile: 'doc1' }); + const { rerender } = render(); + + const textarea = screen.getByRole('textbox'); + expect(textarea).toHaveValue('Doc 1 content'); + + // Change document + rerender(); + + expect(textarea).toHaveValue('Doc 2 content'); + }); + }); + + describe('Scroll Position Persistence', () => { + it('accepts initial scroll positions', () => { + const props = createDefaultProps({ + initialCursorPosition: 10, + initialEditScrollPos: 100, + initialPreviewScrollPos: 50, + }); + + // This should not throw + expect(() => render()).not.toThrow(); + }); + + it('calls onStateChange when mode toggles via keyboard', async () => { + const onStateChange = vi.fn(); + const props = createDefaultProps({ mode: 'edit', onStateChange }); + render(); + + // toggleMode is called via Cmd+E, which does call onStateChange + const textarea = screen.getByRole('textbox'); + fireEvent.keyDown(textarea, { key: 'e', metaKey: true }); + + expect(onStateChange).toHaveBeenCalledWith(expect.objectContaining({ + mode: 'preview', + })); + }); + }); + + describe('Memoization', () => { + it('does not re-render when irrelevant props change', () => { + const props = createDefaultProps(); + const { rerender } = render(); + + // Re-render with same essential props but different callback references + // The memo comparison should prevent unnecessary re-renders + // This is more of an integration test, verifying the memo function exists + expect(() => { + rerender(); + }).not.toThrow(); + }); + }); + + describe('Preview Mode Features', () => { + it('opens search with / key in preview mode', async () => { + const props = createDefaultProps({ mode: 'preview' }); + render(); + + // Find the preview container and trigger keydown + const previewContainer = screen.getByTestId('react-markdown').parentElement!; + fireEvent.keyDown(previewContainer, { key: '/' }); + + await waitFor(() => { + expect(screen.getByPlaceholderText(/Search/)).toBeInTheDocument(); + }); + }); + }); + + describe('Document Selector Integration', () => { + it('calls onSelectDocument when document is selected', async () => { + const props = createDefaultProps(); + render(); + + const select = screen.getByTestId('doc-select'); + fireEvent.change(select, { target: { value: 'another-doc' } }); + + expect(props.onSelectDocument).toHaveBeenCalledWith('another-doc'); + }); + + it('calls onRefresh when refresh button is clicked', async () => { + const props = createDefaultProps(); + render(); + + fireEvent.click(screen.getByTestId('refresh-btn')); + + expect(props.onRefresh).toHaveBeenCalled(); + }); + + it('calls onOpenSetup when change folder button is clicked', async () => { + const props = createDefaultProps(); + render(); + + fireEvent.click(screen.getByTestId('change-folder-btn')); + + expect(props.onOpenSetup).toHaveBeenCalled(); + }); + + it('passes isLoading to document selector', () => { + const props = createDefaultProps({ isLoadingDocuments: true }); + render(); + + expect(screen.getByTestId('loading-indicator')).toBeInTheDocument(); + }); + }); + + describe('Auto-switch Mode on Batch Run', () => { + it('switches to preview mode when batch run starts', () => { + const props = createDefaultProps({ mode: 'edit' }); + const { rerender } = render(); + + // Start batch run + const batchRunState: BatchRunState = { + isRunning: true, + isStopping: false, + currentTaskIndex: 0, + totalTasks: 5, + completedTasks: [], + failedTasks: [], + skippedTasks: [], + }; + rerender(); + + expect(props.onModeChange).toHaveBeenCalledWith('preview'); + }); + }); + + describe('Legacy onChange Prop', () => { + // TODO: PENDING - NEEDS FIX - Legacy onChange requires deep integration testing + // The component's internal state management makes it hard to test the legacy path + // without modifying source code to expose internals + it.skip('falls back to onChange when onContentChange is not provided', async () => { + // This test verifies legacy behavior that is complex to test in isolation + // The functionality has been tested manually + }); + }); + + describe('Textarea Placeholder', () => { + it('shows placeholder text in edit mode', () => { + const props = createDefaultProps({ content: '' }); + render(); + + const textarea = screen.getByPlaceholderText(/Capture notes, images, and tasks/); + expect(textarea).toBeInTheDocument(); + }); + }); + + describe('Container Keyboard Handling', () => { + it('handles Cmd+E on container level', async () => { + const props = createDefaultProps({ mode: 'edit' }); + const { container } = render(); + + const outerContainer = container.firstChild as HTMLElement; + fireEvent.keyDown(outerContainer, { key: 'e', metaKey: true }); + + expect(props.onModeChange).toHaveBeenCalledWith('preview'); + }); + + it('handles Cmd+F on container level', async () => { + const props = createDefaultProps({ mode: 'edit' }); + const { container } = render(); + + const outerContainer = container.firstChild as HTMLElement; + fireEvent.keyDown(outerContainer, { key: 'f', metaKey: true }); + + await waitFor(() => { + expect(screen.getByPlaceholderText(/Search/)).toBeInTheDocument(); + }); + }); + }); + + describe('Preview Mode Content', () => { + it('shows default message when content is empty in preview mode', () => { + const props = createDefaultProps({ mode: 'preview', content: '' }); + render(); + + expect(screen.getByTestId('react-markdown')).toHaveTextContent('No content yet'); + }); + }); +}); + +describe('AutoRun.imageCache', () => { + // Note: imageCache is a module-level Map that caches loaded images + // It cannot be directly tested without exposing it, but we can verify + // the caching behavior indirectly through repeated renders + + it('component loads without throwing when images are present', async () => { + const mockMaestro = setupMaestroMock(); + mockMaestro.autorun.listImages.mockResolvedValue({ + success: true, + images: [{ filename: 'test.png', relativePath: 'images/test.png' }], + }); + + const props = createDefaultProps(); + expect(() => render()).not.toThrow(); + + await waitFor(() => { + expect(mockMaestro.autorun.listImages).toHaveBeenCalled(); + }); + }); +}); + +describe('Undo/Redo Functionality', () => { + let mockMaestro: ReturnType; + + beforeEach(() => { + mockMaestro = setupMaestroMock(); + vi.useFakeTimers({ shouldAdvanceTime: true }); + }); + + afterEach(() => { + vi.clearAllMocks(); + vi.useRealTimers(); + }); + + it('handles Cmd+Z keyboard shortcut', async () => { + const props = createDefaultProps({ content: 'Initial content' }); + render(); + + const textarea = screen.getByRole('textbox') as HTMLTextAreaElement; + fireEvent.focus(textarea); + + // Type new content + fireEvent.change(textarea, { target: { value: 'New content' } }); + expect(textarea).toHaveValue('New content'); + + // Trigger undo (preventDefault should be called even if stack is empty) + const event = new KeyboardEvent('keydown', { key: 'z', metaKey: true, bubbles: true }); + textarea.dispatchEvent(event); + + // Component should handle the shortcut without error + expect(textarea).toBeDefined(); + }); + + it('handles Cmd+Shift+Z keyboard shortcut', async () => { + const props = createDefaultProps({ content: 'Original' }); + render(); + + const textarea = screen.getByRole('textbox') as HTMLTextAreaElement; + fireEvent.focus(textarea); + + // Trigger redo shortcut + fireEvent.keyDown(textarea, { key: 'z', metaKey: true, shiftKey: true }); + + // Component should handle the shortcut without error + expect(textarea).toBeDefined(); + }); + + it('does not change content when undo stack is empty', async () => { + const props = createDefaultProps({ content: 'Initial' }); + render(); + + const textarea = screen.getByRole('textbox'); + fireEvent.focus(textarea); + + // Try to undo with no history + fireEvent.keyDown(textarea, { key: 'z', metaKey: true }); + + // Content should remain unchanged + expect(textarea).toHaveValue('Initial'); + }); +}); + +describe('Lightbox Functionality', () => { + let mockMaestro: ReturnType; + + beforeEach(() => { + mockMaestro = setupMaestroMock(); + vi.useFakeTimers({ shouldAdvanceTime: true }); + }); + + afterEach(() => { + vi.clearAllMocks(); + vi.useRealTimers(); + }); + + it('opens lightbox when clicking an image', async () => { + mockMaestro.autorun.listImages.mockResolvedValue({ + success: true, + images: [{ filename: 'test.png', relativePath: 'images/test.png' }], + }); + mockMaestro.fs.readFile.mockResolvedValue('data:image/png;base64,abc123'); + + const props = createDefaultProps({ mode: 'edit' }); + render(); + + // Wait for attachments to load + await waitFor(() => { + expect(screen.getByText(/Attached Images/)).toBeInTheDocument(); + }); + + // Wait for preview image to load + await waitFor(() => { + const imgs = screen.getAllByRole('img'); + expect(imgs.length).toBeGreaterThanOrEqual(1); + }); + + // Click on image thumbnail to open lightbox + const imgs = screen.getAllByRole('img'); + fireEvent.click(imgs[0]); + + // Lightbox should open - look for lightbox image or controls + await waitFor(() => { + // Check for close button or ESC hint + expect(screen.getByText(/ESC to close/)).toBeInTheDocument(); + }); + }); + + it('closes lightbox on Escape key', async () => { + mockMaestro.autorun.listImages.mockResolvedValue({ + success: true, + images: [{ filename: 'test.png', relativePath: 'images/test.png' }], + }); + mockMaestro.fs.readFile.mockResolvedValue('data:image/png;base64,abc123'); + + const props = createDefaultProps({ mode: 'edit' }); + render(); + + // Wait for attachments and open lightbox + await waitFor(() => { + expect(screen.getByText(/Attached Images/)).toBeInTheDocument(); + }); + + await waitFor(() => { + const imgs = screen.getAllByRole('img'); + expect(imgs.length).toBeGreaterThanOrEqual(1); + }); + + const imgs = screen.getAllByRole('img'); + fireEvent.click(imgs[0]); + + await waitFor(() => { + expect(screen.getByText(/ESC to close/)).toBeInTheDocument(); + }); + + // Press Escape to close + fireEvent.keyDown(document.activeElement || document.body, { key: 'Escape' }); + + await waitFor(() => { + expect(screen.queryByText(/ESC to close/)).not.toBeInTheDocument(); + }); + }); + + it('shows navigation buttons when multiple images are present', async () => { + mockMaestro.autorun.listImages.mockResolvedValue({ + success: true, + images: [ + { filename: 'img1.png', relativePath: 'images/img1.png' }, + { filename: 'img2.png', relativePath: 'images/img2.png' }, + ], + }); + mockMaestro.fs.readFile.mockResolvedValue('data:image/png;base64,abc123'); + + const props = createDefaultProps({ mode: 'edit' }); + render(); + + // Wait for attachments + await waitFor(() => { + expect(screen.getByText(/Attached Images \(2\)/)).toBeInTheDocument(); + }); + + await waitFor(() => { + const imgs = screen.getAllByRole('img'); + expect(imgs.length).toBeGreaterThanOrEqual(2); + }); + + // Open lightbox on first image + const imgs = screen.getAllByRole('img'); + fireEvent.click(imgs[0]); + + // Wait for lightbox to open with navigation + await waitFor(() => { + expect(screen.getByText(/Image 1 of 2/)).toBeInTheDocument(); + }); + + // Navigation buttons should be present + expect(screen.getByTitle('Previous image (←)')).toBeInTheDocument(); + expect(screen.getByTitle('Next image (→)')).toBeInTheDocument(); + }); + + it('navigates to next image via button click', async () => { + mockMaestro.autorun.listImages.mockResolvedValue({ + success: true, + images: [ + { filename: 'img1.png', relativePath: 'images/img1.png' }, + { filename: 'img2.png', relativePath: 'images/img2.png' }, + ], + }); + mockMaestro.fs.readFile.mockResolvedValue('data:image/png;base64,abc123'); + + const props = createDefaultProps({ mode: 'edit' }); + render(); + + // Wait for attachments + await waitFor(() => { + expect(screen.getByText(/Attached Images \(2\)/)).toBeInTheDocument(); + }); + + await waitFor(() => { + const imgs = screen.getAllByRole('img'); + expect(imgs.length).toBeGreaterThanOrEqual(2); + }); + + // Open lightbox on first image + const imgs = screen.getAllByRole('img'); + fireEvent.click(imgs[0]); + + await waitFor(() => { + expect(screen.getByText(/Image 1 of 2/)).toBeInTheDocument(); + }); + + // Click next button + const nextButton = screen.getByTitle('Next image (→)'); + fireEvent.click(nextButton); + + await waitFor(() => { + expect(screen.getByText(/Image 2 of 2/)).toBeInTheDocument(); + }); + }); + + it('navigates to previous image via button click', async () => { + mockMaestro.autorun.listImages.mockResolvedValue({ + success: true, + images: [ + { filename: 'img1.png', relativePath: 'images/img1.png' }, + { filename: 'img2.png', relativePath: 'images/img2.png' }, + ], + }); + mockMaestro.fs.readFile.mockResolvedValue('data:image/png;base64,abc123'); + + const props = createDefaultProps({ mode: 'edit' }); + render(); + + // Wait for attachments + await waitFor(() => { + expect(screen.getByText(/Attached Images \(2\)/)).toBeInTheDocument(); + }); + + await waitFor(() => { + const imgs = screen.getAllByRole('img'); + expect(imgs.length).toBeGreaterThanOrEqual(2); + }); + + // Open lightbox on second image + const imgs = screen.getAllByRole('img'); + fireEvent.click(imgs[1]); + + await waitFor(() => { + expect(screen.getByText(/Image 2 of 2/)).toBeInTheDocument(); + }); + + // Click prev button + const prevButton = screen.getByTitle('Previous image (←)'); + fireEvent.click(prevButton); + + await waitFor(() => { + expect(screen.getByText(/Image 1 of 2/)).toBeInTheDocument(); + }); + }); + + it('navigates to next image via ArrowRight key', async () => { + mockMaestro.autorun.listImages.mockResolvedValue({ + success: true, + images: [ + { filename: 'img1.png', relativePath: 'images/img1.png' }, + { filename: 'img2.png', relativePath: 'images/img2.png' }, + ], + }); + mockMaestro.fs.readFile.mockResolvedValue('data:image/png;base64,abc123'); + + const props = createDefaultProps({ mode: 'edit' }); + render(); + + // Wait for attachments + await waitFor(() => { + expect(screen.getByText(/Attached Images \(2\)/)).toBeInTheDocument(); + }); + + await waitFor(() => { + const imgs = screen.getAllByRole('img'); + expect(imgs.length).toBeGreaterThanOrEqual(2); + }); + + // Open lightbox on first image + const imgs = screen.getAllByRole('img'); + fireEvent.click(imgs[0]); + + await waitFor(() => { + expect(screen.getByText(/Image 1 of 2/)).toBeInTheDocument(); + }); + + // Press ArrowRight key + fireEvent.keyDown(document.activeElement || document.body, { key: 'ArrowRight' }); + + await waitFor(() => { + expect(screen.getByText(/Image 2 of 2/)).toBeInTheDocument(); + }); + }); + + it('navigates to previous image via ArrowLeft key', async () => { + mockMaestro.autorun.listImages.mockResolvedValue({ + success: true, + images: [ + { filename: 'img1.png', relativePath: 'images/img1.png' }, + { filename: 'img2.png', relativePath: 'images/img2.png' }, + ], + }); + mockMaestro.fs.readFile.mockResolvedValue('data:image/png;base64,abc123'); + + const props = createDefaultProps({ mode: 'edit' }); + render(); + + // Wait for attachments + await waitFor(() => { + expect(screen.getByText(/Attached Images \(2\)/)).toBeInTheDocument(); + }); + + await waitFor(() => { + const imgs = screen.getAllByRole('img'); + expect(imgs.length).toBeGreaterThanOrEqual(2); + }); + + // Open lightbox on second image + const imgs = screen.getAllByRole('img'); + fireEvent.click(imgs[1]); + + await waitFor(() => { + expect(screen.getByText(/Image 2 of 2/)).toBeInTheDocument(); + }); + + // Press ArrowLeft key + fireEvent.keyDown(document.activeElement || document.body, { key: 'ArrowLeft' }); + + await waitFor(() => { + expect(screen.getByText(/Image 1 of 2/)).toBeInTheDocument(); + }); + }); + + it('closes lightbox via close button click', async () => { + mockMaestro.autorun.listImages.mockResolvedValue({ + success: true, + images: [{ filename: 'test.png', relativePath: 'images/test.png' }], + }); + mockMaestro.fs.readFile.mockResolvedValue('data:image/png;base64,abc123'); + + const props = createDefaultProps({ mode: 'edit' }); + render(); + + // Wait for attachments + await waitFor(() => { + expect(screen.getByText(/Attached Images/)).toBeInTheDocument(); + }); + + await waitFor(() => { + const imgs = screen.getAllByRole('img'); + expect(imgs.length).toBeGreaterThanOrEqual(1); + }); + + // Open lightbox + const imgs = screen.getAllByRole('img'); + fireEvent.click(imgs[0]); + + await waitFor(() => { + expect(screen.getByText(/ESC to close/)).toBeInTheDocument(); + }); + + // Click close button + const closeButton = screen.getByTitle('Close (ESC)'); + fireEvent.click(closeButton); + + await waitFor(() => { + expect(screen.queryByText(/ESC to close/)).not.toBeInTheDocument(); + }); + }); + + it('deletes image via delete button in lightbox', async () => { + mockMaestro.autorun.listImages.mockResolvedValue({ + success: true, + images: [{ filename: 'test.png', relativePath: 'images/test.png' }], + }); + mockMaestro.fs.readFile.mockResolvedValue('data:image/png;base64,abc123'); + mockMaestro.autorun.deleteImage.mockResolvedValue({ success: true }); + + const content = '# Test\n![test.png](images/test.png)\n'; + const props = createDefaultProps({ content, mode: 'edit' }); + render(); + + // Wait for attachments + await waitFor(() => { + expect(screen.getByText(/Attached Images/)).toBeInTheDocument(); + }); + + await waitFor(() => { + const imgs = screen.getAllByRole('img'); + expect(imgs.length).toBeGreaterThanOrEqual(1); + }); + + // Open lightbox + const imgs = screen.getAllByRole('img'); + fireEvent.click(imgs[0]); + + await waitFor(() => { + expect(screen.getByText(/ESC to close/)).toBeInTheDocument(); + }); + + // Click delete button + const deleteButton = screen.getByTitle('Delete image (Delete key)'); + fireEvent.click(deleteButton); + + // Verify delete was called + await waitFor(() => { + expect(mockMaestro.autorun.deleteImage).toHaveBeenCalledWith('/test/folder', 'images/test.png'); + }); + + // Lightbox should close after deleting the only image + await waitFor(() => { + expect(screen.queryByText(/ESC to close/)).not.toBeInTheDocument(); + }); + }); + + it('deletes image via Delete/Backspace key in lightbox', async () => { + mockMaestro.autorun.listImages.mockResolvedValue({ + success: true, + images: [{ filename: 'test.png', relativePath: 'images/test.png' }], + }); + mockMaestro.fs.readFile.mockResolvedValue('data:image/png;base64,abc123'); + mockMaestro.autorun.deleteImage.mockResolvedValue({ success: true }); + + const content = '# Test\n![test.png](images/test.png)\n'; + const props = createDefaultProps({ content, mode: 'edit' }); + render(); + + // Wait for attachments + await waitFor(() => { + expect(screen.getByText(/Attached Images/)).toBeInTheDocument(); + }); + + await waitFor(() => { + const imgs = screen.getAllByRole('img'); + expect(imgs.length).toBeGreaterThanOrEqual(1); + }); + + // Open lightbox + const imgs = screen.getAllByRole('img'); + fireEvent.click(imgs[0]); + + await waitFor(() => { + expect(screen.getByText(/ESC to close/)).toBeInTheDocument(); + }); + + // Press Delete key + fireEvent.keyDown(document.activeElement || document.body, { key: 'Delete' }); + + // Verify delete was called + await waitFor(() => { + expect(mockMaestro.autorun.deleteImage).toHaveBeenCalledWith('/test/folder', 'images/test.png'); + }); + }); + + it('renders copy button in lightbox and handles click', async () => { + mockMaestro.autorun.listImages.mockResolvedValue({ + success: true, + images: [{ filename: 'test.png', relativePath: 'images/test.png' }], + }); + mockMaestro.fs.readFile.mockResolvedValue('data:image/png;base64,abc123'); + + const props = createDefaultProps({ mode: 'edit' }); + render(); + + // Wait for attachments + await waitFor(() => { + expect(screen.getByText(/Attached Images/)).toBeInTheDocument(); + }); + + await waitFor(() => { + const imgs = screen.getAllByRole('img'); + expect(imgs.length).toBeGreaterThanOrEqual(1); + }); + + // Open lightbox + const imgs = screen.getAllByRole('img'); + fireEvent.click(imgs[0]); + + await waitFor(() => { + expect(screen.getByText(/ESC to close/)).toBeInTheDocument(); + }); + + // Verify copy button is present + const copyButton = screen.getByTitle('Copy image to clipboard'); + expect(copyButton).toBeInTheDocument(); + + // Click it - the actual clipboard copy may fail but we're testing the button renders/clicks + fireEvent.click(copyButton); + + // The button should still be there + expect(screen.getByTitle('Copy image to clipboard')).toBeInTheDocument(); + }); + + it('closes lightbox when clicking overlay background', async () => { + mockMaestro.autorun.listImages.mockResolvedValue({ + success: true, + images: [{ filename: 'test.png', relativePath: 'images/test.png' }], + }); + mockMaestro.fs.readFile.mockResolvedValue('data:image/png;base64,abc123'); + + const props = createDefaultProps({ mode: 'edit' }); + render(); + + // Wait for attachments + await waitFor(() => { + expect(screen.getByText(/Attached Images/)).toBeInTheDocument(); + }); + + await waitFor(() => { + const imgs = screen.getAllByRole('img'); + expect(imgs.length).toBeGreaterThanOrEqual(1); + }); + + // Open lightbox + const imgs = screen.getAllByRole('img'); + fireEvent.click(imgs[0]); + + await waitFor(() => { + expect(screen.getByText(/ESC to close/)).toBeInTheDocument(); + }); + + // Find and click the overlay background (the parent div with bg-black/90) + const overlay = screen.getByText(/ESC to close/).closest('.fixed'); + if (overlay) { + fireEvent.click(overlay); + } + + // Lightbox should close + await waitFor(() => { + expect(screen.queryByText(/ESC to close/)).not.toBeInTheDocument(); + }); + }); + + it('does not close lightbox when clicking on the image itself', async () => { + mockMaestro.autorun.listImages.mockResolvedValue({ + success: true, + images: [{ filename: 'test.png', relativePath: 'images/test.png' }], + }); + mockMaestro.fs.readFile.mockResolvedValue('data:image/png;base64,abc123'); + + const props = createDefaultProps({ mode: 'edit' }); + render(); + + // Wait for attachments + await waitFor(() => { + expect(screen.getByText(/Attached Images/)).toBeInTheDocument(); + }); + + await waitFor(() => { + const imgs = screen.getAllByRole('img'); + expect(imgs.length).toBeGreaterThanOrEqual(1); + }); + + // Open lightbox + const thumbnailImgs = screen.getAllByRole('img'); + fireEvent.click(thumbnailImgs[0]); + + await waitFor(() => { + expect(screen.getByText(/ESC to close/)).toBeInTheDocument(); + }); + + // Find and click the lightbox image (the one in the overlay) + const lightboxImages = screen.getAllByRole('img'); + // Find the main lightbox image (not thumbnail) + const mainImage = lightboxImages.find(img => img.classList.contains('max-w-[90%]')); + if (mainImage) { + fireEvent.click(mainImage); + } + + // Lightbox should still be open + expect(screen.getByText(/ESC to close/)).toBeInTheDocument(); + }); + + it('navigates after deleting middle image in carousel', async () => { + mockMaestro.autorun.listImages.mockResolvedValue({ + success: true, + images: [ + { filename: 'img1.png', relativePath: 'images/img1.png' }, + { filename: 'img2.png', relativePath: 'images/img2.png' }, + { filename: 'img3.png', relativePath: 'images/img3.png' }, + ], + }); + mockMaestro.fs.readFile.mockResolvedValue('data:image/png;base64,abc123'); + mockMaestro.autorun.deleteImage.mockResolvedValue({ success: true }); + + const content = '# Test\n![img1.png](images/img1.png)\n![img2.png](images/img2.png)\n![img3.png](images/img3.png)\n'; + const props = createDefaultProps({ content, mode: 'edit' }); + render(); + + // Wait for attachments + await waitFor(() => { + expect(screen.getByText(/Attached Images \(3\)/)).toBeInTheDocument(); + }); + + await waitFor(() => { + const imgs = screen.getAllByRole('img'); + expect(imgs.length).toBeGreaterThanOrEqual(3); + }); + + // Open lightbox on second image + const imgs = screen.getAllByRole('img'); + fireEvent.click(imgs[1]); + + await waitFor(() => { + expect(screen.getByText(/Image 2 of 3/)).toBeInTheDocument(); + }); + + // Delete the middle image + const deleteButton = screen.getByTitle('Delete image (Delete key)'); + fireEvent.click(deleteButton); + + // Verify delete was called + await waitFor(() => { + expect(mockMaestro.autorun.deleteImage).toHaveBeenCalled(); + }); + }); +}); + +describe('Attachment Management', () => { + let mockMaestro: ReturnType; + + beforeEach(() => { + mockMaestro = setupMaestroMock(); + vi.useFakeTimers({ shouldAdvanceTime: true }); + }); + + afterEach(() => { + vi.clearAllMocks(); + vi.useRealTimers(); + }); + + it('removes attachment when clicking remove button', async () => { + mockMaestro.autorun.listImages.mockResolvedValue({ + success: true, + images: [{ filename: 'test.png', relativePath: 'images/test.png' }], + }); + mockMaestro.fs.readFile.mockResolvedValue('data:image/png;base64,abc123'); + mockMaestro.autorun.deleteImage.mockResolvedValue({ success: true }); + + const content = '# Test\n![test.png](images/test.png)\n'; + const props = createDefaultProps({ content, mode: 'edit' }); + render(); + + // Wait for attachments + await waitFor(() => { + expect(screen.getByText(/Attached Images/)).toBeInTheDocument(); + }); + + // Find and click the remove button (X button on image preview) + await waitFor(() => { + const removeButtons = screen.getAllByTitle('Remove image'); + expect(removeButtons.length).toBeGreaterThanOrEqual(1); + }); + + const removeButton = screen.getAllByTitle('Remove image')[0]; + fireEvent.click(removeButton); + + // Verify delete was called + await waitFor(() => { + expect(mockMaestro.autorun.deleteImage).toHaveBeenCalledWith('/test/folder', 'images/test.png'); + }); + }); + + it('clears attachments when no document is selected', async () => { + const props = createDefaultProps({ selectedFile: null }); + render(); + + // Should not show attachments section + expect(screen.queryByText(/Attached Images/)).not.toBeInTheDocument(); + }); + + // TODO: PENDING - NEEDS FIX - FileReader mocking in jsdom is complex + // The file upload functionality works in the real environment but jsdom + // doesn't properly support FileReader constructor mocking + it.skip('handles image upload via file input', async () => { + // This test requires complex FileReader mocking that doesn't work well in jsdom + // The functionality is tested manually + }); + + it('expands and collapses attachments section', async () => { + mockMaestro.autorun.listImages.mockResolvedValue({ + success: true, + images: [{ filename: 'test.png', relativePath: 'images/test.png' }], + }); + mockMaestro.fs.readFile.mockResolvedValue('data:image/png;base64,abc123'); + + const props = createDefaultProps({ mode: 'edit' }); + render(); + + // Wait for attachments + await waitFor(() => { + expect(screen.getByText(/Attached Images/)).toBeInTheDocument(); + }); + + // Attachments should be expanded by default + const button = screen.getByText(/Attached Images/).closest('button')!; + + // Click to collapse + fireEvent.click(button); + + // Images should be hidden now - check that the image count is still shown but the images aren't + await waitFor(() => { + const imgs = screen.queryAllByRole('img'); + // After collapse, image thumbnails should not be visible + expect(imgs.length).toBe(0); + }); + }); +}); + +describe('Mode Restoration After Batch Run', () => { + let mockMaestro: ReturnType; + + beforeEach(() => { + mockMaestro = setupMaestroMock(); + vi.useFakeTimers({ shouldAdvanceTime: true }); + }); + + afterEach(() => { + vi.clearAllMocks(); + vi.useRealTimers(); + }); + + it('restores previous mode when batch run ends', async () => { + const onModeChange = vi.fn(); + const props = createDefaultProps({ mode: 'edit', onModeChange }); + const { rerender } = render(); + + // Start batch run (this switches to preview mode) + const batchRunState: BatchRunState = { + isRunning: true, + isStopping: false, + currentTaskIndex: 0, + totalTasks: 5, + completedTasks: [], + failedTasks: [], + skippedTasks: [], + }; + rerender(); + + // Should have called onModeChange to switch to preview + expect(onModeChange).toHaveBeenCalledWith('preview'); + onModeChange.mockClear(); + + // End batch run + rerender(); + + // Should restore to edit mode + await waitFor(() => { + expect(onModeChange).toHaveBeenCalledWith('edit'); + }); + }); +}); + +describe('Empty State Refresh', () => { + let mockMaestro: ReturnType; + + beforeEach(() => { + mockMaestro = setupMaestroMock(); + vi.useFakeTimers({ shouldAdvanceTime: true }); + }); + + afterEach(() => { + vi.clearAllMocks(); + vi.useRealTimers(); + }); + + it('shows spinner during refresh in empty state', async () => { + const onRefresh = vi.fn().mockImplementation(() => new Promise(resolve => setTimeout(resolve, 100))); + const props = createDefaultProps({ + documentList: [], + selectedFile: null, + onRefresh + }); + render(); + + // Find and click the Refresh button + const refreshButtons = screen.getAllByText('Refresh'); + const emptyStateRefresh = refreshButtons[refreshButtons.length - 1]; + fireEvent.click(emptyStateRefresh); + + // The button should show animation class + expect(onRefresh).toHaveBeenCalled(); + }); +}); + +describe('Search Bar Navigation Buttons', () => { + let mockMaestro: ReturnType; + + beforeEach(() => { + mockMaestro = setupMaestroMock(); + vi.useFakeTimers({ shouldAdvanceTime: true }); + }); + + afterEach(() => { + vi.clearAllMocks(); + vi.useRealTimers(); + }); + + it('navigates with chevron up and down buttons', async () => { + const props = createDefaultProps({ content: 'test test test test' }); + render(); + + const textarea = screen.getByRole('textbox'); + fireEvent.keyDown(textarea, { key: 'f', metaKey: true }); + + const searchInput = await screen.findByPlaceholderText(/Search/); + fireEvent.change(searchInput, { target: { value: 'test' } }); + + await waitFor(() => { + expect(screen.getByText('1/4')).toBeInTheDocument(); + }); + + // Click next button + const nextButton = screen.getByTitle('Next match (Enter)'); + fireEvent.click(nextButton); + + await waitFor(() => { + expect(screen.getByText('2/4')).toBeInTheDocument(); + }); + + // Click previous button + const prevButton = screen.getByTitle('Previous match (Shift+Enter)'); + fireEvent.click(prevButton); + + await waitFor(() => { + expect(screen.getByText('1/4')).toBeInTheDocument(); + }); + }); + + it('closes search when clicking close button', async () => { + const props = createDefaultProps({ mode: 'edit' }); + render(); + + const textarea = screen.getByRole('textbox'); + fireEvent.keyDown(textarea, { key: 'f', metaKey: true }); + + await waitFor(() => { + expect(screen.getByPlaceholderText(/Search/)).toBeInTheDocument(); + }); + + // Click close button + const closeButton = screen.getByTitle('Close search (Esc)'); + fireEvent.click(closeButton); + + await waitFor(() => { + expect(screen.queryByPlaceholderText(/Search/)).not.toBeInTheDocument(); + }); + }); +}); + +describe('Scroll Position Persistence', () => { + let mockMaestro: ReturnType; + + beforeEach(() => { + mockMaestro = setupMaestroMock(); + vi.useFakeTimers({ shouldAdvanceTime: true }); + }); + + afterEach(() => { + vi.clearAllMocks(); + vi.useRealTimers(); + }); + + it('calls onStateChange when scrolling in preview mode', async () => { + const onStateChange = vi.fn(); + const props = createDefaultProps({ mode: 'preview', onStateChange, content: 'Line\n'.repeat(100) }); + render(); + + const preview = screen.getByTestId('react-markdown').parentElement!; + fireEvent.scroll(preview); + + // onStateChange should be called with scroll position + expect(onStateChange).toHaveBeenCalled(); + }); +}); + +describe('Focus via Imperative Handle', () => { + it('focuses preview container when calling focus in preview mode', () => { + const ref = React.createRef(); + const props = createDefaultProps({ mode: 'preview' }); + render(); + + const preview = screen.getByTestId('react-markdown').parentElement!; + ref.current?.focus(); + + expect(document.activeElement).toBe(preview); + }); +}); + +describe('Control Key Support (Windows/Linux)', () => { + let mockMaestro: ReturnType; + + beforeEach(() => { + mockMaestro = setupMaestroMock(); + vi.useFakeTimers({ shouldAdvanceTime: true }); + }); + + afterEach(() => { + vi.clearAllMocks(); + vi.useRealTimers(); + }); + + it('toggles mode on Ctrl+E (Windows/Linux)', async () => { + const props = createDefaultProps({ mode: 'edit' }); + render(); + + const textarea = screen.getByRole('textbox'); + fireEvent.keyDown(textarea, { key: 'e', ctrlKey: true }); + + expect(props.onModeChange).toHaveBeenCalledWith('preview'); + }); + + it('opens search on Ctrl+F (Windows/Linux)', async () => { + const props = createDefaultProps({ mode: 'edit' }); + render(); + + const textarea = screen.getByRole('textbox'); + fireEvent.keyDown(textarea, { key: 'f', ctrlKey: true }); + + await waitFor(() => { + expect(screen.getByPlaceholderText(/Search/)).toBeInTheDocument(); + }); + }); + + it('inserts checkbox on Ctrl+L (Windows/Linux)', async () => { + const props = createDefaultProps({ content: '' }); + render(); + + const textarea = screen.getByRole('textbox') as HTMLTextAreaElement; + fireEvent.focus(textarea); + textarea.selectionStart = 0; + textarea.selectionEnd = 0; + + fireEvent.keyDown(textarea, { key: 'l', ctrlKey: true }); + + await waitFor(() => { + expect(textarea.value).toBe('- [ ] '); + }); + }); +}); + +describe('Preview Mode with Search', () => { + let mockMaestro: ReturnType; + + beforeEach(() => { + mockMaestro = setupMaestroMock(); + vi.useFakeTimers({ shouldAdvanceTime: true }); + }); + + afterEach(() => { + vi.clearAllMocks(); + vi.useRealTimers(); + }); + + it('shows SearchHighlightedContent when searching in preview mode', async () => { + const props = createDefaultProps({ mode: 'preview', content: 'Find this text' }); + render(); + + const preview = screen.getByTestId('react-markdown').parentElement!; + fireEvent.keyDown(preview, { key: '/' }); + + const searchInput = await screen.findByPlaceholderText(/Search/); + fireEvent.change(searchInput, { target: { value: 'Find' } }); + + await waitFor(() => { + expect(screen.getByText('1/1')).toBeInTheDocument(); + }); + }); + + it('toggles mode with Cmd+E from preview', async () => { + const props = createDefaultProps({ mode: 'preview' }); + render(); + + const preview = screen.getByTestId('react-markdown').parentElement!; + fireEvent.keyDown(preview, { key: 'e', metaKey: true }); + + expect(props.onModeChange).toHaveBeenCalledWith('edit'); + }); +}); + +describe('Batch Run State UI', () => { + let mockMaestro: ReturnType; + + beforeEach(() => { + mockMaestro = setupMaestroMock(); + vi.useFakeTimers({ shouldAdvanceTime: true }); + }); + + afterEach(() => { + vi.clearAllMocks(); + vi.useRealTimers(); + }); + + it('shows task progress in batch run state', () => { + const batchRunState: BatchRunState = { + isRunning: true, + isStopping: false, + currentTaskIndex: 2, + totalTasks: 5, + completedTasks: ['task1', 'task2'], + failedTasks: [], + skippedTasks: [], + }; + const props = createDefaultProps({ batchRunState }); + render(); + + // Stop button should be visible + expect(screen.getByText('Stop')).toBeInTheDocument(); + // Edit button should be disabled + expect(screen.getByText('Edit').closest('button')).toBeDisabled(); + }); + + it('shows textarea as readonly when locked', () => { + const batchRunState: BatchRunState = { + isRunning: true, + isStopping: false, + currentTaskIndex: 0, + totalTasks: 5, + completedTasks: [], + failedTasks: [], + skippedTasks: [], + }; + const props = createDefaultProps({ batchRunState, mode: 'edit' }); + render(); + + const textarea = screen.getByRole('textbox'); + expect(textarea).toHaveAttribute('readonly'); + expect(textarea).toHaveClass('cursor-not-allowed'); + }); +}); + +describe('Content Sync Edge Cases', () => { + let mockMaestro: ReturnType; + + beforeEach(() => { + mockMaestro = setupMaestroMock(); + vi.useFakeTimers({ shouldAdvanceTime: true }); + }); + + afterEach(() => { + vi.clearAllMocks(); + vi.useRealTimers(); + }); + + it('syncs content from prop when switching documents', () => { + const props = createDefaultProps({ content: 'Doc 1 content', selectedFile: 'doc1' }); + const { rerender } = render(); + + const textarea = screen.getByRole('textbox'); + expect(textarea).toHaveValue('Doc 1 content'); + + // Switch to different document - this should sync content + rerender(); + + expect(textarea).toHaveValue('Doc 2 content'); + }); + + it('does not overwrite local changes when content prop changes during editing', async () => { + const props = createDefaultProps({ content: 'Initial' }); + const { rerender } = render(); + + const textarea = screen.getByRole('textbox'); + fireEvent.focus(textarea); + fireEvent.change(textarea, { target: { value: 'User typing...' } }); + + // External content change while user is editing + rerender(); + + // Local content should be preserved + expect(textarea).toHaveValue('User typing...'); + }); +}); + +describe('Document Tree Support', () => { + let mockMaestro: ReturnType; + + beforeEach(() => { + mockMaestro = setupMaestroMock(); + vi.useFakeTimers({ shouldAdvanceTime: true }); + }); + + afterEach(() => { + vi.clearAllMocks(); + vi.useRealTimers(); + }); + + it('passes document tree to document selector', () => { + const documentTree = [ + { name: 'doc1', type: 'file' as const, path: 'doc1.md' }, + { name: 'folder', type: 'folder' as const, path: 'folder', children: [] }, + ]; + const props = createDefaultProps({ documentTree }); + render(); + + // Document selector should be rendered + expect(screen.getByTestId('document-selector')).toBeInTheDocument(); + }); +}); + +describe('Auto-save Cleanup', () => { + let mockMaestro: ReturnType; + + beforeEach(() => { + mockMaestro = setupMaestroMock(); + vi.useFakeTimers({ shouldAdvanceTime: true }); + }); + + afterEach(() => { + vi.clearAllMocks(); + vi.useRealTimers(); + }); + + it('clears auto-save timer when document changes', async () => { + const props = createDefaultProps({ content: 'Initial', selectedFile: 'doc1' }); + const { rerender } = render(); + + const textarea = screen.getByRole('textbox'); + fireEvent.focus(textarea); + fireEvent.change(textarea, { target: { value: 'Changed content' } }); + + // Change document before auto-save fires + rerender(); + + // Advance past auto-save time + await act(async () => { + vi.advanceTimersByTime(6000); + }); + + // Auto-save should NOT have been called for doc1's content + // because we switched documents before the timer fired + // It might be called for doc2 if there are pending changes, but not with doc1 content + const calls = mockMaestro.autorun.writeDoc.mock.calls; + const doc1SaveCalls = calls.filter((call: any[]) => call[1] === 'doc1.md' && call[2] === 'Changed content'); + expect(doc1SaveCalls.length).toBe(0); + }); +}); diff --git a/src/__tests__/renderer/components/AutoRunDocumentSelector.test.tsx b/src/__tests__/renderer/components/AutoRunDocumentSelector.test.tsx new file mode 100644 index 00000000..2bc9c530 --- /dev/null +++ b/src/__tests__/renderer/components/AutoRunDocumentSelector.test.tsx @@ -0,0 +1,1138 @@ +import React from 'react'; +import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'; +import { render, screen, fireEvent, waitFor, within } from '@testing-library/react'; +import userEvent from '@testing-library/user-event'; +import { AutoRunDocumentSelector, DocTreeNode } from '../../../renderer/components/AutoRunDocumentSelector'; +import type { Theme } from '../../../renderer/types'; + +// Mock lucide-react icons +vi.mock('lucide-react', () => ({ + ChevronDown: ({ className, style }: { className?: string; style?: React.CSSProperties }) => ( + ▼ + ), + ChevronRight: ({ className }: { className?: string }) => ( + ▶ + ), + RefreshCw: ({ className }: { className?: string }) => ( + ↻ + ), + FolderOpen: ({ className }: { className?: string }) => ( + 📂 + ), + Plus: ({ className, style }: { className?: string; style?: React.CSSProperties }) => ( + + + ), + Folder: ({ className, style }: { className?: string; style?: React.CSSProperties }) => ( + 📁 + ), +})); + +// Test theme +const mockTheme: Theme = { + id: 'test-theme', + name: 'Test Theme', + mode: 'dark', + colors: { + bgMain: '#1a1a2e', + bgSidebar: '#16213e', + bgActivity: '#0f3460', + border: '#374151', + accent: '#6366f1', + accentForeground: '#ffffff', + textMain: '#e5e7eb', + textDim: '#9ca3af', + success: '#22c55e', + warning: '#eab308', + error: '#ef4444', + purple: '#8b5cf6', + }, +}; + +const defaultProps = { + theme: mockTheme, + documents: ['doc1', 'doc2', 'doc3'], + selectedDocument: null, + onSelectDocument: vi.fn(), + onRefresh: vi.fn(), + onChangeFolder: vi.fn(), + onCreateDocument: vi.fn().mockResolvedValue(true), + isLoading: false, +}; + +describe('AutoRunDocumentSelector', () => { + beforeEach(() => { + vi.clearAllMocks(); + }); + + afterEach(() => { + vi.restoreAllMocks(); + }); + + describe('Exports', () => { + it('exports DocTreeNode interface type', () => { + // TypeScript compile-time check - if this compiles, the export exists + const node: DocTreeNode = { + name: 'test', + type: 'file', + path: 'test', + }; + expect(node.name).toBe('test'); + expect(node.type).toBe('file'); + }); + + it('exports AutoRunDocumentSelector component', () => { + expect(AutoRunDocumentSelector).toBeDefined(); + expect(typeof AutoRunDocumentSelector).toBe('function'); + }); + }); + + describe('Initial Render', () => { + it('renders dropdown button with placeholder when no selection', () => { + render(); + + const button = screen.getByRole('button', { name: /select a document/i }); + expect(button).toBeInTheDocument(); + expect(button).toHaveTextContent('Select a document...'); + }); + + it('renders dropdown button with selected document name', () => { + render(); + + const button = screen.getByRole('button', { name: /doc1\.md/i }); + expect(button).toBeInTheDocument(); + expect(button).toHaveTextContent('doc1.md'); + }); + + it('renders create new document button', () => { + render(); + + const createButton = screen.getByTitle('Create new document'); + expect(createButton).toBeInTheDocument(); + }); + + it('renders refresh button', () => { + render(); + + const refreshButton = screen.getByTitle('Refresh document list'); + expect(refreshButton).toBeInTheDocument(); + }); + + it('renders change folder button', () => { + render(); + + const changeFolderButton = screen.getByTitle('Change folder'); + expect(changeFolderButton).toBeInTheDocument(); + }); + + it('applies theme colors to dropdown button', () => { + render(); + + const button = screen.getByRole('button', { name: /select a document/i }); + expect(button).toHaveStyle({ backgroundColor: mockTheme.colors.bgActivity }); + expect(button).toHaveStyle({ color: mockTheme.colors.textMain }); + }); + }); + + describe('Dropdown Toggle', () => { + it('opens dropdown when button is clicked', () => { + render(); + + const button = screen.getByRole('button', { name: /select a document/i }); + fireEvent.click(button); + + // Dropdown should be visible with document options + expect(screen.getByText('doc1.md')).toBeInTheDocument(); + expect(screen.getByText('doc2.md')).toBeInTheDocument(); + expect(screen.getByText('doc3.md')).toBeInTheDocument(); + }); + + it('closes dropdown when button is clicked again', () => { + render(); + + const button = screen.getByRole('button', { name: /select a document/i }); + fireEvent.click(button); + expect(screen.getByText('doc1.md')).toBeInTheDocument(); + + fireEvent.click(button); + expect(screen.queryByText('doc1.md')).not.toBeInTheDocument(); + }); + + it('rotates chevron icon when dropdown is open', () => { + render(); + + const button = screen.getByRole('button', { name: /select a document/i }); + const chevron = within(button).getByTestId('chevron-down'); + + // Initially not rotated + expect(chevron.className).not.toContain('rotate-180'); + + fireEvent.click(button); + + // Should have rotate-180 class when open + expect(chevron.className).toContain('rotate-180'); + }); + }); + + describe('Document Selection', () => { + it('calls onSelectDocument when document is clicked', () => { + render(); + + // Open dropdown + const button = screen.getByRole('button', { name: /select a document/i }); + fireEvent.click(button); + + // Click on a document + const docButton = screen.getByText('doc2.md'); + fireEvent.click(docButton); + + expect(defaultProps.onSelectDocument).toHaveBeenCalledWith('doc2'); + }); + + it('closes dropdown after selection', () => { + render(); + + const button = screen.getByRole('button', { name: /select a document/i }); + fireEvent.click(button); + + const docButton = screen.getByText('doc1.md'); + fireEvent.click(docButton); + + // Dropdown should be closed + expect(screen.queryByText('doc2.md')).not.toBeInTheDocument(); + }); + + it('highlights selected document in dropdown', () => { + render(); + + const button = screen.getByRole('button', { name: /doc2\.md/i }); + fireEvent.click(button); + + // Find all buttons with doc2.md text, the one in the dropdown is the second one + const docButtons = screen.getAllByText('doc2.md'); + // The dropdown button is the one with the selection highlight styles + const selectedDoc = docButtons.find(el => el.tagName === 'BUTTON' && el.className.includes('hover:bg-white/5')); + expect(selectedDoc).toHaveStyle({ color: mockTheme.colors.accent }); + expect(selectedDoc).toHaveStyle({ backgroundColor: mockTheme.colors.bgActivity }); + }); + }); + + describe('Empty State', () => { + it('shows empty message when no documents', () => { + render(); + + const button = screen.getByRole('button', { name: /select a document/i }); + fireEvent.click(button); + + expect(screen.getByText('No markdown files found')).toBeInTheDocument(); + }); + }); + + describe('Tree Mode', () => { + const documentTree: DocTreeNode[] = [ + { + name: 'folder1', + type: 'folder', + path: 'folder1', + children: [ + { name: 'nested-doc', type: 'file', path: 'folder1/nested-doc' }, + { + name: 'subfolder', + type: 'folder', + path: 'folder1/subfolder', + children: [ + { name: 'deep-doc', type: 'file', path: 'folder1/subfolder/deep-doc' }, + ], + }, + ], + }, + { name: 'root-doc', type: 'file', path: 'root-doc' }, + ]; + + it('renders folder nodes with chevron icons', () => { + render( + + ); + + const button = screen.getByRole('button', { name: /select a document/i }); + fireEvent.click(button); + + // Folder should be visible with chevron + expect(screen.getByText('folder1')).toBeInTheDocument(); + }); + + it('expands folder when clicked', () => { + render( + + ); + + const button = screen.getByRole('button', { name: /select a document/i }); + fireEvent.click(button); + + // Initially folder is collapsed, nested doc shouldn't be visible + expect(screen.queryByText('nested-doc.md')).not.toBeInTheDocument(); + + // Click folder to expand + const folderButton = screen.getByText('folder1'); + fireEvent.click(folderButton); + + // Now nested doc should be visible + expect(screen.getByText('nested-doc.md')).toBeInTheDocument(); + }); + + it('collapses folder when clicked again', () => { + render( + + ); + + const button = screen.getByRole('button', { name: /select a document/i }); + fireEvent.click(button); + + // Expand folder + const folderButton = screen.getByText('folder1'); + fireEvent.click(folderButton); + expect(screen.getByText('nested-doc.md')).toBeInTheDocument(); + + // Collapse folder + fireEvent.click(folderButton); + expect(screen.queryByText('nested-doc.md')).not.toBeInTheDocument(); + }); + + it('renders nested folders correctly', () => { + render( + + ); + + const button = screen.getByRole('button', { name: /select a document/i }); + fireEvent.click(button); + + // Expand folder1 + fireEvent.click(screen.getByText('folder1')); + expect(screen.getByText('subfolder')).toBeInTheDocument(); + + // Expand subfolder + fireEvent.click(screen.getByText('subfolder')); + expect(screen.getByText('deep-doc.md')).toBeInTheDocument(); + }); + + it('selects file from tree', () => { + render( + + ); + + const button = screen.getByRole('button', { name: /select a document/i }); + fireEvent.click(button); + + // Expand folder and select nested doc + fireEvent.click(screen.getByText('folder1')); + fireEvent.click(screen.getByText('nested-doc.md')); + + expect(defaultProps.onSelectDocument).toHaveBeenCalledWith('folder1/nested-doc'); + }); + + it('renders root-level file in tree', () => { + render( + + ); + + const button = screen.getByRole('button', { name: /select a document/i }); + fireEvent.click(button); + + expect(screen.getByText('root-doc.md')).toBeInTheDocument(); + }); + }); + + describe('Click Outside', () => { + it('closes dropdown when clicking outside', () => { + render( +
+
Outside element
+ +
+ ); + + const button = screen.getByRole('button', { name: /select a document/i }); + fireEvent.click(button); + expect(screen.getByText('doc1.md')).toBeInTheDocument(); + + // Click outside + fireEvent.mouseDown(screen.getByTestId('outside')); + expect(screen.queryByText('doc1.md')).not.toBeInTheDocument(); + }); + }); + + describe('Escape Key', () => { + it('closes dropdown when Escape is pressed', () => { + render(); + + const button = screen.getByRole('button', { name: /select a document/i }); + fireEvent.click(button); + expect(screen.getByText('doc1.md')).toBeInTheDocument(); + + fireEvent.keyDown(document, { key: 'Escape' }); + expect(screen.queryByText('doc1.md')).not.toBeInTheDocument(); + }); + + it('returns focus to button after closing with Escape', () => { + render(); + + const button = screen.getByRole('button', { name: /select a document/i }); + fireEvent.click(button); + + fireEvent.keyDown(document, { key: 'Escape' }); + + expect(document.activeElement).toBe(button); + }); + }); + + describe('Refresh Button', () => { + it('calls onRefresh when clicked', () => { + render(); + + const refreshButton = screen.getByTitle('Refresh document list'); + fireEvent.click(refreshButton); + + expect(defaultProps.onRefresh).toHaveBeenCalledTimes(1); + }); + + it('is disabled when loading', () => { + render(); + + const refreshButton = screen.getByTitle('Refresh document list'); + expect(refreshButton).toBeDisabled(); + }); + + it('shows spinning icon when loading', () => { + render(); + + const refreshIcon = screen.getByTestId('refresh-icon'); + expect(refreshIcon.className).toContain('animate-spin'); + }); + + it('does not show spinning icon when not loading', () => { + render(); + + const refreshIcon = screen.getByTestId('refresh-icon'); + expect(refreshIcon.className).not.toContain('animate-spin'); + }); + }); + + describe('Change Folder Button', () => { + it('calls onChangeFolder when top-level button clicked', () => { + render(); + + const changeFolderButton = screen.getByTitle('Change folder'); + fireEvent.click(changeFolderButton); + + expect(defaultProps.onChangeFolder).toHaveBeenCalledTimes(1); + }); + + it('calls onChangeFolder from dropdown option', () => { + render(); + + // Open dropdown + const button = screen.getByRole('button', { name: /select a document/i }); + fireEvent.click(button); + + // Click "Change Folder..." option in dropdown + const changeFolderOption = screen.getByText('Change Folder...'); + fireEvent.click(changeFolderOption); + + expect(defaultProps.onChangeFolder).toHaveBeenCalledTimes(1); + }); + + it('closes dropdown when Change Folder option is clicked', () => { + render(); + + const button = screen.getByRole('button', { name: /select a document/i }); + fireEvent.click(button); + expect(screen.getByText('doc1.md')).toBeInTheDocument(); + + fireEvent.click(screen.getByText('Change Folder...')); + expect(screen.queryByText('doc1.md')).not.toBeInTheDocument(); + }); + }); + + describe('Create Document Modal', () => { + it('opens modal when create button is clicked', () => { + render(); + + const createButton = screen.getByTitle('Create new document'); + fireEvent.click(createButton); + + expect(screen.getByRole('dialog', { name: /create new document/i })).toBeInTheDocument(); + }); + + it('renders modal with correct elements', () => { + render(); + + fireEvent.click(screen.getByTitle('Create new document')); + + expect(screen.getByText('Document Name')).toBeInTheDocument(); + expect(screen.getByPlaceholderText('my-tasks')).toBeInTheDocument(); + expect(screen.getByRole('button', { name: /cancel/i })).toBeInTheDocument(); + expect(screen.getByRole('button', { name: /^create$/i })).toBeInTheDocument(); + }); + + it('focuses input when modal opens', async () => { + render(); + + fireEvent.click(screen.getByTitle('Create new document')); + + await waitFor(() => { + const input = screen.getByPlaceholderText('my-tasks'); + expect(document.activeElement).toBe(input); + }); + }); + + it('closes modal when Cancel is clicked', () => { + render(); + + fireEvent.click(screen.getByTitle('Create new document')); + expect(screen.getByRole('dialog')).toBeInTheDocument(); + + fireEvent.click(screen.getByRole('button', { name: /cancel/i })); + expect(screen.queryByRole('dialog')).not.toBeInTheDocument(); + }); + + it('closes modal when backdrop is clicked', () => { + render(); + + fireEvent.click(screen.getByTitle('Create new document')); + const dialog = screen.getByRole('dialog'); + + // Click on the backdrop (the dialog element itself, not its children) + fireEvent.click(dialog); + expect(screen.queryByRole('dialog')).not.toBeInTheDocument(); + }); + + it('does not close modal when modal content is clicked', () => { + render(); + + fireEvent.click(screen.getByTitle('Create new document')); + + // Click on the input inside the modal + fireEvent.click(screen.getByPlaceholderText('my-tasks')); + expect(screen.getByRole('dialog')).toBeInTheDocument(); + }); + + it('closes modal on Escape key', () => { + render(); + + fireEvent.click(screen.getByTitle('Create new document')); + expect(screen.getByRole('dialog')).toBeInTheDocument(); + + fireEvent.keyDown(screen.getByRole('dialog'), { key: 'Escape' }); + expect(screen.queryByRole('dialog')).not.toBeInTheDocument(); + }); + + it('clears input when modal is closed', () => { + render(); + + fireEvent.click(screen.getByTitle('Create new document')); + const input = screen.getByPlaceholderText('my-tasks'); + fireEvent.change(input, { target: { value: 'test-doc' } }); + expect(input).toHaveValue('test-doc'); + + fireEvent.click(screen.getByRole('button', { name: /cancel/i })); + + // Reopen modal + fireEvent.click(screen.getByTitle('Create new document')); + expect(screen.getByPlaceholderText('my-tasks')).toHaveValue(''); + }); + }); + + describe('Duplicate Detection', () => { + it('shows error when document name already exists', () => { + render(); + + fireEvent.click(screen.getByTitle('Create new document')); + const input = screen.getByPlaceholderText('my-tasks'); + fireEvent.change(input, { target: { value: 'existing-doc' } }); + + expect(screen.getByText(/a document with this name already exists/i)).toBeInTheDocument(); + }); + + it('shows error for case-insensitive duplicates', () => { + render(); + + fireEvent.click(screen.getByTitle('Create new document')); + const input = screen.getByPlaceholderText('my-tasks'); + fireEvent.change(input, { target: { value: 'existingdoc' } }); + + expect(screen.getByText(/a document with this name already exists/i)).toBeInTheDocument(); + }); + + it('shows error when adding .md makes duplicate', () => { + render(); + + fireEvent.click(screen.getByTitle('Create new document')); + const input = screen.getByPlaceholderText('my-tasks'); + fireEvent.change(input, { target: { value: 'test-doc.md' } }); + + expect(screen.getByText(/a document with this name already exists/i)).toBeInTheDocument(); + }); + + it('disables Create button when duplicate', () => { + render(); + + fireEvent.click(screen.getByTitle('Create new document')); + const input = screen.getByPlaceholderText('my-tasks'); + fireEvent.change(input, { target: { value: 'existing-doc' } }); + + const createButton = screen.getByRole('button', { name: /^create$/i }); + expect(createButton).toBeDisabled(); + }); + + it('applies error border color to input when duplicate', () => { + render(); + + fireEvent.click(screen.getByTitle('Create new document')); + const input = screen.getByPlaceholderText('my-tasks'); + fireEvent.change(input, { target: { value: 'existing-doc' } }); + + expect(input).toHaveStyle({ borderColor: mockTheme.colors.error }); + }); + }); + + describe('Form Submission', () => { + it('calls onCreateDocument when Create button is clicked', async () => { + render(); + + fireEvent.click(screen.getByTitle('Create new document')); + const input = screen.getByPlaceholderText('my-tasks'); + fireEvent.change(input, { target: { value: 'new-doc' } }); + + fireEvent.click(screen.getByRole('button', { name: /^create$/i })); + + await waitFor(() => { + expect(defaultProps.onCreateDocument).toHaveBeenCalledWith('new-doc'); + }); + }); + + it('calls onCreateDocument when Enter is pressed', async () => { + render(); + + fireEvent.click(screen.getByTitle('Create new document')); + const input = screen.getByPlaceholderText('my-tasks'); + fireEvent.change(input, { target: { value: 'new-doc' } }); + fireEvent.keyDown(input, { key: 'Enter' }); + + await waitFor(() => { + expect(defaultProps.onCreateDocument).toHaveBeenCalledWith('new-doc'); + }); + }); + + it('does not submit when name is empty', () => { + render(); + + fireEvent.click(screen.getByTitle('Create new document')); + fireEvent.click(screen.getByRole('button', { name: /^create$/i })); + + expect(defaultProps.onCreateDocument).not.toHaveBeenCalled(); + }); + + it('does not submit when name is only whitespace', () => { + render(); + + fireEvent.click(screen.getByTitle('Create new document')); + const input = screen.getByPlaceholderText('my-tasks'); + fireEvent.change(input, { target: { value: ' ' } }); + fireEvent.click(screen.getByRole('button', { name: /^create$/i })); + + expect(defaultProps.onCreateDocument).not.toHaveBeenCalled(); + }); + + it('disables Create button when input is empty', () => { + render(); + + fireEvent.click(screen.getByTitle('Create new document')); + + const createButton = screen.getByRole('button', { name: /^create$/i }); + expect(createButton).toBeDisabled(); + }); + + it('shows Creating... state during submission', async () => { + const slowCreateDocument = vi.fn().mockImplementation( + () => new Promise((resolve) => setTimeout(() => resolve(true), 100)) + ); + + render(); + + fireEvent.click(screen.getByTitle('Create new document')); + const input = screen.getByPlaceholderText('my-tasks'); + fireEvent.change(input, { target: { value: 'new-doc' } }); + fireEvent.click(screen.getByRole('button', { name: /^create$/i })); + + expect(screen.getByText('Creating...')).toBeInTheDocument(); + + await waitFor(() => { + expect(screen.queryByRole('dialog')).not.toBeInTheDocument(); + }); + }); + + it('closes modal on successful creation', async () => { + render(); + + fireEvent.click(screen.getByTitle('Create new document')); + const input = screen.getByPlaceholderText('my-tasks'); + fireEvent.change(input, { target: { value: 'new-doc' } }); + fireEvent.click(screen.getByRole('button', { name: /^create$/i })); + + await waitFor(() => { + expect(screen.queryByRole('dialog')).not.toBeInTheDocument(); + }); + }); + + it('keeps modal open on failed creation', async () => { + const failingCreate = vi.fn().mockResolvedValue(false); + + render(); + + fireEvent.click(screen.getByTitle('Create new document')); + const input = screen.getByPlaceholderText('my-tasks'); + fireEvent.change(input, { target: { value: 'new-doc' } }); + fireEvent.click(screen.getByRole('button', { name: /^create$/i })); + + await waitFor(() => { + expect(screen.getByRole('dialog')).toBeInTheDocument(); + }); + }); + }); + + describe('File Extension Handling', () => { + it('adds .md extension if not provided', async () => { + render(); + + fireEvent.click(screen.getByTitle('Create new document')); + const input = screen.getByPlaceholderText('my-tasks'); + fireEvent.change(input, { target: { value: 'new-doc' } }); + fireEvent.click(screen.getByRole('button', { name: /^create$/i })); + + await waitFor(() => { + expect(defaultProps.onCreateDocument).toHaveBeenCalledWith('new-doc'); + }); + }); + + it('strips .md extension from document name', async () => { + render(); + + fireEvent.click(screen.getByTitle('Create new document')); + const input = screen.getByPlaceholderText('my-tasks'); + fireEvent.change(input, { target: { value: 'new-doc.md' } }); + fireEvent.click(screen.getByRole('button', { name: /^create$/i })); + + await waitFor(() => { + expect(defaultProps.onCreateDocument).toHaveBeenCalledWith('new-doc'); + }); + }); + + it('strips .MD extension (case insensitive)', async () => { + render(); + + fireEvent.click(screen.getByTitle('Create new document')); + const input = screen.getByPlaceholderText('my-tasks'); + fireEvent.change(input, { target: { value: 'new-doc.MD' } }); + fireEvent.click(screen.getByRole('button', { name: /^create$/i })); + + await waitFor(() => { + expect(defaultProps.onCreateDocument).toHaveBeenCalledWith('new-doc'); + }); + }); + }); + + describe('Folder Selection in Create Modal', () => { + const documentTree: DocTreeNode[] = [ + { + name: 'folder1', + type: 'folder', + path: 'folder1', + children: [ + { + name: 'subfolder', + type: 'folder', + path: 'folder1/subfolder', + children: [], + }, + ], + }, + { + name: 'folder2', + type: 'folder', + path: 'folder2', + children: [], + }, + ]; + + it('shows folder selector when tree has folders', () => { + render( + + ); + + fireEvent.click(screen.getByTitle('Create new document')); + + expect(screen.getByText('Location')).toBeInTheDocument(); + expect(screen.getByRole('combobox')).toBeInTheDocument(); + }); + + it('does not show folder selector when no tree', () => { + render(); + + fireEvent.click(screen.getByTitle('Create new document')); + + expect(screen.queryByText('Location')).not.toBeInTheDocument(); + }); + + it('does not show folder selector when tree is empty', () => { + render(); + + fireEvent.click(screen.getByTitle('Create new document')); + + expect(screen.queryByText('Location')).not.toBeInTheDocument(); + }); + + it('lists all folders in selector', () => { + render( + + ); + + fireEvent.click(screen.getByTitle('Create new document')); + + const select = screen.getByRole('combobox'); + expect(select).toBeInTheDocument(); + + // Check options + const options = within(select).getAllByRole('option'); + expect(options).toHaveLength(4); // Root + folder1 + subfolder + folder2 + }); + + it('creates document in selected folder', async () => { + render( + + ); + + fireEvent.click(screen.getByTitle('Create new document')); + + // Select folder + const select = screen.getByRole('combobox'); + fireEvent.change(select, { target: { value: 'folder1' } }); + + // Enter document name + const input = screen.getByPlaceholderText('my-tasks'); + fireEvent.change(input, { target: { value: 'nested-doc' } }); + + fireEvent.click(screen.getByRole('button', { name: /^create$/i })); + + await waitFor(() => { + expect(defaultProps.onCreateDocument).toHaveBeenCalledWith('folder1/nested-doc'); + }); + }); + + it('creates document in nested folder', async () => { + render( + + ); + + fireEvent.click(screen.getByTitle('Create new document')); + + const select = screen.getByRole('combobox'); + fireEvent.change(select, { target: { value: 'folder1/subfolder' } }); + + const input = screen.getByPlaceholderText('my-tasks'); + fireEvent.change(input, { target: { value: 'deep-doc' } }); + + fireEvent.click(screen.getByRole('button', { name: /^create$/i })); + + await waitFor(() => { + expect(defaultProps.onCreateDocument).toHaveBeenCalledWith('folder1/subfolder/deep-doc'); + }); + }); + + it('shows preview of full path in helper text', () => { + render( + + ); + + fireEvent.click(screen.getByTitle('Create new document')); + + const select = screen.getByRole('combobox'); + fireEvent.change(select, { target: { value: 'folder1' } }); + + const input = screen.getByPlaceholderText('my-tasks'); + fireEvent.change(input, { target: { value: 'new-doc' } }); + + expect(screen.getByText(/will create: folder1\/new-doc\.md/i)).toBeInTheDocument(); + }); + + it('detects duplicate in subfolder', () => { + render( + + ); + + fireEvent.click(screen.getByTitle('Create new document')); + + const select = screen.getByRole('combobox'); + fireEvent.change(select, { target: { value: 'folder1' } }); + + const input = screen.getByPlaceholderText('my-tasks'); + fireEvent.change(input, { target: { value: 'existing-doc' } }); + + expect(screen.getByText(/a document with this name already exists in folder1/i)).toBeInTheDocument(); + }); + + it('resets folder selection when modal closes', () => { + render( + + ); + + fireEvent.click(screen.getByTitle('Create new document')); + + const select = screen.getByRole('combobox'); + fireEvent.change(select, { target: { value: 'folder1' } }); + + fireEvent.click(screen.getByRole('button', { name: /cancel/i })); + + // Reopen and check + fireEvent.click(screen.getByTitle('Create new document')); + expect(screen.getByRole('combobox')).toHaveValue(''); + }); + }); + + describe('Helper Text', () => { + it('shows extension hint when no folder selected', () => { + render(); + + fireEvent.click(screen.getByTitle('Create new document')); + + expect(screen.getByText(/the \.md extension will be added automatically/i)).toBeInTheDocument(); + }); + + it('shows path preview when folder is selected', () => { + const documentTree: DocTreeNode[] = [ + { name: 'folder1', type: 'folder', path: 'folder1', children: [] }, + ]; + + render( + + ); + + fireEvent.click(screen.getByTitle('Create new document')); + + const select = screen.getByRole('combobox'); + fireEvent.change(select, { target: { value: 'folder1' } }); + + // With folder selected, shows path preview instead of extension hint + expect(screen.queryByText(/the \.md extension will be added automatically/i)).not.toBeInTheDocument(); + expect(screen.getByText(/will create: folder1\//i)).toBeInTheDocument(); + }); + }); + + describe('Edge Cases', () => { + it('handles documents with special characters', () => { + render( + + ); + + const button = screen.getByRole('button', { name: /select a document/i }); + fireEvent.click(button); + + expect(screen.getByText('doc-with-dash.md')).toBeInTheDocument(); + expect(screen.getByText('doc_with_underscore.md')).toBeInTheDocument(); + expect(screen.getByText('doc.with.dots.md')).toBeInTheDocument(); + }); + + it('handles document names with unicode', () => { + render( + + ); + + const button = screen.getByRole('button', { name: /select a document/i }); + fireEvent.click(button); + + expect(screen.getByText('日本語ドキュメント.md')).toBeInTheDocument(); + expect(screen.getByText('émojis-📝.md')).toBeInTheDocument(); + }); + + it('handles very long document names', () => { + const longName = 'a'.repeat(200); + render( + + ); + + const button = screen.getByRole('button', { name: new RegExp(longName.substring(0, 50)) }); + expect(button).toBeInTheDocument(); + }); + + it('handles rapid dropdown toggling', () => { + render(); + + const button = screen.getByRole('button', { name: /select a document/i }); + + // Rapid toggling + for (let i = 0; i < 10; i++) { + fireEvent.click(button); + } + + // Should be in a consistent state (even number of clicks = closed) + expect(screen.queryByText('doc1.md')).not.toBeInTheDocument(); + }); + + it('handles rapid refresh clicks', () => { + render(); + + const refreshButton = screen.getByTitle('Refresh document list'); + + for (let i = 0; i < 5; i++) { + fireEvent.click(refreshButton); + } + + expect(defaultProps.onRefresh).toHaveBeenCalledTimes(5); + }); + + it('handles tree with only folders (no files)', () => { + const foldersOnly: DocTreeNode[] = [ + { name: 'folder1', type: 'folder', path: 'folder1', children: [] }, + { name: 'folder2', type: 'folder', path: 'folder2', children: [] }, + ]; + + render( + + ); + + const button = screen.getByRole('button', { name: /select a document/i }); + fireEvent.click(button); + + // Should show empty message since no documents exist + expect(screen.getByText('No markdown files found')).toBeInTheDocument(); + }); + + it('handles XSS-like document names safely', () => { + render( + alert("xss")']} + /> + ); + + const button = screen.getByRole('button', { name: /select a document/i }); + fireEvent.click(button); + + // Should render as text, not execute + const docElement = screen.getByText('.md'); + expect(docElement).toBeInTheDocument(); + }); + }); + + describe('Styling', () => { + it('applies theme colors to dropdown menu', () => { + render(); + + const button = screen.getByRole('button', { name: /select a document/i }); + fireEvent.click(button); + + // Find the dropdown menu (the container with border) + const menu = screen.getByText('doc1.md').parentElement; + expect(menu).toHaveStyle({ backgroundColor: mockTheme.colors.bgSidebar }); + }); + + it('applies theme colors to create modal', () => { + render(); + + fireEvent.click(screen.getByTitle('Create new document')); + + // Find the modal content container - it's the inner div with the border style + const modalHeader = screen.getByText('Create New Document'); + const modalContent = modalHeader.closest('div[style*="background"]'); + expect(modalContent).toHaveStyle({ backgroundColor: mockTheme.colors.bgSidebar }); + }); + + it('applies loading opacity to refresh button', () => { + render(); + + const refreshButton = screen.getByTitle('Refresh document list'); + expect(refreshButton.className).toContain('opacity-50'); + }); + }); + + describe('Accessibility', () => { + it('modal has correct aria attributes', () => { + render(); + + fireEvent.click(screen.getByTitle('Create new document')); + + const dialog = screen.getByRole('dialog'); + expect(dialog).toHaveAttribute('aria-modal', 'true'); + expect(dialog).toHaveAttribute('aria-label', 'Create New Document'); + }); + + it('buttons have accessible titles', () => { + render(); + + expect(screen.getByTitle('Create new document')).toBeInTheDocument(); + expect(screen.getByTitle('Refresh document list')).toBeInTheDocument(); + expect(screen.getByTitle('Change folder')).toBeInTheDocument(); + }); + }); +}); diff --git a/src/__tests__/renderer/components/AutoRunSetupModal.test.tsx b/src/__tests__/renderer/components/AutoRunSetupModal.test.tsx new file mode 100644 index 00000000..7d2c0bc0 --- /dev/null +++ b/src/__tests__/renderer/components/AutoRunSetupModal.test.tsx @@ -0,0 +1,1721 @@ +/** + * Tests for AutoRunSetupModal component + * + * AutoRunSetupModal is a modal dialog for setting up Auto Run: + * - Allows user to select a folder for Auto Run documents + * - Validates folder and counts markdown files + * - Supports tilde (~) expansion for home directory paths + * - Registers with layer stack for modal management + * - Provides keyboard shortcuts (Cmd+O, Enter) + * - Debounces folder validation (300ms) + */ + +import React from 'react'; +import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'; +import { render, screen, fireEvent, waitFor, act } from '@testing-library/react'; +import { AutoRunSetupModal } from '../../../renderer/components/AutoRunSetupModal'; +import { LayerStackProvider } from '../../../renderer/contexts/LayerStackContext'; +import type { Theme } from '../../../renderer/types'; + +// Mock lucide-react +vi.mock('lucide-react', () => ({ + X: () => , + Folder: () => , + FileText: () => , + Play: () => , + CheckSquare: () => , +})); + +// Create a test theme +const createTestTheme = (overrides: Partial = {}): Theme => ({ + id: 'test-theme', + name: 'Test Theme', + mode: 'dark', + colors: { + bgMain: '#1e1e1e', + bgSidebar: '#252526', + bgActivity: '#333333', + textMain: '#d4d4d4', + textDim: '#808080', + accent: '#007acc', + accentForeground: '#ffffff', + border: '#404040', + error: '#f14c4c', + warning: '#cca700', + success: '#89d185', + info: '#3794ff', + textInverse: '#000000', + ...overrides, + }, +}); + +// Helper to render with LayerStackProvider +const renderWithLayerStack = (ui: React.ReactElement) => { + return render( + + {ui} + + ); +}; + +describe('AutoRunSetupModal', () => { + let theme: Theme; + + beforeEach(() => { + theme = createTestTheme(); + vi.clearAllMocks(); + vi.useFakeTimers(); + + // Reset mocks to default behavior + vi.mocked(window.maestro.fs.homeDir).mockResolvedValue('/home/testuser'); + vi.mocked(window.maestro.autorun.listDocs).mockResolvedValue({ success: true, files: [] }); + vi.mocked(window.maestro.dialog.selectFolder).mockResolvedValue(null); + }); + + afterEach(() => { + vi.useRealTimers(); + vi.restoreAllMocks(); + }); + + describe('rendering', () => { + it('renders modal with correct structure', async () => { + const onClose = vi.fn(); + const onFolderSelected = vi.fn(); + + renderWithLayerStack( + + ); + + await act(async () => { + await vi.runAllTimersAsync(); + }); + + expect(screen.getByRole('dialog')).toBeInTheDocument(); + expect(screen.getByText('Set Up Auto Run')).toBeInTheDocument(); + }); + + it('renders with "Change Auto Run Folder" title when currentFolder is provided', async () => { + const onClose = vi.fn(); + const onFolderSelected = vi.fn(); + + renderWithLayerStack( + + ); + + await act(async () => { + await vi.runAllTimersAsync(); + }); + + expect(screen.getByText('Change Auto Run Folder')).toBeInTheDocument(); + }); + + it('renders with correct ARIA attributes', async () => { + const onClose = vi.fn(); + const onFolderSelected = vi.fn(); + + renderWithLayerStack( + + ); + + await act(async () => { + await vi.runAllTimersAsync(); + }); + + const dialog = screen.getByRole('dialog'); + expect(dialog).toHaveAttribute('aria-modal', 'true'); + expect(dialog).toHaveAttribute('aria-label', 'Set Up Auto Run'); + }); + + it('renders close button with X icon', async () => { + const onClose = vi.fn(); + const onFolderSelected = vi.fn(); + + renderWithLayerStack( + + ); + + await act(async () => { + await vi.runAllTimersAsync(); + }); + + expect(screen.getByTestId('x-icon')).toBeInTheDocument(); + }); + + it('renders feature explanation section', async () => { + const onClose = vi.fn(); + const onFolderSelected = vi.fn(); + + renderWithLayerStack( + + ); + + await act(async () => { + await vi.runAllTimersAsync(); + }); + + expect(screen.getByText(/Auto Run lets you manage and execute Markdown documents/)).toBeInTheDocument(); + expect(screen.getByText('Markdown Documents')).toBeInTheDocument(); + expect(screen.getByText('Checkbox Tasks')).toBeInTheDocument(); + expect(screen.getByText('Batch Execution')).toBeInTheDocument(); + }); + + it('renders feature icons', async () => { + const onClose = vi.fn(); + const onFolderSelected = vi.fn(); + + renderWithLayerStack( + + ); + + await act(async () => { + await vi.runAllTimersAsync(); + }); + + expect(screen.getByTestId('file-text-icon')).toBeInTheDocument(); + expect(screen.getByTestId('check-square-icon')).toBeInTheDocument(); + expect(screen.getByTestId('play-icon')).toBeInTheDocument(); + }); + + it('renders folder input and browse button', async () => { + const onClose = vi.fn(); + const onFolderSelected = vi.fn(); + + renderWithLayerStack( + + ); + + await act(async () => { + await vi.runAllTimersAsync(); + }); + + expect(screen.getByPlaceholderText(/Select Auto Run folder/)).toBeInTheDocument(); + expect(screen.getByTestId('folder-icon')).toBeInTheDocument(); + }); + + it('renders Cancel and Continue buttons', async () => { + const onClose = vi.fn(); + const onFolderSelected = vi.fn(); + + renderWithLayerStack( + + ); + + await act(async () => { + await vi.runAllTimersAsync(); + }); + + expect(screen.getByRole('button', { name: 'Cancel' })).toBeInTheDocument(); + expect(screen.getByRole('button', { name: 'Continue' })).toBeInTheDocument(); + }); + + it('includes sessionName in placeholder when provided', async () => { + const onClose = vi.fn(); + const onFolderSelected = vi.fn(); + + renderWithLayerStack( + + ); + + await act(async () => { + await vi.runAllTimersAsync(); + }); + + expect(screen.getByPlaceholderText('Select Auto Run folder for My Agent')).toBeInTheDocument(); + }); + + it('applies theme colors to modal container', async () => { + const onClose = vi.fn(); + const onFolderSelected = vi.fn(); + + const { container } = renderWithLayerStack( + + ); + + await act(async () => { + await vi.runAllTimersAsync(); + }); + + const modalContent = container.querySelector('.w-\\[520px\\]'); + expect(modalContent).toHaveStyle({ backgroundColor: theme.colors.bgSidebar }); + }); + }); + + describe('folder input', () => { + it('initializes with currentFolder value', async () => { + const onClose = vi.fn(); + const onFolderSelected = vi.fn(); + + renderWithLayerStack( + + ); + + await act(async () => { + await vi.runAllTimersAsync(); + }); + + const input = screen.getByPlaceholderText(/Select Auto Run folder/); + expect(input).toHaveValue('/existing/path'); + }); + + it('updates selectedFolder on input change', async () => { + const onClose = vi.fn(); + const onFolderSelected = vi.fn(); + + renderWithLayerStack( + + ); + + await act(async () => { + await vi.runAllTimersAsync(); + }); + + const input = screen.getByPlaceholderText(/Select Auto Run folder/); + fireEvent.change(input, { target: { value: '/new/path' } }); + + expect(input).toHaveValue('/new/path'); + }); + }); + + describe('folder validation', () => { + it('shows "Checking folder..." during validation', async () => { + const onClose = vi.fn(); + const onFolderSelected = vi.fn(); + + // Make listDocs take time + vi.mocked(window.maestro.autorun.listDocs).mockImplementation(() => + new Promise(resolve => setTimeout(() => resolve({ success: true, files: [] }), 500)) + ); + + renderWithLayerStack( + + ); + + await act(async () => { + await vi.runAllTimersAsync(); + }); + + const input = screen.getByPlaceholderText(/Select Auto Run folder/); + fireEvent.change(input, { target: { value: '/test/path' } }); + + // Advance past debounce + await act(async () => { + vi.advanceTimersByTime(300); + }); + + expect(screen.getByText('Checking folder...')).toBeInTheDocument(); + }); + + it('shows success message when folder is valid with no documents', async () => { + const onClose = vi.fn(); + const onFolderSelected = vi.fn(); + + vi.mocked(window.maestro.autorun.listDocs).mockResolvedValue({ success: true, files: [] }); + + renderWithLayerStack( + + ); + + await act(async () => { + await vi.runAllTimersAsync(); + }); + + const input = screen.getByPlaceholderText(/Select Auto Run folder/); + fireEvent.change(input, { target: { value: '/valid/folder' } }); + + // Advance past debounce and wait for validation + await act(async () => { + vi.advanceTimersByTime(300); + await vi.runAllTimersAsync(); + }); + + expect(screen.getByText('Folder found (no markdown documents yet)')).toBeInTheDocument(); + }); + + it('shows document count when folder has markdown files (singular)', async () => { + const onClose = vi.fn(); + const onFolderSelected = vi.fn(); + + vi.mocked(window.maestro.autorun.listDocs).mockResolvedValue({ + success: true, + files: ['doc1.md'] + }); + + renderWithLayerStack( + + ); + + await act(async () => { + await vi.runAllTimersAsync(); + }); + + const input = screen.getByPlaceholderText(/Select Auto Run folder/); + fireEvent.change(input, { target: { value: '/folder/with/docs' } }); + + await act(async () => { + vi.advanceTimersByTime(300); + await vi.runAllTimersAsync(); + }); + + expect(screen.getByText('Found 1 markdown document')).toBeInTheDocument(); + }); + + it('shows document count when folder has markdown files (plural)', async () => { + const onClose = vi.fn(); + const onFolderSelected = vi.fn(); + + vi.mocked(window.maestro.autorun.listDocs).mockResolvedValue({ + success: true, + files: ['doc1.md', 'doc2.md', 'doc3.md'] + }); + + renderWithLayerStack( + + ); + + await act(async () => { + await vi.runAllTimersAsync(); + }); + + const input = screen.getByPlaceholderText(/Select Auto Run folder/); + fireEvent.change(input, { target: { value: '/folder/with/docs' } }); + + await act(async () => { + vi.advanceTimersByTime(300); + await vi.runAllTimersAsync(); + }); + + expect(screen.getByText('Found 3 markdown documents')).toBeInTheDocument(); + }); + + it('shows error when folder is not accessible', async () => { + const onClose = vi.fn(); + const onFolderSelected = vi.fn(); + + vi.mocked(window.maestro.autorun.listDocs).mockResolvedValue({ success: false }); + + renderWithLayerStack( + + ); + + await act(async () => { + await vi.runAllTimersAsync(); + }); + + const input = screen.getByPlaceholderText(/Select Auto Run folder/); + fireEvent.change(input, { target: { value: '/invalid/folder' } }); + + await act(async () => { + vi.advanceTimersByTime(300); + await vi.runAllTimersAsync(); + }); + + expect(screen.getByText('Folder not found or not accessible')).toBeInTheDocument(); + }); + + it('shows error when validation throws', async () => { + const onClose = vi.fn(); + const onFolderSelected = vi.fn(); + + vi.mocked(window.maestro.autorun.listDocs).mockRejectedValue(new Error('Network error')); + + renderWithLayerStack( + + ); + + await act(async () => { + await vi.runAllTimersAsync(); + }); + + const input = screen.getByPlaceholderText(/Select Auto Run folder/); + fireEvent.change(input, { target: { value: '/error/folder' } }); + + await act(async () => { + vi.advanceTimersByTime(300); + await vi.runAllTimersAsync(); + }); + + expect(screen.getByText('Failed to access folder')).toBeInTheDocument(); + }); + + it('does not validate empty folder', async () => { + const onClose = vi.fn(); + const onFolderSelected = vi.fn(); + + renderWithLayerStack( + + ); + + await act(async () => { + await vi.runAllTimersAsync(); + }); + + const input = screen.getByPlaceholderText(/Select Auto Run folder/); + fireEvent.change(input, { target: { value: ' ' } }); + + await act(async () => { + vi.advanceTimersByTime(500); + await vi.runAllTimersAsync(); + }); + + expect(window.maestro.autorun.listDocs).not.toHaveBeenCalled(); + }); + + it('debounces validation with 300ms delay', async () => { + const onClose = vi.fn(); + const onFolderSelected = vi.fn(); + + vi.mocked(window.maestro.autorun.listDocs).mockResolvedValue({ success: true, files: [] }); + + renderWithLayerStack( + + ); + + await act(async () => { + await vi.runAllTimersAsync(); + }); + + const input = screen.getByPlaceholderText(/Select Auto Run folder/); + + // Type rapidly + fireEvent.change(input, { target: { value: '/a' } }); + await act(async () => { vi.advanceTimersByTime(100); }); + + fireEvent.change(input, { target: { value: '/ab' } }); + await act(async () => { vi.advanceTimersByTime(100); }); + + fireEvent.change(input, { target: { value: '/abc' } }); + await act(async () => { vi.advanceTimersByTime(100); }); + + // Not yet called (only 300ms since last change) + expect(window.maestro.autorun.listDocs).not.toHaveBeenCalled(); + + // After debounce completes + await act(async () => { + vi.advanceTimersByTime(300); + await vi.runAllTimersAsync(); + }); + + expect(window.maestro.autorun.listDocs).toHaveBeenCalledWith('/abc'); + }); + }); + + describe('tilde expansion', () => { + it('expands ~ to home directory in validation', async () => { + const onClose = vi.fn(); + const onFolderSelected = vi.fn(); + + vi.mocked(window.maestro.fs.homeDir).mockResolvedValue('/home/testuser'); + vi.mocked(window.maestro.autorun.listDocs).mockResolvedValue({ success: true, files: [] }); + + renderWithLayerStack( + + ); + + await act(async () => { + await vi.runAllTimersAsync(); + }); + + const input = screen.getByPlaceholderText(/Select Auto Run folder/); + fireEvent.change(input, { target: { value: '~/Documents' } }); + + await act(async () => { + vi.advanceTimersByTime(300); + await vi.runAllTimersAsync(); + }); + + expect(window.maestro.autorun.listDocs).toHaveBeenCalledWith('/home/testuser/Documents'); + }); + + it('expands standalone ~ to home directory', async () => { + const onClose = vi.fn(); + const onFolderSelected = vi.fn(); + + vi.mocked(window.maestro.fs.homeDir).mockResolvedValue('/home/testuser'); + vi.mocked(window.maestro.autorun.listDocs).mockResolvedValue({ success: true, files: [] }); + + renderWithLayerStack( + + ); + + await act(async () => { + await vi.runAllTimersAsync(); + }); + + const input = screen.getByPlaceholderText(/Select Auto Run folder/); + fireEvent.change(input, { target: { value: '~' } }); + + await act(async () => { + vi.advanceTimersByTime(300); + await vi.runAllTimersAsync(); + }); + + expect(window.maestro.autorun.listDocs).toHaveBeenCalledWith('/home/testuser'); + }); + + it('waits for homeDir before validating tilde paths', async () => { + const onClose = vi.fn(); + const onFolderSelected = vi.fn(); + + // Delay homeDir response + let resolveHomeDir: (value: string) => void; + const homeDirPromise = new Promise(resolve => { + resolveHomeDir = resolve; + }); + vi.mocked(window.maestro.fs.homeDir).mockReturnValue(homeDirPromise); + vi.mocked(window.maestro.autorun.listDocs).mockResolvedValue({ success: true, files: [] }); + + renderWithLayerStack( + + ); + + // Wait for initial effect to fire + await act(async () => { + vi.advanceTimersByTime(10); + }); + + const input = screen.getByPlaceholderText(/Select Auto Run folder/); + fireEvent.change(input, { target: { value: '~/path' } }); + + // Debounce time passed but homeDir not loaded - should show checking + await act(async () => { + vi.advanceTimersByTime(300); + }); + + expect(screen.getByText('Checking folder...')).toBeInTheDocument(); + expect(window.maestro.autorun.listDocs).not.toHaveBeenCalled(); + + // Now resolve homeDir + await act(async () => { + resolveHomeDir!('/home/testuser'); + await vi.runAllTimersAsync(); + }); + + // After homeDir loads, effect re-runs and validation should proceed + await act(async () => { + vi.advanceTimersByTime(300); + await vi.runAllTimersAsync(); + }); + + expect(window.maestro.autorun.listDocs).toHaveBeenCalledWith('/home/testuser/path'); + }); + + it('expands tilde in path when continuing', async () => { + const onClose = vi.fn(); + const onFolderSelected = vi.fn(); + + vi.mocked(window.maestro.fs.homeDir).mockResolvedValue('/home/testuser'); + vi.mocked(window.maestro.autorun.listDocs).mockResolvedValue({ success: true, files: [] }); + + renderWithLayerStack( + + ); + + await act(async () => { + await vi.runAllTimersAsync(); + }); + + const input = screen.getByPlaceholderText(/Select Auto Run folder/); + fireEvent.change(input, { target: { value: '~/Projects' } }); + + await act(async () => { + vi.advanceTimersByTime(300); + await vi.runAllTimersAsync(); + }); + + const continueButton = screen.getByRole('button', { name: 'Continue' }); + fireEvent.click(continueButton); + + expect(onFolderSelected).toHaveBeenCalledWith('/home/testuser/Projects'); + }); + }); + + describe('folder picker dialog', () => { + it('opens folder picker when browse button is clicked', async () => { + const onClose = vi.fn(); + const onFolderSelected = vi.fn(); + + vi.mocked(window.maestro.dialog.selectFolder).mockResolvedValue('/selected/folder'); + + renderWithLayerStack( + + ); + + await act(async () => { + await vi.runAllTimersAsync(); + }); + + const browseButton = screen.getByTestId('folder-icon').closest('button')!; + fireEvent.click(browseButton); + + await act(async () => { + await vi.runAllTimersAsync(); + }); + + expect(window.maestro.dialog.selectFolder).toHaveBeenCalled(); + }); + + it('updates input when folder is selected from picker', async () => { + const onClose = vi.fn(); + const onFolderSelected = vi.fn(); + + vi.mocked(window.maestro.dialog.selectFolder).mockResolvedValue('/selected/folder'); + + renderWithLayerStack( + + ); + + await act(async () => { + await vi.runAllTimersAsync(); + }); + + const browseButton = screen.getByTestId('folder-icon').closest('button')!; + fireEvent.click(browseButton); + + await act(async () => { + await vi.runAllTimersAsync(); + }); + + const input = screen.getByPlaceholderText(/Select Auto Run folder/); + expect(input).toHaveValue('/selected/folder'); + }); + + it('does not update input when folder picker is cancelled', async () => { + const onClose = vi.fn(); + const onFolderSelected = vi.fn(); + + vi.mocked(window.maestro.dialog.selectFolder).mockResolvedValue(null); + + renderWithLayerStack( + + ); + + await act(async () => { + await vi.runAllTimersAsync(); + }); + + const input = screen.getByPlaceholderText(/Select Auto Run folder/); + fireEvent.change(input, { target: { value: '/original/path' } }); + + const browseButton = screen.getByTestId('folder-icon').closest('button')!; + fireEvent.click(browseButton); + + await act(async () => { + await vi.runAllTimersAsync(); + }); + + expect(input).toHaveValue('/original/path'); + }); + }); + + describe('keyboard interactions', () => { + it('opens folder picker on Cmd+O', async () => { + const onClose = vi.fn(); + const onFolderSelected = vi.fn(); + + vi.mocked(window.maestro.dialog.selectFolder).mockResolvedValue('/selected/folder'); + + renderWithLayerStack( + + ); + + await act(async () => { + await vi.runAllTimersAsync(); + }); + + const dialog = screen.getByRole('dialog'); + fireEvent.keyDown(dialog, { key: 'o', metaKey: true }); + + await act(async () => { + await vi.runAllTimersAsync(); + }); + + expect(window.maestro.dialog.selectFolder).toHaveBeenCalled(); + }); + + it('opens folder picker on Ctrl+O', async () => { + const onClose = vi.fn(); + const onFolderSelected = vi.fn(); + + vi.mocked(window.maestro.dialog.selectFolder).mockResolvedValue('/selected/folder'); + + renderWithLayerStack( + + ); + + await act(async () => { + await vi.runAllTimersAsync(); + }); + + const dialog = screen.getByRole('dialog'); + fireEvent.keyDown(dialog, { key: 'O', ctrlKey: true }); + + await act(async () => { + await vi.runAllTimersAsync(); + }); + + expect(window.maestro.dialog.selectFolder).toHaveBeenCalled(); + }); + + it('triggers continue on Enter when folder is selected', async () => { + const onClose = vi.fn(); + const onFolderSelected = vi.fn(); + + vi.mocked(window.maestro.autorun.listDocs).mockResolvedValue({ success: true, files: [] }); + + renderWithLayerStack( + + ); + + await act(async () => { + await vi.runAllTimersAsync(); + }); + + const input = screen.getByPlaceholderText(/Select Auto Run folder/); + fireEvent.change(input, { target: { value: '/valid/path' } }); + + await act(async () => { + vi.advanceTimersByTime(300); + await vi.runAllTimersAsync(); + }); + + const dialog = screen.getByRole('dialog'); + fireEvent.keyDown(dialog, { key: 'Enter' }); + + expect(onFolderSelected).toHaveBeenCalledWith('/valid/path'); + expect(onClose).toHaveBeenCalled(); + }); + + it('does not trigger continue on Enter when folder is empty', async () => { + const onClose = vi.fn(); + const onFolderSelected = vi.fn(); + + renderWithLayerStack( + + ); + + await act(async () => { + await vi.runAllTimersAsync(); + }); + + const dialog = screen.getByRole('dialog'); + fireEvent.keyDown(dialog, { key: 'Enter' }); + + expect(onFolderSelected).not.toHaveBeenCalled(); + expect(onClose).not.toHaveBeenCalled(); + }); + + it('stops propagation of keydown events except Escape', async () => { + const onClose = vi.fn(); + const onFolderSelected = vi.fn(); + const parentHandler = vi.fn(); + + render( +
+ + + +
+ ); + + await act(async () => { + await vi.runAllTimersAsync(); + }); + + const dialog = screen.getByRole('dialog'); + fireEvent.keyDown(dialog, { key: 'a' }); + + expect(parentHandler).not.toHaveBeenCalled(); + }); + + it('handles Escape differently from other keys (LayerStack handles it)', async () => { + const onClose = vi.fn(); + const onFolderSelected = vi.fn(); + + // The modal's onKeyDown handler does NOT call stopPropagation for Escape + // (unlike other keys), allowing LayerStack to handle it at capture phase. + // This test verifies that regular keys get stopPropagation called, + // demonstrating the conditional behavior in the keyDown handler. + const parentHandler = vi.fn(); + + render( +
+ + + +
+ ); + + await act(async () => { + await vi.runAllTimersAsync(); + }); + + const dialog = screen.getByRole('dialog'); + + // Regular key - should NOT reach parent (stopPropagation called by modal) + fireEvent.keyDown(dialog, { key: 'a' }); + expect(parentHandler).not.toHaveBeenCalled(); + + // Note: Escape is handled by LayerStack at capture phase, so it also + // doesn't reach parent, but for a different reason (LayerStack stops it) + parentHandler.mockClear(); + fireEvent.keyDown(dialog, { key: 'Escape' }); + // Parent still doesn't receive it because LayerStack intercepts in capture phase + expect(parentHandler).not.toHaveBeenCalled(); + }); + }); + + describe('close button', () => { + it('calls onClose when X button is clicked', async () => { + const onClose = vi.fn(); + const onFolderSelected = vi.fn(); + + renderWithLayerStack( + + ); + + await act(async () => { + await vi.runAllTimersAsync(); + }); + + const closeButton = screen.getByTestId('x-icon').closest('button'); + fireEvent.click(closeButton!); + + expect(onClose).toHaveBeenCalledTimes(1); + }); + }); + + describe('cancel button', () => { + it('calls onClose when Cancel is clicked', async () => { + const onClose = vi.fn(); + const onFolderSelected = vi.fn(); + + renderWithLayerStack( + + ); + + await act(async () => { + await vi.runAllTimersAsync(); + }); + + fireEvent.click(screen.getByRole('button', { name: 'Cancel' })); + expect(onClose).toHaveBeenCalledTimes(1); + }); + + it('does not call onFolderSelected when Cancel is clicked', async () => { + const onClose = vi.fn(); + const onFolderSelected = vi.fn(); + + renderWithLayerStack( + + ); + + await act(async () => { + await vi.runAllTimersAsync(); + }); + + fireEvent.click(screen.getByRole('button', { name: 'Cancel' })); + expect(onFolderSelected).not.toHaveBeenCalled(); + }); + }); + + describe('continue button', () => { + it('is disabled when no folder is selected', async () => { + const onClose = vi.fn(); + const onFolderSelected = vi.fn(); + + renderWithLayerStack( + + ); + + await act(async () => { + await vi.runAllTimersAsync(); + }); + + const continueButton = screen.getByRole('button', { name: 'Continue' }); + expect(continueButton).toBeDisabled(); + }); + + it('is enabled when folder is selected', async () => { + const onClose = vi.fn(); + const onFolderSelected = vi.fn(); + + renderWithLayerStack( + + ); + + await act(async () => { + await vi.runAllTimersAsync(); + }); + + const input = screen.getByPlaceholderText(/Select Auto Run folder/); + fireEvent.change(input, { target: { value: '/some/path' } }); + + const continueButton = screen.getByRole('button', { name: 'Continue' }); + expect(continueButton).not.toBeDisabled(); + }); + + it('calls onFolderSelected with trimmed path', async () => { + const onClose = vi.fn(); + const onFolderSelected = vi.fn(); + + vi.mocked(window.maestro.autorun.listDocs).mockResolvedValue({ success: true, files: [] }); + + renderWithLayerStack( + + ); + + await act(async () => { + await vi.runAllTimersAsync(); + }); + + const input = screen.getByPlaceholderText(/Select Auto Run folder/); + fireEvent.change(input, { target: { value: ' /path/with/spaces ' } }); + + await act(async () => { + vi.advanceTimersByTime(300); + await vi.runAllTimersAsync(); + }); + + const continueButton = screen.getByRole('button', { name: 'Continue' }); + fireEvent.click(continueButton); + + expect(onFolderSelected).toHaveBeenCalledWith('/path/with/spaces'); + }); + + it('calls onClose after onFolderSelected', async () => { + const callOrder: string[] = []; + const onClose = vi.fn(() => callOrder.push('close')); + const onFolderSelected = vi.fn(() => callOrder.push('folderSelected')); + + vi.mocked(window.maestro.autorun.listDocs).mockResolvedValue({ success: true, files: [] }); + + renderWithLayerStack( + + ); + + await act(async () => { + await vi.runAllTimersAsync(); + }); + + const input = screen.getByPlaceholderText(/Select Auto Run folder/); + fireEvent.change(input, { target: { value: '/test/path' } }); + + await act(async () => { + vi.advanceTimersByTime(300); + await vi.runAllTimersAsync(); + }); + + const continueButton = screen.getByRole('button', { name: 'Continue' }); + fireEvent.click(continueButton); + + expect(callOrder).toEqual(['folderSelected', 'close']); + }); + + it('applies theme accent color', async () => { + const onClose = vi.fn(); + const onFolderSelected = vi.fn(); + + renderWithLayerStack( + + ); + + await act(async () => { + await vi.runAllTimersAsync(); + }); + + const continueButton = screen.getByRole('button', { name: 'Continue' }); + expect(continueButton).toHaveStyle({ backgroundColor: theme.colors.accent }); + }); + }); + + describe('layer stack integration', () => { + it('registers layer on mount', async () => { + const onClose = vi.fn(); + const onFolderSelected = vi.fn(); + + const { unmount } = renderWithLayerStack( + + ); + + await act(async () => { + await vi.runAllTimersAsync(); + }); + + expect(screen.getByRole('dialog')).toBeInTheDocument(); + unmount(); + }); + + it('unregisters layer on unmount', async () => { + const onClose = vi.fn(); + const onFolderSelected = vi.fn(); + + const { unmount } = renderWithLayerStack( + + ); + + await act(async () => { + await vi.runAllTimersAsync(); + }); + + expect(() => unmount()).not.toThrow(); + }); + + it('updates layer handler when onClose changes', async () => { + const onClose1 = vi.fn(); + const onClose2 = vi.fn(); + const onFolderSelected = vi.fn(); + + const { rerender } = renderWithLayerStack( + + ); + + await act(async () => { + await vi.runAllTimersAsync(); + }); + + rerender( + + + + ); + + await act(async () => { + await vi.runAllTimersAsync(); + }); + + expect(screen.getByRole('dialog')).toBeInTheDocument(); + }); + }); + + describe('modal structure', () => { + it('has fixed positioning with backdrop', async () => { + const onClose = vi.fn(); + const onFolderSelected = vi.fn(); + + renderWithLayerStack( + + ); + + await act(async () => { + await vi.runAllTimersAsync(); + }); + + const dialog = screen.getByRole('dialog'); + expect(dialog).toHaveClass('fixed'); + expect(dialog).toHaveClass('inset-0'); + expect(dialog).toHaveClass('z-[9999]'); + }); + + it('has blur backdrop', async () => { + const onClose = vi.fn(); + const onFolderSelected = vi.fn(); + + renderWithLayerStack( + + ); + + await act(async () => { + await vi.runAllTimersAsync(); + }); + + const dialog = screen.getByRole('dialog'); + expect(dialog).toHaveClass('backdrop-blur-sm'); + }); + + it('has animation classes', async () => { + const onClose = vi.fn(); + const onFolderSelected = vi.fn(); + + renderWithLayerStack( + + ); + + await act(async () => { + await vi.runAllTimersAsync(); + }); + + const dialog = screen.getByRole('dialog'); + expect(dialog).toHaveClass('animate-in'); + expect(dialog).toHaveClass('fade-in'); + }); + + it('has tabIndex for focus', async () => { + const onClose = vi.fn(); + const onFolderSelected = vi.fn(); + + renderWithLayerStack( + + ); + + await act(async () => { + await vi.runAllTimersAsync(); + }); + + const dialog = screen.getByRole('dialog'); + expect(dialog).toHaveAttribute('tabIndex', '-1'); + }); + }); + + describe('theme variations', () => { + it('renders with light theme', async () => { + const lightTheme = createTestTheme({ + bgMain: '#ffffff', + bgSidebar: '#f5f5f5', + textMain: '#333333', + textDim: '#666666', + accent: '#0066cc', + success: '#28a745', + error: '#dc3545', + }); + + const onClose = vi.fn(); + const onFolderSelected = vi.fn(); + + const { container } = renderWithLayerStack( + + ); + + await act(async () => { + await vi.runAllTimersAsync(); + }); + + const modalContent = container.querySelector('.w-\\[520px\\]'); + expect(modalContent).toHaveStyle({ backgroundColor: lightTheme.colors.bgSidebar }); + }); + + it('applies success color to validation message', async () => { + const onClose = vi.fn(); + const onFolderSelected = vi.fn(); + + vi.mocked(window.maestro.autorun.listDocs).mockResolvedValue({ success: true, files: [] }); + + renderWithLayerStack( + + ); + + await act(async () => { + await vi.runAllTimersAsync(); + }); + + const input = screen.getByPlaceholderText(/Select Auto Run folder/); + fireEvent.change(input, { target: { value: '/valid/folder' } }); + + await act(async () => { + vi.advanceTimersByTime(300); + await vi.runAllTimersAsync(); + }); + + const successMessage = screen.getByText('Folder found (no markdown documents yet)'); + expect(successMessage).toHaveStyle({ color: theme.colors.success }); + }); + + it('applies error color to error message', async () => { + const onClose = vi.fn(); + const onFolderSelected = vi.fn(); + + vi.mocked(window.maestro.autorun.listDocs).mockResolvedValue({ success: false }); + + renderWithLayerStack( + + ); + + await act(async () => { + await vi.runAllTimersAsync(); + }); + + const input = screen.getByPlaceholderText(/Select Auto Run folder/); + fireEvent.change(input, { target: { value: '/invalid/folder' } }); + + await act(async () => { + vi.advanceTimersByTime(300); + await vi.runAllTimersAsync(); + }); + + const errorMessage = screen.getByText('Folder not found or not accessible'); + expect(errorMessage).toHaveStyle({ color: theme.colors.error }); + }); + }); + + describe('edge cases', () => { + it('handles very long folder paths', async () => { + const onClose = vi.fn(); + const onFolderSelected = vi.fn(); + + const longPath = '/a/'.repeat(100) + 'folder'; + vi.mocked(window.maestro.autorun.listDocs).mockResolvedValue({ success: true, files: [] }); + + renderWithLayerStack( + + ); + + await act(async () => { + await vi.runAllTimersAsync(); + }); + + const input = screen.getByPlaceholderText(/Select Auto Run folder/); + fireEvent.change(input, { target: { value: longPath } }); + + await act(async () => { + vi.advanceTimersByTime(300); + await vi.runAllTimersAsync(); + }); + + expect(input).toHaveValue(longPath); + expect(window.maestro.autorun.listDocs).toHaveBeenCalledWith(longPath); + }); + + it('handles paths with special characters', async () => { + const onClose = vi.fn(); + const onFolderSelected = vi.fn(); + + const specialPath = '/path with spaces/folder (test)/[brackets]'; + vi.mocked(window.maestro.autorun.listDocs).mockResolvedValue({ success: true, files: [] }); + + renderWithLayerStack( + + ); + + await act(async () => { + await vi.runAllTimersAsync(); + }); + + const input = screen.getByPlaceholderText(/Select Auto Run folder/); + fireEvent.change(input, { target: { value: specialPath } }); + + await act(async () => { + vi.advanceTimersByTime(300); + await vi.runAllTimersAsync(); + }); + + const continueButton = screen.getByRole('button', { name: 'Continue' }); + fireEvent.click(continueButton); + + expect(onFolderSelected).toHaveBeenCalledWith(specialPath); + }); + + it('handles unicode paths', async () => { + const onClose = vi.fn(); + const onFolderSelected = vi.fn(); + + const unicodePath = '/Users/テスト/Documenti/文档'; + vi.mocked(window.maestro.autorun.listDocs).mockResolvedValue({ success: true, files: [] }); + + renderWithLayerStack( + + ); + + await act(async () => { + await vi.runAllTimersAsync(); + }); + + const input = screen.getByPlaceholderText(/Select Auto Run folder/); + fireEvent.change(input, { target: { value: unicodePath } }); + + await act(async () => { + vi.advanceTimersByTime(300); + await vi.runAllTimersAsync(); + }); + + const continueButton = screen.getByRole('button', { name: 'Continue' }); + fireEvent.click(continueButton); + + expect(onFolderSelected).toHaveBeenCalledWith(unicodePath); + }); + + it('handles rapid folder changes', async () => { + const onClose = vi.fn(); + const onFolderSelected = vi.fn(); + + vi.mocked(window.maestro.autorun.listDocs).mockResolvedValue({ success: true, files: [] }); + + renderWithLayerStack( + + ); + + await act(async () => { + await vi.runAllTimersAsync(); + }); + + const input = screen.getByPlaceholderText(/Select Auto Run folder/); + + // Rapid changes + for (let i = 0; i < 10; i++) { + fireEvent.change(input, { target: { value: `/path${i}` } }); + await act(async () => { vi.advanceTimersByTime(50); }); + } + + // Wait for final debounce + await act(async () => { + vi.advanceTimersByTime(300); + await vi.runAllTimersAsync(); + }); + + // Only the last path should be validated + expect(window.maestro.autorun.listDocs).toHaveBeenCalledWith('/path9'); + }); + + it('cancels previous validation request when folder changes quickly', async () => { + const onClose = vi.fn(); + const onFolderSelected = vi.fn(); + + vi.mocked(window.maestro.autorun.listDocs).mockResolvedValue({ success: true, files: ['doc.md'] }); + + renderWithLayerStack( + + ); + + await act(async () => { + await vi.runAllTimersAsync(); + }); + + const input = screen.getByPlaceholderText(/Select Auto Run folder/); + + // First change - start typing + fireEvent.change(input, { target: { value: '/first/path' } }); + await act(async () => { vi.advanceTimersByTime(100); }); // Less than debounce time + + // Second change - before first debounce completes + fireEvent.change(input, { target: { value: '/second/path' } }); + await act(async () => { vi.advanceTimersByTime(300); }); // Now debounce fires + + await act(async () => { await vi.runAllTimersAsync(); }); + + // Only the second path should have been validated (first was cancelled by debounce) + expect(window.maestro.autorun.listDocs).toHaveBeenCalledTimes(1); + expect(window.maestro.autorun.listDocs).toHaveBeenCalledWith('/second/path'); + expect(screen.getByText('Found 1 markdown document')).toBeInTheDocument(); + }); + }); + + describe('accessibility', () => { + it('has semantic button elements', async () => { + const onClose = vi.fn(); + const onFolderSelected = vi.fn(); + + renderWithLayerStack( + + ); + + await act(async () => { + await vi.runAllTimersAsync(); + }); + + const buttons = screen.getAllByRole('button'); + expect(buttons.length).toBeGreaterThanOrEqual(3); // X, Browse, Cancel, Continue + }); + + it('has heading for modal title', async () => { + const onClose = vi.fn(); + const onFolderSelected = vi.fn(); + + renderWithLayerStack( + + ); + + await act(async () => { + await vi.runAllTimersAsync(); + }); + + expect(screen.getByRole('heading', { name: 'Set Up Auto Run' })).toBeInTheDocument(); + }); + + it('has labeled input field', async () => { + const onClose = vi.fn(); + const onFolderSelected = vi.fn(); + + renderWithLayerStack( + + ); + + await act(async () => { + await vi.runAllTimersAsync(); + }); + + expect(screen.getByText('Auto Run Folder')).toBeInTheDocument(); + }); + + it('has focus ring on continue button', async () => { + const onClose = vi.fn(); + const onFolderSelected = vi.fn(); + + renderWithLayerStack( + + ); + + await act(async () => { + await vi.runAllTimersAsync(); + }); + + const continueButton = screen.getByRole('button', { name: 'Continue' }); + expect(continueButton).toHaveClass('focus:ring-2'); + expect(continueButton).toHaveClass('focus:ring-offset-1'); + }); + + it('has title attribute on browse button', async () => { + const onClose = vi.fn(); + const onFolderSelected = vi.fn(); + + renderWithLayerStack( + + ); + + await act(async () => { + await vi.runAllTimersAsync(); + }); + + const browseButton = screen.getByTestId('folder-icon').closest('button'); + expect(browseButton).toHaveAttribute('title', 'Browse folders (Cmd+O)'); + }); + }); +}); diff --git a/src/__tests__/renderer/components/AutoRunnerHelpModal.test.tsx b/src/__tests__/renderer/components/AutoRunnerHelpModal.test.tsx new file mode 100644 index 00000000..aa7f92f3 --- /dev/null +++ b/src/__tests__/renderer/components/AutoRunnerHelpModal.test.tsx @@ -0,0 +1,535 @@ +/** + * Tests for AutoRunnerHelpModal component + * + * AutoRunnerHelpModal is a help dialog that displays comprehensive documentation + * about the Auto Run feature. It integrates with the layer stack for modal management. + */ + +import React from 'react'; +import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'; +import { render, screen, fireEvent, cleanup } from '@testing-library/react'; +import { AutoRunnerHelpModal } from '../../../renderer/components/AutoRunnerHelpModal'; +import type { Theme } from '../../../renderer/types'; +import { LayerStackProvider } from '../../../renderer/contexts/LayerStackContext'; + +// Mock the layer stack context +const mockRegisterLayer = vi.fn(() => 'layer-123'); +const mockUnregisterLayer = vi.fn(); +const mockUpdateLayerHandler = vi.fn(); + +vi.mock('../../../renderer/contexts/LayerStackContext', async () => { + const actual = await vi.importActual('../../../renderer/contexts/LayerStackContext'); + return { + ...actual, + useLayerStack: () => ({ + registerLayer: mockRegisterLayer, + unregisterLayer: mockUnregisterLayer, + updateLayerHandler: mockUpdateLayerHandler, + getTopLayer: vi.fn(), + closeTopLayer: vi.fn(), + getLayers: vi.fn(() => []), + hasOpenLayers: vi.fn(() => false), + hasOpenModal: vi.fn(() => false), + layerCount: 0, + }), + }; +}); + +// Mock formatShortcutKeys to return predictable output +vi.mock('../../../renderer/utils/shortcutFormatter', () => ({ + formatShortcutKeys: (keys: string[]) => keys.join('+'), +})); + +// Sample theme for testing +const mockTheme: Theme = { + id: 'test-dark', + name: 'Test Dark', + mode: 'dark', + colors: { + bgMain: '#1a1a1a', + bgSidebar: '#252525', + bgActivity: '#2d2d2d', + border: '#444444', + textMain: '#ffffff', + textDim: '#888888', + accent: '#007acc', + error: '#ff4444', + success: '#44ff44', + warning: '#ffaa00', + cursor: '#ffffff', + selection: '#264f78', + terminalBackground: '#000000', + }, +}; + +describe('AutoRunnerHelpModal', () => { + const mockOnClose = vi.fn(); + + beforeEach(() => { + vi.clearAllMocks(); + }); + + afterEach(() => { + cleanup(); + }); + + describe('Rendering', () => { + it('should render the modal container', () => { + render(); + + // Check for the modal backdrop + const backdrop = document.querySelector('.fixed.inset-0'); + expect(backdrop).toBeInTheDocument(); + }); + + it('should render the header with title', () => { + render(); + + expect(screen.getByText('Auto Run Guide')).toBeInTheDocument(); + }); + + it('should render the close button (X icon) in header', () => { + render(); + + // Find button with X icon (close button in header) + const closeButtons = screen.getAllByRole('button'); + expect(closeButtons.length).toBeGreaterThan(0); + }); + + it('should render the "Got it" button in footer', () => { + render(); + + expect(screen.getByText('Got it')).toBeInTheDocument(); + }); + }); + + describe('Content Sections', () => { + beforeEach(() => { + render(); + }); + + it('should render Introduction section', () => { + expect(screen.getByText(/Auto Run is a file-system-based document runner/)).toBeInTheDocument(); + }); + + it('should render Setting Up section', () => { + expect(screen.getByText('Setting Up a Runner Docs Folder')).toBeInTheDocument(); + expect(screen.getByText(/When you first open the Auto Run tab/)).toBeInTheDocument(); + }); + + it('should render Document Format section', () => { + expect(screen.getByText('Document Format')).toBeInTheDocument(); + expect(screen.getByText(/Create markdown files/)).toBeInTheDocument(); + }); + + it('should render Creating Tasks section', () => { + expect(screen.getByText('Creating Tasks')).toBeInTheDocument(); + expect(screen.getByText(/Write clear, specific task descriptions/)).toBeInTheDocument(); + }); + + it('should render Image Attachments section', () => { + expect(screen.getByText('Image Attachments')).toBeInTheDocument(); + expect(screen.getByText(/Paste images directly into your documents/)).toBeInTheDocument(); + }); + + it('should render Running a Single Document section', () => { + expect(screen.getByText('Running a Single Document')).toBeInTheDocument(); + expect(screen.getByText(/The runner spawns a fresh AI session/)).toBeInTheDocument(); + }); + + it('should render Running Multiple Documents section', () => { + expect(screen.getByText('Running Multiple Documents')).toBeInTheDocument(); + expect(screen.getByText(/Documents are processed sequentially/)).toBeInTheDocument(); + }); + + it('should render Template Variables section', () => { + expect(screen.getByText('Template Variables')).toBeInTheDocument(); + expect(screen.getByText(/Use template variables in your documents/)).toBeInTheDocument(); + }); + + it('should render available template variable examples', () => { + expect(screen.getByText('{{SESSION_NAME}}')).toBeInTheDocument(); + expect(screen.getByText('{{PROJECT_PATH}}')).toBeInTheDocument(); + expect(screen.getByText('{{GIT_BRANCH}}')).toBeInTheDocument(); + expect(screen.getByText('{{DATE}}')).toBeInTheDocument(); + expect(screen.getByText('{{LOOP_NUMBER}}')).toBeInTheDocument(); + expect(screen.getByText('{{DOCUMENT_NAME}}')).toBeInTheDocument(); + }); + + it('should render Reset on Completion section', () => { + expect(screen.getByText('Reset on Completion')).toBeInTheDocument(); + expect(screen.getByText(/Enable the reset toggle/)).toBeInTheDocument(); + }); + + it('should render Loop Mode section', () => { + expect(screen.getByText('Loop Mode')).toBeInTheDocument(); + expect(screen.getByText(/continuously cycle through the document queue/)).toBeInTheDocument(); + }); + + it('should render Playbooks section', () => { + // Use getAllByText since "Playbooks" appears multiple times (heading + reference) + const playbooksElements = screen.getAllByText(/Playbooks/); + expect(playbooksElements.length).toBeGreaterThan(0); + expect(screen.getByText(/Save your batch run configurations/)).toBeInTheDocument(); + }); + + it('should render History & Tracking section', () => { + expect(screen.getByText('History & Tracking')).toBeInTheDocument(); + expect(screen.getByText(/Completed tasks appear in the/)).toBeInTheDocument(); + }); + + it('should render Read-Only Mode section', () => { + expect(screen.getByText('Read-Only Mode')).toBeInTheDocument(); + expect(screen.getByText(/While Auto Run is active, the AI interpreter operates in/)).toBeInTheDocument(); + }); + + it('should render Git Worktree section', () => { + expect(screen.getByText('Git Worktree (Parallel Work)')).toBeInTheDocument(); + expect(screen.getByText(/For Git repositories, enable/)).toBeInTheDocument(); + }); + + it('should render Stopping Auto Run section', () => { + expect(screen.getByText('Stopping Auto Run')).toBeInTheDocument(); + expect(screen.getByText(/to gracefully stop/)).toBeInTheDocument(); + }); + + it('should render Keyboard Shortcuts section', () => { + expect(screen.getByText('Keyboard Shortcuts')).toBeInTheDocument(); + }); + + it('should render all keyboard shortcuts', () => { + expect(screen.getByText('Open Auto Run tab')).toBeInTheDocument(); + expect(screen.getByText('Toggle Edit/Preview mode')).toBeInTheDocument(); + expect(screen.getByText('Insert checkbox at cursor')).toBeInTheDocument(); + expect(screen.getByText('Undo')).toBeInTheDocument(); + expect(screen.getByText('Redo')).toBeInTheDocument(); + }); + + it('should render code examples in Document Format section', () => { + expect(screen.getByText(/# Feature Plan/)).toBeInTheDocument(); + expect(screen.getByText(/Implement user authentication/)).toBeInTheDocument(); + }); + + it('should render list items in Playbooks section', () => { + expect(screen.getByText('Document selection and order')).toBeInTheDocument(); + expect(screen.getByText('Reset-on-completion settings per document')).toBeInTheDocument(); + expect(screen.getByText('Loop mode preference')).toBeInTheDocument(); + expect(screen.getByText('Custom agent prompt')).toBeInTheDocument(); + }); + }); + + describe('Theme Integration', () => { + it('should apply theme background color to modal', () => { + render(); + + // Find modal by its styling class + const modal = document.querySelector('.relative.w-full'); + expect(modal).toHaveStyle({ backgroundColor: mockTheme.colors.bgSidebar }); + }); + + it('should apply theme text color to title', () => { + render(); + + const title = screen.getByText('Auto Run Guide'); + expect(title).toHaveStyle({ color: mockTheme.colors.textMain }); + }); + + it('should apply theme accent color to "Got it" button', () => { + render(); + + const gotItButton = screen.getByText('Got it'); + expect(gotItButton).toHaveStyle({ backgroundColor: mockTheme.colors.accent }); + }); + }); + + describe('User Interactions', () => { + it('should call onClose when backdrop is clicked', () => { + render(); + + // Find and click the backdrop (first element with bg-black/60) + const backdrop = document.querySelector('.absolute.inset-0.bg-black\\/60'); + expect(backdrop).toBeInTheDocument(); + fireEvent.click(backdrop!); + + expect(mockOnClose).toHaveBeenCalledTimes(1); + }); + + it('should call onClose when X button is clicked', () => { + render(); + + // Find the X button (in the header, first button) + const buttons = screen.getAllByRole('button'); + const closeButton = buttons.find(btn => btn.querySelector('svg')); + + if (closeButton) { + fireEvent.click(closeButton); + expect(mockOnClose).toHaveBeenCalledTimes(1); + } + }); + + it('should call onClose when "Got it" button is clicked', () => { + render(); + + const gotItButton = screen.getByText('Got it'); + fireEvent.click(gotItButton); + + expect(mockOnClose).toHaveBeenCalledTimes(1); + }); + }); + + describe('Layer Stack Integration', () => { + it('should register layer on mount', () => { + render(); + + expect(mockRegisterLayer).toHaveBeenCalledTimes(1); + expect(mockRegisterLayer).toHaveBeenCalledWith( + expect.objectContaining({ + type: 'modal', + }) + ); + }); + + it('should register layer with correct onEscape handler', () => { + render(); + + const registerCall = mockRegisterLayer.mock.calls[0][0]; + expect(registerCall.onEscape).toBeDefined(); + + // Call the onEscape handler + registerCall.onEscape(); + expect(mockOnClose).toHaveBeenCalledTimes(1); + }); + + it('should unregister layer on unmount', () => { + const { unmount } = render(); + + unmount(); + + expect(mockUnregisterLayer).toHaveBeenCalledTimes(1); + expect(mockUnregisterLayer).toHaveBeenCalledWith('layer-123'); + }); + + it('should update layer handler when onClose changes', () => { + render(); + + expect(mockUpdateLayerHandler).toHaveBeenCalled(); + }); + + it('should call updated onClose when escape handler is invoked after update', () => { + render(); + + // Get the handler passed to updateLayerHandler + const updateCall = mockUpdateLayerHandler.mock.calls[0]; + if (updateCall && updateCall[1]) { + updateCall[1](); // Invoke the handler + expect(mockOnClose).toHaveBeenCalled(); + } + }); + }); + + describe('Accessibility', () => { + it('should have proper modal structure', () => { + render(); + + // Modal should have proper container structure + const modalContainer = document.querySelector('.fixed.inset-0.flex.items-center.justify-center'); + expect(modalContainer).toBeInTheDocument(); + }); + + it('should have scrollable content area', () => { + render(); + + // Content area should be scrollable + const contentArea = document.querySelector('.overflow-y-auto'); + expect(contentArea).toBeInTheDocument(); + }); + + it('should render section headings as h3 elements', () => { + render(); + + // Main title should be h2 + const mainTitle = screen.getByRole('heading', { level: 2 }); + expect(mainTitle).toHaveTextContent('Auto Run Guide'); + }); + + it('should have keyboard shortcuts displayed with kbd elements', () => { + render(); + + // kbd elements should be present for shortcuts + const kbdElements = document.querySelectorAll('kbd'); + expect(kbdElements.length).toBeGreaterThan(0); + }); + }); + + describe('Content Structure', () => { + it('should render icons for each section', () => { + render(); + + // SVG icons should be present throughout + const svgElements = document.querySelectorAll('svg'); + expect(svgElements.length).toBeGreaterThan(10); // Multiple sections with icons + }); + + it('should render code elements for technical content', () => { + render(); + + // Code elements for file extensions, commands, etc. + const codeElements = document.querySelectorAll('code'); + expect(codeElements.length).toBeGreaterThan(0); + }); + + it('should apply accent color styling to section icons', () => { + render(); + + // Section icons should have accent color + const sectionHeaders = document.querySelectorAll('.flex.items-center.gap-2'); + expect(sectionHeaders.length).toBeGreaterThan(0); + }); + + it('should render border styling with theme colors', () => { + render(); + + // Border elements should use theme border color + const borderedElements = document.querySelectorAll('.border-b'); + expect(borderedElements.length).toBeGreaterThan(0); + }); + }); + + describe('Dynamic Content', () => { + it('should format keyboard shortcuts using formatShortcutKeys', () => { + render(); + + // Our mock returns keys joined with + + // The component uses formatShortcutKeys for shortcuts like ['Meta', 'l'] + // Should render something like "Meta+l" + const kbdElements = document.querySelectorAll('kbd'); + const hasFormattedShortcut = Array.from(kbdElements).some(kbd => + kbd.textContent?.includes('Meta') + ); + expect(hasFormattedShortcut).toBe(true); + }); + + it('should highlight "Quick Insert" tips', () => { + render(); + + // Multiple "Quick Insert" tips exist + const quickInsertElements = screen.getAllByText(/Quick Insert:/); + expect(quickInsertElements.length).toBeGreaterThan(0); + }); + + it('should include template variable syntax examples', () => { + render(); + + // Template variable trigger syntax + expect(screen.getByText('{{')).toBeInTheDocument(); + }); + }); + + describe('Responsive Design', () => { + it('should have max-width constraint on modal', () => { + render(); + + const modal = document.querySelector('.max-w-2xl'); + expect(modal).toBeInTheDocument(); + }); + + it('should have max-height constraint for scrolling', () => { + render(); + + const modal = document.querySelector('.max-h-\\[85vh\\]'); + expect(modal).toBeInTheDocument(); + }); + + it('should use flex layout for modal structure', () => { + render(); + + const flexModal = document.querySelector('.flex.flex-col'); + expect(flexModal).toBeInTheDocument(); + }); + }); + + describe('onCloseRef Updates', () => { + it('should use ref to track onClose for stable layer registration', () => { + const { rerender } = render( + + ); + + const newOnClose = vi.fn(); + rerender(); + + // The updateLayerHandler should have been called + expect(mockUpdateLayerHandler).toHaveBeenCalled(); + + // Get the latest handler and call it + const lastCall = mockUpdateLayerHandler.mock.calls[mockUpdateLayerHandler.mock.calls.length - 1]; + if (lastCall && lastCall[1]) { + lastCall[1](); + // The new onClose should be called due to ref update + expect(newOnClose).toHaveBeenCalled(); + } + }); + }); + + describe('Special Characters in Content', () => { + it('should render checkbox syntax examples', () => { + render(); + + // Checkbox format is mentioned + expect(screen.getByText(/- \[ \]/)).toBeInTheDocument(); + }); + + it('should render file extension examples', () => { + render(); + + // .md extension mentioned + const codeElements = document.querySelectorAll('code'); + const hasMdExtension = Array.from(codeElements).some(code => + code.textContent?.includes('.md') + ); + expect(hasMdExtension).toBe(true); + }); + + it('should render images subfolder reference', () => { + render(); + + // images/ subfolder mentioned + const codeElements = document.querySelectorAll('code'); + const hasImagesFolder = Array.from(codeElements).some(code => + code.textContent?.includes('images/') + ); + expect(hasImagesFolder).toBe(true); + }); + }); + + describe('Warning Colors', () => { + it('should use warning color for Read-Only Mode icon', () => { + render(); + + // Read-Only Mode section uses warning color + const readOnlyHeading = screen.getByText('Read-Only Mode'); + const section = readOnlyHeading.closest('section'); + expect(section).toBeInTheDocument(); + }); + + it('should highlight read-only indicator with warning color', () => { + render(); + + // READ-ONLY text is styled with warning color + expect(screen.getByText('READ-ONLY')).toBeInTheDocument(); + }); + + it('should highlight AUTO label in History section', () => { + render(); + + // AUTO label is mentioned + expect(screen.getByText('AUTO')).toBeInTheDocument(); + }); + + it('should use error color for Stop button in Stopping section', () => { + render(); + + // Stop is highlighted in the stopping section + expect(screen.getByText('Stopping Auto Run')).toBeInTheDocument(); + }); + }); +}); diff --git a/src/__tests__/renderer/components/BatchRunnerModal.test.tsx b/src/__tests__/renderer/components/BatchRunnerModal.test.tsx new file mode 100644 index 00000000..fd87ead1 --- /dev/null +++ b/src/__tests__/renderer/components/BatchRunnerModal.test.tsx @@ -0,0 +1,2321 @@ +import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'; +import { render, screen, fireEvent, waitFor, within, act } from '@testing-library/react'; +import React from 'react'; +import { BatchRunnerModal, DEFAULT_BATCH_PROMPT } from '../../../renderer/components/BatchRunnerModal'; +import type { Theme, Playbook } from '../../../renderer/types'; + +// Mock LayerStackContext +const mockRegisterLayer = vi.fn(() => 'layer-123'); +const mockUnregisterLayer = vi.fn(); +const mockUpdateLayerHandler = vi.fn(); + +vi.mock('../../../renderer/contexts/LayerStackContext', () => ({ + useLayerStack: () => ({ + registerLayer: mockRegisterLayer, + unregisterLayer: mockUnregisterLayer, + updateLayerHandler: mockUpdateLayerHandler, + }), +})); + +// Mock child modals +vi.mock('../../../renderer/components/PlaybookDeleteConfirmModal', () => ({ + PlaybookDeleteConfirmModal: ({ onConfirm, onCancel, playbookName }: { + onConfirm: () => void; + onCancel: () => void; + playbookName: string; + }) => ( +
+ Delete {playbookName}? + + +
+ ), +})); + +vi.mock('../../../renderer/components/PlaybookNameModal', () => ({ + PlaybookNameModal: ({ onSave, onCancel, title }: { + onSave: (name: string) => void; + onCancel: () => void; + title: string; + }) => ( +
+ {title} + + + +
+ ), +})); + +vi.mock('../../../renderer/components/AgentPromptComposerModal', () => ({ + AgentPromptComposerModal: ({ isOpen, onClose, onSubmit, initialValue }: { + isOpen: boolean; + onClose: () => void; + onSubmit: (value: string) => void; + initialValue: string; + }) => isOpen ? ( +
+