@urugus/slack-cli 0.2.12 → 0.3.0

package/src/utils/channel-formatter.ts

@@ -1,45 +0,0 @@
-import { Channel } from './slack-api-client';
-import { formatUnixTimestamp } from './date-utils';
-
-export interface ChannelInfo {
-  id: string;
-  name: string;
-  type: string;
-  members: number;
-  created: string;
-  purpose: string;
-}
-
-export function mapChannelToInfo(channel: Channel): ChannelInfo {
-  let type = 'unknown';
-  if (channel.is_channel && !channel.is_private) type = 'public';
-  else if (channel.is_group || (channel.is_channel && channel.is_private)) type = 'private';
-  else if (channel.is_im) type = 'im';
-  else if (channel.is_mpim) type = 'mpim';
-
-  return {
-    id: channel.id,
-    name: channel.name || 'unnamed',
-    type,
-    members: channel.num_members || 0,
-    created: formatUnixTimestamp(channel.created),
-    purpose: channel.purpose?.value || '',
-  };
-}
-
-export function formatChannelName(channelName?: string): string {
-  if (!channelName) return '#unknown';
-  return channelName.startsWith('#') ? channelName : `#${channelName}`;
-}
-
-export function getChannelTypes(type: string): string {
-  const channelTypeMap: Record<string, string> = {
-    public: 'public_channel',
-    private: 'private_channel',
-    im: 'im',
-    mpim: 'mpim',
-    all: 'public_channel,private_channel,mpim,im',
-  };
-
-  return channelTypeMap[type] || 'public_channel';
-}

package/src/utils/channel-resolver.ts

@@ -1,82 +0,0 @@
-import { Channel } from './slack-api-client';
-
-export type GetChannelsFunction = () => Promise<Channel[]>;
-
-export class ChannelResolver {
-  /**
-   * Check if the given string is a channel ID
-   */
-  isChannelId(channelNameOrId: string): boolean {
-    return /^[CDG][A-Z0-9]{8,}$/.test(channelNameOrId);
-  }
-
-  /**
-   * Find a channel by name from the given list
-   */
-  findChannel(channelName: string, channels: Channel[]): Channel | undefined {
-    return channels.find((c) => {
-      // Direct name match
-      if (c.name === channelName) return true;
-      // Match without # prefix
-      if (c.name === channelName.replace('#', '')) return true;
-      // Case-insensitive match
-      if (c.name?.toLowerCase() === channelName.toLowerCase()) return true;
-      // Match with normalized name
-      if (c.name_normalized === channelName) return true;
-      return false;
-    });
-  }
-
-  /**
-   * Get similar channel names for suggestions
-   */
-  getSimilarChannels(channelName: string, channels: Channel[], limit = 5): string[] {
-    return channels
-      .filter((c) => c.name?.toLowerCase().includes(channelName.toLowerCase()))
-      .slice(0, limit)
-      .map((c) => c.name as string);
-  }
-
-  /**
-   * Create an error with channel suggestions
-   */
-  resolveChannelError(channelName: string, channels: Channel[]): Error {
-    const similarChannels = this.getSimilarChannels(channelName, channels);
-
-    if (similarChannels.length > 0) {
-      return new Error(
-        `Channel '${channelName}' not found. Did you mean one of these? ${similarChannels.join(', ')}`
-      );
-    } else {
-      return new Error(
-        `Channel '${channelName}' not found. Make sure you are a member of this channel.`
-      );
-    }
-  }
-
-  /**
-   * Resolve a channel name or ID to a channel ID
-   */
-  async resolveChannelId(
-    channelNameOrId: string,
-    getChannels: GetChannelsFunction
-  ): Promise<string> {
-    // If it's already an ID, return it
-    if (this.isChannelId(channelNameOrId)) {
-      return channelNameOrId;
-    }
-
-    // Otherwise, fetch channels and resolve the name
-    const channels = await getChannels();
-    const channel = this.findChannel(channelNameOrId, channels);
-
-    if (!channel) {
-      throw this.resolveChannelError(channelNameOrId, channels);
-    }
-
-    return channel.id;
-  }
-}
-
-// Export a singleton instance
-export const channelResolver = new ChannelResolver();

package/src/utils/client-factory.ts

@@ -1,10 +0,0 @@
-import { SlackApiClient } from './slack-api-client';
-import { getConfigOrThrow } from './config-helper';
-
-/**
- * Creates a SlackApiClient instance with configuration from the specified profile
- */
-export async function createSlackClient(profile?: string): Promise<SlackApiClient> {
-  const config = await getConfigOrThrow(profile);
-  return new SlackApiClient(config.token);
-}

package/src/utils/command-wrapper.ts

@@ -1,27 +0,0 @@
-import chalk from 'chalk';
-import { extractErrorMessage } from './error-utils';
-
-export type CommandAction<T = unknown> = (options: T) => Promise<void> | void;
-
-export function wrapCommand<T = unknown>(action: CommandAction<T>): CommandAction<T> {
-  return async (options: T) => {
-    try {
-      await action(options);
-    } catch (error) {
-      console.error(chalk.red('✗ Error:'), extractErrorMessage(error));
-
-      if (process.env.NODE_ENV === 'development' && error instanceof Error) {
-        console.error(chalk.gray(error.stack));
-      }
-
-      process.exit(1);
-    }
-  };
-}
-
-export async function getProfileName(
-  configManager: { getCurrentProfile: () => Promise<string> },
-  providedProfile?: string
-): Promise<string> {
-  return providedProfile || (await configManager.getCurrentProfile());
-}

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

@@ -1,56 +0,0 @@
-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

@@ -1,79 +0,0 @@
-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

@@ -1,80 +0,0 @@
-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/config-helper.ts

@@ -1,21 +0,0 @@
-import { ProfileConfigManager } from './profile-config';
-import { ConfigurationError } from './errors';
-import { ERROR_MESSAGES } from './constants';
-
-/**
- * Helper function to get configuration with proper error handling
- */
-export async function getConfigOrThrow(
-  profile?: string,
-  configManager: ProfileConfigManager = new ProfileConfigManager()
-): Promise<{ token: string }> {
-  const config = await configManager.getConfig(profile);
-
-  if (!config) {
-    const profiles = await configManager.listProfiles();
-    const profileName = profile || profiles.find((p) => p.isDefault)?.name || 'default';
-    throw new ConfigurationError(ERROR_MESSAGES.NO_CONFIG(profileName));
-  }
-
-  return config;
-}

package/src/utils/constants.ts

@@ -1,78 +0,0 @@
-export const TOKEN_MASK_LENGTH = 4;
-export const TOKEN_MIN_LENGTH = 9;
-export const DEFAULT_PROFILE_NAME = 'default';
-
-export const ERROR_MESSAGES = {
-  // Configuration errors
-  NO_CONFIG: (profileName: string) =>
-    `No configuration found for profile "${profileName}". Use "slack-cli config set --token <token> --profile ${profileName}" to set up.`,
-  PROFILE_NOT_FOUND: (profileName: string) => `Profile "${profileName}" not found`,
-  NO_PROFILES_FOUND: 'No profiles found. Use "slack-cli config set --token <token>" to create one.',
-  INVALID_CONFIG_FORMAT: 'Invalid config file format',
-
-  // Validation errors
-  NO_MESSAGE_OR_FILE: 'You must specify either --message or --file',
-  BOTH_MESSAGE_AND_FILE: 'Cannot use both --message and --file',
-  INVALID_THREAD_TIMESTAMP: 'Invalid thread timestamp format',
-  INVALID_SCHEDULE_AT:
-    'Invalid schedule time format. Use Unix timestamp (seconds) or ISO 8601 date-time',
-  INVALID_SCHEDULE_AFTER: '--after must be a positive integer (minutes)',
-  BOTH_SCHEDULE_OPTIONS: 'Cannot use both --at and --after',
-  SCHEDULE_TIME_IN_PAST: 'Schedule time must be in the future',
-
-  // API errors
-  API_ERROR: (error: string) => `API Error: ${error}`,
-  CHANNEL_NOT_FOUND: (channel: string) => `Channel not found: ${channel}`,
-
-  // File errors
-  FILE_READ_ERROR: (file: string, error: string) => `Error reading file ${file}: ${error}`,
-  FILE_NOT_FOUND: (file: string) => `File not found: ${file}`,
-
-  // Channels command errors
-  NO_CHANNELS_FOUND: 'No channels found',
-  ERROR_LISTING_CHANNELS: (error: string) => `Error listing channels: ${error}`,
-} as const;
-
-export const SUCCESS_MESSAGES = {
-  TOKEN_SAVED: (profileName: string) => `Token saved successfully for profile "${profileName}"`,
-  PROFILE_SWITCHED: (profileName: string) => `Switched to profile "${profileName}"`,
-  PROFILE_CLEARED: (profileName: string) => `Profile "${profileName}" cleared successfully`,
-  MESSAGE_SENT: (channel: string) => `Message sent successfully to #${channel}`,
-  MESSAGE_SCHEDULED: (channel: string, postAtIso: string) =>
-    `Message scheduled to #${channel} at ${postAtIso}`,
-} as const;
-
-// File and system constants
-export const FILE_PERMISSIONS = {
-  CONFIG_FILE: 0o600, // Read/write for owner only
-};
-
-// API limits
-export const API_LIMITS = {
-  MAX_MESSAGE_COUNT: 1000,
-  MIN_MESSAGE_COUNT: 1,
-  DEFAULT_MESSAGE_COUNT: 10,
-};
-
-// API Rate Limiting Configuration
-export const RATE_LIMIT = {
-  CONCURRENT_REQUESTS: 3,
-  BATCH_SIZE: 10,
-  BATCH_DELAY_MS: 1000,
-  RETRY_CONFIG: {
-    retries: 3,
-    factor: 2,
-    minTimeout: 1000,
-    maxTimeout: 30000,
-  },
-};
-
-// Default values
-export const DEFAULTS = {
-  HISTORY_LIMIT: 20,
-  CHANNELS_LIMIT: 1000,
-  UNREAD_DISPLAY_LIMIT: 50,
-};
-
-// Time formats
-export const TIME_FORMAT = 'YYYY-MM-DD HH:mm:ss';

package/src/utils/date-utils.ts

@@ -1,8 +0,0 @@
-export function formatUnixTimestamp(timestamp: number): string {
-  return new Date(timestamp * 1000).toISOString().split('T')[0];
-}
-
-export function formatSlackTimestamp(slackTimestamp: string): string {
-  const timestamp = parseFloat(slackTimestamp);
-  return new Date(timestamp * 1000).toLocaleString();
-}

package/src/utils/error-utils.ts

@@ -1,6 +0,0 @@
-export function extractErrorMessage(error: unknown): string {
-  if (error instanceof Error) {
-    return error.message;
-  }
-  return String(error);
-}

package/src/utils/errors.ts

@@ -1,33 +0,0 @@
-export class SlackCliError extends Error {
-  constructor(
-    message: string,
-    public code?: string
-  ) {
-    super(message);
-    this.name = this.constructor.name;
-  }
-}
-
-export class ConfigurationError extends SlackCliError {
-  constructor(message: string) {
-    super(message, 'CONFIGURATION_ERROR');
-  }
-}
-
-export class ValidationError extends SlackCliError {
-  constructor(message: string) {
-    super(message, 'VALIDATION_ERROR');
-  }
-}
-
-export class ApiError extends SlackCliError {
-  constructor(message: string) {
-    super(message, 'API_ERROR');
-  }
-}
-
-export class FileError extends SlackCliError {
-  constructor(message: string) {
-    super(message, 'FILE_ERROR');
-  }
-}

package/src/utils/format-utils.ts

@@ -1,9 +0,0 @@
-import { USER_MENTION_PATTERN } from './slack-patterns';
-
-export function formatMessageWithMentions(message: string, users: Map<string, string>): string {
-  // Replace <@USERID> mentions with @username
-  return message.replace(USER_MENTION_PATTERN, (match, userId) => {
-    const username = users.get(userId) || userId;
-    return `@${username}`;
-  });
-}

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

@@ -1,34 +0,0 @@
-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,71 +0,0 @@
-import chalk from 'chalk';
-import { AbstractFormatter, JsonFormatter, createFormatterFactory } from './base-formatter';
-import { Channel } from '../slack-api-client';
-import { formatChannelName } from '../channel-formatter';
-import { formatSlackTimestamp } from '../date-utils';
-
-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));
-
-    channels.forEach((channel) => {
-      const channelName = formatChannelName(channel.name);
-      const paddedName = channelName.padEnd(16);
-      const count = (channel.unread_count || 0).toString().padEnd(6);
-      const lastRead = channel.last_read ? formatSlackTimestamp(channel.last_read) : 'Unknown';
-      console.log(`${paddedName} ${count}  ${lastRead}`);
-    });
-  }
-}
-
-class ChannelSimpleFormatter extends AbstractFormatter<ChannelFormatterOptions> {
-  format({ channels }: ChannelFormatterOptions): void {
-    channels.forEach((channel) => {
-      const channelName = formatChannelName(channel.name);
-      console.log(`${channelName} (${channel.unread_count || 0})`);
-    });
-  }
-}
-
-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,
-    }));
-  }
-}
-
-class ChannelCountFormatter extends AbstractFormatter<ChannelFormatterOptions> {
-  format({ channels }: ChannelFormatterOptions): void {
-    let totalUnread = 0;
-    channels.forEach((channel) => {
-      const count = channel.unread_count || 0;
-      totalUnread += count;
-      const channelName = formatChannelName(channel.name);
-      console.log(`${channelName}: ${count}`);
-    });
-    console.log(chalk.bold(`Total: ${totalUnread} unread messages`));
-  }
-}
-
-const channelFormatterFactory = createFormatterFactory<ChannelFormatterOptions>({
-  table: new ChannelTableFormatter(),
-  simple: new ChannelSimpleFormatter(),
-  json: new ChannelJsonFormatter(),
-  count: new ChannelCountFormatter(),
-});
-
-export function createChannelFormatter(format: string, countOnly: boolean) {
-  if (countOnly) {
-    return channelFormatterFactory.create('count');
-  }
-  return channelFormatterFactory.create(format);
-}