@urugus/slack-cli 0.2.12 → 0.2.13

package/src/commands/channels.ts

@@ -1,50 +0,0 @@
-import { Command } from 'commander';
-import { wrapCommand } from '../utils/command-wrapper';
-import { createSlackClient } from '../utils/client-factory';
-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');
-
-  channelsCommand
-    .description('List Slack channels')
-    .option('--type <type>', 'Channel type: public, private, im, mpim, all', 'public')
-    .option('--include-archived', 'Include archived channels', false)
-    .option('--format <format>', 'Output format: table, simple, json', 'table')
-    .option('--limit <number>', 'Maximum number of channels to list', '100')
-    .option('--profile <profile>', 'Use specific workspace profile')
-    .action(
-      wrapCommand(async (options: ChannelsOptions) => {
-        // Create Slack client
-        const client = await createSlackClient(options.profile);
-
-        // Map channel type to API types
-        const types = getChannelTypes(options.type);
-
-        // List channels
-        const limit = parseLimit(options.limit, 100);
-        const channels = await client.listChannels({
-          types,
-          exclude_archived: !parseBoolean(options.includeArchived),
-          limit: limit,
-        });
-
-        if (channels.length === 0) {
-          console.log(ERROR_MESSAGES.NO_CHANNELS_FOUND);
-          return;
-        }
-
-        // Format and display channels
-        const channelInfos = channels.map(mapChannelToInfo);
-        const format = parseFormat(options.format);
-        const formatter = createChannelsListFormatter(format);
-        formatter.format({ channels: channelInfos });
-      })
-    );
-
-  return channelsCommand;
-}

package/src/commands/config-subcommands.ts

@@ -1,63 +0,0 @@
-import chalk from 'chalk';
-import { ProfileConfigManager } from '../utils/profile-config';
-import { getProfileName } from '../utils/command-wrapper';
-import { ERROR_MESSAGES, SUCCESS_MESSAGES } from '../utils/constants';
-
-export async function handleSetToken(options: { token: string; profile?: string }): Promise<void> {
-  const configManager = new ProfileConfigManager();
-  const profileName = await getProfileName(configManager, options.profile);
-  await configManager.setToken(options.token, options.profile);
-  console.log(chalk.green(`✓ ${SUCCESS_MESSAGES.TOKEN_SAVED(profileName)}`));
-}
-
-export async function handleGetConfig(options: { profile?: string }): Promise<void> {
-  const configManager = new ProfileConfigManager();
-  const profileName = await getProfileName(configManager, options.profile);
-  const currentConfig = await configManager.getConfig(options.profile);
-
-  if (!currentConfig) {
-    console.log(chalk.yellow(ERROR_MESSAGES.NO_CONFIG(profileName)));
-    return;
-  }
-
-  console.log(chalk.bold(`Configuration for profile "${profileName}":`));
-  console.log(`  Token: ${chalk.cyan(configManager.maskToken(currentConfig.token))}`);
-  console.log(`  Updated: ${chalk.gray(currentConfig.updatedAt)}`);
-}
-
-export async function handleListProfiles(): Promise<void> {
-  const configManager = new ProfileConfigManager();
-  const profiles = await configManager.listProfiles();
-  const currentProfile = await configManager.getCurrentProfile();
-
-  if (profiles.length === 0) {
-    console.log(chalk.yellow(ERROR_MESSAGES.NO_PROFILES_FOUND));
-    return;
-  }
-
-  console.log(chalk.bold('Available profiles:'));
-  profiles.forEach((profile) => {
-    const marker = profile.name === currentProfile ? '*' : ' ';
-    const maskedToken = configManager.maskToken(profile.config.token);
-    console.log(`  ${marker} ${chalk.cyan(profile.name)} (${maskedToken})`);
-  });
-}
-
-export async function handleUseProfile(profile: string): Promise<void> {
-  const configManager = new ProfileConfigManager();
-  await configManager.useProfile(profile);
-  console.log(chalk.green(`✓ ${SUCCESS_MESSAGES.PROFILE_SWITCHED(profile)}`));
-}
-
-export async function handleShowCurrentProfile(): Promise<void> {
-  const configManager = new ProfileConfigManager();
-  const currentProfile = await configManager.getCurrentProfile();
-  console.log(chalk.bold(`Current profile: ${chalk.cyan(currentProfile)}`));
-}
-
-export async function handleClearConfig(options: { profile?: string }): Promise<void> {
-  const configManager = new ProfileConfigManager();
-  const profileName = await getProfileName(configManager, options.profile);
-  await configManager.clearConfig(options.profile);
-  console.log(chalk.green(`✓ ${SUCCESS_MESSAGES.PROFILE_CLEARED(profileName)}`));
-}

package/src/commands/config.ts

@@ -1,50 +0,0 @@
-import { Command } from 'commander';
-import { wrapCommand } from '../utils/command-wrapper';
-import {
-  handleSetToken,
-  handleGetConfig,
-  handleListProfiles,
-  handleUseProfile,
-  handleShowCurrentProfile,
-  handleClearConfig,
-} from './config-subcommands';
-
-export function setupConfigCommand(): Command {
-  const config = new Command('config').description('Manage Slack CLI configuration');
-
-  config
-    .command('set')
-    .description('Set API token')
-    .requiredOption('--token <token>', 'Slack API token')
-    .option('--profile <profile>', 'Profile name (default: "default")')
-    .action(wrapCommand(handleSetToken));
-
-  config
-    .command('get')
-    .description('Show current configuration')
-    .option('--profile <profile>', 'Profile name')
-    .action(wrapCommand(handleGetConfig));
-
-  config
-    .command('profiles')
-    .description('List all profiles')
-    .action(wrapCommand(handleListProfiles));
-
-  config
-    .command('use <profile>')
-    .description('Switch to a different profile')
-    .action(wrapCommand(handleUseProfile));
-
-  config
-    .command('current')
-    .description('Show current active profile')
-    .action(wrapCommand(handleShowCurrentProfile));
-
-  config
-    .command('clear')
-    .description('Clear configuration')
-    .option('--profile <profile>', 'Profile name')
-    .action(wrapCommand(handleClearConfig));
-
-  return config;
-}

package/src/commands/history-display.ts

@@ -1,19 +0,0 @@
-import { Message } from '../utils/slack-api-client';
-import { createHistoryFormatter } from '../utils/formatters/history-formatters';
-
-export function displayHistoryResults(
-  messages: Message[],
-  users: Map<string, string>,
-  channelName: string,
-  format = 'table'
-): void {
-  // Display messages in reverse order (oldest first)
-  const orderedMessages = [...messages].reverse();
-
-  const formatter = createHistoryFormatter(format);
-  formatter.format({
-    channelName,
-    messages: orderedMessages,
-    users,
-  });
-}

package/src/commands/history-validators.ts

@@ -1,46 +0,0 @@
-import { Command } from 'commander';
-import { API_LIMITS } from '../utils/constants';
-
-export function validateMessageCount(
-  value: string | undefined,
-  command: Command
-): number | undefined {
-  if (!value) {
-    return undefined;
-  }
-
-  const num = parseInt(value, 10);
-  if (isNaN(num) || num < API_LIMITS.MIN_MESSAGE_COUNT || num > API_LIMITS.MAX_MESSAGE_COUNT) {
-    command.error(
-      `Error: Message count must be between ${API_LIMITS.MIN_MESSAGE_COUNT} and ${API_LIMITS.MAX_MESSAGE_COUNT}`
-    );
-  }
-
-  return num;
-}
-
-export function validateDateFormat(
-  value: string | undefined,
-  command: Command
-): string | undefined {
-  if (!value) {
-    return undefined;
-  }
-
-  const timestamp = Date.parse(value);
-  if (isNaN(timestamp)) {
-    command.error('Error: Invalid date format. Use YYYY-MM-DD HH:MM:SS');
-  }
-
-  return value;
-}
-
-export function prepareSinceTimestamp(since: string | undefined): string | undefined {
-  if (!since) {
-    return undefined;
-  }
-
-  // Convert date to Unix timestamp (in seconds)
-  const timestamp = Math.floor(Date.parse(since) / 1000);
-  return timestamp.toString();
-}

package/src/commands/history.ts

@@ -1,61 +0,0 @@
-import { Command } from 'commander';
-import { HistoryOptions as ApiHistoryOptions } from '../utils/slack-api-client';
-import { wrapCommand } from '../utils/command-wrapper';
-import { createSlackClient } from '../utils/client-factory';
-import { HistoryOptions } from '../types/commands';
-import { API_LIMITS } from '../utils/constants';
-import { parseCount, parseProfile } from '../utils/option-parsers';
-import { createValidationHook, optionValidators } from '../utils/validators';
-import { parseFormat } from '../utils/option-parsers';
-import { prepareSinceTimestamp } from './history-validators';
-import { displayHistoryResults } from './history-display';
-
-export function setupHistoryCommand(): Command {
-  const historyCommand = new Command('history')
-    .description('Get message history from a Slack channel')
-    .requiredOption('-c, --channel <channel>', 'Target channel name or ID')
-    .option(
-      '-n, --number <number>',
-      'Number of messages to retrieve',
-      API_LIMITS.DEFAULT_MESSAGE_COUNT.toString()
-    )
-    .option('--since <date>', 'Get messages since specific date (YYYY-MM-DD HH:MM:SS)')
-    .option('--format <format>', 'Output format: table, simple, json', 'table')
-    .option('--profile <profile>', 'Use specific workspace profile')
-    .hook(
-      'preAction',
-      createValidationHook([
-        optionValidators.messageCount,
-        optionValidators.sinceDate,
-        optionValidators.format,
-      ])
-    )
-    .action(
-      wrapCommand(async (options: HistoryOptions) => {
-        const profile = parseProfile(options.profile);
-        const client = await createSlackClient(profile);
-
-        const limit = parseCount(
-          options.number,
-          API_LIMITS.DEFAULT_MESSAGE_COUNT,
-          API_LIMITS.MIN_MESSAGE_COUNT,
-          API_LIMITS.MAX_MESSAGE_COUNT
-        );
-
-        const historyOptions: ApiHistoryOptions = {
-          limit,
-        };
-
-        const oldest = prepareSinceTimestamp(options.since);
-        if (oldest) {
-          historyOptions.oldest = oldest;
-        }
-
-        const { messages, users } = await client.getHistory(options.channel, historyOptions);
-        const format = parseFormat(options.format);
-        displayHistoryResults(messages, users, options.channel, format);
-      })
-    );
-
-  return historyCommand;
-}

package/src/commands/scheduled.ts

@@ -1,71 +0,0 @@
-import { Command } from 'commander';
-import { wrapCommand } from '../utils/command-wrapper';
-import { createSlackClient } from '../utils/client-factory';
-import { ScheduledOptions } from '../types/commands';
-import { parseFormat, parseLimit } from '../utils/option-parsers';
-import { createValidationHook, optionValidators } from '../utils/validators';
-
-function formatPostAt(postAt: number): string {
-  return new Date(postAt * 1000).toISOString();
-}
-
-function renderTable(
-  messages: Array<{ id: string; channel_id: string; post_at: number; text?: string }>
-) {
-  const rows = messages.map((message) => ({
-    id: message.id,
-    channel: message.channel_id,
-    post_at: formatPostAt(message.post_at),
-    text: message.text || '',
-  }));
-
-  console.table(rows);
-}
-
-function renderSimple(
-  messages: Array<{ id: string; channel_id: string; post_at: number; text?: string }>
-) {
-  for (const message of messages) {
-    console.log(
-      `${formatPostAt(message.post_at)} ${message.channel_id} ${message.id} ${message.text || ''}`
-    );
-  }
-}
-
-export function setupScheduledCommand(): Command {
-  const scheduledCommand = new Command('scheduled')
-    .description('List scheduled messages')
-    .option('-c, --channel <channel>', 'Filter by channel name or ID')
-    .option('--limit <number>', 'Maximum number of scheduled messages to list', '50')
-    .option('--format <format>', 'Output format: table, simple, json', 'table')
-    .option('--profile <profile>', 'Use specific workspace profile')
-    .hook('preAction', createValidationHook([optionValidators.format]))
-    .action(
-      wrapCommand(async (options: ScheduledOptions) => {
-        const client = await createSlackClient(options.profile);
-        const limit = parseLimit(options.limit, 50);
-        const messages = await client.listScheduledMessages(options.channel, limit);
-
-        if (messages.length === 0) {
-          console.log('No scheduled messages found');
-          return;
-        }
-
-        const format = parseFormat(options.format);
-
-        if (format === 'json') {
-          console.log(JSON.stringify(messages, null, 2));
-          return;
-        }
-
-        if (format === 'simple') {
-          renderSimple(messages);
-          return;
-        }
-
-        renderTable(messages);
-      })
-    );
-
-  return scheduledCommand;
-}

package/src/commands/send.ts

@@ -1,69 +0,0 @@
-import { Command } from 'commander';
-import chalk from 'chalk';
-import { wrapCommand } from '../utils/command-wrapper';
-import { ERROR_MESSAGES, SUCCESS_MESSAGES } from '../utils/constants';
-import { createSlackClient } from '../utils/client-factory';
-import { FileError } from '../utils/errors';
-import { SendOptions } from '../types/commands';
-import { extractErrorMessage } from '../utils/error-utils';
-import { parseProfile } from '../utils/option-parsers';
-import { createValidationHook, optionValidators } from '../utils/validators';
-import { resolvePostAt } from '../utils/schedule-utils';
-import * as fs from 'fs/promises';
-
-export function setupSendCommand(): Command {
-  const sendCommand = new Command('send')
-    .description('Send or schedule a message to a Slack channel')
-    .requiredOption('-c, --channel <channel>', 'Target channel name or ID')
-    .option('-m, --message <message>', 'Message to send')
-    .option('-f, --file <file>', 'File containing message content')
-    .option('-t, --thread <thread>', 'Thread timestamp to reply to')
-    .option('--at <time>', 'Schedule time (Unix timestamp in seconds or ISO 8601)')
-    .option('--after <minutes>', 'Schedule message after N minutes')
-    .option('--profile <profile>', 'Use specific workspace profile')
-    .hook(
-      'preAction',
-      createValidationHook([
-        optionValidators.messageOrFile,
-        optionValidators.threadTimestamp,
-        optionValidators.scheduleTiming,
-      ])
-    )
-    .action(
-      wrapCommand(async (options: SendOptions) => {
-        // Get message content
-        let messageContent: string;
-        if (options.file) {
-          try {
-            messageContent = await fs.readFile(options.file, 'utf-8');
-          } catch (error) {
-            throw new FileError(
-              ERROR_MESSAGES.FILE_READ_ERROR(options.file, extractErrorMessage(error))
-            );
-          }
-        } else {
-          messageContent = options.message!; // This is safe because of preAction validation
-        }
-
-        const postAt = resolvePostAt(options.at, options.after);
-
-        // Send message
-        const profile = parseProfile(options.profile);
-        const client = await createSlackClient(profile);
-
-        if (postAt !== null) {
-          await client.scheduleMessage(options.channel, messageContent, postAt, options.thread);
-          const postAtIso = new Date(postAt * 1000).toISOString();
-          console.log(
-            chalk.green(`✓ ${SUCCESS_MESSAGES.MESSAGE_SCHEDULED(options.channel, postAtIso)}`)
-          );
-          return;
-        }
-
-        await client.sendMessage(options.channel, messageContent, options.thread);
-        console.log(chalk.green(`✓ ${SUCCESS_MESSAGES.MESSAGE_SENT(options.channel)}`));
-      })
-    );
-
-  return sendCommand;
-}

package/src/commands/unread.ts

@@ -1,122 +0,0 @@
-import { Command } from 'commander';
-import { wrapCommand } from '../utils/command-wrapper';
-import { createSlackClient } from '../utils/client-factory';
-import { SlackApiClient, ChannelUnreadResult, Channel } from '../utils/slack-api-client';
-import { UnreadOptions } from '../types/commands';
-import chalk from 'chalk';
-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 fetchChannelUnreadData(client: SlackApiClient, channelName: string) {
-  return await client.getChannelUnread(channelName);
-}
-
-function formatChannelUnreadOutput(
-  result: ChannelUnreadResult,
-  format: string,
-  countOnly: boolean
-): void {
-  const formatter = createMessageFormatter(format);
-  formatter.format({
-    channel: result.channel,
-    messages: result.messages,
-    users: result.users,
-    countOnly: countOnly,
-    format: format,
-  });
-}
-
-async function markChannelAsRead(client: SlackApiClient, channel: Channel): Promise<void> {
-  await client.markAsRead(channel.id);
-  console.log(chalk.green(`✓ Marked messages in #${channel.name} as read`));
-}
-
-async function handleSpecificChannelUnread(
-  client: SlackApiClient,
-  options: UnreadOptions
-): Promise<void> {
-  const result = await fetchChannelUnreadData(client, options.channel!);
-
-  const format = parseFormat(options.format);
-  const countOnly = parseBoolean(options.countOnly);
-
-  formatChannelUnreadOutput(result, format, countOnly);
-
-  if (parseBoolean(options.markRead)) {
-    await markChannelAsRead(client, result.channel);
-  }
-}
-
-async function fetchAllUnreadChannels(client: SlackApiClient) {
-  return await client.listUnreadChannels();
-}
-
-function formatAllChannelsOutput(
-  channels: Channel[],
-  format: string,
-  countOnly: boolean,
-  limit: number
-): void {
-  const displayChannels = channels.slice(0, limit);
-  const formatter = createChannelFormatter(format, countOnly);
-  formatter.format({ channels: displayChannels, countOnly: countOnly });
-}
-
-async function markAllChannelsAsRead(client: SlackApiClient, channels: Channel[]): Promise<void> {
-  for (const channel of channels) {
-    await client.markAsRead(channel.id);
-  }
-  console.log(chalk.green('✓ Marked all messages as read'));
-}
-
-async function handleAllChannelsUnread(
-  client: SlackApiClient,
-  options: UnreadOptions
-): Promise<void> {
-  const channels = await fetchAllUnreadChannels(client);
-
-  if (channels.length === 0) {
-    console.log(chalk.green('✓ No unread messages'));
-    return;
-  }
-
-  const limit = parseLimit(options.limit, DEFAULTS.UNREAD_DISPLAY_LIMIT);
-  const format = parseFormat(options.format);
-  const countOnly = parseBoolean(options.countOnly);
-
-  formatAllChannelsOutput(channels, format, countOnly, limit);
-
-  if (parseBoolean(options.markRead)) {
-    await markAllChannelsAsRead(client, channels);
-  }
-}
-
-export function setupUnreadCommand(): Command {
-  const unreadCommand = new Command('unread')
-    .description('Show unread messages across channels')
-    .option('-c, --channel <channel>', 'Show unread for a specific channel')
-    .option('--format <format>', 'Output format: table, simple, json', 'table')
-    .option('--count-only', 'Show only unread counts', false)
-    .option(
-      '--limit <number>',
-      'Maximum number of channels to display',
-      DEFAULTS.UNREAD_DISPLAY_LIMIT.toString()
-    )
-    .option('--mark-read', 'Mark messages as read after fetching', false)
-    .option('--profile <profile>', 'Use specific workspace profile')
-    .action(
-      wrapCommand(async (options: UnreadOptions) => {
-        const client = await createSlackClient(options.profile);
-
-        if (options.channel) {
-          await handleSpecificChannelUnread(client, options);
-        } else {
-          await handleAllChannelsUnread(client, options);
-        }
-      })
-    );
-
-  return unreadCommand;
-}

package/src/index.ts

@@ -1,27 +0,0 @@
-#!/usr/bin/env node
-import { Command } from 'commander';
-import { setupConfigCommand } from './commands/config';
-import { setupSendCommand } from './commands/send';
-import { setupChannelsCommand } from './commands/channels';
-import { setupHistoryCommand } from './commands/history';
-import { setupUnreadCommand } from './commands/unread';
-import { setupScheduledCommand } from './commands/scheduled';
-import { readFileSync } from 'fs';
-import { join } from 'path';
-
-const program = new Command();
-
-// Read version from package.json
-const packageJson = JSON.parse(readFileSync(join(__dirname, '..', 'package.json'), 'utf-8'));
-const version = packageJson.version;
-
-program.name('slack-cli').description('CLI tool to send messages via Slack API').version(version);
-
-program.addCommand(setupConfigCommand());
-program.addCommand(setupSendCommand());
-program.addCommand(setupChannelsCommand());
-program.addCommand(setupHistoryCommand());
-program.addCommand(setupUnreadCommand());
-program.addCommand(setupScheduledCommand());
-
-program.parse();

package/src/types/commands.ts

@@ -1,58 +0,0 @@
-export interface ConfigSetOptions {
-  token: string;
-  profile?: string;
-}
-
-export interface ConfigGetOptions {
-  profile?: string;
-}
-
-export interface ConfigUseOptions {
-  profile: string;
-}
-
-export interface ConfigClearOptions {
-  profile?: string;
-}
-
-export interface SendOptions {
-  channel: string;
-  message?: string;
-  file?: string;
-  thread?: string;
-  at?: string;
-  after?: string;
-  profile?: string;
-}
-
-export interface ScheduledOptions {
-  channel?: string;
-  limit?: string;
-  format?: 'table' | 'simple' | 'json';
-  profile?: string;
-}
-
-export interface ChannelsOptions {
-  type: 'public' | 'private' | 'im' | 'mpim' | 'all';
-  includeArchived: boolean;
-  format: 'table' | 'simple' | 'json';
-  limit: string;
-  profile?: string;
-}
-
-export interface HistoryOptions {
-  channel: string;
-  number?: string;
-  since?: string;
-  format?: 'table' | 'simple' | 'json';
-  profile?: string;
-}
-
-export interface UnreadOptions {
-  channel?: string;
-  format?: 'table' | 'simple' | 'json';
-  countOnly?: boolean;
-  limit?: string;
-  markRead?: boolean;
-  profile?: string;
-}

package/src/types/config.ts

@@ -1,20 +0,0 @@
-export interface Config {
-  token: string;
-  updatedAt: string;
-}
-
-export interface Profile {
-  name: string;
-  config: Config;
-  isDefault?: boolean;
-}
-
-export interface ConfigStore {
-  profiles: Record<string, Config>;
-  defaultProfile?: string;
-}
-
-export interface ConfigOptions {
-  configDir?: string;
-  profile?: string;
-}