@urugus/slack-cli 0.2.11 → 0.2.13

package/src/utils/validators.ts

@@ -1,263 +0,0 @@
-import { Command } from 'commander';
-import { ERROR_MESSAGES } from './constants';
-import { parseScheduledTimestamp } from './schedule-utils';
-
-/**
- * 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 schedule options for send command
-   */
-  scheduleTiming: (options: Record<string, unknown>): string | null => {
-    const at = options.at as string | undefined;
-    const after = options.after as string | undefined;
-
-    if (at && after) {
-      return ERROR_MESSAGES.BOTH_SCHEDULE_OPTIONS;
-    }
-
-    if (at) {
-      const postAt = parseScheduledTimestamp(at);
-      if (postAt === null) {
-        return ERROR_MESSAGES.INVALID_SCHEDULE_AT;
-      }
-
-      if (postAt <= Math.floor(Date.now() / 1000)) {
-        return ERROR_MESSAGES.SCHEDULE_TIME_IN_PAST;
-      }
-    }
-
-    if (after) {
-      const trimmedAfter = after.trim();
-      if (!/^\d+$/.test(trimmedAfter)) {
-        return ERROR_MESSAGES.INVALID_SCHEDULE_AFTER;
-      }
-
-      const minutes = Number.parseInt(trimmedAfter, 10);
-      if (!Number.isSafeInteger(minutes) || minutes <= 0) {
-        return ERROR_MESSAGES.INVALID_SCHEDULE_AFTER;
-      }
-    }
-
-    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/channels.test.ts

@@ -1,250 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { setupChannelsCommand } from '../../src/commands/channels';
-import { SlackApiClient } from '../../src/utils/slack-api-client';
-import { ProfileConfigManager } from '../../src/utils/profile-config';
-import { setupMockConsole, createTestProgram, restoreMocks } from '../test-utils';
-import { ERROR_MESSAGES } from '../../src/utils/constants';
-
-vi.mock('../../src/utils/slack-api-client');
-vi.mock('../../src/utils/profile-config');
-
-describe('channels command', () => {
-  let program: any;
-  let mockSlackClient: SlackApiClient;
-  let mockConfigManager: ProfileConfigManager;
-  let mockConsole: any;
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-    
-    mockConfigManager = new ProfileConfigManager();
-    vi.mocked(ProfileConfigManager).mockReturnValue(mockConfigManager);
-    
-    mockSlackClient = new SlackApiClient('test-token');
-    vi.mocked(SlackApiClient).mockReturnValue(mockSlackClient);
-    
-    mockConsole = setupMockConsole();
-    program = createTestProgram();
-    program.addCommand(setupChannelsCommand());
-  });
-
-  afterEach(() => {
-    restoreMocks();
-  });
-
-  const mockChannels = [
-    {
-      id: 'C1234567890',
-      name: 'general',
-      is_channel: true,
-      is_private: false,
-      num_members: 250,
-      created: 1579075200,
-      purpose: { value: 'Company announcements' }
-    },
-    {
-      id: 'C0987654321',
-      name: 'random',
-      is_channel: true,
-      is_private: false,
-      num_members: 145,
-      created: 1579075200,
-      purpose: { value: 'Random discussions' }
-    }
-  ];
-
-  describe('basic functionality', () => {
-    it('should list public channels by default', async () => {
-      vi.mocked(mockConfigManager.getConfig).mockResolvedValue({
-        token: 'test-token',
-        updatedAt: new Date().toISOString()
-      });
-      vi.mocked(mockSlackClient.listChannels).mockResolvedValue(mockChannels);
-
-      await program.parseAsync(['node', 'slack-cli', 'channels']);
-
-      expect(mockSlackClient.listChannels).toHaveBeenCalledWith({
-        types: 'public_channel',
-        exclude_archived: true,
-        limit: 100
-      });
-      expect(mockConsole.logSpy).toHaveBeenCalledWith(expect.stringContaining('general'));
-      expect(mockConsole.logSpy).toHaveBeenCalledWith(expect.stringContaining('random'));
-    });
-
-    it('should show error when no token is configured', async () => {
-      vi.mocked(mockConfigManager.getConfig).mockResolvedValue(null);
-      vi.mocked(mockConfigManager.listProfiles).mockResolvedValue([]);
-
-      await program.parseAsync(['node', 'slack-cli', 'channels']);
-
-      expect(mockConsole.errorSpy).toHaveBeenCalledWith('✗ Error:', ERROR_MESSAGES.NO_CONFIG('default'));
-      expect(mockConsole.exitSpy).toHaveBeenCalledWith(1);
-    });
-  });
-
-  describe('channel type filtering', () => {
-    it('should list private channels when type is private', async () => {
-      vi.mocked(mockConfigManager.getConfig).mockResolvedValue({
-        token: 'test-token',
-        updatedAt: new Date().toISOString()
-      });
-      vi.mocked(mockSlackClient.listChannels).mockResolvedValue(mockChannels);
-
-      await program.parseAsync(['node', 'slack-cli', 'channels', '--type', 'private']);
-
-      expect(mockSlackClient.listChannels).toHaveBeenCalledWith({
-        types: 'private_channel',
-        exclude_archived: true,
-        limit: 100
-      });
-    });
-
-    it('should list all channel types when type is all', async () => {
-      vi.mocked(mockConfigManager.getConfig).mockResolvedValue({
-        token: 'test-token',
-        updatedAt: new Date().toISOString()
-      });
-      vi.mocked(mockSlackClient.listChannels).mockResolvedValue(mockChannels);
-
-      await program.parseAsync(['node', 'slack-cli', 'channels', '--type', 'all']);
-
-      expect(mockSlackClient.listChannels).toHaveBeenCalledWith({
-        types: 'public_channel,private_channel,mpim,im',
-        exclude_archived: true,
-        limit: 100
-      });
-    });
-
-    it('should list direct messages when type is im', async () => {
-      vi.mocked(mockConfigManager.getConfig).mockResolvedValue({
-        token: 'test-token',
-        updatedAt: new Date().toISOString()
-      });
-      vi.mocked(mockSlackClient.listChannels).mockResolvedValue(mockChannels);
-
-      await program.parseAsync(['node', 'slack-cli', 'channels', '--type', 'im']);
-
-      expect(mockSlackClient.listChannels).toHaveBeenCalledWith({
-        types: 'im',
-        exclude_archived: true,
-        limit: 100
-      });
-    });
-  });
-
-  describe('output formatting', () => {
-    it('should output in table format by default', async () => {
-      vi.mocked(mockConfigManager.getConfig).mockResolvedValue({
-        token: 'test-token',
-        updatedAt: new Date().toISOString()
-      });
-      vi.mocked(mockSlackClient.listChannels).mockResolvedValue(mockChannels);
-
-      await program.parseAsync(['node', 'slack-cli', 'channels']);
-
-      expect(mockConsole.logSpy).toHaveBeenCalledWith(expect.stringContaining('Name'));
-      expect(mockConsole.logSpy).toHaveBeenCalledWith(expect.stringContaining('Type'));
-      expect(mockConsole.logSpy).toHaveBeenCalledWith(expect.stringContaining('Members'));
-    });
-
-    it('should output in simple format when specified', async () => {
-      vi.mocked(mockConfigManager.getConfig).mockResolvedValue({
-        token: 'test-token',
-        updatedAt: new Date().toISOString()
-      });
-      vi.mocked(mockSlackClient.listChannels).mockResolvedValue(mockChannels);
-
-      await program.parseAsync(['node', 'slack-cli', 'channels', '--format', 'simple']);
-
-      expect(mockConsole.logSpy).toHaveBeenCalledWith('general');
-      expect(mockConsole.logSpy).toHaveBeenCalledWith('random');
-    });
-
-    it('should output in JSON format when specified', async () => {
-      vi.mocked(mockConfigManager.getConfig).mockResolvedValue({
-        token: 'test-token',
-        updatedAt: new Date().toISOString()
-      });
-      vi.mocked(mockSlackClient.listChannels).mockResolvedValue(mockChannels);
-
-      await program.parseAsync(['node', 'slack-cli', 'channels', '--format', 'json']);
-
-      expect(mockConsole.logSpy).toHaveBeenCalledWith(expect.stringContaining('"name": "general"'));
-    });
-  });
-
-  describe('additional options', () => {
-    it('should include archived channels when flag is set', async () => {
-      vi.mocked(mockConfigManager.getConfig).mockResolvedValue({
-        token: 'test-token',
-        updatedAt: new Date().toISOString()
-      });
-      vi.mocked(mockSlackClient.listChannels).mockResolvedValue(mockChannels);
-
-      await program.parseAsync(['node', 'slack-cli', 'channels', '--include-archived']);
-
-      expect(mockSlackClient.listChannels).toHaveBeenCalledWith({
-        types: 'public_channel',
-        exclude_archived: false,
-        limit: 100
-      });
-    });
-
-    it('should respect custom limit', async () => {
-      vi.mocked(mockConfigManager.getConfig).mockResolvedValue({
-        token: 'test-token',
-        updatedAt: new Date().toISOString()
-      });
-      vi.mocked(mockSlackClient.listChannels).mockResolvedValue(mockChannels);
-
-      await program.parseAsync(['node', 'slack-cli', 'channels', '--limit', '50']);
-
-      expect(mockSlackClient.listChannels).toHaveBeenCalledWith({
-        types: 'public_channel',
-        exclude_archived: true,
-        limit: 50
-      });
-    });
-
-    it('should use specified profile', async () => {
-      vi.mocked(mockConfigManager.getConfig).mockResolvedValue({
-        token: 'work-token',
-        updatedAt: new Date().toISOString()
-      });
-      vi.mocked(mockSlackClient.listChannels).mockResolvedValue(mockChannels);
-
-      await program.parseAsync(['node', 'slack-cli', 'channels', '--profile', 'work']);
-
-      expect(mockConfigManager.getConfig).toHaveBeenCalledWith('work');
-      expect(SlackApiClient).toHaveBeenCalledWith('work-token');
-    });
-  });
-
-  describe('error handling', () => {
-    it('should handle API errors gracefully', async () => {
-      vi.mocked(mockConfigManager.getConfig).mockResolvedValue({
-        token: 'test-token',
-        updatedAt: new Date().toISOString()
-      });
-      vi.mocked(mockSlackClient.listChannels).mockRejectedValue(new Error('API Error'));
-
-      await program.parseAsync(['node', 'slack-cli', 'channels']);
-
-      expect(mockConsole.errorSpy).toHaveBeenCalledWith('✗ Error:', 'API Error');
-      expect(mockConsole.exitSpy).toHaveBeenCalledWith(1);
-    });
-
-    it('should show message when no channels found', async () => {
-      vi.mocked(mockConfigManager.getConfig).mockResolvedValue({
-        token: 'test-token',
-        updatedAt: new Date().toISOString()
-      });
-      vi.mocked(mockSlackClient.listChannels).mockResolvedValue([]);
-
-      await program.parseAsync(['node', 'slack-cli', 'channels']);
-
-      expect(mockConsole.logSpy).toHaveBeenCalledWith(ERROR_MESSAGES.NO_CHANNELS_FOUND);
-    });
-  });
-});

package/tests/commands/config.test.ts

@@ -1,158 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import { setupConfigCommand } from '../../src/commands/config';
-import { ProfileConfigManager } from '../../src/utils/profile-config';
-import type { Config, Profile } from '../../src/types/config';
-import { setupMockConsole, createTestProgram, restoreMocks } from '../test-utils';
-import { SUCCESS_MESSAGES, ERROR_MESSAGES } from '../../src/utils/constants';
-
-vi.mock('../../src/utils/profile-config');
-
-describe('profile config command', () => {
-  let program: any;
-  let mockConfigManager: ProfileConfigManager;
-  let mockConsole: any;
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-    
-    mockConfigManager = new ProfileConfigManager();
-    vi.mocked(ProfileConfigManager).mockReturnValue(mockConfigManager);
-    
-    mockConsole = setupMockConsole();
-    program = createTestProgram();
-    program.addCommand(setupConfigCommand());
-  });
-
-  afterEach(() => {
-    restoreMocks();
-  });
-
-  describe('config set with profile', () => {
-    it('should set token for specified profile', async () => {
-      vi.mocked(mockConfigManager.setToken).mockResolvedValue(undefined);
-
-      await program.parseAsync(['node', 'slack-cli', 'config', 'set', '--token', 'test-token-123', '--profile', 'work']);
-
-      expect(mockConfigManager.setToken).toHaveBeenCalledWith('test-token-123', 'work');
-      expect(mockConsole.logSpy).toHaveBeenCalledWith(expect.stringContaining(SUCCESS_MESSAGES.TOKEN_SAVED('work')));
-    });
-
-    it('should set token for default profile when no profile specified', async () => {
-      vi.mocked(mockConfigManager.setToken).mockResolvedValue(undefined);
-      vi.mocked(mockConfigManager.getCurrentProfile).mockResolvedValue('default');
-
-      await program.parseAsync(['node', 'slack-cli', 'config', 'set', '--token', 'test-token-123']);
-
-      expect(mockConfigManager.setToken).toHaveBeenCalledWith('test-token-123', undefined);
-      expect(mockConsole.logSpy).toHaveBeenCalledWith(expect.stringContaining('Token saved successfully for profile "default"'));
-    });
-  });
-
-  describe('config get with profile', () => {
-    it('should display config for specified profile', async () => {
-      const mockConfig: Config = {
-        token: 'test-token-1234567890-abcdefghijklmnop',
-        updatedAt: '2025-06-21T10:00:00.000Z'
-      };
-
-      vi.mocked(mockConfigManager.getConfig).mockResolvedValue(mockConfig);
-      vi.mocked(mockConfigManager.maskToken).mockReturnValue('test-****-****-mnop');
-
-      await program.parseAsync(['node', 'slack-cli', 'config', 'get', '--profile', 'work']);
-
-      expect(mockConfigManager.getConfig).toHaveBeenCalledWith('work');
-      expect(mockConsole.logSpy).toHaveBeenCalledWith(expect.stringContaining('Configuration for profile "work":'));
-    });
-  });
-
-  describe('config profiles', () => {
-    it('should list all profiles', async () => {
-      const mockProfiles: Profile[] = [
-        {
-          name: 'default',
-          config: {
-            token: 'default-token',
-            updatedAt: '2025-06-21T10:00:00.000Z'
-          }
-        },
-        {
-          name: 'work',
-          config: {
-            token: 'work-token',
-            updatedAt: '2025-06-21T11:00:00.000Z'
-          }
-        }
-      ];
-
-      vi.mocked(mockConfigManager.listProfiles).mockResolvedValue(mockProfiles);
-      vi.mocked(mockConfigManager.getCurrentProfile).mockResolvedValue('work');
-
-      await program.parseAsync(['node', 'slack-cli', 'config', 'profiles']);
-
-      expect(mockConfigManager.listProfiles).toHaveBeenCalled();
-      expect(mockConsole.logSpy).toHaveBeenCalledWith(expect.stringContaining('Available profiles:'));
-      expect(mockConsole.logSpy).toHaveBeenCalledWith(expect.stringContaining('default'));
-      expect(mockConsole.logSpy).toHaveBeenCalledWith(expect.stringContaining('* work')); // current profile marked
-    });
-
-    it('should show message when no profiles exist', async () => {
-      vi.mocked(mockConfigManager.listProfiles).mockResolvedValue([]);
-
-      await program.parseAsync(['node', 'slack-cli', 'config', 'profiles']);
-
-      expect(mockConsole.logSpy).toHaveBeenCalledWith(expect.stringContaining('No profiles found'));
-    });
-  });
-
-  describe('config use', () => {
-    it('should switch default profile', async () => {
-      vi.mocked(mockConfigManager.useProfile).mockResolvedValue(undefined);
-
-      await program.parseAsync(['node', 'slack-cli', 'config', 'use', 'work']);
-
-      expect(mockConfigManager.useProfile).toHaveBeenCalledWith('work');
-      expect(mockConsole.logSpy).toHaveBeenCalledWith(expect.stringContaining('Switched to profile "work"'));
-    });
-
-    it('should show error when profile does not exist', async () => {
-      vi.mocked(mockConfigManager.useProfile).mockRejectedValue(new Error('Profile "nonexistent" does not exist'));
-
-      await program.parseAsync(['node', 'slack-cli', 'config', 'use', 'nonexistent']);
-
-      expect(mockConsole.errorSpy).toHaveBeenCalledWith(expect.stringContaining('Error:'), expect.any(String));
-      expect(mockConsole.exitSpy).toHaveBeenCalledWith(1);
-    });
-  });
-
-  describe('config current', () => {
-    it('should show current active profile', async () => {
-      vi.mocked(mockConfigManager.getCurrentProfile).mockResolvedValue('work');
-
-      await program.parseAsync(['node', 'slack-cli', 'config', 'current']);
-
-      expect(mockConfigManager.getCurrentProfile).toHaveBeenCalled();
-      expect(mockConsole.logSpy).toHaveBeenCalledWith(expect.stringContaining('Current profile: work'));
-    });
-  });
-
-  describe('config clear with profile', () => {
-    it('should clear specific profile', async () => {
-      vi.mocked(mockConfigManager.clearConfig).mockResolvedValue(undefined);
-
-      await program.parseAsync(['node', 'slack-cli', 'config', 'clear', '--profile', 'work']);
-
-      expect(mockConfigManager.clearConfig).toHaveBeenCalledWith('work');
-      expect(mockConsole.logSpy).toHaveBeenCalledWith(expect.stringContaining('Profile "work" cleared successfully'));
-    });
-
-    it('should clear current profile when no profile specified', async () => {
-      vi.mocked(mockConfigManager.clearConfig).mockResolvedValue(undefined);
-      vi.mocked(mockConfigManager.getCurrentProfile).mockResolvedValue('default');
-
-      await program.parseAsync(['node', 'slack-cli', 'config', 'clear']);
-
-      expect(mockConfigManager.clearConfig).toHaveBeenCalledWith(undefined);
-      expect(mockConsole.logSpy).toHaveBeenCalledWith(expect.stringContaining('Profile "default" cleared successfully'));
-    });
-  });
-});