@urugus/slack-cli 0.1.0

package/dist/utils/slack-api-client.js

@@ -0,0 +1,132 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.slackApiClient = exports.SlackApiClient = void 0;
+const web_api_1 = require("@slack/web-api");
+class SlackApiClient {
+    constructor(token) {
+        this.client = new web_api_1.WebClient(token);
+    }
+    async sendMessage(channel, text) {
+        return await this.client.chat.postMessage({
+            channel,
+            text,
+        });
+    }
+    async listChannels(options) {
+        const response = await this.client.conversations.list({
+            types: options.types,
+            exclude_archived: options.exclude_archived,
+            limit: options.limit,
+        });
+        return response.channels;
+    }
+    async getHistory(channel, options) {
+        const response = await this.client.conversations.history({
+            channel,
+            limit: options.limit,
+            oldest: options.oldest,
+        });
+        const messages = response.messages;
+        // Get unique user IDs
+        const userIds = [...new Set(messages.filter((m) => m.user).map((m) => m.user))];
+        const users = new Map();
+        // Fetch user information
+        if (userIds.length > 0) {
+            for (const userId of userIds) {
+                try {
+                    const userInfo = await this.client.users.info({ user: userId });
+                    if (userInfo.user?.name) {
+                        users.set(userId, userInfo.user.name);
+                    }
+                }
+                catch (error) {
+                    // If we can't get user info, we'll use the ID
+                    users.set(userId, userId);
+                }
+            }
+        }
+        return { messages, users };
+    }
+    async listUnreadChannels() {
+        // Get all conversations the user is a member of
+        const response = await this.client.conversations.list({
+            types: 'public_channel,private_channel,im,mpim',
+            exclude_archived: true,
+            limit: 1000,
+        });
+        const channels = response.channels;
+        // Get unread count for each channel
+        const channelsWithUnread = await Promise.all(channels.map(async (channel) => {
+            try {
+                const info = await this.client.conversations.info({
+                    channel: channel.id,
+                    include_num_members: false,
+                });
+                const channelInfo = info.channel;
+                return {
+                    ...channel,
+                    unread_count: channelInfo.unread_count || 0,
+                    unread_count_display: channelInfo.unread_count_display || 0,
+                    last_read: channelInfo.last_read,
+                };
+            }
+            catch {
+                return channel;
+            }
+        }));
+        // Filter to only channels with unread messages
+        return channelsWithUnread.filter((channel) => (channel.unread_count_display || 0) > 0);
+    }
+    async getChannelUnread(channelNameOrId) {
+        // First, find the channel
+        let channelId = channelNameOrId;
+        if (!channelNameOrId.startsWith('C') &&
+            !channelNameOrId.startsWith('D') &&
+            !channelNameOrId.startsWith('G')) {
+            // It's a name, not an ID - need to find the ID
+            const channels = await this.listChannels({
+                types: 'public_channel,private_channel,im,mpim',
+                exclude_archived: true,
+                limit: 1000,
+            });
+            const channel = channels.find((c) => c.name === channelNameOrId || c.name === channelNameOrId.replace('#', ''));
+            if (!channel) {
+                throw new Error('channel_not_found');
+            }
+            channelId = channel.id;
+        }
+        // Get channel info with unread count
+        const info = await this.client.conversations.info({
+            channel: channelId,
+        });
+        const channel = info.channel;
+        // Get unread messages
+        let messages = [];
+        let users = new Map();
+        if (channel.last_read && channel.unread_count > 0) {
+            const historyResult = await this.getHistory(channelId, {
+                limit: channel.unread_count,
+                oldest: channel.last_read,
+            });
+            messages = historyResult.messages;
+            users = historyResult.users;
+        }
+        return {
+            channel: {
+                ...channel,
+                unread_count: channel.unread_count || 0,
+                unread_count_display: channel.unread_count_display || 0,
+            },
+            messages,
+            users,
+        };
+    }
+}
+exports.SlackApiClient = SlackApiClient;
+exports.slackApiClient = {
+    listChannels: async (token, options) => {
+        const client = new SlackApiClient(token);
+        return client.listChannels(options);
+    },
+};
+//# sourceMappingURL=slack-api-client.js.map

package/dist/utils/slack-api-client.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"slack-api-client.js","sourceRoot":"","sources":["../../src/utils/slack-api-client.ts"],"names":[],"mappings":";;;AAAA,4CAAoE;AAoEpE,MAAa,cAAc;IAGzB,YAAY,KAAa;QACvB,IAAI,CAAC,MAAM,GAAG,IAAI,mBAAS,CAAC,KAAK,CAAC,CAAC;IACrC,CAAC;IAED,KAAK,CAAC,WAAW,CAAC,OAAe,EAAE,IAAY;QAC7C,OAAO,MAAM,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC;YACxC,OAAO;YACP,IAAI;SACL,CAAC,CAAC;IACL,CAAC;IAED,KAAK,CAAC,YAAY,CAAC,OAA4B;QAC7C,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,IAAI,CAAC;YACpD,KAAK,EAAE,OAAO,CAAC,KAAK;YACpB,gBAAgB,EAAE,OAAO,CAAC,gBAAgB;YAC1C,KAAK,EAAE,OAAO,CAAC,KAAK;SACrB,CAAC,CAAC;QAEH,OAAO,QAAQ,CAAC,QAAqB,CAAC;IACxC,CAAC;IAED,KAAK,CAAC,UAAU,CAAC,OAAe,EAAE,OAAuB;QACvD,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,OAAO,CAAC;YACvD,OAAO;YACP,KAAK,EAAE,OAAO,CAAC,KAAK;YACpB,MAAM,EAAE,OAAO,CAAC,MAAM;SACvB,CAAC,CAAC;QAEH,MAAM,QAAQ,GAAG,QAAQ,CAAC,QAAqB,CAAC;QAEhD,sBAAsB;QACtB,MAAM,OAAO,GAAG,CAAC,GAAG,IAAI,GAAG,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAK,CAAC,CAAC,CAAC,CAAC;QACjF,MAAM,KAAK,GAAG,IAAI,GAAG,EAAkB,CAAC;QAExC,yBAAyB;QACzB,IAAI,OAAO,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YACvB,KAAK,MAAM,MAAM,IAAI,OAAO,EAAE,CAAC;gBAC7B,IAAI,CAAC;oBACH,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC,CAAC;oBAChE,IAAI,QAAQ,CAAC,IAAI,EAAE,IAAI,EAAE,CAAC;wBACxB,KAAK,CAAC,GAAG,CAAC,MAAM,EAAE,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;oBACxC,CAAC;gBACH,CAAC;gBAAC,OAAO,KAAK,EAAE,CAAC;oBACf,8CAA8C;oBAC9C,KAAK,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;gBAC5B,CAAC;YACH,CAAC;QACH,CAAC;QAED,OAAO,EAAE,QAAQ,EAAE,KAAK,EAAE,CAAC;IAC7B,CAAC;IAED,KAAK,CAAC,kBAAkB;QACtB,gDAAgD;QAChD,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,IAAI,CAAC;YACpD,KAAK,EAAE,wCAAwC;YAC/C,gBAAgB,EAAE,IAAI;YACtB,KAAK,EAAE,IAAI;SACZ,CAAC,CAAC;QAEH,MAAM,QAAQ,GAAG,QAAQ,CAAC,QAAqB,CAAC;QAEhD,oCAAoC;QACpC,MAAM,kBAAkB,GAAG,MAAM,OAAO,CAAC,GAAG,CAC1C,QAAQ,CAAC,GAAG,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE;YAC7B,IAAI,CAAC;gBACH,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,IAAI,CAAC;oBAChD,OAAO,EAAE,OAAO,CAAC,EAAE;oBACnB,mBAAmB,EAAE,KAAK;iBAC3B,CAAC,CAAC;gBACH,MAAM,WAAW,GAAG,IAAI,CAAC,OAAc,CAAC;gBACxC,OAAO;oBACL,GAAG,OAAO;oBACV,YAAY,EAAE,WAAW,CAAC,YAAY,IAAI,CAAC;oBAC3C,oBAAoB,EAAE,WAAW,CAAC,oBAAoB,IAAI,CAAC;oBAC3D,SAAS,EAAE,WAAW,CAAC,SAAS;iBACjC,CAAC;YACJ,CAAC;YAAC,MAAM,CAAC;gBACP,OAAO,OAAO,CAAC;YACjB,CAAC;QACH,CAAC,CAAC,CACH,CAAC;QAEF,+CAA+C;QAC/C,OAAO,kBAAkB,CAAC,MAAM,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC,OAAO,CAAC,oBAAoB,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;IACzF,CAAC;IAED,KAAK,CAAC,gBAAgB,CAAC,eAAuB;QAC5C,0BAA0B;QAC1B,IAAI,SAAS,GAAG,eAAe,CAAC;QAChC,IACE,CAAC,eAAe,CAAC,UAAU,CAAC,GAAG,CAAC;YAChC,CAAC,eAAe,CAAC,UAAU,CAAC,GAAG,CAAC;YAChC,CAAC,eAAe,CAAC,UAAU,CAAC,GAAG,CAAC,EAChC,CAAC;YACD,+CAA+C;YAC/C,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,YAAY,CAAC;gBACvC,KAAK,EAAE,wCAAwC;gBAC/C,gBAAgB,EAAE,IAAI;gBACtB,KAAK,EAAE,IAAI;aACZ,CAAC,CAAC;YACH,MAAM,OAAO,GAAG,QAAQ,CAAC,IAAI,CAC3B,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,eAAe,IAAI,CAAC,CAAC,IAAI,KAAK,eAAe,CAAC,OAAO,CAAC,GAAG,EAAE,EAAE,CAAC,CACjF,CAAC;YACF,IAAI,CAAC,OAAO,EAAE,CAAC;gBACb,MAAM,IAAI,KAAK,CAAC,mBAAmB,CAAC,CAAC;YACvC,CAAC;YACD,SAAS,GAAG,OAAO,CAAC,EAAE,CAAC;QACzB,CAAC;QAED,qCAAqC;QACrC,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,IAAI,CAAC;YAChD,OAAO,EAAE,SAAS;SACnB,CAAC,CAAC;QACH,MAAM,OAAO,GAAG,IAAI,CAAC,OAAc,CAAC;QAEpC,sBAAsB;QACtB,IAAI,QAAQ,GAAc,EAAE,CAAC;QAC7B,IAAI,KAAK,GAAG,IAAI,GAAG,EAAkB,CAAC;QAEtC,IAAI,OAAO,CAAC,SAAS,IAAI,OAAO,CAAC,YAAY,GAAG,CAAC,EAAE,CAAC;YAClD,MAAM,aAAa,GAAG,MAAM,IAAI,CAAC,UAAU,CAAC,SAAS,EAAE;gBACrD,KAAK,EAAE,OAAO,CAAC,YAAY;gBAC3B,MAAM,EAAE,OAAO,CAAC,SAAS;aAC1B,CAAC,CAAC;YACH,QAAQ,GAAG,aAAa,CAAC,QAAQ,CAAC;YAClC,KAAK,GAAG,aAAa,CAAC,KAAK,CAAC;QAC9B,CAAC;QAED,OAAO;YACL,OAAO,EAAE;gBACP,GAAG,OAAO;gBACV,YAAY,EAAE,OAAO,CAAC,YAAY,IAAI,CAAC;gBACvC,oBAAoB,EAAE,OAAO,CAAC,oBAAoB,IAAI,CAAC;aACxD;YACD,QAAQ;YACR,KAAK;SACN,CAAC;IACJ,CAAC;CACF;AA9ID,wCA8IC;AAEY,QAAA,cAAc,GAAG;IAC5B,YAAY,EAAE,KAAK,EAAE,KAAa,EAAE,OAA4B,EAAsB,EAAE;QACtF,MAAM,MAAM,GAAG,IAAI,cAAc,CAAC,KAAK,CAAC,CAAC;QACzC,OAAO,MAAM,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC;IACtC,CAAC;CACF,CAAC"}

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@urugus/slack-cli",
+  "version": "0.1.0",
+  "description": "A command-line tool for sending messages to Slack",
+  "main": "dist/index.js",
+  "bin": {
+    "slack-cli": "./dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "ts-node src/index.ts",
+    "start": "node dist/index.js",
+    "test": "vitest",
+    "test:watch": "vitest --watch",
+    "test:coverage": "vitest --coverage",
+    "lint": "eslint src/**/*.ts",
+    "format": "prettier --write \"src/**/*.{ts,tsx,js,jsx,json,md}\"",
+    "format:check": "prettier --check \"src/**/*.{ts,tsx,js,jsx,json,md}\"",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "slack",
+    "cli",
+    "command-line",
+    "messaging",
+    "api"
+  ],
+  "author": "urugus",
+  "publishConfig": {
+    "access": "public"
+  },
+  "license": "MIT",
+  "dependencies": {
+    "@slack/web-api": "^6.9.0",
+    "commander": "^11.1.0",
+    "dotenv": "^16.3.1",
+    "chalk": "^4.1.2",
+    "inquirer": "^8.2.6"
+  },
+  "devDependencies": {
+    "@types/node": "^20.10.0",
+    "@types/inquirer": "^8.2.10",
+    "@typescript-eslint/eslint-plugin": "^6.13.0",
+    "@typescript-eslint/parser": "^6.13.0",
+    "@vitest/coverage-v8": "^1.0.4",
+    "eslint": "^8.55.0",
+    "eslint-config-prettier": "^9.1.0",
+    "prettier": "^3.1.1",
+    "ts-node": "^10.9.1",
+    "typescript": "^5.3.2",
+    "vitest": "^1.0.4"
+  },
+  "engines": {
+    "node": ">=16.0.0"
+  }
+}

package/src/commands/channels.ts

@@ -0,0 +1,65 @@
+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,
+  formatChannelsAsTable,
+  formatChannelsAsSimple,
+  formatChannelsAsJson,
+  getChannelTypes,
+} from '../utils/channel-formatter';
+
+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 channels = await client.listChannels({
+          types,
+          exclude_archived: !options.includeArchived,
+          limit: parseInt(options.limit, 10),
+        });
+
+        if (channels.length === 0) {
+          console.log(ERROR_MESSAGES.NO_CHANNELS_FOUND);
+          return;
+        }
+
+        // Format and display channels
+        const channelInfos = channels.map(mapChannelToInfo);
+
+        switch (options.format) {
+          case 'simple':
+            formatChannelsAsSimple(channelInfos);
+            break;
+
+          case 'json':
+            formatChannelsAsJson(channelInfos);
+            break;
+
+          case 'table':
+          default:
+            formatChannelsAsTable(channelInfos);
+            break;
+        }
+      })
+    );
+
+  return channelsCommand;
+}

package/src/commands/config.ts

@@ -0,0 +1,104 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { ProfileConfigManager } from '../utils/profile-config';
+import { wrapCommand, getProfileName } from '../utils/command-wrapper';
+import { ERROR_MESSAGES, SUCCESS_MESSAGES } from '../utils/constants';
+
+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(async (options) => {
+        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)}`));
+      })
+    );
+
+  config
+    .command('get')
+    .description('Show current configuration')
+    .option('--profile <profile>', 'Profile name')
+    .action(
+      wrapCommand(async (options) => {
+        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)}`);
+      })
+    );
+
+  config
+    .command('profiles')
+    .description('List all profiles')
+    .action(
+      wrapCommand(async () => {
+        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})`);
+        });
+      })
+    );
+
+  config
+    .command('use <profile>')
+    .description('Switch to a different profile')
+    .action(
+      wrapCommand(async (profile) => {
+        const configManager = new ProfileConfigManager();
+        await configManager.useProfile(profile);
+        console.log(chalk.green(`✓ ${SUCCESS_MESSAGES.PROFILE_SWITCHED(profile)}`));
+      })
+    );
+
+  config
+    .command('current')
+    .description('Show current active profile')
+    .action(
+      wrapCommand(async () => {
+        const configManager = new ProfileConfigManager();
+        const currentProfile = await configManager.getCurrentProfile();
+        console.log(chalk.bold(`Current profile: ${chalk.cyan(currentProfile)}`));
+      })
+    );
+
+  config
+    .command('clear')
+    .description('Clear configuration')
+    .option('--profile <profile>', 'Profile name')
+    .action(
+      wrapCommand(async (options) => {
+        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)}`));
+      })
+    );
+
+  return config;
+}

package/src/commands/history.ts

@@ -0,0 +1,96 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { HistoryOptions as ApiHistoryOptions, Message } from '../utils/slack-api-client';
+import { wrapCommand } from '../utils/command-wrapper';
+import { createSlackClient } from '../utils/client-factory';
+import { HistoryOptions } from '../types/commands';
+import { formatSlackTimestamp } from '../utils/date-utils';
+import { API_LIMITS } from '../utils/constants';
+
+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('--profile <profile>', 'Use specific workspace profile')
+    .hook('preAction', (thisCommand) => {
+      const options = thisCommand.opts();
+
+      // Validate number option
+      if (options.number) {
+        const num = parseInt(options.number, 10);
+        if (
+          isNaN(num) ||
+          num < API_LIMITS.MIN_MESSAGE_COUNT ||
+          num > API_LIMITS.MAX_MESSAGE_COUNT
+        ) {
+          thisCommand.error(
+            `Error: Message count must be between ${API_LIMITS.MIN_MESSAGE_COUNT} and ${API_LIMITS.MAX_MESSAGE_COUNT}`
+          );
+        }
+      }
+
+      // Validate since option
+      if (options.since) {
+        const timestamp = Date.parse(options.since);
+        if (isNaN(timestamp)) {
+          thisCommand.error('Error: Invalid date format. Use YYYY-MM-DD HH:MM:SS');
+        }
+      }
+    })
+    .action(
+      wrapCommand(async (options: HistoryOptions) => {
+        // Create Slack client
+        const client = await createSlackClient(options.profile);
+
+        // Prepare API options
+        const historyOptions: ApiHistoryOptions = {
+          limit: parseInt(options.number || API_LIMITS.DEFAULT_MESSAGE_COUNT.toString(), 10),
+        };
+
+        if (options.since) {
+          // Convert date to Unix timestamp (in seconds)
+          const timestamp = Math.floor(Date.parse(options.since) / 1000);
+          historyOptions.oldest = timestamp.toString();
+        }
+
+        // Get message history
+        const { messages, users } = await client.getHistory(options.channel, historyOptions);
+
+        // Display results
+        if (messages.length === 0) {
+          console.log(chalk.yellow('No messages found in the specified channel.'));
+          return;
+        }
+
+        console.log(chalk.bold(`\nMessage History for #${options.channel}:\n`));
+
+        // Display messages in reverse order (oldest first)
+        messages.reverse().forEach((message: Message) => {
+          const timestamp = formatSlackTimestamp(message.ts);
+          let author = 'Unknown';
+
+          if (message.user && users.has(message.user)) {
+            author = users.get(message.user)!;
+          } else if (message.bot_id) {
+            author = 'Bot';
+          }
+
+          console.log(chalk.gray(`[${timestamp}]`) + ' ' + chalk.cyan(author));
+          if (message.text) {
+            console.log(message.text);
+          }
+          console.log(''); // Empty line between messages
+        });
+
+        console.log(chalk.green(`✓ Displayed ${messages.length} message(s)`));
+      })
+    );
+
+  return historyCommand;
+}

package/src/commands/send.ts

@@ -0,0 +1,52 @@
+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 * as fs from 'fs/promises';
+
+export function setupSendCommand(): Command {
+  const sendCommand = new Command('send')
+    .description('Send 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('--profile <profile>', 'Use specific workspace profile')
+    .hook('preAction', (thisCommand) => {
+      const options = thisCommand.opts();
+      if (!options.message && !options.file) {
+        thisCommand.error(`Error: ${ERROR_MESSAGES.NO_MESSAGE_OR_FILE}`);
+      }
+      if (options.message && options.file) {
+        thisCommand.error(`Error: ${ERROR_MESSAGES.BOTH_MESSAGE_AND_FILE}`);
+      }
+    })
+    .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
+        }
+
+        // Send message
+        const client = await createSlackClient(options.profile);
+        await client.sendMessage(options.channel, messageContent);
+
+        console.log(chalk.green(`✓ ${SUCCESS_MESSAGES.MESSAGE_SENT(options.channel)}`));
+      })
+    );
+
+  return sendCommand;
+}

package/src/commands/unread.ts

@@ -0,0 +1,118 @@
+import { Command } from 'commander';
+import { wrapCommand } from '../utils/command-wrapper';
+import { createSlackClient } from '../utils/client-factory';
+import { SlackApiClient, Channel } 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';
+
+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`));
+
+  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('');
+    });
+  }
+}
+
+async function handleAllChannelsUnread(
+  client: SlackApiClient,
+  options: UnreadOptions
+): Promise<void> {
+  const channels = await client.listUnreadChannels();
+
+  if (channels.length === 0) {
+    console.log(chalk.green('✓ No unread messages'));
+    return;
+  }
+
+  // Apply limit
+  const limit = parseInt(options.limit || '50', 10);
+  const displayChannels = channels.slice(0, limit);
+
+  if (options.countOnly) {
+    displayCountOnly(displayChannels);
+  } else if (options.format === 'json') {
+    displayAsJson(displayChannels);
+  } else if (options.format === 'simple') {
+    displayAsSimple(displayChannels);
+  } else {
+    displayAsTable(displayChannels);
+  }
+}
+
+function displayCountOnly(channels: Channel[]): 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`));
+}
+
+function displayAsJson(channels: Channel[]): void {
+  const output = channels.map((channel) => ({
+    channel: formatChannelName(channel.name),
+    channelId: channel.id,
+    unreadCount: channel.unread_count || 0,
+  }));
+  console.log(JSON.stringify(output, null, 2));
+}
+
+function displayAsSimple(channels: Channel[]): void {
+  channels.forEach((channel) => {
+    const channelName = formatChannelName(channel.name);
+    console.log(`${channelName} (${channel.unread_count || 0})`);
+  });
+}
+
+function displayAsTable(channels: Channel[]): 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}`);
+  });
+}
+
+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', '50')
+    .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

@@ -0,0 +1,19 @@
+#!/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';
+
+const program = new Command();
+
+program.name('slack-cli').description('CLI tool to send messages via Slack API').version('1.0.0');
+
+program.addCommand(setupConfigCommand());
+program.addCommand(setupSendCommand());
+program.addCommand(setupChannelsCommand());
+program.addCommand(setupHistoryCommand());
+program.addCommand(setupUnreadCommand());
+
+program.parse();