@urugus/slack-cli 0.2.2 → 0.2.3

package/src/utils/option-parsers.ts

@@ -0,0 +1,100 @@
+/**
+ * Common option parsing utilities to reduce duplication
+ */
+
+/**
+ * Parse format option with default value
+ */
+export function parseFormat(format?: string, defaultFormat = 'table'): string {
+  return format || defaultFormat;
+}
+
+/**
+ * Parse limit option with default value
+ */
+export function parseLimit(limit: string | undefined, defaultLimit: number): number {
+  return parseInt(limit || defaultLimit.toString(), 10);
+}
+
+/**
+ * Parse boolean option with default value
+ */
+export function parseBoolean(value?: boolean, defaultValue = false): boolean {
+  return value !== undefined ? value : defaultValue;
+}
+
+/**
+ * Parse count option with default value
+ */
+export function parseCount(
+  count: string | undefined,
+  defaultCount: number,
+  min?: number,
+  max?: number
+): number {
+  const parsed = parseInt(count || defaultCount.toString(), 10);
+
+  if (isNaN(parsed)) {
+    return defaultCount;
+  }
+
+  if (min !== undefined && parsed < min) {
+    return min;
+  }
+
+  if (max !== undefined && parsed > max) {
+    return max;
+  }
+
+  return parsed;
+}
+
+/**
+ * Parse profile option
+ */
+export function parseProfile(profile?: string): string | undefined {
+  return profile;
+}
+
+/**
+ * Common option defaults
+ */
+export const OPTION_DEFAULTS = {
+  format: 'table',
+  limit: 100,
+  countOnly: false,
+  includeArchived: false,
+} as const;
+
+/**
+ * Parse common list options
+ */
+export interface ListOptions {
+  format?: string;
+  limit?: string;
+  countOnly?: boolean;
+}
+
+export interface ParsedListOptions {
+  format: string;
+  limit: number;
+  countOnly: boolean;
+}
+
+export function parseListOptions(
+  options: ListOptions,
+  defaults?: Partial<ParsedListOptions>
+): ParsedListOptions {
+  const mergedDefaults = {
+    format: OPTION_DEFAULTS.format,
+    limit: OPTION_DEFAULTS.limit,
+    countOnly: OPTION_DEFAULTS.countOnly,
+    ...defaults,
+  };
+
+  return {
+    format: parseFormat(options.format, mergedDefaults.format),
+    limit: parseLimit(options.limit, mergedDefaults.limit),
+    countOnly: parseBoolean(options.countOnly, mergedDefaults.countOnly),
+  };
+}

package/src/utils/profile-config-refactored.ts

@@ -0,0 +1,161 @@
+import type { Config, ConfigOptions, Profile } from '../types/config';
+import { TOKEN_MASK_LENGTH, TOKEN_MIN_LENGTH, DEFAULT_PROFILE_NAME } from './constants';
+import { ConfigFileManager } from './config/config-file-manager';
+import { TokenCryptoService } from './config/token-crypto-service';
+import { ProfileManager } from './config/profile-manager';
+import * as fs from 'fs/promises';
+
+export class ProfileConfigManager {
+  private fileManager: ConfigFileManager;
+  private cryptoService: TokenCryptoService;
+  private profileManager: ProfileManager;
+
+  constructor(_options: ConfigOptions = {}) {
+    // Note: ConfigFileManager currently doesn't support custom configDir
+    // This would need to be added if required
+    this.fileManager = new ConfigFileManager();
+    this.cryptoService = new TokenCryptoService();
+    this.profileManager = new ProfileManager(this.fileManager, this.cryptoService);
+  }
+
+  async setToken(token: string, profile?: string): Promise<void> {
+    const profileName = profile || (await this.profileManager.getCurrentProfile());
+    const config: Config = {
+      token,
+      updatedAt: new Date().toISOString(),
+    };
+
+    await this.profileManager.setProfile(profileName, config);
+
+    // Set as default profile if it's the first one or explicitly setting default
+    const profiles = await this.profileManager.listProfiles();
+    if (profiles.length === 1 || profileName === DEFAULT_PROFILE_NAME) {
+      await this.profileManager.setCurrentProfile(profileName);
+    }
+  }
+
+  async getConfig(profile?: string): Promise<Config | null> {
+    const profileName = profile || (await this.profileManager.getCurrentProfile());
+
+    try {
+      return await this.profileManager.getProfile(profileName);
+    } catch (error) {
+      // Return null if profile not found
+      if (error instanceof Error && error.message.includes('not found')) {
+        return null;
+      }
+      throw error;
+    }
+  }
+
+  async listProfiles(): Promise<Profile[]> {
+    const profileNames = await this.profileManager.listProfiles();
+    const currentProfile = await this.profileManager.getCurrentProfile();
+
+    const profiles: Profile[] = [];
+    for (const name of profileNames) {
+      const config = await this.profileManager.getProfile(name);
+      profiles.push({
+        name,
+        config,
+        isDefault: name === currentProfile,
+      });
+    }
+
+    return profiles;
+  }
+
+  async useProfile(profile: string): Promise<void> {
+    const exists = await this.profileManager.profileExists(profile);
+    if (!exists) {
+      throw new Error(`Profile "${profile}" does not exist`);
+    }
+
+    await this.profileManager.setCurrentProfile(profile);
+  }
+
+  async getCurrentProfile(): Promise<string> {
+    return await this.profileManager.getCurrentProfile();
+  }
+
+  async clearConfig(profile?: string): Promise<void> {
+    const profileName = profile || (await this.profileManager.getCurrentProfile());
+
+    try {
+      await this.profileManager.deleteProfile(profileName);
+    } catch (error) {
+      // If profile doesn't exist, do nothing
+      if (error instanceof Error && error.message.includes('not found')) {
+        return;
+      }
+      throw error;
+    }
+
+    // If we deleted the current profile, set a new default
+    const currentProfile = await this.profileManager.getCurrentProfile();
+    if (currentProfile === profileName) {
+      const remainingProfiles = await this.profileManager.listProfiles();
+      if (remainingProfiles.length > 0) {
+        await this.profileManager.setCurrentProfile(remainingProfiles[0]);
+      } else {
+        // No profiles left, delete the config file
+        try {
+          await fs.unlink(this.fileManager.getConfigPath());
+        } catch (error: unknown) {
+          if (error && typeof error === 'object' && 'code' in error && error.code !== 'ENOENT') {
+            throw error;
+          }
+        }
+      }
+    }
+  }
+
+  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}`;
+  }
+
+  // Migration support - to be called separately if needed
+  async migrateIfNeeded(): Promise<void> {
+    const data = await this.fileManager.read();
+
+    // Check if migration is needed (old format detection)
+    const anyData = data as unknown as Record<string, unknown>;
+    if (anyData.token && !anyData.profiles) {
+      // Old format detected, migrate
+      const oldConfig: Config = {
+        token: anyData.token as string,
+        updatedAt: (anyData.updatedAt as string) || new Date().toISOString(),
+      };
+
+      // Create new format
+      const newData = {
+        profiles: { [DEFAULT_PROFILE_NAME]: oldConfig },
+        currentProfile: DEFAULT_PROFILE_NAME,
+      };
+
+      await this.fileManager.write(newData);
+
+      // Re-encrypt token using new service
+      await this.setToken(oldConfig.token, DEFAULT_PROFILE_NAME);
+    }
+  }
+}
+
+// Export a simplified version for backward compatibility
+export const profileConfig = {
+  getCurrentProfile: (): string => {
+    return DEFAULT_PROFILE_NAME;
+  },
+  getToken: (_profile?: string): string | undefined => {
+    // This is a simplified version for testing
+    // In real usage, it would need to be async
+    return undefined;
+  },
+};

package/tests/commands/unread.test.ts

@@ -174,6 +174,118 @@ describe('unread command', () => {
       expect(mockConsole.logSpy).toHaveBeenCalledWith(expect.stringContaining('Hello world'));
       expect(mockConsole.logSpy).toHaveBeenCalledWith(expect.stringContaining('Test message'));
     });
+
+    it('should display channel unread in JSON format when specified', async () => {
+      vi.mocked(mockConfigManager.getConfig).mockResolvedValue({
+        token: 'test-token',
+        updatedAt: new Date().toISOString()
+      });
+      vi.mocked(mockSlackClient.getChannelUnread).mockResolvedValue({
+        channel: mockChannelsWithUnread[0],
+        messages: mockUnreadMessages,
+        users: new Map([
+          ['U123', 'john.doe'],
+          ['U456', 'jane.smith']
+        ])
+      });
+
+      await program.parseAsync(['node', 'slack-cli', 'unread', '--channel', 'general', '--format', 'json']);
+
+      expect(mockSlackClient.getChannelUnread).toHaveBeenCalledWith('general');
+      
+      const logCall = mockConsole.logSpy.mock.calls[0][0];
+      const parsed = JSON.parse(logCall);
+      
+      expect(parsed).toEqual({
+        channel: '#general',
+        channelId: 'C123',
+        unreadCount: 5,
+        messages: [
+          {
+            timestamp: expect.any(String),
+            author: 'john.doe',
+            text: 'Hello world'
+          },
+          {
+            timestamp: expect.any(String),
+            author: 'jane.smith',
+            text: 'Test message'
+          }
+        ]
+      });
+    });
+
+    it('should display channel unread in simple format when specified', async () => {
+      vi.mocked(mockConfigManager.getConfig).mockResolvedValue({
+        token: 'test-token',
+        updatedAt: new Date().toISOString()
+      });
+      vi.mocked(mockSlackClient.getChannelUnread).mockResolvedValue({
+        channel: mockChannelsWithUnread[0],
+        messages: mockUnreadMessages,
+        users: new Map([
+          ['U123', 'john.doe'],
+          ['U456', 'jane.smith']
+        ])
+      });
+
+      await program.parseAsync(['node', 'slack-cli', 'unread', '--channel', 'general', '--format', 'simple']);
+
+      expect(mockSlackClient.getChannelUnread).toHaveBeenCalledWith('general');
+      expect(mockConsole.logSpy).toHaveBeenCalledWith('#general (5)');
+      expect(mockConsole.logSpy).toHaveBeenCalledWith(expect.stringMatching(/^\[.*\] john\.doe: Hello world$/));
+      expect(mockConsole.logSpy).toHaveBeenCalledWith(expect.stringMatching(/^\[.*\] jane\.smith: Test message$/));
+    });
+
+    it('should show only count for channel when --count-only is specified', async () => {
+      vi.mocked(mockConfigManager.getConfig).mockResolvedValue({
+        token: 'test-token',
+        updatedAt: new Date().toISOString()
+      });
+      vi.mocked(mockSlackClient.getChannelUnread).mockResolvedValue({
+        channel: mockChannelsWithUnread[0],
+        messages: mockUnreadMessages,
+        users: new Map([
+          ['U123', 'john.doe'],
+          ['U456', 'jane.smith']
+        ])
+      });
+
+      await program.parseAsync(['node', 'slack-cli', 'unread', '--channel', 'general', '--count-only']);
+
+      expect(mockSlackClient.getChannelUnread).toHaveBeenCalledWith('general');
+      expect(mockConsole.logSpy).toHaveBeenCalledWith(chalk.bold(`#general: 5 unread messages`));
+      expect(mockConsole.logSpy).not.toHaveBeenCalledWith(expect.stringContaining('Hello world'));
+      expect(mockConsole.logSpy).not.toHaveBeenCalledWith(expect.stringContaining('Test message'));
+    });
+
+    it('should show count only in JSON format when both --count-only and --format json are specified', async () => {
+      vi.mocked(mockConfigManager.getConfig).mockResolvedValue({
+        token: 'test-token',
+        updatedAt: new Date().toISOString()
+      });
+      vi.mocked(mockSlackClient.getChannelUnread).mockResolvedValue({
+        channel: mockChannelsWithUnread[0],
+        messages: mockUnreadMessages,
+        users: new Map([
+          ['U123', 'john.doe'],
+          ['U456', 'jane.smith']
+        ])
+      });
+
+      await program.parseAsync(['node', 'slack-cli', 'unread', '--channel', 'general', '--count-only', '--format', 'json']);
+
+      expect(mockSlackClient.getChannelUnread).toHaveBeenCalledWith('general');
+      
+      const logCall = mockConsole.logSpy.mock.calls[0][0];
+      const parsed = JSON.parse(logCall);
+      
+      expect(parsed).toEqual({
+        channel: '#general',
+        channelId: 'C123',
+        unreadCount: 5
+      });
+    });
   });
 
   describe('limit option', () => {

package/tests/utils/config/config-file-manager.test.ts

@@ -0,0 +1,118 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import * as fs from 'fs/promises';
+import * as os from 'os';
+import * as path from 'path';
+import { ConfigFileManager } from '../../../src/utils/config/config-file-manager';
+
+vi.mock('fs/promises');
+vi.mock('os');
+
+describe('ConfigFileManager', () => {
+  let manager: ConfigFileManager;
+  const mockHomeDir = '/home/user';
+  const mockConfigPath = path.join(mockHomeDir, '.slack-cli', 'config.json');
+
+  beforeEach(() => {
+    vi.mocked(os.homedir).mockReturnValue(mockHomeDir);
+    manager = new ConfigFileManager();
+  });
+
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe('read', () => {
+    it('should read and parse config file when it exists', async () => {
+      const mockConfig = {
+        profiles: { default: { token: 'encrypted-token' } },
+        currentProfile: 'default'
+      };
+      vi.mocked(fs.access).mockResolvedValueOnce(undefined);
+      vi.mocked(fs.readFile).mockResolvedValueOnce(JSON.stringify(mockConfig));
+
+      const result = await manager.read();
+
+      expect(result).toEqual(mockConfig);
+      expect(fs.readFile).toHaveBeenCalledWith(mockConfigPath, 'utf-8');
+    });
+
+    it('should return default config when file does not exist', async () => {
+      vi.mocked(fs.access).mockRejectedValueOnce(new Error('ENOENT'));
+
+      const result = await manager.read();
+
+      expect(result).toEqual({
+        profiles: {},
+        currentProfile: 'default'
+      });
+    });
+
+    it('should throw error for invalid JSON', async () => {
+      vi.mocked(fs.access).mockResolvedValueOnce(undefined);
+      vi.mocked(fs.readFile).mockResolvedValueOnce('invalid json');
+
+      await expect(manager.read()).rejects.toThrow('Invalid configuration file');
+    });
+  });
+
+  describe('write', () => {
+    it('should create directory and write config file', async () => {
+      const mockConfig = {
+        profiles: { default: { token: 'encrypted-token' } },
+        currentProfile: 'default'
+      };
+      vi.mocked(fs.mkdir).mockResolvedValueOnce(undefined as any);
+      vi.mocked(fs.writeFile).mockResolvedValueOnce(undefined);
+
+      await manager.write(mockConfig);
+
+      expect(fs.mkdir).toHaveBeenCalledWith(
+        path.dirname(mockConfigPath),
+        { recursive: true }
+      );
+      expect(fs.writeFile).toHaveBeenCalledWith(
+        mockConfigPath,
+        JSON.stringify(mockConfig, null, 2),
+        'utf-8'
+      );
+    });
+
+    it('should handle write errors', async () => {
+      const mockConfig = {
+        profiles: {},
+        currentProfile: 'default'
+      };
+      vi.mocked(fs.mkdir).mockResolvedValueOnce(undefined as any);
+      vi.mocked(fs.writeFile).mockRejectedValueOnce(new Error('Write failed'));
+
+      await expect(manager.write(mockConfig)).rejects.toThrow('Write failed');
+    });
+  });
+
+  describe('exists', () => {
+    it('should return true when config file exists', async () => {
+      vi.mocked(fs.access).mockResolvedValueOnce(undefined);
+
+      const result = await manager.exists();
+
+      expect(result).toBe(true);
+      expect(fs.access).toHaveBeenCalledWith(mockConfigPath);
+    });
+
+    it('should return false when config file does not exist', async () => {
+      vi.mocked(fs.access).mockRejectedValueOnce(new Error('ENOENT'));
+
+      const result = await manager.exists();
+
+      expect(result).toBe(false);
+    });
+  });
+
+  describe('getConfigPath', () => {
+    it('should return the correct config path', () => {
+      const result = manager.getConfigPath();
+
+      expect(result).toBe(mockConfigPath);
+    });
+  });
+});