@urugus/slack-cli 0.2.2 → 0.2.4

package/tests/commands/unread.test.ts

@@ -174,6 +174,118 @@ describe('unread command', () => {
       expect(mockConsole.logSpy).toHaveBeenCalledWith(expect.stringContaining('Hello world'));
       expect(mockConsole.logSpy).toHaveBeenCalledWith(expect.stringContaining('Test message'));
     });
+
+    it('should display channel unread in JSON format when specified', async () => {
+      vi.mocked(mockConfigManager.getConfig).mockResolvedValue({
+        token: 'test-token',
+        updatedAt: new Date().toISOString()
+      });
+      vi.mocked(mockSlackClient.getChannelUnread).mockResolvedValue({
+        channel: mockChannelsWithUnread[0],
+        messages: mockUnreadMessages,
+        users: new Map([
+          ['U123', 'john.doe'],
+          ['U456', 'jane.smith']
+        ])
+      });
+
+      await program.parseAsync(['node', 'slack-cli', 'unread', '--channel', 'general', '--format', 'json']);
+
+      expect(mockSlackClient.getChannelUnread).toHaveBeenCalledWith('general');
+      
+      const logCall = mockConsole.logSpy.mock.calls[0][0];
+      const parsed = JSON.parse(logCall);
+      
+      expect(parsed).toEqual({
+        channel: '#general',
+        channelId: 'C123',
+        unreadCount: 5,
+        messages: [
+          {
+            timestamp: expect.any(String),
+            author: 'john.doe',
+            text: 'Hello world'
+          },
+          {
+            timestamp: expect.any(String),
+            author: 'jane.smith',
+            text: 'Test message'
+          }
+        ]
+      });
+    });
+
+    it('should display channel unread in simple format when specified', async () => {
+      vi.mocked(mockConfigManager.getConfig).mockResolvedValue({
+        token: 'test-token',
+        updatedAt: new Date().toISOString()
+      });
+      vi.mocked(mockSlackClient.getChannelUnread).mockResolvedValue({
+        channel: mockChannelsWithUnread[0],
+        messages: mockUnreadMessages,
+        users: new Map([
+          ['U123', 'john.doe'],
+          ['U456', 'jane.smith']
+        ])
+      });
+
+      await program.parseAsync(['node', 'slack-cli', 'unread', '--channel', 'general', '--format', 'simple']);
+
+      expect(mockSlackClient.getChannelUnread).toHaveBeenCalledWith('general');
+      expect(mockConsole.logSpy).toHaveBeenCalledWith('#general (5)');
+      expect(mockConsole.logSpy).toHaveBeenCalledWith(expect.stringMatching(/^\[.*\] john\.doe: Hello world$/));
+      expect(mockConsole.logSpy).toHaveBeenCalledWith(expect.stringMatching(/^\[.*\] jane\.smith: Test message$/));
+    });
+
+    it('should show only count for channel when --count-only is specified', async () => {
+      vi.mocked(mockConfigManager.getConfig).mockResolvedValue({
+        token: 'test-token',
+        updatedAt: new Date().toISOString()
+      });
+      vi.mocked(mockSlackClient.getChannelUnread).mockResolvedValue({
+        channel: mockChannelsWithUnread[0],
+        messages: mockUnreadMessages,
+        users: new Map([
+          ['U123', 'john.doe'],
+          ['U456', 'jane.smith']
+        ])
+      });
+
+      await program.parseAsync(['node', 'slack-cli', 'unread', '--channel', 'general', '--count-only']);
+
+      expect(mockSlackClient.getChannelUnread).toHaveBeenCalledWith('general');
+      expect(mockConsole.logSpy).toHaveBeenCalledWith(chalk.bold(`#general: 5 unread messages`));
+      expect(mockConsole.logSpy).not.toHaveBeenCalledWith(expect.stringContaining('Hello world'));
+      expect(mockConsole.logSpy).not.toHaveBeenCalledWith(expect.stringContaining('Test message'));
+    });
+
+    it('should show count only in JSON format when both --count-only and --format json are specified', async () => {
+      vi.mocked(mockConfigManager.getConfig).mockResolvedValue({
+        token: 'test-token',
+        updatedAt: new Date().toISOString()
+      });
+      vi.mocked(mockSlackClient.getChannelUnread).mockResolvedValue({
+        channel: mockChannelsWithUnread[0],
+        messages: mockUnreadMessages,
+        users: new Map([
+          ['U123', 'john.doe'],
+          ['U456', 'jane.smith']
+        ])
+      });
+
+      await program.parseAsync(['node', 'slack-cli', 'unread', '--channel', 'general', '--count-only', '--format', 'json']);
+
+      expect(mockSlackClient.getChannelUnread).toHaveBeenCalledWith('general');
+      
+      const logCall = mockConsole.logSpy.mock.calls[0][0];
+      const parsed = JSON.parse(logCall);
+      
+      expect(parsed).toEqual({
+        channel: '#general',
+        channelId: 'C123',
+        unreadCount: 5
+      });
+    });
   });
 
   describe('limit option', () => {

package/tests/utils/config/config-file-manager.test.ts

@@ -0,0 +1,118 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import * as fs from 'fs/promises';
+import * as os from 'os';
+import * as path from 'path';
+import { ConfigFileManager } from '../../../src/utils/config/config-file-manager';
+
+vi.mock('fs/promises');
+vi.mock('os');
+
+describe('ConfigFileManager', () => {
+  let manager: ConfigFileManager;
+  const mockHomeDir = '/home/user';
+  const mockConfigPath = path.join(mockHomeDir, '.slack-cli', 'config.json');
+
+  beforeEach(() => {
+    vi.mocked(os.homedir).mockReturnValue(mockHomeDir);
+    manager = new ConfigFileManager();
+  });
+
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe('read', () => {
+    it('should read and parse config file when it exists', async () => {
+      const mockConfig = {
+        profiles: { default: { token: 'encrypted-token' } },
+        currentProfile: 'default'
+      };
+      vi.mocked(fs.access).mockResolvedValueOnce(undefined);
+      vi.mocked(fs.readFile).mockResolvedValueOnce(JSON.stringify(mockConfig));
+
+      const result = await manager.read();
+
+      expect(result).toEqual(mockConfig);
+      expect(fs.readFile).toHaveBeenCalledWith(mockConfigPath, 'utf-8');
+    });
+
+    it('should return default config when file does not exist', async () => {
+      vi.mocked(fs.access).mockRejectedValueOnce(new Error('ENOENT'));
+
+      const result = await manager.read();
+
+      expect(result).toEqual({
+        profiles: {},
+        currentProfile: 'default'
+      });
+    });
+
+    it('should throw error for invalid JSON', async () => {
+      vi.mocked(fs.access).mockResolvedValueOnce(undefined);
+      vi.mocked(fs.readFile).mockResolvedValueOnce('invalid json');
+
+      await expect(manager.read()).rejects.toThrow('Invalid configuration file');
+    });
+  });
+
+  describe('write', () => {
+    it('should create directory and write config file', async () => {
+      const mockConfig = {
+        profiles: { default: { token: 'encrypted-token' } },
+        currentProfile: 'default'
+      };
+      vi.mocked(fs.mkdir).mockResolvedValueOnce(undefined as any);
+      vi.mocked(fs.writeFile).mockResolvedValueOnce(undefined);
+
+      await manager.write(mockConfig);
+
+      expect(fs.mkdir).toHaveBeenCalledWith(
+        path.dirname(mockConfigPath),
+        { recursive: true }
+      );
+      expect(fs.writeFile).toHaveBeenCalledWith(
+        mockConfigPath,
+        JSON.stringify(mockConfig, null, 2),
+        'utf-8'
+      );
+    });
+
+    it('should handle write errors', async () => {
+      const mockConfig = {
+        profiles: {},
+        currentProfile: 'default'
+      };
+      vi.mocked(fs.mkdir).mockResolvedValueOnce(undefined as any);
+      vi.mocked(fs.writeFile).mockRejectedValueOnce(new Error('Write failed'));
+
+      await expect(manager.write(mockConfig)).rejects.toThrow('Write failed');
+    });
+  });
+
+  describe('exists', () => {
+    it('should return true when config file exists', async () => {
+      vi.mocked(fs.access).mockResolvedValueOnce(undefined);
+
+      const result = await manager.exists();
+
+      expect(result).toBe(true);
+      expect(fs.access).toHaveBeenCalledWith(mockConfigPath);
+    });
+
+    it('should return false when config file does not exist', async () => {
+      vi.mocked(fs.access).mockRejectedValueOnce(new Error('ENOENT'));
+
+      const result = await manager.exists();
+
+      expect(result).toBe(false);
+    });
+  });
+
+  describe('getConfigPath', () => {
+    it('should return the correct config path', () => {
+      const result = manager.getConfigPath();
+
+      expect(result).toBe(mockConfigPath);
+    });
+  });
+});

package/tests/utils/config/profile-manager.test.ts

@@ -0,0 +1,266 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { ProfileManager } from '../../../src/utils/config/profile-manager';
+import { ConfigFileManager } from '../../../src/utils/config/config-file-manager';
+import { TokenCryptoService } from '../../../src/utils/config/token-crypto-service';
+import { Config } from '../../../src/types/config';
+
+vi.mock('../../../src/utils/config/config-file-manager');
+vi.mock('../../../src/utils/config/token-crypto-service');
+
+describe('ProfileManager', () => {
+  let manager: ProfileManager;
+  let mockFileManager: ConfigFileManager;
+  let mockCryptoService: TokenCryptoService;
+
+  beforeEach(() => {
+    mockFileManager = new ConfigFileManager();
+    mockCryptoService = new TokenCryptoService();
+    manager = new ProfileManager(mockFileManager, mockCryptoService);
+    
+    vi.clearAllMocks();
+  });
+
+  describe('getProfile', () => {
+    it('should get and decrypt a profile token', async () => {
+      const mockConfig = {
+        profiles: {
+          test: { token: 'encrypted-token', updatedAt: '2024-01-01' }
+        },
+        currentProfile: 'test'
+      };
+      
+      vi.mocked(mockFileManager.read).mockResolvedValueOnce(mockConfig);
+      vi.mocked(mockCryptoService.isEncrypted).mockReturnValueOnce(true);
+      vi.mocked(mockCryptoService.decrypt).mockReturnValueOnce('decrypted-token');
+
+      const result = await manager.getProfile('test');
+
+      expect(result).toEqual({
+        token: 'decrypted-token',
+        updatedAt: '2024-01-01'
+      });
+      expect(mockCryptoService.decrypt).toHaveBeenCalledWith('encrypted-token');
+    });
+
+    it('should throw error if profile does not exist', async () => {
+      const mockConfig = {
+        profiles: {},
+        currentProfile: 'default'
+      };
+      
+      vi.mocked(mockFileManager.read).mockResolvedValueOnce(mockConfig);
+
+      await expect(manager.getProfile('nonexistent')).rejects.toThrow(
+        'Profile "nonexistent" not found'
+      );
+    });
+
+    it('should handle already decrypted tokens', async () => {
+      const mockConfig = {
+        profiles: {
+          test: { token: 'plain-token', updatedAt: '2024-01-01' }
+        },
+        currentProfile: 'test'
+      };
+      
+      vi.mocked(mockFileManager.read).mockResolvedValueOnce(mockConfig);
+      vi.mocked(mockCryptoService.isEncrypted).mockReturnValueOnce(false);
+
+      const result = await manager.getProfile('test');
+
+      expect(result).toEqual({
+        token: 'plain-token',
+        updatedAt: '2024-01-01'
+      });
+      expect(mockCryptoService.decrypt).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('setProfile', () => {
+    it('should set and encrypt a profile token', async () => {
+      const mockConfig = {
+        profiles: {},
+        currentProfile: 'default'
+      };
+      const newProfile: Config = {
+        token: 'new-token',
+        updatedAt: '2024-01-01'
+      };
+      
+      vi.mocked(mockFileManager.read).mockResolvedValueOnce(mockConfig);
+      vi.mocked(mockCryptoService.encrypt).mockReturnValueOnce('encrypted-new-token');
+      vi.mocked(mockFileManager.write).mockResolvedValueOnce(undefined);
+
+      await manager.setProfile('test', newProfile);
+
+      expect(mockCryptoService.encrypt).toHaveBeenCalledWith('new-token');
+      expect(mockFileManager.write).toHaveBeenCalledWith({
+        profiles: {
+          test: { token: 'encrypted-new-token', updatedAt: '2024-01-01' }
+        },
+        currentProfile: 'default'
+      });
+    });
+
+    it('should update existing profile', async () => {
+      const mockConfig = {
+        profiles: {
+          test: { token: 'old-encrypted', updatedAt: '2024-01-01' }
+        },
+        currentProfile: 'test'
+      };
+      const updatedProfile: Config = {
+        token: 'updated-token',
+        updatedAt: '2024-01-02'
+      };
+      
+      vi.mocked(mockFileManager.read).mockResolvedValueOnce(mockConfig);
+      vi.mocked(mockCryptoService.encrypt).mockReturnValueOnce('encrypted-updated-token');
+      vi.mocked(mockFileManager.write).mockResolvedValueOnce(undefined);
+
+      await manager.setProfile('test', updatedProfile);
+
+      expect(mockFileManager.write).toHaveBeenCalledWith({
+        profiles: {
+          test: { token: 'encrypted-updated-token', updatedAt: '2024-01-02' }
+        },
+        currentProfile: 'test'
+      });
+    });
+  });
+
+  describe('deleteProfile', () => {
+    it('should delete a profile', async () => {
+      const mockConfig = {
+        profiles: {
+          test: { token: 'encrypted-token', updatedAt: '2024-01-01' },
+          another: { token: 'another-token', updatedAt: '2024-01-01' }
+        },
+        currentProfile: 'test'
+      };
+      
+      vi.mocked(mockFileManager.read).mockResolvedValueOnce(mockConfig);
+      vi.mocked(mockFileManager.write).mockResolvedValueOnce(undefined);
+
+      await manager.deleteProfile('test');
+
+      expect(mockFileManager.write).toHaveBeenCalledWith({
+        profiles: {
+          another: { token: 'another-token', updatedAt: '2024-01-01' }
+        },
+        currentProfile: 'test'
+      });
+    });
+
+    it('should throw error if trying to delete non-existent profile', async () => {
+      const mockConfig = {
+        profiles: {},
+        currentProfile: 'default'
+      };
+      
+      vi.mocked(mockFileManager.read).mockResolvedValueOnce(mockConfig);
+
+      await expect(manager.deleteProfile('nonexistent')).rejects.toThrow(
+        'Profile "nonexistent" not found'
+      );
+    });
+  });
+
+  describe('listProfiles', () => {
+    it('should list all profile names', async () => {
+      const mockConfig = {
+        profiles: {
+          default: { token: 'token1', updatedAt: '2024-01-01' },
+          work: { token: 'token2', updatedAt: '2024-01-01' },
+          personal: { token: 'token3', updatedAt: '2024-01-01' }
+        },
+        currentProfile: 'default'
+      };
+      
+      vi.mocked(mockFileManager.read).mockResolvedValueOnce(mockConfig);
+
+      const result = await manager.listProfiles();
+
+      expect(result).toEqual(['default', 'work', 'personal']);
+    });
+
+    it('should return empty array if no profiles', async () => {
+      const mockConfig = {
+        profiles: {},
+        currentProfile: 'default'
+      };
+      
+      vi.mocked(mockFileManager.read).mockResolvedValueOnce(mockConfig);
+
+      const result = await manager.listProfiles();
+
+      expect(result).toEqual([]);
+    });
+  });
+
+  describe('getCurrentProfile', () => {
+    it('should return the current profile name', async () => {
+      const mockConfig = {
+        profiles: {
+          test: { token: 'token', updatedAt: '2024-01-01' }
+        },
+        currentProfile: 'test'
+      };
+      
+      vi.mocked(mockFileManager.read).mockResolvedValueOnce(mockConfig);
+
+      const result = await manager.getCurrentProfile();
+
+      expect(result).toBe('test');
+    });
+
+    it('should return default if no current profile set', async () => {
+      const mockConfig = {
+        profiles: {},
+        currentProfile: 'default'
+      };
+      
+      vi.mocked(mockFileManager.read).mockResolvedValueOnce(mockConfig);
+
+      const result = await manager.getCurrentProfile();
+
+      expect(result).toBe('default');
+    });
+  });
+
+  describe('setCurrentProfile', () => {
+    it('should set the current profile', async () => {
+      const mockConfig = {
+        profiles: {
+          test: { token: 'token', updatedAt: '2024-01-01' }
+        },
+        currentProfile: 'default'
+      };
+      
+      vi.mocked(mockFileManager.read).mockResolvedValueOnce(mockConfig);
+      vi.mocked(mockFileManager.write).mockResolvedValueOnce(undefined);
+
+      await manager.setCurrentProfile('test');
+
+      expect(mockFileManager.write).toHaveBeenCalledWith({
+        profiles: {
+          test: { token: 'token', updatedAt: '2024-01-01' }
+        },
+        currentProfile: 'test'
+      });
+    });
+
+    it('should throw error if profile does not exist', async () => {
+      const mockConfig = {
+        profiles: {},
+        currentProfile: 'default'
+      };
+      
+      vi.mocked(mockFileManager.read).mockResolvedValueOnce(mockConfig);
+
+      await expect(manager.setCurrentProfile('nonexistent')).rejects.toThrow(
+        'Profile "nonexistent" not found'
+      );
+    });
+  });
+});

package/tests/utils/config/token-crypto-service.test.ts

@@ -0,0 +1,98 @@
+import { describe, it, expect } from 'vitest';
+import { TokenCryptoService } from '../../../src/utils/config/token-crypto-service';
+
+describe('TokenCryptoService', () => {
+  let service: TokenCryptoService;
+
+  beforeEach(() => {
+    service = new TokenCryptoService();
+  });
+
+  describe('encrypt and decrypt', () => {
+    it('should encrypt and decrypt a token correctly', () => {
+      const originalToken = 'test-token-1234567890-abcdefghijklmnop';
+      
+      const encrypted = service.encrypt(originalToken);
+      expect(encrypted).not.toBe(originalToken);
+      expect(encrypted.length).toBeGreaterThan(0);
+      
+      const decrypted = service.decrypt(encrypted);
+      expect(decrypted).toBe(originalToken);
+    });
+
+    it('should produce different encrypted values for the same token', () => {
+      const token = 'test-token-1234567890-abcdefghijklmnop';
+      
+      const encrypted1 = service.encrypt(token);
+      const encrypted2 = service.encrypt(token);
+      
+      // Different encrypted values due to random IV
+      expect(encrypted1).not.toBe(encrypted2);
+      
+      // But both decrypt to the same value
+      expect(service.decrypt(encrypted1)).toBe(token);
+      expect(service.decrypt(encrypted2)).toBe(token);
+    });
+
+    it('should handle empty token', () => {
+      const emptyToken = '';
+      
+      const encrypted = service.encrypt(emptyToken);
+      expect(encrypted.length).toBeGreaterThan(0);
+      
+      const decrypted = service.decrypt(encrypted);
+      expect(decrypted).toBe(emptyToken);
+    });
+
+    it('should handle special characters in token', () => {
+      const specialToken = 'test-!@#$%^&*()_+-=[]{}|;:,.<>?';
+      
+      const encrypted = service.encrypt(specialToken);
+      const decrypted = service.decrypt(encrypted);
+      
+      expect(decrypted).toBe(specialToken);
+    });
+
+    it('should handle very long tokens', () => {
+      const longToken = 'x'.repeat(1000);
+      
+      const encrypted = service.encrypt(longToken);
+      const decrypted = service.decrypt(encrypted);
+      
+      expect(decrypted).toBe(longToken);
+    });
+  });
+
+  describe('decrypt error handling', () => {
+    it('should throw error for invalid encrypted data', () => {
+      expect(() => service.decrypt('invalid-data')).toThrow('Failed to decrypt token');
+    });
+
+    it('should throw error for empty encrypted data', () => {
+      expect(() => service.decrypt('')).toThrow('Failed to decrypt token');
+    });
+
+    it('should throw error for malformed encrypted data', () => {
+      // Missing IV separator
+      expect(() => service.decrypt('aabbccdd')).toThrow('Failed to decrypt token');
+    });
+  });
+
+  describe('isEncrypted', () => {
+    it('should return true for encrypted tokens', () => {
+      const token = 'test-token-1234567890';
+      const encrypted = service.encrypt(token);
+      
+      expect(service.isEncrypted(encrypted)).toBe(true);
+    });
+
+    it('should return false for plain tokens', () => {
+      expect(service.isEncrypted('test-token-1234567890')).toBe(false);
+      expect(service.isEncrypted('plain-text')).toBe(false);
+    });
+
+    it('should return false for empty string', () => {
+      expect(service.isEncrypted('')).toBe(false);
+    });
+  });
+});

package/tests/utils/mention-utils.test.ts

@@ -0,0 +1,100 @@
+import { describe, it, expect } from 'vitest';
+import { extractUserIdsFromMentions, extractAllUserIds } from '../../src/utils/mention-utils';
+
+describe('mention-utils', () => {
+  describe('extractUserIdsFromMentions', () => {
+    it('should extract single user ID from mention', () => {
+      const text = 'Hello <@U123456789>';
+      const userIds = extractUserIdsFromMentions(text);
+      expect(userIds).toEqual(['U123456789']);
+    });
+
+    it('should extract multiple user IDs from mentions', () => {
+      const text = 'Hey <@U123456789> and <@U987654321>, please check this';
+      const userIds = extractUserIdsFromMentions(text);
+      expect(userIds).toEqual(['U123456789', 'U987654321']);
+    });
+
+    it('should handle duplicate mentions', () => {
+      const text = '<@U123456789> mentioned <@U123456789> again';
+      const userIds = extractUserIdsFromMentions(text);
+      expect(userIds).toEqual(['U123456789', 'U123456789']);
+    });
+
+    it('should return empty array for text without mentions', () => {
+      const text = 'No mentions here';
+      const userIds = extractUserIdsFromMentions(text);
+      expect(userIds).toEqual([]);
+    });
+
+    it('should handle empty text', () => {
+      const userIds = extractUserIdsFromMentions('');
+      expect(userIds).toEqual([]);
+    });
+
+    it('should ignore malformed mentions', () => {
+      const text = 'Invalid <@> mention and <@lowercase> mention';
+      const userIds = extractUserIdsFromMentions(text);
+      expect(userIds).toEqual([]);
+    });
+  });
+
+  describe('extractAllUserIds', () => {
+    it('should extract user IDs from message authors only', () => {
+      const messages = [
+        { user: 'U111111111', text: 'Hello world' },
+        { user: 'U222222222', text: 'Hi there' },
+      ];
+      const userIds = extractAllUserIds(messages);
+      expect(userIds).toEqual(['U111111111', 'U222222222']);
+    });
+
+    it('should extract user IDs from mentions only', () => {
+      const messages = [
+        { text: 'Hello <@U333333333>' },
+        { text: 'Hi <@U444444444>' },
+      ];
+      const userIds = extractAllUserIds(messages);
+      expect(userIds).toEqual(['U333333333', 'U444444444']);
+    });
+
+    it('should extract both authors and mentioned users', () => {
+      const messages = [
+        { user: 'U111111111', text: 'Hello <@U222222222>' },
+        { user: 'U333333333', text: 'Hi <@U444444444> and <@U555555555>' },
+      ];
+      const userIds = extractAllUserIds(messages);
+      expect(userIds.sort()).toEqual([
+        'U111111111',
+        'U222222222',
+        'U333333333',
+        'U444444444',
+        'U555555555',
+      ]);
+    });
+
+    it('should remove duplicate user IDs', () => {
+      const messages = [
+        { user: 'U111111111', text: 'Hello <@U111111111>' },
+        { user: 'U111111111', text: 'Another message' },
+      ];
+      const userIds = extractAllUserIds(messages);
+      expect(userIds).toEqual(['U111111111']);
+    });
+
+    it('should handle messages without user or text', () => {
+      const messages = [
+        { user: 'U111111111' },
+        { text: 'No user here' },
+        {},
+      ];
+      const userIds = extractAllUserIds(messages);
+      expect(userIds).toEqual(['U111111111']);
+    });
+
+    it('should handle empty messages array', () => {
+      const userIds = extractAllUserIds([]);
+      expect(userIds).toEqual([]);
+    });
+  });
+});