@urugus/slack-cli 0.1.6 → 0.1.8

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

@@ -1,7 +1,6 @@
-import { WebClient, ChatPostMessageResponse } from '@slack/web-api';
-import pLimit from 'p-limit';
-import { channelResolver } from './channel-resolver';
-import { RATE_LIMIT, DEFAULTS } from './constants';
+import { ChatPostMessageResponse } from '@slack/web-api';
+import { ChannelOperations } from './slack-operations/channel-operations';
+import { MessageOperations } from './slack-operations/message-operations';
 
 export interface Channel {
   id: string;
@@ -36,13 +35,6 @@ 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;
@@ -77,184 +69,32 @@ export interface ChannelUnreadResult {
 }
 
 export class SlackApiClient {
-  private client: WebClient;
-  private rateLimiter: ReturnType<typeof pLimit>;
+  private channelOps: ChannelOperations;
+  private messageOps: MessageOperations;
 
   constructor(token: string) {
-    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);
+    this.channelOps = new ChannelOperations(token);
+    this.messageOps = new MessageOperations(token);
   }
 
   async sendMessage(channel: string, text: string): Promise<ChatPostMessageResponse> {
-    return await this.client.chat.postMessage({
-      channel,
-      text,
-    });
+    return this.messageOps.sendMessage(channel, text);
   }
 
   async listChannels(options: ListChannelsOptions): Promise<Channel[]> {
-    const channels: Channel[] = [];
-    let cursor: string | undefined;
-
-    // Paginate through all channels
-    do {
-      const response = await this.client.conversations.list({
-        types: options.types,
-        exclude_archived: options.exclude_archived,
-        limit: options.limit,
-        cursor,
-      });
-
-      if (response.channels) {
-        channels.push(...(response.channels as Channel[]));
-      }
-
-      cursor = response.response_metadata?.next_cursor;
-    } while (cursor);
-
-    return channels;
+    return this.channelOps.listChannels(options);
   }
 
   async getHistory(channel: string, options: HistoryOptions): Promise<HistoryResult> {
-    // 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: DEFAULTS.CHANNELS_LIMIT,
-      })
-    );
-
-    const response = await this.client.conversations.history({
-      channel: channelId,
-      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 };
+    return this.messageOps.getHistory(channel, options);
   }
 
   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[];
-
-    // 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);
+    return this.channelOps.listUnreadChannels();
   }
 
   async getChannelUnread(channelNameOrId: string): Promise<ChannelUnreadResult> {
-    // 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: DEFAULTS.CHANNELS_LIMIT,
-      })
-    );
-
-    // Get channel info with unread count
-    const info = await this.client.conversations.info({
-      channel: channelId,
-    });
-    const channel = info.channel as ChannelWithUnreadInfo;
-
-    // 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,
-    };
+    return this.messageOps.getChannelUnread(channelNameOrId);
   }
 }
 

package/src/utils/slack-operations/base-client.ts

@@ -0,0 +1,30 @@
+import { WebClient, LogLevel } from '@slack/web-api';
+import pLimit from 'p-limit';
+import { RATE_LIMIT } from '../constants';
+
+export class BaseSlackClient {
+  protected client: WebClient;
+  protected rateLimiter: ReturnType<typeof pLimit>;
+
+  constructor(token: string) {
+    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);
+  }
+
+  protected async handleRateLimit(error: unknown): Promise<void> {
+    if (error instanceof Error && error.message?.includes('rate limit')) {
+      // If we hit rate limit, wait longer
+      await new Promise((resolve) => setTimeout(resolve, 5000));
+    }
+  }
+
+  protected async delay(ms: number): Promise<void> {
+    await new Promise((resolve) => setTimeout(resolve, ms));
+  }
+}

package/src/utils/slack-operations/channel-operations.ts

@@ -0,0 +1,112 @@
+import { BaseSlackClient } from './base-client';
+import { channelResolver } from '../channel-resolver';
+import { DEFAULTS } from '../constants';
+import { Channel, ListChannelsOptions } from '../slack-api-client';
+
+interface ChannelWithUnreadInfo extends Channel {
+  unread_count: number;
+  unread_count_display: number;
+  last_read?: string;
+}
+
+export class ChannelOperations extends BaseSlackClient {
+  async listChannels(options: ListChannelsOptions): Promise<Channel[]> {
+    const channels: Channel[] = [];
+    let cursor: string | undefined;
+
+    // Paginate through all channels
+    do {
+      const response = await this.client.conversations.list({
+        types: options.types,
+        exclude_archived: options.exclude_archived,
+        limit: options.limit,
+        cursor,
+      });
+
+      if (response.channels) {
+        channels.push(...(response.channels as Channel[]));
+      }
+
+      cursor = response.response_metadata?.next_cursor;
+    } while (cursor);
+
+    return channels;
+  }
+
+  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,
+      });
+
+      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',
+      exclude_archived: true,
+      limit: 1000,
+    });
+
+    const channels = response.channels as Channel[];
+    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,
+          });
+        }
+
+        // Add delay between API calls to avoid rate limiting
+        await this.delay(100);
+      } catch (error) {
+        // Skip channels that fail
+        await this.handleRateLimit(error);
+      }
+    }
+
+    return channelsWithUnread;
+  }
+
+  async getChannelInfo(channelNameOrId: string): Promise<ChannelWithUnreadInfo> {
+    const channelId = await channelResolver.resolveChannelId(channelNameOrId, () =>
+      this.listChannels({
+        types: 'public_channel,private_channel,im,mpim',
+        exclude_archived: true,
+        limit: DEFAULTS.CHANNELS_LIMIT,
+      })
+    );
+
+    const info = await this.client.conversations.info({
+      channel: channelId,
+    });
+
+    return info.channel as ChannelWithUnreadInfo;
+  }
+}

package/src/utils/slack-operations/index.ts

@@ -0,0 +1,3 @@
+export { BaseSlackClient } from './base-client';
+export { ChannelOperations } from './channel-operations';
+export { MessageOperations } from './message-operations';

package/src/utils/slack-operations/message-operations.ts

@@ -0,0 +1,94 @@
+import { ChatPostMessageResponse } from '@slack/web-api';
+import { BaseSlackClient } from './base-client';
+import { channelResolver } from '../channel-resolver';
+import { DEFAULTS } from '../constants';
+import { Message, HistoryOptions, HistoryResult, ChannelUnreadResult } from '../slack-api-client';
+import { ChannelOperations } from './channel-operations';
+
+export class MessageOperations extends BaseSlackClient {
+  private channelOps: ChannelOperations;
+
+  constructor(token: string) {
+    super(token);
+    this.channelOps = new ChannelOperations(token);
+  }
+
+  async sendMessage(channel: string, text: string): Promise<ChatPostMessageResponse> {
+    return await this.client.chat.postMessage({
+      channel,
+      text,
+    });
+  }
+
+  async getHistory(channel: string, options: HistoryOptions): Promise<HistoryResult> {
+    // Resolve channel name to ID if needed
+    const channelId = await channelResolver.resolveChannelId(channel, () =>
+      this.channelOps.listChannels({
+        types: 'public_channel,private_channel,im,mpim',
+        exclude_archived: true,
+        limit: DEFAULTS.CHANNELS_LIMIT,
+      })
+    );
+
+    const response = await this.client.conversations.history({
+      channel: channelId,
+      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 = await this.fetchUserInfo(userIds);
+
+    return { messages, users };
+  }
+
+  async getChannelUnread(channelNameOrId: string): Promise<ChannelUnreadResult> {
+    const channel = await this.channelOps.getChannelInfo(channelNameOrId);
+
+    // 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(channel.id, {
+        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,
+    };
+  }
+
+  private async fetchUserInfo(userIds: string[]): Promise<Map<string, string>> {
+    const users = new Map<string, string>();
+
+    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 users;
+  }
+}

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);
@@ -26,11 +30,9 @@ describe('SlackApiClient', () => {
     it('should create WebClient with provided token', () => {
       expect(WebClient).toHaveBeenCalledWith('test-token', {
         retryConfig: {
-          retries: 3,
-          factor: 2,
-          minTimeout: 1000,
-          maxTimeout: 30000,
+          retries: 0, // Disabled to handle rate limits manually
         },
+        logLevel: LogLevel.ERROR,
       });
     });
   });