@urugus/slack-cli 0.2.12 → 0.3.0

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

@@ -1,135 +0,0 @@
-import { ChatPostMessageResponse, ChatScheduleMessageResponse } from '@slack/web-api';
-import { ChannelOperations } from './slack-operations/channel-operations';
-import { MessageOperations } from './slack-operations/message-operations';
-
-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 ScheduledMessage {
-  id: string;
-  channel_id: string;
-  post_at: number;
-  date_created: number;
-  text?: string;
-}
-
-export interface HistoryResult {
-  messages: Message[];
-  users: Map<string, string>;
-}
-
-export interface ChannelUnreadResult {
-  channel: Channel;
-  messages: Message[];
-  users: Map<string, string>;
-}
-
-export class SlackApiClient {
-  private channelOps: ChannelOperations;
-  private messageOps: MessageOperations;
-
-  constructor(token: string) {
-    this.channelOps = new ChannelOperations(token);
-    this.messageOps = new MessageOperations(token);
-  }
-
-  async sendMessage(
-    channel: string,
-    text: string,
-    thread_ts?: string
-  ): Promise<ChatPostMessageResponse> {
-    return this.messageOps.sendMessage(channel, text, thread_ts);
-  }
-
-  async scheduleMessage(
-    channel: string,
-    text: string,
-    post_at: number,
-    thread_ts?: string
-  ): Promise<ChatScheduleMessageResponse> {
-    return this.messageOps.scheduleMessage(channel, text, post_at, thread_ts);
-  }
-
-  async listScheduledMessages(channel?: string, limit = 50): Promise<ScheduledMessage[]> {
-    return this.messageOps.listScheduledMessages(channel, limit);
-  }
-
-  async listChannels(options: ListChannelsOptions): Promise<Channel[]> {
-    return this.channelOps.listChannels(options);
-  }
-
-  async getHistory(channel: string, options: HistoryOptions): Promise<HistoryResult> {
-    return this.messageOps.getHistory(channel, options);
-  }
-
-  async listUnreadChannels(): Promise<Channel[]> {
-    return this.channelOps.listUnreadChannels();
-  }
-
-  async getChannelUnread(channelNameOrId: string): Promise<ChannelUnreadResult> {
-    return this.messageOps.getChannelUnread(channelNameOrId);
-  }
-
-  async markAsRead(channelId: string): Promise<void> {
-    return this.messageOps.markAsRead(channelId);
-  }
-}
-
-export const slackApiClient = {
-  listChannels: async (token: string, options: ListChannelsOptions): Promise<Channel[]> => {
-    const client = new SlackApiClient(token);
-    return client.listChannels(options);
-  },
-};

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

@@ -1,30 +0,0 @@
-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

@@ -1,161 +0,0 @@
-import { BaseSlackClient } from './base-client';
-import { channelResolver } from '../channel-resolver';
-import { DEFAULTS } from '../constants';
-import { Channel, ListChannelsOptions } from '../slack-api-client';
-import { WebClient } from '@slack/web-api';
-
-interface ChannelWithUnreadInfo extends Channel {
-  unread_count: number;
-  unread_count_display: number;
-  last_read?: string;
-}
-
-export class ChannelOperations extends BaseSlackClient {
-  constructor(tokenOrClient: string | WebClient) {
-    if (typeof tokenOrClient === 'string') {
-      super(tokenOrClient);
-    } else {
-      super('dummy-token'); // Call parent constructor
-      this.client = tokenOrClient; // Override the client for testing
-    }
-  }
-
-  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[]> {
-    const channels = await this.fetchAllChannels();
-    const channelsWithUnread: Channel[] = [];
-
-    // Process channels one by one with delay to avoid rate limits
-    for (const channel of channels) {
-      try {
-        const unreadInfo = await this.getChannelUnreadInfo(channel);
-        if (unreadInfo) {
-          channelsWithUnread.push(unreadInfo);
-        }
-
-        // 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;
-  }
-
-  private async fetchAllChannels(): Promise<Channel[]> {
-    const response = await this.client.conversations.list({
-      types: 'public_channel,private_channel,im,mpim',
-      exclude_archived: true,
-      limit: 1000,
-    });
-
-    return response.channels as Channel[];
-  }
-
-  private async getChannelUnreadInfo(channel: Channel): Promise<Channel | null> {
-    const channelInfo = await this.fetchChannelInfo(channel.id);
-    const unreadCount = await this.calculateUnreadCount(channel.id, channelInfo);
-
-    if (unreadCount > 0) {
-      return {
-        ...channel,
-        unread_count: unreadCount,
-        unread_count_display: unreadCount,
-        last_read: channelInfo.last_read,
-      };
-    }
-
-    return null;
-  }
-
-  private async fetchChannelInfo(channelId: string): Promise<ChannelWithUnreadInfo> {
-    const info = await this.client.conversations.info({
-      channel: channelId,
-      include_num_members: false,
-    });
-    return info.channel as ChannelWithUnreadInfo;
-  }
-
-  private async calculateUnreadCount(
-    channelId: string,
-    channelInfo: ChannelWithUnreadInfo
-  ): Promise<number> {
-    // Get the latest message to check if channel has any messages
-    const latestMessage = await this.fetchLatestMessage(channelId);
-    if (!latestMessage) {
-      return 0;
-    }
-
-    if (channelInfo.last_read) {
-      return await this.fetchUnreadMessageCount(channelId, channelInfo.last_read);
-    } else {
-      // If no last_read, all messages are unread
-      return await this.fetchAllMessageCount(channelId);
-    }
-  }
-
-  private async fetchLatestMessage(channelId: string): Promise<any> {
-    const history = await this.client.conversations.history({
-      channel: channelId,
-      limit: 1,
-    });
-    return history.messages && history.messages.length > 0 ? history.messages[0] : null;
-  }
-
-  private async fetchUnreadMessageCount(channelId: string, lastRead: string): Promise<number> {
-    const unreadHistory = await this.client.conversations.history({
-      channel: channelId,
-      oldest: lastRead,
-      limit: 100, // Get up to 100 unread messages
-    });
-    return unreadHistory.messages?.length || 0;
-  }
-
-  private async fetchAllMessageCount(channelId: string): Promise<number> {
-    const allHistory = await this.client.conversations.history({
-      channel: channelId,
-      limit: 100,
-    });
-    return allHistory.messages?.length || 0;
-  }
-
-  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

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

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

@@ -1,176 +0,0 @@
-import {
-  ChatPostMessageResponse,
-  ChatPostMessageArguments,
-  ChatScheduleMessageArguments,
-  ChatScheduleMessageResponse,
-} from '@slack/web-api';
-import { BaseSlackClient } from './base-client';
-import { channelResolver } from '../channel-resolver';
-import { DEFAULTS } from '../constants';
-import {
-  Message,
-  HistoryOptions,
-  HistoryResult,
-  ChannelUnreadResult,
-  ScheduledMessage,
-} from '../slack-api-client';
-import { ChannelOperations } from './channel-operations';
-import { extractAllUserIds } from '../mention-utils';
-
-export class MessageOperations extends BaseSlackClient {
-  private channelOps: ChannelOperations;
-
-  constructor(token: string) {
-    super(token);
-    this.channelOps = new ChannelOperations(token);
-  }
-
-  async sendMessage(
-    channel: string,
-    text: string,
-    thread_ts?: string
-  ): Promise<ChatPostMessageResponse> {
-    const params: ChatPostMessageArguments = {
-      channel,
-      text,
-    };
-
-    if (thread_ts) {
-      params.thread_ts = thread_ts;
-    }
-
-    return await this.client.chat.postMessage(params);
-  }
-
-  async scheduleMessage(
-    channel: string,
-    text: string,
-    post_at: number,
-    thread_ts?: string
-  ): Promise<ChatScheduleMessageResponse> {
-    const params: ChatScheduleMessageArguments = {
-      channel,
-      text,
-      post_at,
-    };
-
-    if (thread_ts) {
-      params.thread_ts = thread_ts;
-    }
-
-    return await this.client.chat.scheduleMessage(params);
-  }
-
-  async listScheduledMessages(channel?: string, limit = 50): Promise<ScheduledMessage[]> {
-    const channelId = channel
-      ? await channelResolver.resolveChannelId(channel, () =>
-          this.channelOps.listChannels({
-            types: 'public_channel,private_channel,im,mpim',
-            exclude_archived: true,
-            limit: DEFAULTS.CHANNELS_LIMIT,
-          })
-        )
-      : undefined;
-
-    const params: { channel?: string; limit: number } = {
-      limit,
-    };
-
-    if (channelId) {
-      params.channel = channelId;
-    }
-
-    const response = await this.client.chat.scheduledMessages.list(params as any);
-    return (response.scheduled_messages || []) as ScheduledMessage[];
-  }
-
-  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[];
-
-    // Extract all unique user IDs (authors and mentioned users)
-    const userIds = extractAllUserIds(messages);
-    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>();
-    let actualUnreadCount = 0;
-
-    if (channel.last_read) {
-      // Always fetch messages after last_read to get accurate unread count
-      const historyResult = await this.getHistory(channel.id, {
-        limit: 100, // Fetch up to 100 messages after last_read
-        oldest: channel.last_read,
-      });
-      messages = historyResult.messages;
-      users = historyResult.users;
-      actualUnreadCount = messages.length;
-    } else if (!channel.last_read) {
-      // If no last_read, all messages are unread
-      const historyResult = await this.getHistory(channel.id, {
-        limit: 100,
-      });
-      messages = historyResult.messages;
-      users = historyResult.users;
-      actualUnreadCount = messages.length;
-    }
-
-    return {
-      channel: {
-        ...channel,
-        unread_count: actualUnreadCount,
-        unread_count_display: actualUnreadCount,
-      },
-      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;
-  }
-
-  async markAsRead(channelId: string): Promise<void> {
-    await this.client.conversations.mark({
-      channel: channelId,
-      ts: Date.now() / 1000 + '',
-    });
-  }
-}

package/src/utils/slack-patterns.ts

@@ -1,9 +0,0 @@
-/**
- * Common regex patterns for Slack message parsing
- */
-
-// Matches Slack user mentions in the format <@USERID>
-export const USER_MENTION_PATTERN = /<@([A-Z0-9]+)>/g;
-
-// Matches a single user mention (non-global)
-export const SINGLE_USER_MENTION_PATTERN = /<@([A-Z0-9]+)>/;

package/src/utils/token-utils.ts

@@ -1,17 +0,0 @@
-import { TOKEN_MASK_LENGTH, TOKEN_MIN_LENGTH } from './constants';
-
-/**
- * Masks a token for display purposes, showing only first and last few characters
- * @param token The token to mask
- * @returns Masked token in format "xoxb-****-****-abcd"
- */
-export function maskToken(token: string): string {
-  if (token.length <= TOKEN_MIN_LENGTH) {
-    return '****';
-  }
-
-  const prefix = token.substring(0, TOKEN_MASK_LENGTH);
-  const suffix = token.substring(token.length - TOKEN_MASK_LENGTH);
-
-  return `${prefix}-****-****-${suffix}`;
-}