@urugus/slack-cli 0.2.6 → 0.2.8

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

@@ -2,6 +2,7 @@ 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;
@@ -10,6 +11,15 @@ interface ChannelWithUnreadInfo extends Channel {
 }
 
 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;
@@ -34,65 +44,15 @@ export class ChannelOperations extends BaseSlackClient {
   }
 
   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[];
+    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 info = await this.client.conversations.info({
-          channel: channel.id,
-          include_num_members: false,
-        });
-        const channelInfo = info.channel as ChannelWithUnreadInfo;
-
-        // Get the latest message in the channel
-        const history = await this.client.conversations.history({
-          channel: channel.id,
-          limit: 1,
-        });
-
-        // Always check for messages after last_read timestamp
-        if (channelInfo.last_read) {
-          // Fetch messages after last_read
-          const unreadHistory = await this.client.conversations.history({
-            channel: channel.id,
-            oldest: channelInfo.last_read,
-            limit: 100, // Get up to 100 unread messages
-          });
-
-          const unreadCount = unreadHistory.messages?.length || 0;
-          if (unreadCount > 0) {
-            channelsWithUnread.push({
-              ...channel,
-              unread_count: unreadCount,
-              unread_count_display: unreadCount,
-              last_read: channelInfo.last_read,
-            });
-          }
-        } else if (history.messages && history.messages.length > 0) {
-          // If no last_read, all messages are unread
-          const allHistory = await this.client.conversations.history({
-            channel: channel.id,
-            limit: 100,
-          });
-          const unreadCount = allHistory.messages?.length || 0;
-
-          if (unreadCount > 0) {
-            channelsWithUnread.push({
-              ...channel,
-              unread_count: unreadCount,
-              unread_count_display: unreadCount,
-              last_read: channelInfo.last_read,
-            });
-          }
+        const unreadInfo = await this.getChannelUnreadInfo(channel);
+        if (unreadInfo) {
+          channelsWithUnread.push(unreadInfo);
         }
 
         // Add delay between API calls to avoid rate limiting
@@ -106,6 +66,83 @@ export class ChannelOperations extends BaseSlackClient {
     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({

package/src/utils/token-utils.ts

@@ -0,0 +1,17 @@
+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}`;
+}

package/src/utils/validators.ts

@@ -0,0 +1,225 @@
+import { Command } from 'commander';
+import { ERROR_MESSAGES } from './constants';
+
+/**
+ * Common validation functions for CLI commands
+ */
+
+export interface ValidationRule<T = unknown> {
+  validate: (value: T) => boolean | string;
+  errorMessage?: string;
+}
+
+export interface ValidationOptions {
+  required?: boolean;
+  rules?: ValidationRule[];
+}
+
+/**
+ * Validates that a value exists (not undefined, null, or empty string)
+ */
+export function validateRequired(value: unknown, fieldName: string): string | null {
+  if (value === undefined || value === null || value === '') {
+    return `${fieldName} is required`;
+  }
+  return null;
+}
+
+/**
+ * Validates mutually exclusive options
+ */
+export function validateMutuallyExclusive(
+  options: Record<string, unknown>,
+  fields: string[],
+  errorMessage?: string
+): string | null {
+  const presentFields = fields.filter((field) => options[field] !== undefined);
+  if (presentFields.length > 1) {
+    return errorMessage || `Cannot use both ${presentFields.join(' and ')}`;
+  }
+  if (presentFields.length === 0) {
+    return errorMessage || `Must specify one of: ${fields.join(', ')}`;
+  }
+  return null;
+}
+
+/**
+ * Validates string format using regex
+ */
+export function validateFormat(
+  value: string,
+  pattern: RegExp,
+  errorMessage: string
+): string | null {
+  if (!pattern.test(value)) {
+    return errorMessage;
+  }
+  return null;
+}
+
+/**
+ * Validates numeric range
+ */
+export function validateRange(
+  value: number,
+  min?: number,
+  max?: number,
+  fieldName = 'Value'
+): string | null {
+  if (min !== undefined && value < min) {
+    return `${fieldName} must be at least ${min}`;
+  }
+  if (max !== undefined && value > max) {
+    return `${fieldName} must be at most ${max}`;
+  }
+  return null;
+}
+
+/**
+ * Validates date format
+ */
+export function validateDateFormat(dateString: string): string | null {
+  const date = new Date(dateString);
+  if (isNaN(date.getTime())) {
+    return 'Invalid date format';
+  }
+  return null;
+}
+
+/**
+ * Common format validators
+ */
+export const formatValidators = {
+  /**
+   * Validates Slack thread timestamp format (1234567890.123456)
+   */
+  threadTimestamp: (value: string): string | null => {
+    const pattern = /^\d{10}\.\d{6}$/;
+    return validateFormat(value, pattern, ERROR_MESSAGES.INVALID_THREAD_TIMESTAMP);
+  },
+
+  /**
+   * Validates Slack channel ID format (C1234567890, D1234567890, G1234567890)
+   */
+  channelId: (value: string): string | null => {
+    const pattern = /^[CDG][A-Z0-9]{10,}$/;
+    return validateFormat(value, pattern, 'Invalid channel ID format');
+  },
+
+  /**
+   * Validates output format options
+   */
+  outputFormat: (value: string): string | null => {
+    const validFormats = ['table', 'simple', 'json', 'compact'];
+    if (!validFormats.includes(value)) {
+      return `Invalid format. Must be one of: ${validFormats.join(', ')}`;
+    }
+    return null;
+  },
+};
+
+/**
+ * Creates a preAction hook for command validation
+ */
+export function createValidationHook(
+  validations: Array<(options: Record<string, unknown>, command: Command) => string | null>
+): (thisCommand: Command) => void {
+  return (thisCommand: Command) => {
+    const options = thisCommand.opts();
+
+    for (const validation of validations) {
+      const error = validation(options, thisCommand);
+      if (error) {
+        thisCommand.error(`Error: ${error}`);
+        break; // Stop processing after first error
+      }
+    }
+  };
+}
+
+/**
+ * Common command option validators
+ */
+export const optionValidators = {
+  /**
+   * Validates message/file options for send command
+   */
+  messageOrFile: (options: Record<string, unknown>): string | null => {
+    if (!options.message && !options.file) {
+      return ERROR_MESSAGES.NO_MESSAGE_OR_FILE;
+    }
+    if (options.message && options.file) {
+      return ERROR_MESSAGES.BOTH_MESSAGE_AND_FILE;
+    }
+    return null;
+  },
+
+  /**
+   * Validates thread timestamp if provided
+   */
+  threadTimestamp: (options: Record<string, unknown>): string | null => {
+    if (options.thread) {
+      return formatValidators.threadTimestamp(options.thread as string);
+    }
+    return null;
+  },
+
+  /**
+   * Validates message count for history command
+   */
+  messageCount: (options: Record<string, unknown>): string | null => {
+    if (options.number) {
+      const count = parseInt(options.number as string, 10);
+      if (isNaN(count)) {
+        return 'Message count must be a number';
+      }
+      return validateRange(count, 1, 1000, 'Message count');
+    }
+    return null;
+  },
+
+  /**
+   * Validates date format for history command
+   */
+  sinceDate: (options: Record<string, unknown>): string | null => {
+    if (options.since) {
+      const error = validateDateFormat(options.since as string);
+      if (error) {
+        return 'Invalid date format. Use YYYY-MM-DD HH:MM:SS';
+      }
+    }
+    return null;
+  },
+
+  /**
+   * Validates format option
+   */
+  format: (options: Record<string, unknown>): string | null => {
+    if (options.format) {
+      const validFormats = ['table', 'simple', 'json'];
+      if (!validFormats.includes(options.format as string)) {
+        return `Invalid format '${options.format}'. Must be one of: ${validFormats.join(', ')}`;
+      }
+    }
+    return null;
+  },
+};
+
+/**
+ * Creates a validated option parser
+ */
+export function createOptionParser<T>(
+  parser: (value: string | undefined, defaultValue: T) => T,
+  validator?: (value: T) => string | null
+): (value: string | undefined, defaultValue: T) => T {
+  return (value: string | undefined, defaultValue: T): T => {
+    const parsed = parser(value, defaultValue);
+    if (validator) {
+      const error = validator(parsed);
+      if (error) {
+        throw new Error(error);
+      }
+    }
+    return parsed;
+  };
+}

package/tests/commands/history.test.ts

@@ -217,6 +217,121 @@ describe('history command', () => {
   });
 
   describe('output formatting', () => {
+    describe('format options', () => {
+      it('should display messages in JSON format when --format json is specified', async () => {
+        vi.mocked(mockConfigManager.getConfig).mockResolvedValue({
+          token: 'test-token',
+          updatedAt: new Date().toISOString()
+        });
+
+        const mockMessages = [
+          {
+            type: 'message',
+            text: 'Hello world',
+            user: 'U123456',
+            ts: '1609459200.000100',
+          },
+          {
+            type: 'message',
+            text: 'Another message',
+            user: 'U789012',
+            ts: '1609459300.000200',
+          },
+        ];
+        
+        vi.mocked(mockSlackClient.getHistory).mockResolvedValue({
+          messages: mockMessages,
+          users: new Map([
+            ['U123456', 'john.doe'],
+            ['U789012', 'jane.smith']
+          ])
+        });
+
+        await program.parseAsync(['node', 'slack-cli', 'history', '-c', 'general', '--format', 'json']);
+
+        const expectedOutput = {
+          channel: 'general',
+          messages: [
+            {
+              timestamp: '2021-01-01 00:01:40',
+              user: 'jane.smith',
+              text: 'Another message'
+            },
+            {
+              timestamp: '2021-01-01 00:00:00',
+              user: 'john.doe',
+              text: 'Hello world'
+            }
+          ],
+          total: 2
+        };
+
+        expect(mockConsole.logSpy).toHaveBeenCalledWith(JSON.stringify(expectedOutput, null, 2));
+      });
+
+      it('should display messages in simple format when --format simple is specified', async () => {
+        vi.mocked(mockConfigManager.getConfig).mockResolvedValue({
+          token: 'test-token',
+          updatedAt: new Date().toISOString()
+        });
+
+        const mockMessages = [
+          {
+            type: 'message',
+            text: 'Hello world',
+            user: 'U123456',
+            ts: '1609459200.000100',
+          },
+        ];
+        
+        vi.mocked(mockSlackClient.getHistory).mockResolvedValue({
+          messages: mockMessages,
+          users: new Map([['U123456', 'john.doe']])
+        });
+
+        await program.parseAsync(['node', 'slack-cli', 'history', '-c', 'general', '--format', 'simple']);
+
+        expect(mockConsole.logSpy).toHaveBeenCalledWith('[2021-01-01 00:00:00] john.doe: Hello world');
+      });
+
+      it('should display messages in table format by default', async () => {
+        vi.mocked(mockConfigManager.getConfig).mockResolvedValue({
+          token: 'test-token',
+          updatedAt: new Date().toISOString()
+        });
+
+        const mockMessages = [
+          {
+            type: 'message',
+            text: 'Hello world',
+            user: 'U123456',
+            ts: '1609459200.000100',
+          },
+        ];
+        
+        vi.mocked(mockSlackClient.getHistory).mockResolvedValue({
+          messages: mockMessages,
+          users: new Map([['U123456', 'john.doe']])
+        });
+
+        await program.parseAsync(['node', 'slack-cli', 'history', '-c', 'general']);
+
+        // Should display in table format (current format)
+        expect(mockConsole.logSpy).toHaveBeenCalledWith(expect.stringContaining('Message History for #general'));
+        expect(mockConsole.logSpy).toHaveBeenCalledWith(expect.stringContaining('john.doe'));
+        expect(mockConsole.logSpy).toHaveBeenCalledWith(expect.stringContaining('Hello world'));
+      });
+
+      it('should handle invalid format option', async () => {
+        const historyCommand = setupHistoryCommand();
+        historyCommand.exitOverride();
+        
+        await expect(
+          historyCommand.parseAsync(['-c', 'general', '--format', 'invalid'], { from: 'user' })
+        ).rejects.toThrow();
+      });
+    });
+
     it('should format messages with user names and timestamps', async () => {
       vi.mocked(mockConfigManager.getConfig).mockResolvedValue({
         token: 'test-token',