@urugus/slack-cli 0.1.5 → 0.1.6

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

@@ -1,4 +1,7 @@
 import { WebClient, ChatPostMessageResponse } 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,14 @@ 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: RATE_LIMIT.RETRY_CONFIG,
+    });
+    // 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 +119,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,
@@ -187,84 +168,70 @@ 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 {
-            ...channel,
-            unread_count: channelInfo.unread_count || 0,
-            unread_count_display: channelInfo.unread_count_display || 0,
-            last_read: channelInfo.last_read,
-          };
-        } catch {
-          return channel;
-        }
-      })
-    );
+    // Batch process channels to reduce rate limit issues
+    const batchSize = RATE_LIMIT.BATCH_SIZE;
+    const batches: Channel[][] = [];
+    for (let i = 0; i < channels.length; i += batchSize) {
+      batches.push(channels.slice(i, i + batchSize));
+    }
+
+    const channelsWithUnread: Channel[] = [];
+
+    // Process batches sequentially with delay
+    for (const batch of batches) {
+      const batchResults = await Promise.all(
+        batch.map((channel) =>
+          this.rateLimiter(async () => {
+            try {
+              const info = await this.client.conversations.info({
+                channel: channel.id,
+                include_num_members: false,
+              });
+              const channelInfo = info.channel as ChannelWithUnreadInfo;
+              return {
+                ...channel,
+                unread_count: channelInfo.unread_count || 0,
+                unread_count_display: channelInfo.unread_count_display || 0,
+                last_read: channelInfo.last_read,
+              };
+            } catch (error) {
+              // Log rate limit errors but continue processing
+              if (error instanceof Error && error.message?.includes('rate limit')) {
+                console.warn(`Rate limit hit for channel ${channel.name}, skipping...`);
+              }
+              return channel;
+            }
+          })
+        )
+      );
+
+      channelsWithUnread.push(...batchResults);
+
+      // Add delay between batches to avoid rate limiting
+      if (batches.indexOf(batch) < batches.length - 1) {
+        await new Promise((resolve) => setTimeout(resolve, RATE_LIMIT.BATCH_DELAY_MS));
+      }
+    }
 
     // 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({
+    // 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

@@ -24,7 +24,14 @@ describe('SlackApiClient', () => {
 
   describe('constructor', () => {
     it('should create WebClient with provided token', () => {
-      expect(WebClient).toHaveBeenCalledWith('test-token');
+      expect(WebClient).toHaveBeenCalledWith('test-token', {
+        retryConfig: {
+          retries: 3,
+          factor: 2,
+          minTimeout: 1000,
+          maxTimeout: 30000,
+        },
+      });
     });
   });