@urugus/slack-cli 0.2.1 → 0.2.3

package/src/commands/channels.ts

@@ -5,6 +5,7 @@ import { ERROR_MESSAGES } from '../utils/constants';
 import { ChannelsOptions } from '../types/commands';
 import { mapChannelToInfo, getChannelTypes } from '../utils/channel-formatter';
 import { createChannelsListFormatter } from '../utils/formatters/channels-list-formatters';
+import { parseFormat, parseLimit, parseBoolean } from '../utils/option-parsers';
 
 export function setupChannelsCommand(): Command {
   const channelsCommand = new Command('channels');
@@ -25,10 +26,11 @@ export function setupChannelsCommand(): Command {
         const types = getChannelTypes(options.type);
 
         // List channels
+        const limit = parseLimit(options.limit, 100);
         const channels = await client.listChannels({
           types,
-          exclude_archived: !options.includeArchived,
-          limit: parseInt(options.limit, 10),
+          exclude_archived: !parseBoolean(options.includeArchived),
+          limit: limit,
         });
 
         if (channels.length === 0) {
@@ -38,8 +40,9 @@ export function setupChannelsCommand(): Command {
 
         // Format and display channels
         const channelInfos = channels.map(mapChannelToInfo);
-        const formatter = createChannelsListFormatter(options.format);
-        formatter.format(channelInfos);
+        const format = parseFormat(options.format);
+        const formatter = createChannelsListFormatter(format);
+        formatter.format({ channels: channelInfos });
       })
     );
 

package/src/commands/history-display.ts

@@ -1,6 +1,7 @@
 import chalk from 'chalk';
 import { Message } from '../utils/slack-api-client';
 import { formatSlackTimestamp } from '../utils/date-utils';
+import { formatMessageWithMentions } from '../utils/format-utils';
 
 export function displayHistoryResults(
   messages: Message[],
@@ -27,7 +28,8 @@ export function displayHistoryResults(
 
     console.log(chalk.gray(`[${timestamp}]`) + ' ' + chalk.cyan(author));
     if (message.text) {
-      console.log(message.text);
+      const formattedText = formatMessageWithMentions(message.text, users);
+      console.log(formattedText);
     }
     console.log(''); // Empty line between messages
   });

package/src/commands/unread.ts

@@ -4,30 +4,28 @@ import { createSlackClient } from '../utils/client-factory';
 import { SlackApiClient } from '../utils/slack-api-client';
 import { UnreadOptions } from '../types/commands';
 import chalk from 'chalk';
-import { formatSlackTimestamp } from '../utils/date-utils';
-import { formatChannelName } from '../utils/channel-formatter';
 import { createChannelFormatter } from '../utils/formatters/channel-formatters';
+import { createMessageFormatter } from '../utils/formatters/message-formatters';
 import { DEFAULTS } from '../utils/constants';
+import { parseLimit, parseFormat, parseBoolean } from '../utils/option-parsers';
 
 async function handleSpecificChannelUnread(
   client: SlackApiClient,
   options: UnreadOptions
 ): Promise<void> {
   const result = await client.getChannelUnread(options.channel!);
-  const channelName = formatChannelName(result.channel.name);
 
-  console.log(chalk.bold(`${channelName}: ${result.channel.unread_count || 0} unread messages`));
+  const format = parseFormat(options.format);
+  const countOnly = parseBoolean(options.countOnly);
 
-  if (!options.countOnly && result.messages.length > 0) {
-    console.log('');
-    result.messages.forEach((message) => {
-      const timestamp = formatSlackTimestamp(message.ts);
-      const author = message.user ? result.users.get(message.user) || message.user : 'unknown';
-      console.log(`${chalk.gray(timestamp)} ${chalk.cyan(author)}`);
-      console.log(message.text || '(no text)');
-      console.log('');
-    });
-  }
+  const formatter = createMessageFormatter(format);
+  formatter.format({
+    channel: result.channel,
+    messages: result.messages,
+    users: result.users,
+    countOnly: countOnly,
+    format: format,
+  });
 }
 
 async function handleAllChannelsUnread(
@@ -42,11 +40,14 @@ async function handleAllChannelsUnread(
   }
 
   // Apply limit
-  const limit = parseInt(options.limit || DEFAULTS.UNREAD_DISPLAY_LIMIT.toString(), 10);
+  const limit = parseLimit(options.limit, DEFAULTS.UNREAD_DISPLAY_LIMIT);
   const displayChannels = channels.slice(0, limit);
 
-  const formatter = createChannelFormatter(options.format || 'table', options.countOnly || false);
-  formatter.format(displayChannels);
+  const format = parseFormat(options.format);
+  const countOnly = parseBoolean(options.countOnly);
+
+  const formatter = createChannelFormatter(format, countOnly);
+  formatter.format({ channels: displayChannels, countOnly: countOnly });
 }
 
 export function setupUnreadCommand(): Command {

package/src/utils/config/config-file-manager.ts

@@ -0,0 +1,56 @@
+import * as fs from 'fs/promises';
+import * as os from 'os';
+import * as path from 'path';
+
+export interface ConfigData {
+  profiles: Record<string, any>;
+  currentProfile: string;
+}
+
+export class ConfigFileManager {
+  private readonly configPath: string;
+
+  constructor() {
+    this.configPath = path.join(os.homedir(), '.slack-cli', 'config.json');
+  }
+
+  async read(): Promise<ConfigData> {
+    try {
+      await fs.access(this.configPath);
+      const data = await fs.readFile(this.configPath, 'utf-8');
+      try {
+        return JSON.parse(data);
+      } catch {
+        throw new Error('Invalid configuration file');
+      }
+    } catch (error: any) {
+      if (error.message === 'Invalid configuration file') {
+        throw error;
+      }
+      // File doesn't exist, return default config
+      return {
+        profiles: {},
+        currentProfile: 'default',
+      };
+    }
+  }
+
+  async write(data: ConfigData): Promise<void> {
+    const dir = path.dirname(this.configPath);
+    await fs.mkdir(dir, { recursive: true });
+    await fs.writeFile(this.configPath, JSON.stringify(data, null, 2), 'utf-8');
+  }
+
+  async exists(): Promise<boolean> {
+    try {
+      await fs.access(this.configPath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  getConfigPath(): string {
+    return this.configPath;
+  }
+}

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

@@ -0,0 +1,79 @@
+import { Config } from '../../types/config';
+import { ConfigFileManager, ConfigData } from './config-file-manager';
+import { TokenCryptoService } from './token-crypto-service';
+
+export class ProfileManager {
+  constructor(
+    private fileManager: ConfigFileManager,
+    private cryptoService: TokenCryptoService
+  ) {}
+
+  async getProfile(profileName: string): Promise<Config> {
+    const data = await this.fileManager.read();
+    const profile = data.profiles[profileName];
+
+    if (!profile) {
+      throw new Error(`Profile "${profileName}" not found`);
+    }
+
+    // Decrypt token if encrypted
+    const token = this.cryptoService.isEncrypted(profile.token)
+      ? this.cryptoService.decrypt(profile.token)
+      : profile.token;
+
+    return {
+      ...profile,
+      token,
+    };
+  }
+
+  async setProfile(profileName: string, config: Config): Promise<void> {
+    const data = await this.fileManager.read();
+
+    // Encrypt the token before saving
+    const encryptedConfig = {
+      ...config,
+      token: this.cryptoService.encrypt(config.token),
+    };
+
+    data.profiles[profileName] = encryptedConfig;
+    await this.fileManager.write(data);
+  }
+
+  async deleteProfile(profileName: string): Promise<void> {
+    const data = await this.fileManager.read();
+
+    if (!data.profiles[profileName]) {
+      throw new Error(`Profile "${profileName}" not found`);
+    }
+
+    delete data.profiles[profileName];
+    await this.fileManager.write(data);
+  }
+
+  async listProfiles(): Promise<string[]> {
+    const data = await this.fileManager.read();
+    return Object.keys(data.profiles);
+  }
+
+  async getCurrentProfile(): Promise<string> {
+    const data = await this.fileManager.read();
+    return data.currentProfile || 'default';
+  }
+
+  async setCurrentProfile(profileName: string): Promise<void> {
+    const data = await this.fileManager.read();
+
+    if (!data.profiles[profileName]) {
+      throw new Error(`Profile "${profileName}" not found`);
+    }
+
+    data.currentProfile = profileName;
+    await this.fileManager.write(data);
+  }
+
+  async profileExists(profileName: string): Promise<boolean> {
+    const data = await this.fileManager.read();
+    return profileName in data.profiles;
+  }
+}

package/src/utils/config/token-crypto-service.ts

@@ -0,0 +1,80 @@
+import * as crypto from 'crypto';
+
+export class TokenCryptoService {
+  private readonly algorithm = 'aes-256-cbc';
+  private readonly keyLength = 32;
+  private readonly ivLength = 16;
+  private readonly separator = ':';
+
+  private deriveKey(): Buffer {
+    // Derive a consistent key from a fixed string
+    // In production, this should use a more secure method
+    const fixedSalt = 'slack-cli-salt-v1';
+    return crypto.pbkdf2Sync('slack-cli-key', fixedSalt, 100000, this.keyLength, 'sha256');
+  }
+
+  encrypt(token: string): string {
+    try {
+      const key = this.deriveKey();
+      const iv = crypto.randomBytes(this.ivLength);
+      const cipher = crypto.createCipheriv(this.algorithm, key, iv);
+
+      let encrypted = cipher.update(token, 'utf8', 'hex');
+      encrypted += cipher.final('hex');
+
+      // Combine IV and encrypted data
+      return iv.toString('hex') + this.separator + encrypted;
+    } catch (error) {
+      throw new Error('Failed to encrypt token');
+    }
+  }
+
+  decrypt(encryptedData: string): string {
+    try {
+      if (!encryptedData || !encryptedData.includes(this.separator)) {
+        throw new Error('Invalid encrypted data format');
+      }
+
+      const parts = encryptedData.split(this.separator);
+      if (parts.length !== 2) {
+        throw new Error('Invalid encrypted data format');
+      }
+
+      const iv = Buffer.from(parts[0], 'hex');
+      const encrypted = parts[1];
+
+      if (iv.length !== this.ivLength) {
+        throw new Error('Invalid IV length');
+      }
+
+      const key = this.deriveKey();
+      const decipher = crypto.createDecipheriv(this.algorithm, key, iv);
+
+      let decrypted = decipher.update(encrypted, 'hex', 'utf8');
+      decrypted += decipher.final('utf8');
+
+      return decrypted;
+    } catch (error) {
+      throw new Error('Failed to decrypt token');
+    }
+  }
+
+  isEncrypted(value: string): boolean {
+    if (!value) return false;
+
+    // Check if the value has the expected format
+    const parts = value.split(this.separator);
+    if (parts.length !== 2) return false;
+
+    // Check if the IV part is valid hex and has correct length
+    try {
+      const ivHex = parts[0];
+      if (!/^[0-9a-fA-F]+$/.test(ivHex)) return false;
+      if (ivHex.length !== this.ivLength * 2) return false;
+
+      return true;
+    } catch {
+      return false;
+    }
+  }
+}

package/src/utils/format-utils.ts

@@ -0,0 +1,7 @@
+export function formatMessageWithMentions(message: string, users: Map<string, string>): string {
+  // Replace <@USERID> mentions with @username
+  return message.replace(/<@([A-Z0-9]+)>/g, (match, userId) => {
+    const username = users.get(userId) || userId;
+    return `@${username}`;
+  });
+}

package/src/utils/formatters/base-formatter.ts

@@ -0,0 +1,34 @@
+export interface BaseFormatter<T> {
+  format(data: T): void;
+}
+
+export abstract class AbstractFormatter<T> implements BaseFormatter<T> {
+  abstract format(data: T): void;
+}
+
+export abstract class JsonFormatter<TInput, TOutput = any> extends AbstractFormatter<TInput> {
+  protected abstract transform(data: TInput): TOutput;
+
+  format(data: TInput): void {
+    console.log(JSON.stringify(this.transform(data), null, 2));
+  }
+}
+
+export interface FormatterMap<T> {
+  table: BaseFormatter<T>;
+  simple: BaseFormatter<T>;
+  json: BaseFormatter<T>;
+  [key: string]: BaseFormatter<T>;
+}
+
+export class FormatterFactory<T> {
+  constructor(private formatters: FormatterMap<T>) {}
+
+  create(format: string = 'table'): BaseFormatter<T> {
+    return this.formatters[format] || this.formatters.table;
+  }
+}
+
+export function createFormatterFactory<T>(formatters: FormatterMap<T>): FormatterFactory<T> {
+  return new FormatterFactory(formatters);
+}

package/src/utils/formatters/channel-formatters.ts

@@ -1,11 +1,16 @@
 import chalk from 'chalk';
-import { BaseFormatter } from './output-formatter';
+import { AbstractFormatter, JsonFormatter, createFormatterFactory } from './base-formatter';
 import { Channel } from '../slack-api-client';
 import { formatChannelName } from '../channel-formatter';
 import { formatSlackTimestamp } from '../date-utils';
 
-export class ChannelTableFormatter extends BaseFormatter<Channel> {
-  format(channels: Channel[]): void {
+export interface ChannelFormatterOptions {
+  channels: Channel[];
+  countOnly?: boolean;
+}
+
+class ChannelTableFormatter extends AbstractFormatter<ChannelFormatterOptions> {
+  format({ channels }: ChannelFormatterOptions): void {
     console.log(chalk.bold('Channel          Unread  Last Message'));
     console.log('─'.repeat(50));
 
@@ -19,8 +24,8 @@ export class ChannelTableFormatter extends BaseFormatter<Channel> {
   }
 }
 
-export class ChannelSimpleFormatter extends BaseFormatter<Channel> {
-  format(channels: Channel[]): void {
+class ChannelSimpleFormatter extends AbstractFormatter<ChannelFormatterOptions> {
+  format({ channels }: ChannelFormatterOptions): void {
     channels.forEach((channel) => {
       const channelName = formatChannelName(channel.name);
       console.log(`${channelName} (${channel.unread_count || 0})`);
@@ -28,19 +33,18 @@ export class ChannelSimpleFormatter extends BaseFormatter<Channel> {
   }
 }
 
-export class ChannelJsonFormatter extends BaseFormatter<Channel> {
-  format(channels: Channel[]): void {
-    const output = channels.map((channel) => ({
+class ChannelJsonFormatter extends JsonFormatter<ChannelFormatterOptions> {
+  protected transform({ channels }: ChannelFormatterOptions) {
+    return channels.map((channel) => ({
       channel: formatChannelName(channel.name),
       channelId: channel.id,
       unreadCount: channel.unread_count || 0,
     }));
-    console.log(JSON.stringify(output, null, 2));
   }
 }
 
-export class ChannelCountFormatter extends BaseFormatter<Channel> {
-  format(channels: Channel[]): void {
+class ChannelCountFormatter extends AbstractFormatter<ChannelFormatterOptions> {
+  format({ channels }: ChannelFormatterOptions): void {
     let totalUnread = 0;
     channels.forEach((channel) => {
       const count = channel.unread_count || 0;
@@ -52,18 +56,16 @@ export class ChannelCountFormatter extends BaseFormatter<Channel> {
   }
 }
 
-export function createChannelFormatter(format: string, countOnly: boolean): BaseFormatter<Channel> {
-  if (countOnly) {
-    return new ChannelCountFormatter();
-  }
+const channelFormatterFactory = createFormatterFactory<ChannelFormatterOptions>({
+  table: new ChannelTableFormatter(),
+  simple: new ChannelSimpleFormatter(),
+  json: new ChannelJsonFormatter(),
+  count: new ChannelCountFormatter(),
+});
 
-  switch (format) {
-    case 'json':
-      return new ChannelJsonFormatter();
-    case 'simple':
-      return new ChannelSimpleFormatter();
-    case 'table':
-    default:
-      return new ChannelTableFormatter();
+export function createChannelFormatter(format: string, countOnly: boolean) {
+  if (countOnly) {
+    return channelFormatterFactory.create('count');
   }
+  return channelFormatterFactory.create(format);
 }

package/src/utils/formatters/channels-list-formatters.ts

@@ -1,8 +1,12 @@
-import { BaseFormatter } from './output-formatter';
+import { AbstractFormatter, JsonFormatter, createFormatterFactory } from './base-formatter';
 import { ChannelInfo } from '../channel-formatter';
 
-export class ChannelsTableFormatter extends BaseFormatter<ChannelInfo> {
-  format(channels: ChannelInfo[]): void {
+export interface ChannelsListFormatterOptions {
+  channels: ChannelInfo[];
+}
+
+class ChannelsTableFormatter extends AbstractFormatter<ChannelsListFormatterOptions> {
+  format({ channels }: ChannelsListFormatterOptions): void {
     // Print table header
     console.log('Name              Type      Members  Created      Description');
     console.log('─'.repeat(65));
@@ -21,39 +25,31 @@ export class ChannelsTableFormatter extends BaseFormatter<ChannelInfo> {
   }
 }
 
-export class ChannelsSimpleFormatter extends BaseFormatter<ChannelInfo> {
-  format(channels: ChannelInfo[]): void {
+class ChannelsSimpleFormatter extends AbstractFormatter<ChannelsListFormatterOptions> {
+  format({ channels }: ChannelsListFormatterOptions): void {
     channels.forEach((channel) => console.log(channel.name));
   }
 }
 
-export class ChannelsJsonFormatter extends BaseFormatter<ChannelInfo> {
-  format(channels: ChannelInfo[]): void {
-    console.log(
-      JSON.stringify(
-        channels.map((channel) => ({
-          id: channel.id,
-          name: channel.name,
-          type: channel.type,
-          members: channel.members,
-          created: channel.created + 'T00:00:00Z',
-          purpose: channel.purpose,
-        })),
-        null,
-        2
-      )
-    );
+class ChannelsJsonFormatter extends JsonFormatter<ChannelsListFormatterOptions> {
+  protected transform({ channels }: ChannelsListFormatterOptions) {
+    return channels.map((channel) => ({
+      id: channel.id,
+      name: channel.name,
+      type: channel.type,
+      members: channel.members,
+      created: channel.created + 'T00:00:00Z',
+      purpose: channel.purpose,
+    }));
   }
 }
 
-export function createChannelsListFormatter(format: string): BaseFormatter<ChannelInfo> {
-  switch (format) {
-    case 'json':
-      return new ChannelsJsonFormatter();
-    case 'simple':
-      return new ChannelsSimpleFormatter();
-    case 'table':
-    default:
-      return new ChannelsTableFormatter();
-  }
+const channelsListFormatterFactory = createFormatterFactory<ChannelsListFormatterOptions>({
+  table: new ChannelsTableFormatter(),
+  simple: new ChannelsSimpleFormatter(),
+  json: new ChannelsJsonFormatter(),
+});
+
+export function createChannelsListFormatter(format: string) {
+  return channelsListFormatterFactory.create(format);
 }

package/src/utils/formatters/message-formatters.ts

@@ -0,0 +1,85 @@
+import chalk from 'chalk';
+import { AbstractFormatter, JsonFormatter, createFormatterFactory } from './base-formatter';
+import { formatSlackTimestamp } from '../date-utils';
+import { formatMessageWithMentions } from '../format-utils';
+import { formatChannelName } from '../channel-formatter';
+
+export interface MessageFormatterOptions {
+  channel: any;
+  messages: any[];
+  users: Map<string, string>;
+  countOnly: boolean;
+  format: string;
+}
+
+class TableMessageFormatter extends AbstractFormatter<MessageFormatterOptions> {
+  format(options: MessageFormatterOptions): void {
+    const { channel, messages, users, countOnly } = options;
+    const channelName = formatChannelName(channel.name);
+
+    console.log(chalk.bold(`${channelName}: ${channel.unread_count || 0} unread messages`));
+
+    if (!countOnly && messages.length > 0) {
+      console.log('');
+      messages.forEach((message) => {
+        const timestamp = formatSlackTimestamp(message.ts);
+        const author = message.user ? users.get(message.user) || message.user : 'unknown';
+        console.log(`${chalk.gray(timestamp)} ${chalk.cyan(author)}`);
+        const text = message.text ? formatMessageWithMentions(message.text, users) : '(no text)';
+        console.log(text);
+        console.log('');
+      });
+    }
+  }
+}
+
+class SimpleMessageFormatter extends AbstractFormatter<MessageFormatterOptions> {
+  format(options: MessageFormatterOptions): void {
+    const { channel, messages, users, countOnly } = options;
+    const channelName = formatChannelName(channel.name);
+
+    console.log(`${channelName} (${channel.unread_count || 0})`);
+
+    if (!countOnly && messages.length > 0) {
+      messages.forEach((message) => {
+        const timestamp = formatSlackTimestamp(message.ts);
+        const author = message.user ? users.get(message.user) || message.user : 'unknown';
+        const text = message.text ? formatMessageWithMentions(message.text, users) : '(no text)';
+        console.log(`[${timestamp}] ${author}: ${text}`);
+      });
+    }
+  }
+}
+
+class JsonMessageFormatter extends JsonFormatter<MessageFormatterOptions> {
+  protected transform(options: MessageFormatterOptions) {
+    const { channel, messages, users, countOnly } = options;
+    const channelName = formatChannelName(channel.name);
+
+    const output: any = {
+      channel: channelName,
+      channelId: channel.id,
+      unreadCount: channel.unread_count || 0,
+    };
+
+    if (!countOnly && messages.length > 0) {
+      output.messages = messages.map((message) => ({
+        timestamp: formatSlackTimestamp(message.ts),
+        author: message.user ? users.get(message.user) || message.user : 'unknown',
+        text: message.text || '(no text)',
+      }));
+    }
+
+    return output;
+  }
+}
+
+const messageFormatterFactory = createFormatterFactory<MessageFormatterOptions>({
+  table: new TableMessageFormatter(),
+  simple: new SimpleMessageFormatter(),
+  json: new JsonMessageFormatter(),
+});
+
+export function createMessageFormatter(format: string) {
+  return messageFormatterFactory.create(format);
+}