@urugus/slack-cli 0.1.0

package/tests/utils/config.test.ts

@@ -0,0 +1,400 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import * as os from 'os';
+import { ProfileConfigManager } from '../../src/utils/profile-config';
+import type { Config, ConfigStore } from '../../src/types/config';
+
+vi.mock('fs/promises');
+vi.mock('os');
+
+describe('ProfileConfigManager', () => {
+  let configManager: ProfileConfigManager;
+  const mockHomeDir = '/mock/home';
+  const mockConfigPath = path.join(mockHomeDir, '.slack-cli', 'config.json');
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    vi.mocked(os.homedir).mockReturnValue(mockHomeDir);
+    configManager = new ProfileConfigManager();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  describe('setToken', () => {
+    it('should save token to default profile when no profile specified and no default set', async () => {
+      vi.mocked(fs.mkdir).mockResolvedValue(undefined);
+      vi.mocked(fs.writeFile).mockResolvedValue(undefined);
+      vi.mocked(fs.chmod).mockResolvedValue(undefined);
+      vi.mocked(fs.readFile).mockRejectedValue({ code: 'ENOENT' });
+
+      await configManager.setToken('test-token-123');
+
+      const writeCall = vi.mocked(fs.writeFile).mock.calls[0];
+      const writtenData = JSON.parse(writeCall[1] as string) as ConfigStore;
+      
+      expect(writtenData.profiles.default).toBeDefined();
+      expect(writtenData.profiles.default.token).toBe('test-token-123');
+      expect(writtenData.defaultProfile).toBe('default');
+    });
+
+    it('should save token to current default profile when no profile specified', async () => {
+      const existingStore: ConfigStore = {
+        profiles: {
+          personal: {
+            token: 'personal-token',
+            updatedAt: '2025-01-01T00:00:00.000Z'
+          }
+        },
+        defaultProfile: 'personal'
+      };
+
+      vi.mocked(fs.readFile).mockResolvedValue(JSON.stringify(existingStore));
+      vi.mocked(fs.mkdir).mockResolvedValue(undefined);
+      vi.mocked(fs.writeFile).mockResolvedValue(undefined);
+      vi.mocked(fs.chmod).mockResolvedValue(undefined);
+
+      await configManager.setToken('updated-token-123');
+
+      const writeCall = vi.mocked(fs.writeFile).mock.calls[0];
+      const writtenData = JSON.parse(writeCall[1] as string) as ConfigStore;
+      
+      expect(writtenData.profiles.personal.token).toBe('updated-token-123');
+      expect(writtenData.defaultProfile).toBe('personal');
+    });
+
+    it('should save token to specified profile', async () => {
+      vi.mocked(fs.mkdir).mockResolvedValue(undefined);
+      vi.mocked(fs.writeFile).mockResolvedValue(undefined);
+      vi.mocked(fs.chmod).mockResolvedValue(undefined);
+      vi.mocked(fs.readFile).mockRejectedValue({ code: 'ENOENT' });
+
+      await configManager.setToken('work-token-123', 'work');
+
+      const writeCall = vi.mocked(fs.writeFile).mock.calls[0];
+      const writtenData = JSON.parse(writeCall[1] as string) as ConfigStore;
+      
+      expect(writtenData.profiles.work).toBeDefined();
+      expect(writtenData.profiles.work.token).toBe('work-token-123');
+    });
+
+    it('should preserve existing profiles when adding new one', async () => {
+      const existingStore: ConfigStore = {
+        profiles: {
+          personal: {
+            token: 'personal-token',
+            updatedAt: '2025-01-01T00:00:00.000Z'
+          }
+        },
+        defaultProfile: 'personal'
+      };
+
+      vi.mocked(fs.readFile).mockResolvedValue(JSON.stringify(existingStore));
+      vi.mocked(fs.writeFile).mockResolvedValue(undefined);
+      vi.mocked(fs.chmod).mockResolvedValue(undefined);
+
+      await configManager.setToken('work-token-123', 'work');
+
+      const writeCall = vi.mocked(fs.writeFile).mock.calls[0];
+      const writtenData = JSON.parse(writeCall[1] as string) as ConfigStore;
+      
+      expect(writtenData.profiles.personal).toBeDefined();
+      expect(writtenData.profiles.work).toBeDefined();
+      expect(writtenData.profiles.work.token).toBe('work-token-123');
+      expect(writtenData.defaultProfile).toBe('personal'); // default unchanged
+    });
+  });
+
+  describe('getConfig', () => {
+    it('should return config from default profile', async () => {
+      const mockStore: ConfigStore = {
+        profiles: {
+          default: {
+            token: 'default-token',
+            updatedAt: '2025-06-21T10:00:00.000Z'
+          },
+          work: {
+            token: 'work-token',
+            updatedAt: '2025-06-21T11:00:00.000Z'
+          }
+        },
+        defaultProfile: 'default'
+      };
+
+      vi.mocked(fs.readFile).mockResolvedValue(JSON.stringify(mockStore));
+
+      const config = await configManager.getConfig();
+
+      expect(config).toEqual(mockStore.profiles.default);
+    });
+
+    it('should return config from specified profile', async () => {
+      const mockStore: ConfigStore = {
+        profiles: {
+          default: {
+            token: 'default-token',
+            updatedAt: '2025-06-21T10:00:00.000Z'
+          },
+          work: {
+            token: 'work-token',
+            updatedAt: '2025-06-21T11:00:00.000Z'
+          }
+        },
+        defaultProfile: 'default'
+      };
+
+      vi.mocked(fs.readFile).mockResolvedValue(JSON.stringify(mockStore));
+
+      const config = await configManager.getConfig('work');
+
+      expect(config).toEqual(mockStore.profiles.work);
+    });
+
+    it('should return null when profile does not exist', async () => {
+      const mockStore: ConfigStore = {
+        profiles: {
+          default: {
+            token: 'default-token',
+            updatedAt: '2025-06-21T10:00:00.000Z'
+          }
+        },
+        defaultProfile: 'default'
+      };
+
+      vi.mocked(fs.readFile).mockResolvedValue(JSON.stringify(mockStore));
+
+      const config = await configManager.getConfig('nonexistent');
+
+      expect(config).toBeNull();
+    });
+  });
+
+  describe('listProfiles', () => {
+    it('should return all profiles with current profile marked', async () => {
+      const mockStore: ConfigStore = {
+        profiles: {
+          default: {
+            token: 'default-token',
+            updatedAt: '2025-06-21T10:00:00.000Z'
+          },
+          work: {
+            token: 'work-token',
+            updatedAt: '2025-06-21T11:00:00.000Z'
+          },
+          personal: {
+            token: 'personal-token',
+            updatedAt: '2025-06-21T12:00:00.000Z'
+          }
+        },
+        defaultProfile: 'work'
+      };
+
+      vi.mocked(fs.readFile).mockResolvedValue(JSON.stringify(mockStore));
+
+      const profiles = await configManager.listProfiles();
+
+      expect(profiles).toHaveLength(3);
+      expect(profiles.find(p => p.name === 'work')?.isDefault).toBe(true);
+      expect(profiles.find(p => p.name === 'default')?.isDefault).toBe(false);
+    });
+
+    it('should return empty array when no profiles exist', async () => {
+      vi.mocked(fs.readFile).mockRejectedValue({ code: 'ENOENT' });
+
+      const profiles = await configManager.listProfiles();
+
+      expect(profiles).toEqual([]);
+    });
+  });
+
+  describe('useProfile', () => {
+    it('should set default profile', async () => {
+      const mockStore: ConfigStore = {
+        profiles: {
+          default: {
+            token: 'default-token',
+            updatedAt: '2025-06-21T10:00:00.000Z'
+          },
+          work: {
+            token: 'work-token',
+            updatedAt: '2025-06-21T11:00:00.000Z'
+          }
+        },
+        defaultProfile: 'default'
+      };
+
+      vi.mocked(fs.readFile).mockResolvedValue(JSON.stringify(mockStore));
+      vi.mocked(fs.writeFile).mockResolvedValue(undefined);
+      vi.mocked(fs.chmod).mockResolvedValue(undefined);
+
+      await configManager.useProfile('work');
+
+      const writeCall = vi.mocked(fs.writeFile).mock.calls[0];
+      const writtenData = JSON.parse(writeCall[1] as string) as ConfigStore;
+      
+      expect(writtenData.defaultProfile).toBe('work');
+    });
+
+    it('should throw error when profile does not exist', async () => {
+      const mockStore: ConfigStore = {
+        profiles: {
+          default: {
+            token: 'default-token',
+            updatedAt: '2025-06-21T10:00:00.000Z'
+          }
+        },
+        defaultProfile: 'default'
+      };
+
+      vi.mocked(fs.readFile).mockResolvedValue(JSON.stringify(mockStore));
+
+      await expect(configManager.useProfile('nonexistent')).rejects.toThrow('Profile "nonexistent" does not exist');
+    });
+  });
+
+  describe('getCurrentProfile', () => {
+    it('should return current default profile name', async () => {
+      const mockStore: ConfigStore = {
+        profiles: {
+          default: {
+            token: 'default-token',
+            updatedAt: '2025-06-21T10:00:00.000Z'
+          },
+          work: {
+            token: 'work-token',
+            updatedAt: '2025-06-21T11:00:00.000Z'
+          }
+        },
+        defaultProfile: 'work'
+      };
+
+      vi.mocked(fs.readFile).mockResolvedValue(JSON.stringify(mockStore));
+
+      const currentProfile = await configManager.getCurrentProfile();
+
+      expect(currentProfile).toBe('work');
+    });
+
+    it('should return "default" when no default profile set', async () => {
+      const mockStore: ConfigStore = {
+        profiles: {
+          default: {
+            token: 'default-token',
+            updatedAt: '2025-06-21T10:00:00.000Z'
+          }
+        }
+      };
+
+      vi.mocked(fs.readFile).mockResolvedValue(JSON.stringify(mockStore));
+
+      const currentProfile = await configManager.getCurrentProfile();
+
+      expect(currentProfile).toBe('default');
+    });
+  });
+
+  describe('clearConfig', () => {
+    it('should clear specific profile', async () => {
+      const mockStore: ConfigStore = {
+        profiles: {
+          default: {
+            token: 'default-token',
+            updatedAt: '2025-06-21T10:00:00.000Z'
+          },
+          work: {
+            token: 'work-token',
+            updatedAt: '2025-06-21T11:00:00.000Z'
+          }
+        },
+        defaultProfile: 'work'
+      };
+
+      vi.mocked(fs.readFile).mockResolvedValue(JSON.stringify(mockStore));
+      vi.mocked(fs.writeFile).mockResolvedValue(undefined);
+      vi.mocked(fs.chmod).mockResolvedValue(undefined);
+
+      await configManager.clearConfig('work');
+
+      const writeCall = vi.mocked(fs.writeFile).mock.calls[0];
+      const writtenData = JSON.parse(writeCall[1] as string) as ConfigStore;
+      
+      expect(writtenData.profiles.work).toBeUndefined();
+      expect(writtenData.profiles.default).toBeDefined();
+      expect(writtenData.defaultProfile).toBe('default'); // fallback to default
+    });
+
+    it('should clear default profile and reset defaultProfile', async () => {
+      const mockStore: ConfigStore = {
+        profiles: {
+          default: {
+            token: 'default-token',
+            updatedAt: '2025-06-21T10:00:00.000Z'
+          },
+          work: {
+            token: 'work-token',
+            updatedAt: '2025-06-21T11:00:00.000Z'
+          }
+        },
+        defaultProfile: 'default'
+      };
+
+      vi.mocked(fs.readFile).mockResolvedValue(JSON.stringify(mockStore));
+      vi.mocked(fs.writeFile).mockResolvedValue(undefined);
+      vi.mocked(fs.chmod).mockResolvedValue(undefined);
+
+      await configManager.clearConfig('default');
+
+      const writeCall = vi.mocked(fs.writeFile).mock.calls[0];
+      const writtenData = JSON.parse(writeCall[1] as string) as ConfigStore;
+      
+      expect(writtenData.profiles.default).toBeUndefined();
+      expect(writtenData.profiles.work).toBeDefined();
+      expect(writtenData.defaultProfile).toBe('work'); // switch to remaining profile
+    });
+
+    it('should delete config file when clearing last profile', async () => {
+      const mockStore: ConfigStore = {
+        profiles: {
+          default: {
+            token: 'default-token',
+            updatedAt: '2025-06-21T10:00:00.000Z'
+          }
+        },
+        defaultProfile: 'default'
+      };
+
+      vi.mocked(fs.readFile).mockResolvedValue(JSON.stringify(mockStore));
+      vi.mocked(fs.unlink).mockResolvedValue(undefined);
+
+      await configManager.clearConfig('default');
+
+      expect(fs.unlink).toHaveBeenCalledWith(mockConfigPath);
+    });
+  });
+
+  describe('migration from old config', () => {
+    it('should automatically migrate old single-token config to profile format', async () => {
+      const oldConfig = {
+        token: 'old-token-123',
+        updatedAt: '2025-01-01T00:00:00.000Z'
+      };
+
+      vi.mocked(fs.readFile).mockResolvedValue(JSON.stringify(oldConfig));
+      vi.mocked(fs.writeFile).mockResolvedValue(undefined);
+      vi.mocked(fs.chmod).mockResolvedValue(undefined);
+
+      const config = await configManager.getConfig();
+
+      expect(config).toEqual(oldConfig);
+      
+      // Verify migration happened
+      const writeCall = vi.mocked(fs.writeFile).mock.calls[0];
+      const writtenData = JSON.parse(writeCall[1] as string) as ConfigStore;
+      
+      expect(writtenData.profiles.default).toEqual(oldConfig);
+      expect(writtenData.defaultProfile).toBe('default');
+    });
+  });
+});

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

@@ -0,0 +1,30 @@
+import { describe, it, expect } from 'vitest';
+import { formatUnixTimestamp, formatSlackTimestamp } from '../../src/utils/date-utils';
+
+describe('date-utils', () => {
+  describe('formatUnixTimestamp', () => {
+    it('should format unix timestamp to ISO date string', () => {
+      const timestamp = 1640995200; // 2022-01-01 00:00:00 UTC
+      expect(formatUnixTimestamp(timestamp)).toBe('2022-01-01');
+    });
+
+    it('should handle different timestamps correctly', () => {
+      const timestamp = 1672531200; // 2023-01-01 00:00:00 UTC
+      expect(formatUnixTimestamp(timestamp)).toBe('2023-01-01');
+    });
+  });
+
+  describe('formatSlackTimestamp', () => {
+    it('should format Slack timestamp to locale string', () => {
+      const slackTimestamp = '1640995200.000000';
+      const result = formatSlackTimestamp(slackTimestamp);
+      expect(result).toContain('2022');
+    });
+
+    it('should handle timestamps with milliseconds', () => {
+      const slackTimestamp = '1640995200.123456';
+      const result = formatSlackTimestamp(slackTimestamp);
+      expect(result).toContain('2022');
+    });
+  });
+});

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

@@ -0,0 +1,34 @@
+import { describe, it, expect } from 'vitest';
+import { extractErrorMessage } from '../../src/utils/error-utils';
+
+describe('extractErrorMessage', () => {
+  it('should extract message from Error instance', () => {
+    const error = new Error('Test error message');
+    expect(extractErrorMessage(error)).toBe('Test error message');
+  });
+
+  it('should convert string to string', () => {
+    const error = 'String error';
+    expect(extractErrorMessage(error)).toBe('String error');
+  });
+
+  it('should convert number to string', () => {
+    const error = 404;
+    expect(extractErrorMessage(error)).toBe('404');
+  });
+
+  it('should convert object to string', () => {
+    const error = { code: 'ERROR_CODE', detail: 'Some detail' };
+    expect(extractErrorMessage(error)).toBe('[object Object]');
+  });
+
+  it('should handle null', () => {
+    const error = null;
+    expect(extractErrorMessage(error)).toBe('null');
+  });
+
+  it('should handle undefined', () => {
+    const error = undefined;
+    expect(extractErrorMessage(error)).toBe('undefined');
+  });
+});

package/tests/utils/slack-api-client.test.ts

@@ -0,0 +1,170 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { SlackApiClient } from '../../src/utils/slack-api-client';
+import { WebClient } from '@slack/web-api';
+
+vi.mock('@slack/web-api');
+
+describe('SlackApiClient', () => {
+  let client: SlackApiClient;
+  let mockWebClient: any;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockWebClient = {
+      chat: {
+        postMessage: vi.fn()
+      },
+      conversations: {
+        list: vi.fn()
+      }
+    };
+    vi.mocked(WebClient).mockReturnValue(mockWebClient);
+    client = new SlackApiClient('test-token');
+  });
+
+  describe('constructor', () => {
+    it('should create WebClient with provided token', () => {
+      expect(WebClient).toHaveBeenCalledWith('test-token');
+    });
+  });
+
+  describe('sendMessage', () => {
+    it('should send message to channel', async () => {
+      const mockResponse = { ok: true, ts: '1234567890.123456' };
+      vi.mocked(mockWebClient.chat.postMessage).mockResolvedValue(mockResponse as any);
+
+      const result = await client.sendMessage('general', 'Hello, World!');
+
+      expect(mockWebClient.chat.postMessage).toHaveBeenCalledWith({
+        channel: 'general',
+        text: 'Hello, World!'
+      });
+      expect(result).toEqual(mockResponse);
+    });
+
+    it('should handle channel ID format', async () => {
+      const mockResponse = { ok: true, ts: '1234567890.123456' };
+      vi.mocked(mockWebClient.chat.postMessage).mockResolvedValue(mockResponse as any);
+
+      await client.sendMessage('C1234567890', 'Hello!');
+
+      expect(mockWebClient.chat.postMessage).toHaveBeenCalledWith({
+        channel: 'C1234567890',
+        text: 'Hello!'
+      });
+    });
+
+    it('should handle multi-line messages', async () => {
+      const mockResponse = { ok: true, ts: '1234567890.123456' };
+      vi.mocked(mockWebClient.chat.postMessage).mockResolvedValue(mockResponse as any);
+
+      const multiLineMessage = 'Line 1\nLine 2\nLine 3';
+      await client.sendMessage('general', multiLineMessage);
+
+      expect(mockWebClient.chat.postMessage).toHaveBeenCalledWith({
+        channel: 'general',
+        text: multiLineMessage
+      });
+    });
+
+    it('should throw error on API failure', async () => {
+      const mockError = new Error('channel_not_found');
+      vi.mocked(mockWebClient.chat.postMessage).mockRejectedValue(mockError);
+
+      await expect(client.sendMessage('nonexistent', 'Hello')).rejects.toThrow('channel_not_found');
+    });
+  });
+
+  describe('listChannels', () => {
+    it('should list channels with default options', async () => {
+      const mockChannels = [
+        {
+          id: 'C1234567890',
+          name: 'general',
+          is_channel: true,
+          is_private: false,
+          num_members: 150,
+          created: 1579075200,
+          purpose: { value: 'Company announcements' }
+        }
+      ];
+      vi.mocked(mockWebClient.conversations.list).mockResolvedValue({
+        ok: true,
+        channels: mockChannels
+      } as any);
+
+      const result = await client.listChannels({
+        types: 'public_channel',
+        exclude_archived: true,
+        limit: 100
+      });
+
+      expect(mockWebClient.conversations.list).toHaveBeenCalledWith({
+        types: 'public_channel',
+        exclude_archived: true,
+        limit: 100
+      });
+      expect(result).toEqual(mockChannels);
+    });
+
+    it('should handle private channels', async () => {
+      const mockChannels = [
+        {
+          id: 'G1234567890',
+          name: 'private-channel',
+          is_group: true,
+          is_private: true,
+          num_members: 10,
+          created: 1579075200,
+          purpose: { value: 'Private discussions' }
+        }
+      ];
+      vi.mocked(mockWebClient.conversations.list).mockResolvedValue({
+        ok: true,
+        channels: mockChannels
+      } as any);
+
+      const result = await client.listChannels({
+        types: 'private_channel',
+        exclude_archived: true,
+        limit: 50
+      });
+
+      expect(mockWebClient.conversations.list).toHaveBeenCalledWith({
+        types: 'private_channel',
+        exclude_archived: true,
+        limit: 50
+      });
+      expect(result).toEqual(mockChannels);
+    });
+
+    it('should handle multiple channel types', async () => {
+      vi.mocked(mockWebClient.conversations.list).mockResolvedValue({
+        ok: true,
+        channels: []
+      } as any);
+
+      await client.listChannels({
+        types: 'public_channel,private_channel,im',
+        exclude_archived: false,
+        limit: 200
+      });
+
+      expect(mockWebClient.conversations.list).toHaveBeenCalledWith({
+        types: 'public_channel,private_channel,im',
+        exclude_archived: false,
+        limit: 200
+      });
+    });
+
+    it('should handle API errors', async () => {
+      vi.mocked(mockWebClient.conversations.list).mockRejectedValue(new Error('invalid_auth'));
+
+      await expect(client.listChannels({
+        types: 'public_channel',
+        exclude_archived: true,
+        limit: 100
+      })).rejects.toThrow('invalid_auth');
+    });
+  });
+});

package/tsconfig.json

@@ -0,0 +1,22 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "commonjs",
+    "lib": ["ES2020"],
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "noImplicitAny": true,
+    "resolveJsonModule": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "moduleResolution": "node",
+    "allowSyntheticDefaultImports": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "tests"]
+}

package/vitest.config.ts

@@ -0,0 +1,27 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: 'node',
+    coverage: {
+      provider: 'v8',
+      reporter: ['text', 'json', 'html'],
+      exclude: [
+        'node_modules/',
+        'dist/',
+        '**/*.d.ts',
+        '**/*.config.*',
+        '**/mockData/**',
+        '**/tests/**',
+      ],
+    },
+    include: ['tests/**/*.{test,spec}.{js,mjs,cjs,ts,mts,cts,jsx,tsx}'],
+    testTimeout: 10000,
+  },
+  resolve: {
+    alias: {
+      '@': '/src',
+    },
+  },
+});