@urugus/slack-cli 0.2.9 → 0.2.11

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/index.ts

@@ -5,6 +5,7 @@ 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';
 
@@ -21,5 +22,6 @@ program.addCommand(setupSendCommand());
 program.addCommand(setupChannelsCommand());
 program.addCommand(setupHistoryCommand());
 program.addCommand(setupUnreadCommand());
+program.addCommand(setupScheduledCommand());
 
 program.parse();

package/src/types/commands.ts

@@ -20,6 +20,15 @@ export interface SendOptions {
   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;
 }
 

package/src/utils/channel-resolver.ts

@@ -7,11 +7,7 @@ export class ChannelResolver {
    * Check if the given string is a channel ID
    */
   isChannelId(channelNameOrId: string): boolean {
-    return (
-      channelNameOrId.startsWith('C') ||
-      channelNameOrId.startsWith('D') ||
-      channelNameOrId.startsWith('G')
-    );
+    return /^[CDG][A-Z0-9]{8,}$/.test(channelNameOrId);
   }
 
   /**

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/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';
 
@@ -57,6 +57,14 @@ export interface Message {
   blocks?: unknown[];
 }
 
+export interface ScheduledMessage {
+  id: string;
+  channel_id: string;
+  post_at: number;
+  date_created: number;
+  text?: string;
+}
+
 export interface HistoryResult {
   messages: Message[];
   users: Map<string, string>;
@@ -85,6 +93,19 @@ 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 listScheduledMessages(channel?: string, limit = 50): Promise<ScheduledMessage[]> {
+    return this.messageOps.listScheduledMessages(channel, limit);
+  }
+
   async listChannels(options: ListChannelsOptions): Promise<Channel[]> {
     return this.channelOps.listChannels(options);
   }

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

@@ -1,8 +1,19 @@
-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';
-import { Message, HistoryOptions, HistoryResult, ChannelUnreadResult } from '../slack-api-client';
+import {
+  Message,
+  HistoryOptions,
+  HistoryResult,
+  ChannelUnreadResult,
+  ScheduledMessage,
+} from '../slack-api-client';
 import { ChannelOperations } from './channel-operations';
 import { extractAllUserIds } from '../mention-utils';
 
@@ -31,6 +42,48 @@ 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 listScheduledMessages(channel?: string, limit = 50): Promise<ScheduledMessage[]> {
+    const channelId = channel
+      ? await channelResolver.resolveChannelId(channel, () =>
+          this.channelOps.listChannels({
+            types: 'public_channel,private_channel,im,mpim',
+            exclude_archived: true,
+            limit: DEFAULTS.CHANNELS_LIMIT,
+          })
+        )
+      : undefined;
+
+    const params: { channel?: string; limit: number } = {
+      limit,
+    };
+
+    if (channelId) {
+      params.channel = channelId;
+    }
+
+    const response = await this.client.chat.scheduledMessages.list(params as any);
+    return (response.scheduled_messages || []) as ScheduledMessage[];
+  }
+
   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
    */

package/tests/commands/scheduled.test.ts

@@ -0,0 +1,131 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { setupScheduledCommand } from '../../src/commands/scheduled';
+import { SlackApiClient } from '../../src/utils/slack-api-client';
+import { ProfileConfigManager } from '../../src/utils/profile-config';
+import { setupMockConsole, createTestProgram, restoreMocks } from '../test-utils';
+
+vi.mock('../../src/utils/slack-api-client');
+vi.mock('../../src/utils/profile-config');
+
+describe('scheduled command', () => {
+  let program: any;
+  let mockSlackClient: SlackApiClient;
+  let mockConfigManager: ProfileConfigManager;
+  let mockConsole: any;
+  let tableSpy: any;
+
+  const mockScheduledMessages = [
+    {
+      id: 'Q123',
+      channel_id: 'C1234567890',
+      post_at: 1770855000,
+      date_created: 1770854400,
+      text: 'Scheduled message 1',
+    },
+    {
+      id: 'Q456',
+      channel_id: 'C0987654321',
+      post_at: 1770858600,
+      date_created: 1770854400,
+      text: 'Scheduled message 2',
+    },
+  ];
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+
+    mockConfigManager = new ProfileConfigManager();
+    vi.mocked(ProfileConfigManager).mockReturnValue(mockConfigManager);
+
+    mockSlackClient = new SlackApiClient('test-token');
+    vi.mocked(SlackApiClient).mockReturnValue(mockSlackClient);
+
+    mockConsole = setupMockConsole();
+    tableSpy = vi.spyOn(console, 'table').mockImplementation(() => {});
+
+    program = createTestProgram();
+    program.addCommand(setupScheduledCommand());
+  });
+
+  afterEach(() => {
+    restoreMocks();
+  });
+
+  it('should list scheduled messages in table format by default', async () => {
+    vi.mocked(mockConfigManager.getConfig).mockResolvedValue({
+      token: 'test-token',
+      updatedAt: new Date().toISOString(),
+    });
+    vi.mocked(mockSlackClient.listScheduledMessages).mockResolvedValue(
+      mockScheduledMessages as any
+    );
+
+    await program.parseAsync(['node', 'slack-cli', 'scheduled']);
+
+    expect(mockSlackClient.listScheduledMessages).toHaveBeenCalledWith(undefined, 50);
+    expect(tableSpy).toHaveBeenCalled();
+  });
+
+  it('should filter by channel and limit', async () => {
+    vi.mocked(mockConfigManager.getConfig).mockResolvedValue({
+      token: 'test-token',
+      updatedAt: new Date().toISOString(),
+    });
+    vi.mocked(mockSlackClient.listScheduledMessages).mockResolvedValue(
+      mockScheduledMessages as any
+    );
+
+    await program.parseAsync([
+      'node',
+      'slack-cli',
+      'scheduled',
+      '--channel',
+      'general',
+      '--limit',
+      '10',
+    ]);
+
+    expect(mockSlackClient.listScheduledMessages).toHaveBeenCalledWith('general', 10);
+  });
+
+  it('should output json format', async () => {
+    vi.mocked(mockConfigManager.getConfig).mockResolvedValue({
+      token: 'test-token',
+      updatedAt: new Date().toISOString(),
+    });
+    vi.mocked(mockSlackClient.listScheduledMessages).mockResolvedValue(
+      mockScheduledMessages as any
+    );
+
+    await program.parseAsync(['node', 'slack-cli', 'scheduled', '--format', 'json']);
+
+    expect(mockConsole.logSpy).toHaveBeenCalledWith(expect.stringContaining('"id": "Q123"'));
+  });
+
+  it('should output simple format', async () => {
+    vi.mocked(mockConfigManager.getConfig).mockResolvedValue({
+      token: 'test-token',
+      updatedAt: new Date().toISOString(),
+    });
+    vi.mocked(mockSlackClient.listScheduledMessages).mockResolvedValue(
+      mockScheduledMessages as any
+    );
+
+    await program.parseAsync(['node', 'slack-cli', 'scheduled', '--format', 'simple']);
+
+    expect(mockConsole.logSpy).toHaveBeenCalledWith(expect.stringContaining('Q123'));
+    expect(mockConsole.logSpy).toHaveBeenCalledWith(expect.stringContaining('Q456'));
+  });
+
+  it('should show empty message when no scheduled messages', async () => {
+    vi.mocked(mockConfigManager.getConfig).mockResolvedValue({
+      token: 'test-token',
+      updatedAt: new Date().toISOString(),
+    });
+    vi.mocked(mockSlackClient.listScheduledMessages).mockResolvedValue([] as any);
+
+    await program.parseAsync(['node', 'slack-cli', 'scheduled']);
+
+    expect(mockConsole.logSpy).toHaveBeenCalledWith('No scheduled messages found');
+  });
+});