@urugus/slack-cli 0.2.6 → 0.2.7

package/dist/utils/validators.js

@@ -0,0 +1,175 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.optionValidators = exports.formatValidators = void 0;
+exports.validateRequired = validateRequired;
+exports.validateMutuallyExclusive = validateMutuallyExclusive;
+exports.validateFormat = validateFormat;
+exports.validateRange = validateRange;
+exports.validateDateFormat = validateDateFormat;
+exports.createValidationHook = createValidationHook;
+exports.createOptionParser = createOptionParser;
+const constants_1 = require("./constants");
+/**
+ * Validates that a value exists (not undefined, null, or empty string)
+ */
+function validateRequired(value, fieldName) {
+    if (value === undefined || value === null || value === '') {
+        return `${fieldName} is required`;
+    }
+    return null;
+}
+/**
+ * Validates mutually exclusive options
+ */
+function validateMutuallyExclusive(options, fields, errorMessage) {
+    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
+ */
+function validateFormat(value, pattern, errorMessage) {
+    if (!pattern.test(value)) {
+        return errorMessage;
+    }
+    return null;
+}
+/**
+ * Validates numeric range
+ */
+function validateRange(value, min, max, fieldName = 'Value') {
+    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
+ */
+function validateDateFormat(dateString) {
+    const date = new Date(dateString);
+    if (isNaN(date.getTime())) {
+        return 'Invalid date format';
+    }
+    return null;
+}
+/**
+ * Common format validators
+ */
+exports.formatValidators = {
+    /**
+     * Validates Slack thread timestamp format (1234567890.123456)
+     */
+    threadTimestamp: (value) => {
+        const pattern = /^\d{10}\.\d{6}$/;
+        return validateFormat(value, pattern, constants_1.ERROR_MESSAGES.INVALID_THREAD_TIMESTAMP);
+    },
+    /**
+     * Validates Slack channel ID format (C1234567890, D1234567890, G1234567890)
+     */
+    channelId: (value) => {
+        const pattern = /^[CDG][A-Z0-9]{10,}$/;
+        return validateFormat(value, pattern, 'Invalid channel ID format');
+    },
+    /**
+     * Validates output format options
+     */
+    outputFormat: (value) => {
+        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
+ */
+function createValidationHook(validations) {
+    return (thisCommand) => {
+        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
+ */
+exports.optionValidators = {
+    /**
+     * Validates message/file options for send command
+     */
+    messageOrFile: (options) => {
+        if (!options.message && !options.file) {
+            return constants_1.ERROR_MESSAGES.NO_MESSAGE_OR_FILE;
+        }
+        if (options.message && options.file) {
+            return constants_1.ERROR_MESSAGES.BOTH_MESSAGE_AND_FILE;
+        }
+        return null;
+    },
+    /**
+     * Validates thread timestamp if provided
+     */
+    threadTimestamp: (options) => {
+        if (options.thread) {
+            return exports.formatValidators.threadTimestamp(options.thread);
+        }
+        return null;
+    },
+    /**
+     * Validates message count for history command
+     */
+    messageCount: (options) => {
+        if (options.number) {
+            const count = parseInt(options.number, 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) => {
+        if (options.since) {
+            const error = validateDateFormat(options.since);
+            if (error) {
+                return 'Invalid date format. Use YYYY-MM-DD HH:MM:SS';
+            }
+        }
+        return null;
+    },
+};
+/**
+ * Creates a validated option parser
+ */
+function createOptionParser(parser, validator) {
+    return (value, defaultValue) => {
+        const parsed = parser(value, defaultValue);
+        if (validator) {
+            const error = validator(parsed);
+            if (error) {
+                throw new Error(error);
+            }
+        }
+        return parsed;
+    };
+}
+//# sourceMappingURL=validators.js.map

package/dist/utils/validators.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"validators.js","sourceRoot":"","sources":["../../src/utils/validators.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@urugus/slack-cli",
-  "version": "0.2.6",
+  "version": "0.2.7",
   "description": "A command-line tool for sending messages to Slack",
   "main": "dist/index.js",
   "bin": {

package/src/commands/history.ts

@@ -4,11 +4,9 @@ import { wrapCommand } from '../utils/command-wrapper';
 import { createSlackClient } from '../utils/client-factory';
 import { HistoryOptions } from '../types/commands';
 import { API_LIMITS } from '../utils/constants';
-import {
-  validateMessageCount,
-  validateDateFormat,
-  prepareSinceTimestamp,
-} from './history-validators';
+import { parseCount, parseProfile } from '../utils/option-parsers';
+import { createValidationHook, optionValidators } from '../utils/validators';
+import { prepareSinceTimestamp } from './history-validators';
 import { displayHistoryResults } from './history-display';
 
 export function setupHistoryCommand(): Command {
@@ -22,17 +20,24 @@ export function setupHistoryCommand(): Command {
     )
     .option('--since <date>', 'Get messages since specific date (YYYY-MM-DD HH:MM:SS)')
     .option('--profile <profile>', 'Use specific workspace profile')
-    .hook('preAction', (thisCommand) => {
-      const options = thisCommand.opts();
-      validateMessageCount(options.number, thisCommand);
-      validateDateFormat(options.since, thisCommand);
-    })
+    .hook(
+      'preAction',
+      createValidationHook([optionValidators.messageCount, optionValidators.sinceDate])
+    )
     .action(
       wrapCommand(async (options: HistoryOptions) => {
-        const client = await createSlackClient(options.profile);
+        const profile = parseProfile(options.profile);
+        const client = await createSlackClient(profile);
+
+        const limit = parseCount(
+          options.number,
+          API_LIMITS.DEFAULT_MESSAGE_COUNT,
+          API_LIMITS.MIN_MESSAGE_COUNT,
+          API_LIMITS.MAX_MESSAGE_COUNT
+        );
 
         const historyOptions: ApiHistoryOptions = {
-          limit: parseInt(options.number || API_LIMITS.DEFAULT_MESSAGE_COUNT.toString(), 10),
+          limit,
         };
 
         const oldest = prepareSinceTimestamp(options.since);

package/src/commands/send.ts

@@ -6,14 +6,10 @@ import { createSlackClient } from '../utils/client-factory';
 import { FileError } from '../utils/errors';
 import { SendOptions } from '../types/commands';
 import { extractErrorMessage } from '../utils/error-utils';
+import { parseProfile } from '../utils/option-parsers';
+import { createValidationHook, optionValidators } from '../utils/validators';
 import * as fs from 'fs/promises';
 
-function isValidThreadTimestamp(timestamp: string): boolean {
-  // Slack timestamp format: 1234567890.123456
-  const timestampRegex = /^\d{10}\.\d{6}$/;
-  return timestampRegex.test(timestamp);
-}
-
 export function setupSendCommand(): Command {
   const sendCommand = new Command('send')
     .description('Send a message to a Slack channel')
@@ -22,18 +18,10 @@ export function setupSendCommand(): Command {
     .option('-f, --file <file>', 'File containing message content')
     .option('-t, --thread <thread>', 'Thread timestamp to reply to')
     .option('--profile <profile>', 'Use specific workspace profile')
-    .hook('preAction', (thisCommand) => {
-      const options = thisCommand.opts();
-      if (!options.message && !options.file) {
-        thisCommand.error(`Error: ${ERROR_MESSAGES.NO_MESSAGE_OR_FILE}`);
-      }
-      if (options.message && options.file) {
-        thisCommand.error(`Error: ${ERROR_MESSAGES.BOTH_MESSAGE_AND_FILE}`);
-      }
-      if (options.thread && !isValidThreadTimestamp(options.thread)) {
-        thisCommand.error(`Error: ${ERROR_MESSAGES.INVALID_THREAD_TIMESTAMP}`);
-      }
-    })
+    .hook(
+      'preAction',
+      createValidationHook([optionValidators.messageOrFile, optionValidators.threadTimestamp])
+    )
     .action(
       wrapCommand(async (options: SendOptions) => {
         // Get message content
@@ -51,7 +39,8 @@ export function setupSendCommand(): Command {
         }
 
         // Send message
-        const client = await createSlackClient(options.profile);
+        const profile = parseProfile(options.profile);
+        const client = await createSlackClient(profile);
         await client.sendMessage(options.channel, messageContent, options.thread);
 
         console.log(chalk.green(`✓ ${SUCCESS_MESSAGES.MESSAGE_SENT(options.channel)}`));

package/src/utils/profile-config.ts

@@ -2,13 +2,8 @@ import * as fs from 'fs/promises';
 import * as path from 'path';
 import * as os from 'os';
 import type { Config, ConfigOptions, ConfigStore, Profile } from '../types/config';
-import {
-  TOKEN_MASK_LENGTH,
-  TOKEN_MIN_LENGTH,
-  DEFAULT_PROFILE_NAME,
-  ERROR_MESSAGES,
-  FILE_PERMISSIONS,
-} from './constants';
+import { DEFAULT_PROFILE_NAME, ERROR_MESSAGES, FILE_PERMISSIONS } from './constants';
+import { maskToken } from './token-utils';
 
 export class ProfileConfigManager {
   private configPath: string;
@@ -98,14 +93,7 @@ export class ProfileConfigManager {
   }
 
   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}`;
+    return maskToken(token);
   }
 
   private async getConfigStore(): Promise<ConfigStore> {

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}`;
+}