@urugus/slack-cli 0.2.8 → 0.2.10

package/eslint.config.js

@@ -0,0 +1,38 @@
+import eslint from '@eslint/js';
+import tseslint from 'typescript-eslint';
+import prettierConfig from 'eslint-config-prettier';
+
+export default [
+  {
+    ignores: ['dist/**', 'node_modules/**', 'coverage/**', 'vitest.config.ts']
+  },
+  eslint.configs.recommended,
+  ...tseslint.configs.recommended,
+  prettierConfig,
+  {
+    languageOptions: {
+      ecmaVersion: 2020,
+      sourceType: 'module',
+      parserOptions: {
+        project: './tsconfig.json'
+      },
+      globals: {
+        console: 'readonly',
+        process: 'readonly',
+        Buffer: 'readonly',
+        __dirname: 'readonly',
+        __filename: 'readonly',
+        exports: 'readonly',
+        module: 'readonly',
+        require: 'readonly',
+        global: 'readonly'
+      }
+    },
+    rules: {
+      '@typescript-eslint/explicit-function-return-type': 'off',
+      '@typescript-eslint/no-explicit-any': 'warn',
+      '@typescript-eslint/no-unused-vars': ['error', { argsIgnorePattern: '^_' }],
+      'no-console': 'off'
+    }
+  }
+];

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@urugus/slack-cli",
-  "version": "0.2.8",
+  "version": "0.2.10",
   "description": "A command-line tool for sending messages to Slack",
   "main": "dist/index.js",
   "bin": {
-    "slack-cli": "./dist/index.js"
+    "slack-cli": "dist/index.js"
   },
   "scripts": {
     "build": "tsc",
@@ -31,27 +31,25 @@
   },
   "license": "MIT",
   "dependencies": {
-    "@slack/web-api": "^6.9.0",
-    "chalk": "^4.1.2",
-    "commander": "^11.1.0",
-    "dotenv": "^16.3.1",
-    "inquirer": "^8.2.6",
+    "@slack/web-api": "^7.9.3",
+    "chalk": "^5.4.1",
+    "commander": "^14.0.0",
     "p-limit": "^3.1.0"
   },
   "devDependencies": {
-    "@types/inquirer": "^8.2.10",
     "@types/node": "^20.10.0",
-    "@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",
+    "@typescript-eslint/eslint-plugin": "^8.34.1",
+    "@typescript-eslint/parser": "^8.34.1",
+    "@vitest/coverage-v8": "^3.2.4",
+    "eslint": "^9.30.0",
+    "eslint-config-prettier": "^10.1.5",
     "prettier": "^3.1.1",
     "ts-node": "^10.9.1",
     "typescript": "^5.3.2",
-    "vitest": "^1.0.4"
+    "typescript-eslint": "^8.35.0",
+    "vitest": "^3.2.4"
   },
   "engines": {
-    "node": ">=16.0.0"
+    "node": ">=20.0.0"
   }
 }

package/src/commands/send.ts

@@ -8,19 +8,26 @@ 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 a message to a Slack channel')
+    .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])
+      createValidationHook([
+        optionValidators.messageOrFile,
+        optionValidators.threadTimestamp,
+        optionValidators.scheduleTiming,
+      ])
     )
     .action(
       wrapCommand(async (options: SendOptions) => {
@@ -38,11 +45,22 @@ export function setupSendCommand(): Command {
           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);
-        await client.sendMessage(options.channel, messageContent, options.thread);
 
+        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)}`));
       })
     );

package/src/commands/unread.ts

@@ -1,7 +1,7 @@
 import { Command } from 'commander';
 import { wrapCommand } from '../utils/command-wrapper';
 import { createSlackClient } from '../utils/client-factory';
-import { SlackApiClient } from '../utils/slack-api-client';
+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';
@@ -9,15 +9,15 @@ 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 format = parseFormat(options.format);
-  const countOnly = parseBoolean(options.countOnly);
+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,
@@ -26,40 +26,70 @@ async function handleSpecificChannelUnread(
     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 client.markAsRead(result.channel.id);
-    console.log(chalk.green(`✓ Marked messages in #${result.channel.name} as read`));
+    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 client.listUnreadChannels();
+  const channels = await fetchAllUnreadChannels(client);
 
   if (channels.length === 0) {
     console.log(chalk.green('✓ No unread messages'));
     return;
   }
 
-  // Apply limit
   const limit = parseLimit(options.limit, DEFAULTS.UNREAD_DISPLAY_LIMIT);
-  const displayChannels = channels.slice(0, limit);
-
   const format = parseFormat(options.format);
   const countOnly = parseBoolean(options.countOnly);
 
-  const formatter = createChannelFormatter(format, countOnly);
-  formatter.format({ channels: displayChannels, countOnly: countOnly });
+  formatAllChannelsOutput(channels, format, countOnly, limit);
 
   if (parseBoolean(options.markRead)) {
-    // Mark all unread channels as read
-    for (const channel of channels) {
-      await client.markAsRead(channel.id);
-    }
-    console.log(chalk.green('✓ Marked all messages as read'));
+    await markAllChannelsAsRead(client, channels);
   }
 }
 

package/src/types/commands.ts

@@ -20,6 +20,8 @@ export interface SendOptions {
   message?: string;
   file?: string;
   thread?: string;
+  at?: string;
+  after?: string;
   profile?: string;
 }
 

package/src/utils/constants.ts

@@ -14,6 +14,11 @@ export const ERROR_MESSAGES = {
   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}`,
@@ -33,6 +38,8 @@ export const SUCCESS_MESSAGES = {
   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

package/src/utils/errors.ts

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

package/src/utils/schedule-utils.ts

@@ -0,0 +1,41 @@
+export function parseScheduledTimestamp(value: string): number | null {
+  const trimmed = value.trim();
+
+  if (/^\d+$/.test(trimmed)) {
+    const timestamp = Number.parseInt(trimmed, 10);
+    return Number.isSafeInteger(timestamp) ? timestamp : null;
+  }
+
+  const parsedMs = Date.parse(trimmed);
+  if (Number.isNaN(parsedMs)) {
+    return null;
+  }
+
+  return Math.floor(parsedMs / 1000);
+}
+
+export function resolvePostAt(
+  at: string | undefined,
+  afterMinutes: string | undefined,
+  nowMs = Date.now()
+): number | null {
+  if (at) {
+    return parseScheduledTimestamp(at);
+  }
+
+  if (!afterMinutes) {
+    return null;
+  }
+
+  const trimmedAfter = afterMinutes.trim();
+  if (!/^\d+$/.test(trimmedAfter)) {
+    return null;
+  }
+
+  const minutes = Number.parseInt(trimmedAfter, 10);
+  if (!Number.isSafeInteger(minutes) || minutes <= 0) {
+    return null;
+  }
+
+  return Math.floor(nowMs / 1000) + minutes * 60;
+}

package/src/utils/slack-api-client.ts

@@ -1,4 +1,4 @@
-import { ChatPostMessageResponse } from '@slack/web-api';
+import { ChatPostMessageResponse, ChatScheduleMessageResponse } from '@slack/web-api';
 import { ChannelOperations } from './slack-operations/channel-operations';
 import { MessageOperations } from './slack-operations/message-operations';
 
@@ -85,6 +85,15 @@ export class SlackApiClient {
     return this.messageOps.sendMessage(channel, text, thread_ts);
   }
 
+  async scheduleMessage(
+    channel: string,
+    text: string,
+    post_at: number,
+    thread_ts?: string
+  ): Promise<ChatScheduleMessageResponse> {
+    return this.messageOps.scheduleMessage(channel, text, post_at, thread_ts);
+  }
+
   async listChannels(options: ListChannelsOptions): Promise<Channel[]> {
     return this.channelOps.listChannels(options);
   }

package/src/utils/slack-operations/message-operations.ts

@@ -1,4 +1,9 @@
-import { ChatPostMessageResponse, ChatPostMessageArguments } from '@slack/web-api';
+import {
+  ChatPostMessageResponse,
+  ChatPostMessageArguments,
+  ChatScheduleMessageArguments,
+  ChatScheduleMessageResponse,
+} from '@slack/web-api';
 import { BaseSlackClient } from './base-client';
 import { channelResolver } from '../channel-resolver';
 import { DEFAULTS } from '../constants';
@@ -31,6 +36,25 @@ export class MessageOperations extends BaseSlackClient {
     return await this.client.chat.postMessage(params);
   }
 
+  async scheduleMessage(
+    channel: string,
+    text: string,
+    post_at: number,
+    thread_ts?: string
+  ): Promise<ChatScheduleMessageResponse> {
+    const params: ChatScheduleMessageArguments = {
+      channel,
+      text,
+      post_at,
+    };
+
+    if (thread_ts) {
+      params.thread_ts = thread_ts;
+    }
+
+    return await this.client.chat.scheduleMessage(params);
+  }
+
   async getHistory(channel: string, options: HistoryOptions): Promise<HistoryResult> {
     // Resolve channel name to ID if needed
     const channelId = await channelResolver.resolveChannelId(channel, () =>

package/src/utils/validators.ts

@@ -1,5 +1,6 @@
 import { Command } from 'commander';
 import { ERROR_MESSAGES } from './constants';
+import { parseScheduledTimestamp } from './schedule-utils';
 
 /**
  * Common validation functions for CLI commands
@@ -164,6 +165,43 @@ export const optionValidators = {
     return null;
   },
 
+  /**
+   * Validates schedule options for send command
+   */
+  scheduleTiming: (options: Record<string, unknown>): string | null => {
+    const at = options.at as string | undefined;
+    const after = options.after as string | undefined;
+
+    if (at && after) {
+      return ERROR_MESSAGES.BOTH_SCHEDULE_OPTIONS;
+    }
+
+    if (at) {
+      const postAt = parseScheduledTimestamp(at);
+      if (postAt === null) {
+        return ERROR_MESSAGES.INVALID_SCHEDULE_AT;
+      }
+
+      if (postAt <= Math.floor(Date.now() / 1000)) {
+        return ERROR_MESSAGES.SCHEDULE_TIME_IN_PAST;
+      }
+    }
+
+    if (after) {
+      const trimmedAfter = after.trim();
+      if (!/^\d+$/.test(trimmedAfter)) {
+        return ERROR_MESSAGES.INVALID_SCHEDULE_AFTER;
+      }
+
+      const minutes = Number.parseInt(trimmedAfter, 10);
+      if (!Number.isSafeInteger(minutes) || minutes <= 0) {
+        return ERROR_MESSAGES.INVALID_SCHEDULE_AFTER;
+      }
+    }
+
+    return null;
+  },
+
   /**
    * Validates message count for history command
    */