@urugus/slack-cli 0.1.0

package/src/utils/slack-api-client.ts

@@ -0,0 +1,218 @@
+import { WebClient, ChatPostMessageResponse } from '@slack/web-api';
+
+export interface Channel {
+  id: string;
+  name: string;
+  is_channel?: boolean;
+  is_group?: boolean;
+  is_im?: boolean;
+  is_mpim?: boolean;
+  is_private: boolean;
+  created: number;
+  is_archived?: boolean;
+  is_general?: boolean;
+  unlinked?: number;
+  name_normalized?: string;
+  is_shared?: boolean;
+  is_ext_shared?: boolean;
+  is_org_shared?: boolean;
+  is_member?: boolean;
+  num_members?: number;
+  unread_count?: number;
+  unread_count_display?: number;
+  last_read?: string;
+  topic?: {
+    value: string;
+    creator?: string;
+    last_set?: number;
+  };
+  purpose?: {
+    value: string;
+    creator?: string;
+    last_set?: number;
+  };
+}
+
+export interface ListChannelsOptions {
+  types: string;
+  exclude_archived: boolean;
+  limit: number;
+}
+
+export interface HistoryOptions {
+  limit: number;
+  oldest?: string;
+}
+
+export interface Message {
+  type: string;
+  text?: string;
+  user?: string;
+  bot_id?: string;
+  ts: string;
+  thread_ts?: string;
+  attachments?: unknown[];
+  blocks?: unknown[];
+}
+
+export interface HistoryResult {
+  messages: Message[];
+  users: Map<string, string>;
+}
+
+export interface ChannelUnreadResult {
+  channel: Channel;
+  messages: Message[];
+  users: Map<string, string>;
+}
+
+export class SlackApiClient {
+  private client: WebClient;
+
+  constructor(token: string) {
+    this.client = new WebClient(token);
+  }
+
+  async sendMessage(channel: string, text: string): Promise<ChatPostMessageResponse> {
+    return await this.client.chat.postMessage({
+      channel,
+      text,
+    });
+  }
+
+  async listChannels(options: ListChannelsOptions): Promise<Channel[]> {
+    const response = await this.client.conversations.list({
+      types: options.types,
+      exclude_archived: options.exclude_archived,
+      limit: options.limit,
+    });
+
+    return response.channels as Channel[];
+  }
+
+  async getHistory(channel: string, options: HistoryOptions): Promise<HistoryResult> {
+    const response = await this.client.conversations.history({
+      channel,
+      limit: options.limit,
+      oldest: options.oldest,
+    });
+
+    const messages = response.messages as Message[];
+
+    // Get unique user IDs
+    const userIds = [...new Set(messages.filter((m) => m.user).map((m) => m.user!))];
+    const users = new Map<string, string>();
+
+    // Fetch user information
+    if (userIds.length > 0) {
+      for (const userId of userIds) {
+        try {
+          const userInfo = await this.client.users.info({ user: userId });
+          if (userInfo.user?.name) {
+            users.set(userId, userInfo.user.name);
+          }
+        } catch (error) {
+          // If we can't get user info, we'll use the ID
+          users.set(userId, userId);
+        }
+      }
+    }
+
+    return { messages, users };
+  }
+
+  async listUnreadChannels(): Promise<Channel[]> {
+    // Get all conversations the user is a member of
+    const response = await this.client.conversations.list({
+      types: 'public_channel,private_channel,im,mpim',
+      exclude_archived: true,
+      limit: 1000,
+    });
+
+    const channels = response.channels as Channel[];
+
+    // Get unread count for each channel
+    const channelsWithUnread = await Promise.all(
+      channels.map(async (channel) => {
+        try {
+          const info = await this.client.conversations.info({
+            channel: channel.id,
+            include_num_members: false,
+          });
+          const channelInfo = info.channel as any;
+          return {
+            ...channel,
+            unread_count: channelInfo.unread_count || 0,
+            unread_count_display: channelInfo.unread_count_display || 0,
+            last_read: channelInfo.last_read,
+          };
+        } catch {
+          return channel;
+        }
+      })
+    );
+
+    // Filter to only channels with unread messages
+    return channelsWithUnread.filter((channel) => (channel.unread_count_display || 0) > 0);
+  }
+
+  async getChannelUnread(channelNameOrId: string): Promise<ChannelUnreadResult> {
+    // First, find the channel
+    let channelId = channelNameOrId;
+    if (
+      !channelNameOrId.startsWith('C') &&
+      !channelNameOrId.startsWith('D') &&
+      !channelNameOrId.startsWith('G')
+    ) {
+      // It's a name, not an ID - need to find the ID
+      const channels = await this.listChannels({
+        types: 'public_channel,private_channel,im,mpim',
+        exclude_archived: true,
+        limit: 1000,
+      });
+      const channel = channels.find(
+        (c) => c.name === channelNameOrId || c.name === channelNameOrId.replace('#', '')
+      );
+      if (!channel) {
+        throw new Error('channel_not_found');
+      }
+      channelId = channel.id;
+    }
+
+    // Get channel info with unread count
+    const info = await this.client.conversations.info({
+      channel: channelId,
+    });
+    const channel = info.channel as any;
+
+    // Get unread messages
+    let messages: Message[] = [];
+    let users = new Map<string, string>();
+
+    if (channel.last_read && channel.unread_count > 0) {
+      const historyResult = await this.getHistory(channelId, {
+        limit: channel.unread_count,
+        oldest: channel.last_read,
+      });
+      messages = historyResult.messages;
+      users = historyResult.users;
+    }
+
+    return {
+      channel: {
+        ...channel,
+        unread_count: channel.unread_count || 0,
+        unread_count_display: channel.unread_count_display || 0,
+      },
+      messages,
+      users,
+    };
+  }
+}
+
+export const slackApiClient = {
+  listChannels: async (token: string, options: ListChannelsOptions): Promise<Channel[]> => {
+    const client = new SlackApiClient(token);
+    return client.listChannels(options);
+  },
+};

package/tests/commands/channels.test.ts

@@ -0,0 +1,250 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { setupChannelsCommand } from '../../src/commands/channels';
+import { SlackApiClient } from '../../src/utils/slack-api-client';
+import { ProfileConfigManager } from '../../src/utils/profile-config';
+import { setupMockConsole, createTestProgram, restoreMocks } from '../test-utils';
+import { ERROR_MESSAGES } from '../../src/utils/constants';
+
+vi.mock('../../src/utils/slack-api-client');
+vi.mock('../../src/utils/profile-config');
+
+describe('channels command', () => {
+  let program: any;
+  let mockSlackClient: SlackApiClient;
+  let mockConfigManager: ProfileConfigManager;
+  let mockConsole: any;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    
+    mockConfigManager = new ProfileConfigManager();
+    vi.mocked(ProfileConfigManager).mockReturnValue(mockConfigManager);
+    
+    mockSlackClient = new SlackApiClient('test-token');
+    vi.mocked(SlackApiClient).mockReturnValue(mockSlackClient);
+    
+    mockConsole = setupMockConsole();
+    program = createTestProgram();
+    program.addCommand(setupChannelsCommand());
+  });
+
+  afterEach(() => {
+    restoreMocks();
+  });
+
+  const mockChannels = [
+    {
+      id: 'C1234567890',
+      name: 'general',
+      is_channel: true,
+      is_private: false,
+      num_members: 250,
+      created: 1579075200,
+      purpose: { value: 'Company announcements' }
+    },
+    {
+      id: 'C0987654321',
+      name: 'random',
+      is_channel: true,
+      is_private: false,
+      num_members: 145,
+      created: 1579075200,
+      purpose: { value: 'Random discussions' }
+    }
+  ];
+
+  describe('basic functionality', () => {
+    it('should list public channels by default', async () => {
+      vi.mocked(mockConfigManager.getConfig).mockResolvedValue({
+        token: 'test-token',
+        updatedAt: new Date().toISOString()
+      });
+      vi.mocked(mockSlackClient.listChannels).mockResolvedValue(mockChannels);
+
+      await program.parseAsync(['node', 'slack-cli', 'channels']);
+
+      expect(mockSlackClient.listChannels).toHaveBeenCalledWith({
+        types: 'public_channel',
+        exclude_archived: true,
+        limit: 100
+      });
+      expect(mockConsole.logSpy).toHaveBeenCalledWith(expect.stringContaining('general'));
+      expect(mockConsole.logSpy).toHaveBeenCalledWith(expect.stringContaining('random'));
+    });
+
+    it('should show error when no token is configured', async () => {
+      vi.mocked(mockConfigManager.getConfig).mockResolvedValue(null);
+      vi.mocked(mockConfigManager.listProfiles).mockResolvedValue([]);
+
+      await program.parseAsync(['node', 'slack-cli', 'channels']);
+
+      expect(mockConsole.errorSpy).toHaveBeenCalledWith('✗ Error:', ERROR_MESSAGES.NO_CONFIG('default'));
+      expect(mockConsole.exitSpy).toHaveBeenCalledWith(1);
+    });
+  });
+
+  describe('channel type filtering', () => {
+    it('should list private channels when type is private', async () => {
+      vi.mocked(mockConfigManager.getConfig).mockResolvedValue({
+        token: 'test-token',
+        updatedAt: new Date().toISOString()
+      });
+      vi.mocked(mockSlackClient.listChannels).mockResolvedValue(mockChannels);
+
+      await program.parseAsync(['node', 'slack-cli', 'channels', '--type', 'private']);
+
+      expect(mockSlackClient.listChannels).toHaveBeenCalledWith({
+        types: 'private_channel',
+        exclude_archived: true,
+        limit: 100
+      });
+    });
+
+    it('should list all channel types when type is all', async () => {
+      vi.mocked(mockConfigManager.getConfig).mockResolvedValue({
+        token: 'test-token',
+        updatedAt: new Date().toISOString()
+      });
+      vi.mocked(mockSlackClient.listChannels).mockResolvedValue(mockChannels);
+
+      await program.parseAsync(['node', 'slack-cli', 'channels', '--type', 'all']);
+
+      expect(mockSlackClient.listChannels).toHaveBeenCalledWith({
+        types: 'public_channel,private_channel,mpim,im',
+        exclude_archived: true,
+        limit: 100
+      });
+    });
+
+    it('should list direct messages when type is im', async () => {
+      vi.mocked(mockConfigManager.getConfig).mockResolvedValue({
+        token: 'test-token',
+        updatedAt: new Date().toISOString()
+      });
+      vi.mocked(mockSlackClient.listChannels).mockResolvedValue(mockChannels);
+
+      await program.parseAsync(['node', 'slack-cli', 'channels', '--type', 'im']);
+
+      expect(mockSlackClient.listChannels).toHaveBeenCalledWith({
+        types: 'im',
+        exclude_archived: true,
+        limit: 100
+      });
+    });
+  });
+
+  describe('output formatting', () => {
+    it('should output in table format by default', async () => {
+      vi.mocked(mockConfigManager.getConfig).mockResolvedValue({
+        token: 'test-token',
+        updatedAt: new Date().toISOString()
+      });
+      vi.mocked(mockSlackClient.listChannels).mockResolvedValue(mockChannels);
+
+      await program.parseAsync(['node', 'slack-cli', 'channels']);
+
+      expect(mockConsole.logSpy).toHaveBeenCalledWith(expect.stringContaining('Name'));
+      expect(mockConsole.logSpy).toHaveBeenCalledWith(expect.stringContaining('Type'));
+      expect(mockConsole.logSpy).toHaveBeenCalledWith(expect.stringContaining('Members'));
+    });
+
+    it('should output in simple format when specified', async () => {
+      vi.mocked(mockConfigManager.getConfig).mockResolvedValue({
+        token: 'test-token',
+        updatedAt: new Date().toISOString()
+      });
+      vi.mocked(mockSlackClient.listChannels).mockResolvedValue(mockChannels);
+
+      await program.parseAsync(['node', 'slack-cli', 'channels', '--format', 'simple']);
+
+      expect(mockConsole.logSpy).toHaveBeenCalledWith('general');
+      expect(mockConsole.logSpy).toHaveBeenCalledWith('random');
+    });
+
+    it('should output in JSON format when specified', async () => {
+      vi.mocked(mockConfigManager.getConfig).mockResolvedValue({
+        token: 'test-token',
+        updatedAt: new Date().toISOString()
+      });
+      vi.mocked(mockSlackClient.listChannels).mockResolvedValue(mockChannels);
+
+      await program.parseAsync(['node', 'slack-cli', 'channels', '--format', 'json']);
+
+      expect(mockConsole.logSpy).toHaveBeenCalledWith(expect.stringContaining('"name": "general"'));
+    });
+  });
+
+  describe('additional options', () => {
+    it('should include archived channels when flag is set', async () => {
+      vi.mocked(mockConfigManager.getConfig).mockResolvedValue({
+        token: 'test-token',
+        updatedAt: new Date().toISOString()
+      });
+      vi.mocked(mockSlackClient.listChannels).mockResolvedValue(mockChannels);
+
+      await program.parseAsync(['node', 'slack-cli', 'channels', '--include-archived']);
+
+      expect(mockSlackClient.listChannels).toHaveBeenCalledWith({
+        types: 'public_channel',
+        exclude_archived: false,
+        limit: 100
+      });
+    });
+
+    it('should respect custom limit', async () => {
+      vi.mocked(mockConfigManager.getConfig).mockResolvedValue({
+        token: 'test-token',
+        updatedAt: new Date().toISOString()
+      });
+      vi.mocked(mockSlackClient.listChannels).mockResolvedValue(mockChannels);
+
+      await program.parseAsync(['node', 'slack-cli', 'channels', '--limit', '50']);
+
+      expect(mockSlackClient.listChannels).toHaveBeenCalledWith({
+        types: 'public_channel',
+        exclude_archived: true,
+        limit: 50
+      });
+    });
+
+    it('should use specified profile', async () => {
+      vi.mocked(mockConfigManager.getConfig).mockResolvedValue({
+        token: 'work-token',
+        updatedAt: new Date().toISOString()
+      });
+      vi.mocked(mockSlackClient.listChannels).mockResolvedValue(mockChannels);
+
+      await program.parseAsync(['node', 'slack-cli', 'channels', '--profile', 'work']);
+
+      expect(mockConfigManager.getConfig).toHaveBeenCalledWith('work');
+      expect(SlackApiClient).toHaveBeenCalledWith('work-token');
+    });
+  });
+
+  describe('error handling', () => {
+    it('should handle API errors gracefully', async () => {
+      vi.mocked(mockConfigManager.getConfig).mockResolvedValue({
+        token: 'test-token',
+        updatedAt: new Date().toISOString()
+      });
+      vi.mocked(mockSlackClient.listChannels).mockRejectedValue(new Error('API Error'));
+
+      await program.parseAsync(['node', 'slack-cli', 'channels']);
+
+      expect(mockConsole.errorSpy).toHaveBeenCalledWith('✗ Error:', 'API Error');
+      expect(mockConsole.exitSpy).toHaveBeenCalledWith(1);
+    });
+
+    it('should show message when no channels found', async () => {
+      vi.mocked(mockConfigManager.getConfig).mockResolvedValue({
+        token: 'test-token',
+        updatedAt: new Date().toISOString()
+      });
+      vi.mocked(mockSlackClient.listChannels).mockResolvedValue([]);
+
+      await program.parseAsync(['node', 'slack-cli', 'channels']);
+
+      expect(mockConsole.logSpy).toHaveBeenCalledWith(ERROR_MESSAGES.NO_CHANNELS_FOUND);
+    });
+  });
+});

package/tests/commands/config.test.ts

@@ -0,0 +1,158 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { setupConfigCommand } from '../../src/commands/config';
+import { ProfileConfigManager } from '../../src/utils/profile-config';
+import type { Config, Profile } from '../../src/types/config';
+import { setupMockConsole, createTestProgram, restoreMocks } from '../test-utils';
+import { SUCCESS_MESSAGES, ERROR_MESSAGES } from '../../src/utils/constants';
+
+vi.mock('../../src/utils/profile-config');
+
+describe('profile config command', () => {
+  let program: any;
+  let mockConfigManager: ProfileConfigManager;
+  let mockConsole: any;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    
+    mockConfigManager = new ProfileConfigManager();
+    vi.mocked(ProfileConfigManager).mockReturnValue(mockConfigManager);
+    
+    mockConsole = setupMockConsole();
+    program = createTestProgram();
+    program.addCommand(setupConfigCommand());
+  });
+
+  afterEach(() => {
+    restoreMocks();
+  });
+
+  describe('config set with profile', () => {
+    it('should set token for specified profile', async () => {
+      vi.mocked(mockConfigManager.setToken).mockResolvedValue(undefined);
+
+      await program.parseAsync(['node', 'slack-cli', 'config', 'set', '--token', 'test-token-123', '--profile', 'work']);
+
+      expect(mockConfigManager.setToken).toHaveBeenCalledWith('test-token-123', 'work');
+      expect(mockConsole.logSpy).toHaveBeenCalledWith(expect.stringContaining(SUCCESS_MESSAGES.TOKEN_SAVED('work')));
+    });
+
+    it('should set token for default profile when no profile specified', async () => {
+      vi.mocked(mockConfigManager.setToken).mockResolvedValue(undefined);
+      vi.mocked(mockConfigManager.getCurrentProfile).mockResolvedValue('default');
+
+      await program.parseAsync(['node', 'slack-cli', 'config', 'set', '--token', 'test-token-123']);
+
+      expect(mockConfigManager.setToken).toHaveBeenCalledWith('test-token-123', undefined);
+      expect(mockConsole.logSpy).toHaveBeenCalledWith(expect.stringContaining('Token saved successfully for profile "default"'));
+    });
+  });
+
+  describe('config get with profile', () => {
+    it('should display config for specified profile', async () => {
+      const mockConfig: Config = {
+        token: 'test-token-1234567890-abcdefghijklmnop',
+        updatedAt: '2025-06-21T10:00:00.000Z'
+      };
+
+      vi.mocked(mockConfigManager.getConfig).mockResolvedValue(mockConfig);
+      vi.mocked(mockConfigManager.maskToken).mockReturnValue('test-****-****-mnop');
+
+      await program.parseAsync(['node', 'slack-cli', 'config', 'get', '--profile', 'work']);
+
+      expect(mockConfigManager.getConfig).toHaveBeenCalledWith('work');
+      expect(mockConsole.logSpy).toHaveBeenCalledWith(expect.stringContaining('Configuration for profile "work":'));
+    });
+  });
+
+  describe('config profiles', () => {
+    it('should list all profiles', async () => {
+      const mockProfiles: Profile[] = [
+        {
+          name: 'default',
+          config: {
+            token: 'default-token',
+            updatedAt: '2025-06-21T10:00:00.000Z'
+          }
+        },
+        {
+          name: 'work',
+          config: {
+            token: 'work-token',
+            updatedAt: '2025-06-21T11:00:00.000Z'
+          }
+        }
+      ];
+
+      vi.mocked(mockConfigManager.listProfiles).mockResolvedValue(mockProfiles);
+      vi.mocked(mockConfigManager.getCurrentProfile).mockResolvedValue('work');
+
+      await program.parseAsync(['node', 'slack-cli', 'config', 'profiles']);
+
+      expect(mockConfigManager.listProfiles).toHaveBeenCalled();
+      expect(mockConsole.logSpy).toHaveBeenCalledWith(expect.stringContaining('Available profiles:'));
+      expect(mockConsole.logSpy).toHaveBeenCalledWith(expect.stringContaining('default'));
+      expect(mockConsole.logSpy).toHaveBeenCalledWith(expect.stringContaining('* work')); // current profile marked
+    });
+
+    it('should show message when no profiles exist', async () => {
+      vi.mocked(mockConfigManager.listProfiles).mockResolvedValue([]);
+
+      await program.parseAsync(['node', 'slack-cli', 'config', 'profiles']);
+
+      expect(mockConsole.logSpy).toHaveBeenCalledWith(expect.stringContaining('No profiles found'));
+    });
+  });
+
+  describe('config use', () => {
+    it('should switch default profile', async () => {
+      vi.mocked(mockConfigManager.useProfile).mockResolvedValue(undefined);
+
+      await program.parseAsync(['node', 'slack-cli', 'config', 'use', 'work']);
+
+      expect(mockConfigManager.useProfile).toHaveBeenCalledWith('work');
+      expect(mockConsole.logSpy).toHaveBeenCalledWith(expect.stringContaining('Switched to profile "work"'));
+    });
+
+    it('should show error when profile does not exist', async () => {
+      vi.mocked(mockConfigManager.useProfile).mockRejectedValue(new Error('Profile "nonexistent" does not exist'));
+
+      await program.parseAsync(['node', 'slack-cli', 'config', 'use', 'nonexistent']);
+
+      expect(mockConsole.errorSpy).toHaveBeenCalledWith(expect.stringContaining('Error:'), expect.any(String));
+      expect(mockConsole.exitSpy).toHaveBeenCalledWith(1);
+    });
+  });
+
+  describe('config current', () => {
+    it('should show current active profile', async () => {
+      vi.mocked(mockConfigManager.getCurrentProfile).mockResolvedValue('work');
+
+      await program.parseAsync(['node', 'slack-cli', 'config', 'current']);
+
+      expect(mockConfigManager.getCurrentProfile).toHaveBeenCalled();
+      expect(mockConsole.logSpy).toHaveBeenCalledWith(expect.stringContaining('Current profile: work'));
+    });
+  });
+
+  describe('config clear with profile', () => {
+    it('should clear specific profile', async () => {
+      vi.mocked(mockConfigManager.clearConfig).mockResolvedValue(undefined);
+
+      await program.parseAsync(['node', 'slack-cli', 'config', 'clear', '--profile', 'work']);
+
+      expect(mockConfigManager.clearConfig).toHaveBeenCalledWith('work');
+      expect(mockConsole.logSpy).toHaveBeenCalledWith(expect.stringContaining('Profile "work" cleared successfully'));
+    });
+
+    it('should clear current profile when no profile specified', async () => {
+      vi.mocked(mockConfigManager.clearConfig).mockResolvedValue(undefined);
+      vi.mocked(mockConfigManager.getCurrentProfile).mockResolvedValue('default');
+
+      await program.parseAsync(['node', 'slack-cli', 'config', 'clear']);
+
+      expect(mockConfigManager.clearConfig).toHaveBeenCalledWith(undefined);
+      expect(mockConsole.logSpy).toHaveBeenCalledWith(expect.stringContaining('Profile "default" cleared successfully'));
+    });
+  });
+});