@urugus/slack-cli 0.2.6 → 0.2.7

package/src/utils/validators.ts

@@ -0,0 +1,212 @@
+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;
+  },
+};
+
+/**
+ * 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/utils/option-parsers.test.ts

@@ -0,0 +1,173 @@
+import { describe, it, expect } from 'vitest';
+import {
+  parseFormat,
+  parseLimit,
+  parseBoolean,
+  parseCount,
+  parseProfile,
+  parseListOptions,
+  OPTION_DEFAULTS,
+} from '../../src/utils/option-parsers';
+
+describe('option-parsers', () => {
+  describe('parseFormat', () => {
+    it('should return default format when undefined', () => {
+      expect(parseFormat(undefined)).toBe('table');
+    });
+
+    it('should return custom default format when specified', () => {
+      expect(parseFormat(undefined, 'json')).toBe('json');
+    });
+
+    it('should return provided format', () => {
+      expect(parseFormat('compact')).toBe('compact');
+    });
+
+    it('should handle empty string', () => {
+      expect(parseFormat('')).toBe('table');
+    });
+  });
+
+  describe('parseLimit', () => {
+    it('should return default limit when undefined', () => {
+      expect(parseLimit(undefined, 100)).toBe(100);
+    });
+
+    it('should parse string limit', () => {
+      expect(parseLimit('50', 100)).toBe(50);
+    });
+
+    it('should handle invalid number string', () => {
+      expect(parseLimit('abc', 100)).toBe(NaN);
+    });
+
+    it('should handle empty string', () => {
+      expect(parseLimit('', 100)).toBe(100);
+    });
+  });
+
+  describe('parseBoolean', () => {
+    it('should return default value when undefined', () => {
+      expect(parseBoolean(undefined)).toBe(false);
+      expect(parseBoolean(undefined, true)).toBe(true);
+    });
+
+    it('should return provided boolean value', () => {
+      expect(parseBoolean(true)).toBe(true);
+      expect(parseBoolean(false)).toBe(false);
+    });
+
+    it('should handle explicit false over default true', () => {
+      expect(parseBoolean(false, true)).toBe(false);
+    });
+  });
+
+  describe('parseCount', () => {
+    it('should return default count when undefined', () => {
+      expect(parseCount(undefined, 10)).toBe(10);
+    });
+
+    it('should parse string count', () => {
+      expect(parseCount('25', 10)).toBe(25);
+    });
+
+    it('should handle invalid number string', () => {
+      expect(parseCount('invalid', 10)).toBe(10);
+    });
+
+    it('should enforce minimum value', () => {
+      expect(parseCount('5', 10, 10, 100)).toBe(10);
+    });
+
+    it('should enforce maximum value', () => {
+      expect(parseCount('150', 10, 10, 100)).toBe(100);
+    });
+
+    it('should allow values within range', () => {
+      expect(parseCount('50', 10, 10, 100)).toBe(50);
+    });
+
+    it('should handle empty string', () => {
+      expect(parseCount('', 20)).toBe(20);
+    });
+  });
+
+  describe('parseProfile', () => {
+    it('should return undefined when not provided', () => {
+      expect(parseProfile(undefined)).toBeUndefined();
+    });
+
+    it('should return provided profile', () => {
+      expect(parseProfile('production')).toBe('production');
+    });
+
+    it('should handle empty string', () => {
+      expect(parseProfile('')).toBe('');
+    });
+  });
+
+  describe('parseListOptions', () => {
+    it('should use all defaults when no options provided', () => {
+      const result = parseListOptions({});
+      expect(result).toEqual({
+        format: 'table',
+        limit: 100,
+        countOnly: false,
+      });
+    });
+
+    it('should override specific options', () => {
+      const result = parseListOptions({
+        format: 'json',
+        limit: '50',
+        countOnly: true,
+      });
+      expect(result).toEqual({
+        format: 'json',
+        limit: 50,
+        countOnly: true,
+      });
+    });
+
+    it('should use custom defaults', () => {
+      const result = parseListOptions({}, {
+        format: 'compact',
+        limit: 200,
+        countOnly: true,
+      });
+      expect(result).toEqual({
+        format: 'compact',
+        limit: 200,
+        countOnly: true,
+      });
+    });
+
+    it('should override custom defaults with provided options', () => {
+      const result = parseListOptions(
+        {
+          format: 'json',
+        },
+        {
+          format: 'compact',
+          limit: 200,
+        }
+      );
+      expect(result).toEqual({
+        format: 'json',
+        limit: 200,
+        countOnly: false,
+      });
+    });
+  });
+
+  describe('OPTION_DEFAULTS', () => {
+    it('should have expected default values', () => {
+      expect(OPTION_DEFAULTS).toEqual({
+        format: 'table',
+        limit: 100,
+        countOnly: false,
+        includeArchived: false,
+      });
+    });
+  });
+});

package/tests/utils/profile-config.test.ts

@@ -0,0 +1,282 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import * as os from 'os';
+import { ProfileConfigManager } from '../../src/utils/profile-config';
+
+vi.mock('fs/promises');
+vi.mock('os');
+
+describe('ProfileConfigManager', () => {
+  let configManager: ProfileConfigManager;
+  const mockConfigPath = '/home/user/.slack-cli/config.json';
+
+  beforeEach(() => {
+    vi.resetAllMocks();
+    vi.mocked(os.homedir).mockReturnValue('/home/user');
+    configManager = new ProfileConfigManager();
+  });
+
+  describe('setToken', () => {
+    it('should set token for default profile when no profile specified', async () => {
+      vi.mocked(fs.readFile).mockRejectedValueOnce({ code: 'ENOENT' });
+      vi.mocked(fs.mkdir).mockResolvedValue(undefined);
+      vi.mocked(fs.writeFile).mockResolvedValue();
+      vi.mocked(fs.chmod).mockResolvedValue();
+
+      await configManager.setToken('test-token');
+
+      expect(fs.writeFile).toHaveBeenCalledWith(
+        mockConfigPath,
+        expect.stringContaining('"default"'),
+      );
+    });
+
+    it('should set token for specified profile', async () => {
+      vi.mocked(fs.readFile).mockRejectedValueOnce({ code: 'ENOENT' });
+      vi.mocked(fs.mkdir).mockResolvedValue(undefined);
+      vi.mocked(fs.writeFile).mockResolvedValue();
+      vi.mocked(fs.chmod).mockResolvedValue();
+
+      await configManager.setToken('test-token', 'production');
+
+      const writeCall = vi.mocked(fs.writeFile).mock.calls[0];
+      const savedData = JSON.parse(writeCall[1] as string);
+      expect(savedData.profiles.production.token).toBe('test-token');
+    });
+  });
+
+  describe('getConfig', () => {
+    it('should return null when no config exists', async () => {
+      vi.mocked(fs.readFile).mockRejectedValueOnce({ code: 'ENOENT' });
+
+      const config = await configManager.getConfig();
+
+      expect(config).toBeNull();
+    });
+
+    it('should return config for default profile', async () => {
+      const mockStore = {
+        profiles: {
+          default: {
+            token: 'test-token',
+            updatedAt: '2024-01-01T00:00:00.000Z',
+          },
+        },
+        defaultProfile: 'default',
+      };
+      vi.mocked(fs.readFile).mockResolvedValueOnce(JSON.stringify(mockStore));
+
+      const config = await configManager.getConfig();
+
+      expect(config).toEqual(mockStore.profiles.default);
+    });
+
+    it('should return config for specified profile', async () => {
+      const mockStore = {
+        profiles: {
+          production: {
+            token: 'prod-token',
+            updatedAt: '2024-01-01T00:00:00.000Z',
+          },
+        },
+        defaultProfile: 'default',
+      };
+      vi.mocked(fs.readFile).mockResolvedValueOnce(JSON.stringify(mockStore));
+
+      const config = await configManager.getConfig('production');
+
+      expect(config).toEqual(mockStore.profiles.production);
+    });
+  });
+
+  describe('listProfiles', () => {
+    it('should return empty array when no profiles exist', async () => {
+      vi.mocked(fs.readFile).mockRejectedValueOnce({ code: 'ENOENT' });
+
+      const profiles = await configManager.listProfiles();
+
+      expect(profiles).toEqual([]);
+    });
+
+    it('should return all profiles with default flag', async () => {
+      const mockStore = {
+        profiles: {
+          default: {
+            token: 'default-token',
+            updatedAt: '2024-01-01T00:00:00.000Z',
+          },
+          production: {
+            token: 'prod-token',
+            updatedAt: '2024-01-02T00:00:00.000Z',
+          },
+        },
+        defaultProfile: 'default',
+      };
+      vi.mocked(fs.readFile).mockResolvedValueOnce(JSON.stringify(mockStore));
+
+      const profiles = await configManager.listProfiles();
+
+      expect(profiles).toHaveLength(2);
+      expect(profiles.find((p) => p.name === 'default')?.isDefault).toBe(true);
+      expect(profiles.find((p) => p.name === 'production')?.isDefault).toBe(false);
+    });
+  });
+
+  describe('useProfile', () => {
+    it('should switch to existing profile', async () => {
+      const mockStore = {
+        profiles: {
+          default: { token: 'default-token', updatedAt: '2024-01-01T00:00:00.000Z' },
+          production: { token: 'prod-token', updatedAt: '2024-01-02T00:00:00.000Z' },
+        },
+        defaultProfile: 'default',
+      };
+      vi.mocked(fs.readFile).mockResolvedValueOnce(JSON.stringify(mockStore));
+      vi.mocked(fs.mkdir).mockResolvedValue(undefined);
+      vi.mocked(fs.writeFile).mockResolvedValue();
+      vi.mocked(fs.chmod).mockResolvedValue();
+
+      await configManager.useProfile('production');
+
+      const writeCall = vi.mocked(fs.writeFile).mock.calls[0];
+      const savedData = JSON.parse(writeCall[1] as string);
+      expect(savedData.defaultProfile).toBe('production');
+    });
+
+    it('should throw error when profile does not exist', async () => {
+      const mockStore = {
+        profiles: {
+          default: { token: 'default-token', updatedAt: '2024-01-01T00:00:00.000Z' },
+        },
+        defaultProfile: 'default',
+      };
+      vi.mocked(fs.readFile).mockResolvedValueOnce(JSON.stringify(mockStore));
+
+      await expect(configManager.useProfile('nonexistent')).rejects.toThrow(
+        'Profile "nonexistent" does not exist',
+      );
+    });
+  });
+
+  describe('getCurrentProfile', () => {
+    it('should return default profile when none set', async () => {
+      vi.mocked(fs.readFile).mockRejectedValueOnce({ code: 'ENOENT' });
+
+      const profile = await configManager.getCurrentProfile();
+
+      expect(profile).toBe('default');
+    });
+
+    it('should return current profile', async () => {
+      const mockStore = {
+        profiles: {},
+        defaultProfile: 'production',
+      };
+      vi.mocked(fs.readFile).mockResolvedValueOnce(JSON.stringify(mockStore));
+
+      const profile = await configManager.getCurrentProfile();
+
+      expect(profile).toBe('production');
+    });
+  });
+
+  describe('clearConfig', () => {
+    it('should remove specified profile', async () => {
+      const mockStore = {
+        profiles: {
+          default: { token: 'default-token', updatedAt: '2024-01-01T00:00:00.000Z' },
+          production: { token: 'prod-token', updatedAt: '2024-01-02T00:00:00.000Z' },
+        },
+        defaultProfile: 'default',
+      };
+      vi.mocked(fs.readFile).mockResolvedValueOnce(JSON.stringify(mockStore));
+      vi.mocked(fs.mkdir).mockResolvedValue(undefined);
+      vi.mocked(fs.writeFile).mockResolvedValue();
+      vi.mocked(fs.chmod).mockResolvedValue();
+
+      await configManager.clearConfig('production');
+
+      const writeCall = vi.mocked(fs.writeFile).mock.calls[0];
+      const savedData = JSON.parse(writeCall[1] as string);
+      expect(savedData.profiles.production).toBeUndefined();
+      expect(savedData.profiles.default).toBeDefined();
+    });
+
+    it('should delete config file when last profile removed', async () => {
+      const mockStore = {
+        profiles: {
+          default: { token: 'default-token', updatedAt: '2024-01-01T00:00:00.000Z' },
+        },
+        defaultProfile: 'default',
+      };
+      vi.mocked(fs.readFile).mockResolvedValueOnce(JSON.stringify(mockStore));
+      vi.mocked(fs.unlink).mockResolvedValue();
+
+      await configManager.clearConfig('default');
+
+      expect(fs.unlink).toHaveBeenCalledWith(mockConfigPath);
+    });
+
+    it('should set new default when current default is removed', async () => {
+      const mockStore = {
+        profiles: {
+          default: { token: 'default-token', updatedAt: '2024-01-01T00:00:00.000Z' },
+          production: { token: 'prod-token', updatedAt: '2024-01-02T00:00:00.000Z' },
+        },
+        defaultProfile: 'default',
+      };
+      vi.mocked(fs.readFile).mockResolvedValueOnce(JSON.stringify(mockStore));
+      vi.mocked(fs.mkdir).mockResolvedValue(undefined);
+      vi.mocked(fs.writeFile).mockResolvedValue();
+      vi.mocked(fs.chmod).mockResolvedValue();
+
+      await configManager.clearConfig('default');
+
+      const writeCall = vi.mocked(fs.writeFile).mock.calls[0];
+      const savedData = JSON.parse(writeCall[1] as string);
+      expect(savedData.defaultProfile).toBe('production');
+    });
+  });
+
+  describe('maskToken', () => {
+    it('should mask short tokens completely', () => {
+      const masked = configManager.maskToken('short');
+      expect(masked).toBe('****');
+    });
+
+    it('should mask long tokens showing prefix and suffix', () => {
+      const token = 'test-1234567890-abcdefghijklmnop';
+      const masked = configManager.maskToken(token);
+      expect(masked).toBe('test-****-****-mnop');
+    });
+  });
+
+  describe('migration', () => {
+    it('should migrate old format to new format', async () => {
+      const oldConfig = {
+        token: 'old-token',
+        updatedAt: '2024-01-01T00:00:00.000Z',
+      };
+      vi.mocked(fs.readFile).mockResolvedValueOnce(JSON.stringify(oldConfig));
+      vi.mocked(fs.mkdir).mockResolvedValue(undefined);
+      vi.mocked(fs.writeFile).mockResolvedValue();
+      vi.mocked(fs.chmod).mockResolvedValue();
+
+      const config = await configManager.getConfig();
+
+      expect(config).toEqual(oldConfig);
+      const writeCall = vi.mocked(fs.writeFile).mock.calls[0];
+      const savedData = JSON.parse(writeCall[1] as string);
+      expect(savedData.profiles.default).toEqual(oldConfig);
+    });
+  });
+
+  describe('error handling', () => {
+    it('should throw error for invalid JSON', async () => {
+      vi.mocked(fs.readFile).mockResolvedValueOnce('invalid json');
+
+      await expect(configManager.getConfig()).rejects.toThrow('Invalid config file format');
+    });
+  });
+});