@urugus/slack-cli 0.1.5 → 0.1.7

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

@@ -1,4 +1,7 @@
-import { WebClient, ChatPostMessageResponse } from '@slack/web-api';
+import { WebClient, ChatPostMessageResponse, LogLevel } from '@slack/web-api';
+import pLimit from 'p-limit';
+import { channelResolver } from './channel-resolver';
+import { RATE_LIMIT, DEFAULTS } from './constants';
 
 export interface Channel {
   id: string;
@@ -33,6 +36,13 @@ export interface Channel {
   };
 }
 
+// Extended channel interface with additional properties from API
+interface ChannelWithUnreadInfo extends Channel {
+  unread_count: number;
+  unread_count_display: number;
+  last_read?: string;
+}
+
 export interface ListChannelsOptions {
   types: string;
   exclude_archived: boolean;
@@ -68,9 +78,17 @@ export interface ChannelUnreadResult {
 
 export class SlackApiClient {
   private client: WebClient;
+  private rateLimiter: ReturnType<typeof pLimit>;
 
   constructor(token: string) {
-    this.client = new WebClient(token);
+    this.client = new WebClient(token, {
+      retryConfig: {
+        retries: 0, // Disable automatic retries to handle rate limits manually
+      },
+      logLevel: LogLevel.ERROR, // Reduce noise from WebClient logs
+    });
+    // Limit concurrent API calls to avoid rate limiting
+    this.rateLimiter = pLimit(RATE_LIMIT.CONCURRENT_REQUESTS);
   }
 
   async sendMessage(channel: string, text: string): Promise<ChatPostMessageResponse> {
@@ -104,48 +122,14 @@ export class SlackApiClient {
   }
 
   async getHistory(channel: string, options: HistoryOptions): Promise<HistoryResult> {
-    // First, resolve channel name to ID if needed
-    let channelId = channel;
-    if (!channel.startsWith('C') && !channel.startsWith('D') && !channel.startsWith('G')) {
-      // It's a name, not an ID - need to find the ID
-      const channels = await this.listChannels({
+    // Resolve channel name to ID if needed
+    const channelId = await channelResolver.resolveChannelId(channel, () =>
+      this.listChannels({
         types: 'public_channel,private_channel,im,mpim',
         exclude_archived: true,
-        limit: 1000,
-      });
-
-      // Try multiple matching strategies
-      const foundChannel = channels.find((c) => {
-        // Direct name match
-        if (c.name === channel) return true;
-        // Match without # prefix
-        if (c.name === channel.replace('#', '')) return true;
-        // Case-insensitive match
-        if (c.name?.toLowerCase() === channel.toLowerCase()) return true;
-        // Match with normalized name
-        if (c.name_normalized === channel) return true;
-        return false;
-      });
-
-      if (!foundChannel) {
-        // Provide helpful error message
-        const similarChannels = channels
-          .filter((c) => c.name?.toLowerCase().includes(channel.toLowerCase()))
-          .slice(0, 5)
-          .map((c) => c.name);
-
-        if (similarChannels.length > 0) {
-          throw new Error(
-            `Channel '${channel}' not found. Did you mean one of these? ${similarChannels.join(', ')}`
-          );
-        } else {
-          throw new Error(
-            `Channel '${channel}' not found. Make sure you are a member of this channel.`
-          );
-        }
-      }
-      channelId = foundChannel.id;
-    }
+        limit: DEFAULTS.CHANNELS_LIMIT,
+      })
+    );
 
     const response = await this.client.conversations.history({
       channel: channelId,
@@ -178,6 +162,28 @@ export class SlackApiClient {
   }
 
   async listUnreadChannels(): Promise<Channel[]> {
+    try {
+      // Use users.conversations to get unread counts in a single API call
+      const response = await this.client.users.conversations({
+        types: 'public_channel,private_channel,im,mpim',
+        exclude_archived: true,
+        limit: 1000,
+        user: undefined, // Current authenticated user
+      });
+
+      const channels = response.channels as Channel[];
+
+      // Filter to only channels with unread messages
+      // The users.conversations endpoint includes unread_count_display
+      return channels.filter((channel) => (channel.unread_count_display || 0) > 0);
+    } catch (error) {
+      // Fallback to the old method if users.conversations fails
+      console.warn('Failed to use users.conversations, falling back to conversations.list');
+      return this.listUnreadChannelsFallback();
+    }
+  }
+
+  private async listUnreadChannelsFallback(): 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',
@@ -186,85 +192,55 @@ export class SlackApiClient {
     });
 
     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 {
+    const channelsWithUnread: Channel[] = [];
+
+    // Process channels one by one with delay to avoid rate limits
+    for (const channel of channels) {
+      try {
+        const info = await this.client.conversations.info({
+          channel: channel.id,
+          include_num_members: false,
+        });
+        const channelInfo = info.channel as ChannelWithUnreadInfo;
+        
+        if (channelInfo.unread_count_display && channelInfo.unread_count_display > 0) {
+          channelsWithUnread.push({
             ...channel,
             unread_count: channelInfo.unread_count || 0,
             unread_count_display: channelInfo.unread_count_display || 0,
             last_read: channelInfo.last_read,
-          };
-        } catch {
-          return channel;
+          });
         }
-      })
-    );
+        
+        // Add delay between API calls to avoid rate limiting
+        await new Promise((resolve) => setTimeout(resolve, 100));
+      } catch (error) {
+        // Skip channels that fail
+        if (error instanceof Error && error.message?.includes('rate limit')) {
+          // If we hit rate limit, wait longer
+          await new Promise((resolve) => setTimeout(resolve, 5000));
+        }
+      }
+    }
 
-    // Filter to only channels with unread messages
-    return channelsWithUnread.filter((channel) => (channel.unread_count_display || 0) > 0);
+    return channelsWithUnread;
   }
 
   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({
+    // Resolve channel name to ID if needed
+    const channelId = await channelResolver.resolveChannelId(channelNameOrId, () =>
+      this.listChannels({
         types: 'public_channel,private_channel,im,mpim',
         exclude_archived: true,
-        limit: 1000,
-      });
-
-      // Try multiple matching strategies (same as getHistory)
-      const channel = channels.find((c) => {
-        // Direct name match
-        if (c.name === channelNameOrId) return true;
-        // Match without # prefix
-        if (c.name === channelNameOrId.replace('#', '')) return true;
-        // Case-insensitive match
-        if (c.name?.toLowerCase() === channelNameOrId.toLowerCase()) return true;
-        // Match with normalized name
-        if (c.name_normalized === channelNameOrId) return true;
-        return false;
-      });
-
-      if (!channel) {
-        // Provide helpful error message
-        const similarChannels = channels
-          .filter((c) => c.name?.toLowerCase().includes(channelNameOrId.toLowerCase()))
-          .slice(0, 5)
-          .map((c) => c.name);
-
-        if (similarChannels.length > 0) {
-          throw new Error(
-            `Channel '${channelNameOrId}' not found. Did you mean one of these? ${similarChannels.join(', ')}`
-          );
-        } else {
-          throw new Error(
-            `Channel '${channelNameOrId}' not found. Make sure you are a member of this channel.`
-          );
-        }
-      }
-      channelId = channel.id;
-    }
+        limit: DEFAULTS.CHANNELS_LIMIT,
+      })
+    );
 
     // Get channel info with unread count
     const info = await this.client.conversations.info({
       channel: channelId,
     });
-    const channel = info.channel as any;
+    const channel = info.channel as ChannelWithUnreadInfo;
 
     // Get unread messages
     let messages: Message[] = [];

package/tests/commands/unread.test.ts

@@ -245,4 +245,35 @@ describe('unread command', () => {
       expect(SlackApiClient).toHaveBeenCalledWith('work-token');
     });
   });
+
+  describe('rate limiting', () => {
+    it('should handle rate limit errors gracefully', async () => {
+      vi.mocked(mockConfigManager.getConfig).mockResolvedValue({
+        token: 'test-token',
+        updatedAt: new Date().toISOString()
+      });
+      
+      const rateLimitError = new Error('A rate limit was exceeded (url: conversations.info, retry-after: 10)');
+      vi.mocked(mockSlackClient.listUnreadChannels).mockRejectedValue(rateLimitError);
+
+      await program.parseAsync(['node', 'slack-cli', 'unread']);
+
+      expect(mockConsole.errorSpy).toHaveBeenCalledWith(expect.stringContaining('Error:'), expect.stringContaining('rate limit'));
+      expect(mockConsole.exitSpy).toHaveBeenCalledWith(1);
+    });
+
+    it('should not retry indefinitely on rate limit errors', async () => {
+      vi.mocked(mockConfigManager.getConfig).mockResolvedValue({
+        token: 'test-token',
+        updatedAt: new Date().toISOString()
+      });
+      
+      const rateLimitError = new Error('A rate limit was exceeded (url: conversations.info, retry-after: 10)');
+      vi.mocked(mockSlackClient.listUnreadChannels).mockRejectedValue(rateLimitError);
+
+      await program.parseAsync(['node', 'slack-cli', 'unread']);
+
+      expect(mockSlackClient.listUnreadChannels).toHaveBeenCalledTimes(1);
+    });
+  });
 });

package/tests/utils/channel-resolver.test.ts

@@ -0,0 +1,157 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { ChannelResolver } from '../../src/utils/channel-resolver';
+import { Channel } from '../../src/utils/slack-api-client';
+
+describe('ChannelResolver', () => {
+  let resolver: ChannelResolver;
+  let mockChannels: Channel[];
+
+  beforeEach(() => {
+    resolver = new ChannelResolver();
+    mockChannels = [
+      {
+        id: 'C123',
+        name: 'general',
+        is_private: false,
+        created: 1234567890,
+        is_member: true,
+      },
+      {
+        id: 'C456',
+        name: 'random',
+        is_private: false,
+        created: 1234567890,
+        is_member: true,
+      },
+      {
+        id: 'C789',
+        name: 'dev-team',
+        is_private: false,
+        created: 1234567890,
+        is_member: true,
+        name_normalized: 'dev-team',
+      },
+      {
+        id: 'G123',
+        name: 'private-channel',
+        is_private: true,
+        created: 1234567890,
+        is_member: true,
+      },
+    ];
+  });
+
+  describe('isChannelId', () => {
+    it('should identify channel IDs starting with C', () => {
+      expect(resolver.isChannelId('C123456')).toBe(true);
+    });
+
+    it('should identify DM IDs starting with D', () => {
+      expect(resolver.isChannelId('D123456')).toBe(true);
+    });
+
+    it('should identify group IDs starting with G', () => {
+      expect(resolver.isChannelId('G123456')).toBe(true);
+    });
+
+    it('should return false for channel names', () => {
+      expect(resolver.isChannelId('general')).toBe(false);
+      expect(resolver.isChannelId('#general')).toBe(false);
+    });
+  });
+
+  describe('findChannel', () => {
+    it('should find channel by exact name match', () => {
+      const result = resolver.findChannel('general', mockChannels);
+      expect(result).toEqual(mockChannels[0]);
+    });
+
+    it('should find channel by name without # prefix', () => {
+      const result = resolver.findChannel('#general', mockChannels);
+      expect(result).toEqual(mockChannels[0]);
+    });
+
+    it('should find channel by case-insensitive match', () => {
+      const result = resolver.findChannel('GENERAL', mockChannels);
+      expect(result).toEqual(mockChannels[0]);
+    });
+
+    it('should find channel by normalized name', () => {
+      const result = resolver.findChannel('dev-team', mockChannels);
+      expect(result).toEqual(mockChannels[2]);
+    });
+
+    it('should return undefined when channel not found', () => {
+      const result = resolver.findChannel('nonexistent', mockChannels);
+      expect(result).toBeUndefined();
+    });
+  });
+
+  describe('getSimilarChannels', () => {
+    it('should find similar channels by partial match', () => {
+      const result = resolver.getSimilarChannels('gen', mockChannels);
+      expect(result).toEqual(['general']);
+    });
+
+    it('should limit results to specified count', () => {
+      const manyChannels = [
+        ...mockChannels,
+        { id: 'C999', name: 'general-2', is_private: false, created: 0 },
+        { id: 'C888', name: 'general-3', is_private: false, created: 0 },
+      ];
+      const result = resolver.getSimilarChannels('general', manyChannels, 2);
+      expect(result).toHaveLength(2);
+    });
+
+    it('should return empty array when no similar channels found', () => {
+      const result = resolver.getSimilarChannels('xyz', mockChannels);
+      expect(result).toEqual([]);
+    });
+  });
+
+  describe('resolveChannelError', () => {
+    it('should create error with suggestions when similar channels exist', () => {
+      const error = resolver.resolveChannelError('genera', mockChannels);
+      expect(error.message).toContain("Channel 'genera' not found");
+      expect(error.message).toContain('Did you mean one of these?');
+      expect(error.message).toContain('general');
+    });
+
+    it('should create error without suggestions when no similar channels', () => {
+      const error = resolver.resolveChannelError('xyz', mockChannels);
+      expect(error.message).toContain("Channel 'xyz' not found");
+      expect(error.message).toContain('Make sure you are a member of this channel');
+      expect(error.message).not.toContain('Did you mean');
+    });
+  });
+
+  describe('resolveChannelId', () => {
+    it('should return ID directly if already an ID', async () => {
+      const getChannelsFn = vi.fn();
+      const result = await resolver.resolveChannelId('C123456', getChannelsFn);
+      expect(result).toBe('C123456');
+      expect(getChannelsFn).not.toHaveBeenCalled();
+    });
+
+    it('should resolve channel name to ID', async () => {
+      const getChannelsFn = vi.fn().mockResolvedValue(mockChannels);
+      const result = await resolver.resolveChannelId('general', getChannelsFn);
+      expect(result).toBe('C123');
+      expect(getChannelsFn).toHaveBeenCalled();
+    });
+
+    it('should throw error when channel not found', async () => {
+      const getChannelsFn = vi.fn().mockResolvedValue(mockChannels);
+      await expect(resolver.resolveChannelId('nonexistent', getChannelsFn)).rejects.toThrow(
+        "Channel 'nonexistent' not found"
+      );
+    });
+
+    it('should include suggestions in error when similar channels exist', async () => {
+      const getChannelsFn = vi.fn().mockResolvedValue(mockChannels);
+      await expect(resolver.resolveChannelId('genera', getChannelsFn)).rejects.toThrow(
+        'Did you mean one of these? general'
+      );
+    });
+  });
+});

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

@@ -1,6 +1,6 @@
 import { describe, it, expect, beforeEach, vi } from 'vitest';
 import { SlackApiClient } from '../../src/utils/slack-api-client';
-import { WebClient } from '@slack/web-api';
+import { WebClient, LogLevel } from '@slack/web-api';
 
 vi.mock('@slack/web-api');
 
@@ -15,7 +15,11 @@ describe('SlackApiClient', () => {
         postMessage: vi.fn()
       },
       conversations: {
-        list: vi.fn()
+        list: vi.fn(),
+        info: vi.fn()
+      },
+      users: {
+        conversations: vi.fn()
       }
     };
     vi.mocked(WebClient).mockReturnValue(mockWebClient);
@@ -24,7 +28,12 @@ describe('SlackApiClient', () => {
 
   describe('constructor', () => {
     it('should create WebClient with provided token', () => {
-      expect(WebClient).toHaveBeenCalledWith('test-token');
+      expect(WebClient).toHaveBeenCalledWith('test-token', {
+        retryConfig: {
+          retries: 0, // Disabled to handle rate limits manually
+        },
+        logLevel: LogLevel.ERROR,
+      });
     });
   });