@urugus/slack-cli 0.2.8 → 0.2.10

package/tests/commands/send.test.ts

@@ -18,13 +18,13 @@ describe('send command', () => {
 
   beforeEach(() => {
     vi.clearAllMocks();
-    
+
     mockConfigManager = new ProfileConfigManager();
     vi.mocked(ProfileConfigManager).mockReturnValue(mockConfigManager);
-    
+
     mockSlackClient = new SlackApiClient('test-token');
     vi.mocked(SlackApiClient).mockReturnValue(mockSlackClient);
-    
+
     mockConsole = setupMockConsole();
     program = createTestProgram();
     program.addCommand(setupSendCommand());
@@ -38,30 +38,42 @@ describe('send command', () => {
     it('should send a message to specified channel', async () => {
       vi.mocked(mockConfigManager.getConfig).mockResolvedValue({
         token: 'test-token',
-        updatedAt: new Date().toISOString()
+        updatedAt: new Date().toISOString(),
       });
       vi.mocked(mockSlackClient.sendMessage).mockResolvedValue({
         ok: true,
-        ts: '1234567890.123456'
+        ts: '1234567890.123456',
       });
 
       await program.parseAsync(['node', 'slack-cli', 'send', '-c', 'general', '-m', 'Hello, World!']);
 
       expect(mockSlackClient.sendMessage).toHaveBeenCalledWith('general', 'Hello, World!', undefined);
-      expect(mockConsole.logSpy).toHaveBeenCalledWith(expect.stringContaining(SUCCESS_MESSAGES.MESSAGE_SENT('general')));
+      expect(mockConsole.logSpy).toHaveBeenCalledWith(
+        expect.stringContaining(SUCCESS_MESSAGES.MESSAGE_SENT('general'))
+      );
     });
 
     it('should use specified profile', async () => {
       vi.mocked(mockConfigManager.getConfig).mockResolvedValue({
         token: 'work-token',
-        updatedAt: new Date().toISOString()
+        updatedAt: new Date().toISOString(),
       });
       vi.mocked(mockSlackClient.sendMessage).mockResolvedValue({
         ok: true,
-        ts: '1234567890.123456'
+        ts: '1234567890.123456',
       });
 
-      await program.parseAsync(['node', 'slack-cli', 'send', '-c', 'general', '-m', 'Hello', '--profile', 'work']);
+      await program.parseAsync([
+        'node',
+        'slack-cli',
+        'send',
+        '-c',
+        'general',
+        '-m',
+        'Hello',
+        '--profile',
+        'work',
+      ]);
 
       expect(mockConfigManager.getConfig).toHaveBeenCalledWith('work');
       expect(SlackApiClient).toHaveBeenCalledWith('work-token');
@@ -74,11 +86,11 @@ describe('send command', () => {
       vi.mocked(fs.readFile).mockResolvedValue(fileContent);
       vi.mocked(mockConfigManager.getConfig).mockResolvedValue({
         token: 'test-token',
-        updatedAt: new Date().toISOString()
+        updatedAt: new Date().toISOString(),
       });
       vi.mocked(mockSlackClient.sendMessage).mockResolvedValue({
         ok: true,
-        ts: '1234567890.123456'
+        ts: '1234567890.123456',
       });
 
       await program.parseAsync(['node', 'slack-cli', 'send', '-c', 'general', '-f', 'message.txt']);
@@ -92,46 +104,80 @@ describe('send command', () => {
     it('should send a reply to a thread with --thread option', async () => {
       vi.mocked(mockConfigManager.getConfig).mockResolvedValue({
         token: 'test-token',
-        updatedAt: new Date().toISOString()
+        updatedAt: new Date().toISOString(),
       });
       vi.mocked(mockSlackClient.sendMessage).mockResolvedValue({
         ok: true,
-        ts: '1234567890.123456'
+        ts: '1234567890.123456',
       });
 
-      await program.parseAsync(['node', 'slack-cli', 'send', '-c', 'general', '-m', 'Reply to thread', '--thread', '1719207629.000100']);
-
-      expect(mockSlackClient.sendMessage).toHaveBeenCalledWith('general', 'Reply to thread', '1719207629.000100');
-      expect(mockConsole.logSpy).toHaveBeenCalledWith(expect.stringContaining(SUCCESS_MESSAGES.MESSAGE_SENT('general')));
+      await program.parseAsync([
+        'node',
+        'slack-cli',
+        'send',
+        '-c',
+        'general',
+        '-m',
+        'Reply to thread',
+        '--thread',
+        '1719207629.000100',
+      ]);
+
+      expect(mockSlackClient.sendMessage).toHaveBeenCalledWith(
+        'general',
+        'Reply to thread',
+        '1719207629.000100'
+      );
+      expect(mockConsole.logSpy).toHaveBeenCalledWith(
+        expect.stringContaining(SUCCESS_MESSAGES.MESSAGE_SENT('general'))
+      );
     });
 
     it('should send a reply to a thread with -t option', async () => {
       vi.mocked(mockConfigManager.getConfig).mockResolvedValue({
         token: 'test-token',
-        updatedAt: new Date().toISOString()
+        updatedAt: new Date().toISOString(),
       });
       vi.mocked(mockSlackClient.sendMessage).mockResolvedValue({
         ok: true,
-        ts: '1234567890.123456'
+        ts: '1234567890.123456',
       });
 
-      await program.parseAsync(['node', 'slack-cli', 'send', '-c', 'general', '-m', 'Reply to thread', '-t', '1719207629.000100']);
-
-      expect(mockSlackClient.sendMessage).toHaveBeenCalledWith('general', 'Reply to thread', '1719207629.000100');
-      expect(mockConsole.logSpy).toHaveBeenCalledWith(expect.stringContaining(SUCCESS_MESSAGES.MESSAGE_SENT('general')));
+      await program.parseAsync([
+        'node',
+        'slack-cli',
+        'send',
+        '-c',
+        'general',
+        '-m',
+        'Reply to thread',
+        '-t',
+        '1719207629.000100',
+      ]);
+
+      expect(mockSlackClient.sendMessage).toHaveBeenCalledWith(
+        'general',
+        'Reply to thread',
+        '1719207629.000100'
+      );
+      expect(mockConsole.logSpy).toHaveBeenCalledWith(
+        expect.stringContaining(SUCCESS_MESSAGES.MESSAGE_SENT('general'))
+      );
     });
 
     it('should validate thread timestamp format', async () => {
       vi.mocked(mockConfigManager.getConfig).mockResolvedValue({
         token: 'test-token',
-        updatedAt: new Date().toISOString()
+        updatedAt: new Date().toISOString(),
       });
 
       const sendCommand = setupSendCommand();
       sendCommand.exitOverride();
 
       await expect(
-        sendCommand.parseAsync(['-c', 'general', '-m', 'Reply', '-t', 'invalid-timestamp'], { from: 'user' })
+        sendCommand.parseAsync(['-c', 'general', '-m', 'Reply', '-t', 'invalid-timestamp'], {
+          from: 'user',
+        })
       ).rejects.toThrow(ERROR_MESSAGES.INVALID_THREAD_TIMESTAMP);
     });
 
@@ -140,18 +186,107 @@ describe('send command', () => {
       vi.mocked(fs.readFile).mockResolvedValue(fileContent);
       vi.mocked(mockConfigManager.getConfig).mockResolvedValue({
         token: 'test-token',
-        updatedAt: new Date().toISOString()
+        updatedAt: new Date().toISOString(),
       });
       vi.mocked(mockSlackClient.sendMessage).mockResolvedValue({
         ok: true,
-        ts: '1234567890.123456'
+        ts: '1234567890.123456',
       });
 
-      await program.parseAsync(['node', 'slack-cli', 'send', '-c', 'general', '-f', 'reply.txt', '-t', '1719207629.000100']);
+      await program.parseAsync([
+        'node',
+        'slack-cli',
+        'send',
+        '-c',
+        'general',
+        '-f',
+        'reply.txt',
+        '-t',
+        '1719207629.000100',
+      ]);
 
       expect(fs.readFile).toHaveBeenCalledWith('reply.txt', 'utf-8');
-      expect(mockSlackClient.sendMessage).toHaveBeenCalledWith('general', fileContent, '1719207629.000100');
-      expect(mockConsole.logSpy).toHaveBeenCalledWith(expect.stringContaining(SUCCESS_MESSAGES.MESSAGE_SENT('general')));
+      expect(mockSlackClient.sendMessage).toHaveBeenCalledWith(
+        'general',
+        fileContent,
+        '1719207629.000100'
+      );
+      expect(mockConsole.logSpy).toHaveBeenCalledWith(
+        expect.stringContaining(SUCCESS_MESSAGES.MESSAGE_SENT('general'))
+      );
+    });
+  });
+
+  describe('schedule message', () => {
+    it('should schedule message with --at', async () => {
+      vi.mocked(mockConfigManager.getConfig).mockResolvedValue({
+        token: 'test-token',
+        updatedAt: new Date().toISOString(),
+      });
+      vi.mocked(mockSlackClient.scheduleMessage).mockResolvedValue({
+        ok: true,
+        scheduled_message_id: 'Q1298393284',
+        post_at: 2051258400,
+      } as any);
+
+      await program.parseAsync([
+        'node',
+        'slack-cli',
+        'send',
+        '-c',
+        'general',
+        '-m',
+        'Future message',
+        '--at',
+        '2035-01-01T10:00:00Z',
+      ]);
+
+      expect(mockSlackClient.scheduleMessage).toHaveBeenCalledWith(
+        'general',
+        'Future message',
+        2051258400,
+        undefined
+      );
+      expect(mockSlackClient.sendMessage).not.toHaveBeenCalled();
+      expect(mockConsole.logSpy).toHaveBeenCalledWith(
+        expect.stringContaining('Message scheduled to #general')
+      );
+    });
+
+    it('should schedule message with --after', async () => {
+      vi.useFakeTimers();
+      vi.setSystemTime(new Date('2026-02-12T00:00:00Z'));
+
+      vi.mocked(mockConfigManager.getConfig).mockResolvedValue({
+        token: 'test-token',
+        updatedAt: new Date().toISOString(),
+      });
+      vi.mocked(mockSlackClient.scheduleMessage).mockResolvedValue({
+        ok: true,
+        scheduled_message_id: 'Q1298393284',
+        post_at: 1770868800,
+      } as any);
+
+      await program.parseAsync([
+        'node',
+        'slack-cli',
+        'send',
+        '-c',
+        'general',
+        '-m',
+        'Future message',
+        '--after',
+        '10',
+      ]);
+
+      expect(mockSlackClient.scheduleMessage).toHaveBeenCalledWith(
+        'general',
+        'Future message',
+        1770855000,
+        undefined
+      );
+
+      vi.useRealTimers();
     });
   });
 
@@ -160,9 +295,9 @@ describe('send command', () => {
       const sendCommand = setupSendCommand();
       sendCommand.exitOverride();
 
-      await expect(
-        sendCommand.parseAsync(['-c', 'general'], { from: 'user' })
-      ).rejects.toThrow(`Error: ${ERROR_MESSAGES.NO_MESSAGE_OR_FILE}`);
+      await expect(sendCommand.parseAsync(['-c', 'general'], { from: 'user' })).rejects.toThrow(
+        `Error: ${ERROR_MESSAGES.NO_MESSAGE_OR_FILE}`
+      );
     });
 
     it('should fail when both message and file are provided', async () => {
@@ -170,17 +305,64 @@ describe('send command', () => {
       sendCommand.exitOverride();
 
       await expect(
-        sendCommand.parseAsync(['-c', 'general', '-m', 'Hello', '-f', 'file.txt'], { from: 'user' })
+        sendCommand.parseAsync(['-c', 'general', '-m', 'Hello', '-f', 'file.txt'], {
+          from: 'user',
+        })
       ).rejects.toThrow(`Error: ${ERROR_MESSAGES.BOTH_MESSAGE_AND_FILE}`);
     });
 
-    it('should fail when no channel is provided', async () => {
+    it('should fail when both --at and --after are provided', async () => {
+      const sendCommand = setupSendCommand();
+      sendCommand.exitOverride();
+
+      await expect(
+        sendCommand.parseAsync(
+          ['-c', 'general', '-m', 'Hello', '--at', '2030-01-01T10:00:00Z', '--after', '10'],
+          {
+            from: 'user',
+          }
+        )
+      ).rejects.toThrow(`Error: ${ERROR_MESSAGES.BOTH_SCHEDULE_OPTIONS}`);
+    });
+
+    it('should fail with invalid --at', async () => {
+      const sendCommand = setupSendCommand();
+      sendCommand.exitOverride();
+
+      await expect(
+        sendCommand.parseAsync(['-c', 'general', '-m', 'Hello', '--at', 'invalid-date'], {
+          from: 'user',
+        })
+      ).rejects.toThrow(`Error: ${ERROR_MESSAGES.INVALID_SCHEDULE_AT}`);
+    });
+
+    it('should fail with past --at', async () => {
       const sendCommand = setupSendCommand();
       sendCommand.exitOverride();
-      
+
       await expect(
-        sendCommand.parseAsync(['-m', 'Hello'], { from: 'user' })
-      ).rejects.toThrow();
+        sendCommand.parseAsync(['-c', 'general', '-m', 'Hello', '--at', '1'], {
+          from: 'user',
+        })
+      ).rejects.toThrow(`Error: ${ERROR_MESSAGES.SCHEDULE_TIME_IN_PAST}`);
+    });
+
+    it('should fail with invalid --after', async () => {
+      const sendCommand = setupSendCommand();
+      sendCommand.exitOverride();
+
+      await expect(
+        sendCommand.parseAsync(['-c', 'general', '-m', 'Hello', '--after', '0'], {
+          from: 'user',
+        })
+      ).rejects.toThrow(`Error: ${ERROR_MESSAGES.INVALID_SCHEDULE_AFTER}`);
+    });
+
+    it('should fail when no channel is provided', async () => {
+      const sendCommand = setupSendCommand();
+      sendCommand.exitOverride();
+
+      await expect(sendCommand.parseAsync(['-m', 'Hello'], { from: 'user' })).rejects.toThrow();
     });
   });
 
@@ -190,20 +372,26 @@ describe('send command', () => {
 
       await program.parseAsync(['node', 'slack-cli', 'send', '-c', 'general', '-m', 'Hello']);
 
-      expect(mockConsole.errorSpy).toHaveBeenCalledWith(expect.stringContaining('Error:'), expect.any(String));
+      expect(mockConsole.errorSpy).toHaveBeenCalledWith(
+        expect.stringContaining('Error:'),
+        expect.any(String)
+      );
       expect(mockConsole.exitSpy).toHaveBeenCalledWith(1);
     });
 
     it('should handle Slack API errors', async () => {
       vi.mocked(mockConfigManager.getConfig).mockResolvedValue({
         token: 'test-token',
-        updatedAt: new Date().toISOString()
+        updatedAt: new Date().toISOString(),
       });
       vi.mocked(mockSlackClient.sendMessage).mockRejectedValue(new Error('channel_not_found'));
 
       await program.parseAsync(['node', 'slack-cli', 'send', '-c', 'nonexistent', '-m', 'Hello']);
 
-      expect(mockConsole.errorSpy).toHaveBeenCalledWith(expect.stringContaining('Error:'), expect.any(String));
+      expect(mockConsole.errorSpy).toHaveBeenCalledWith(
+        expect.stringContaining('Error:'),
+        expect.any(String)
+      );
       expect(mockConsole.exitSpy).toHaveBeenCalledWith(1);
     });
 
@@ -211,13 +399,16 @@ describe('send command', () => {
       vi.mocked(fs.readFile).mockRejectedValue(new Error('ENOENT: no such file'));
       vi.mocked(mockConfigManager.getConfig).mockResolvedValue({
         token: 'test-token',
-        updatedAt: new Date().toISOString()
+        updatedAt: new Date().toISOString(),
       });
 
       await program.parseAsync(['node', 'slack-cli', 'send', '-c', 'general', '-f', 'nonexistent.txt']);
 
-      expect(mockConsole.errorSpy).toHaveBeenCalledWith(expect.stringContaining('Error:'), expect.any(String));
+      expect(mockConsole.errorSpy).toHaveBeenCalledWith(
+        expect.stringContaining('Error:'),
+        expect.any(String)
+      );
       expect(mockConsole.exitSpy).toHaveBeenCalledWith(1);
     });
   });
-});
+});

package/tests/index.test.ts

@@ -4,7 +4,7 @@ import { readFileSync } from 'fs';
 import { join } from 'path';
 
 describe('slack-cli version', () => {
-  it('should display the correct version from package.json', () => {
+  it('should display the correct version from package.json', { timeout: 20000 }, () => {
     // Read the expected version from package.json
     const packageJson = JSON.parse(
       readFileSync(join(__dirname, '..', 'package.json'), 'utf-8')
@@ -21,7 +21,7 @@ describe('slack-cli version', () => {
     expect(output).toBe(expectedVersion);
   });
 
-  it('should display version with -V flag', () => {
+  it('should display version with -V flag', { timeout: 20000 }, () => {
     // Read the expected version from package.json
     const packageJson = JSON.parse(
       readFileSync(join(__dirname, '..', 'package.json'), 'utf-8')

package/tests/utils/schedule-utils.test.ts

@@ -0,0 +1,63 @@
+import { describe, expect, it, vi } from 'vitest';
+import { parseScheduledTimestamp, resolvePostAt } from '../../src/utils/schedule-utils';
+import { optionValidators } from '../../src/utils/validators';
+
+describe('schedule utils', () => {
+  describe('parseScheduledTimestamp', () => {
+    it('parses unix timestamp seconds', () => {
+      expect(parseScheduledTimestamp('1770855000')).toBe(1770855000);
+    });
+
+    it('parses ISO date string', () => {
+      expect(parseScheduledTimestamp('2026-02-12T00:10:00Z')).toBe(1770855000);
+    });
+
+    it('returns null for invalid input', () => {
+      expect(parseScheduledTimestamp('invalid')).toBeNull();
+    });
+  });
+
+  describe('resolvePostAt', () => {
+    it('returns parsed timestamp for --at', () => {
+      expect(resolvePostAt('1770855000', undefined)).toBe(1770855000);
+    });
+
+    it('returns now + minutes for --after', () => {
+      expect(resolvePostAt(undefined, '10', Date.parse('2026-02-12T00:00:00Z'))).toBe(1770855000);
+    });
+
+    it('returns null when invalid --after is provided', () => {
+      expect(resolvePostAt(undefined, '0')).toBeNull();
+      expect(resolvePostAt(undefined, '1.5')).toBeNull();
+      expect(resolvePostAt(undefined, '10minutes')).toBeNull();
+    });
+  });
+
+  describe('optionValidators.scheduleTiming', () => {
+    it('rejects both --at and --after', () => {
+      expect(optionValidators.scheduleTiming({ at: '1770855000', after: '10' })).toBe(
+        'Cannot use both --at and --after'
+      );
+    });
+
+    it('rejects past --at timestamp', () => {
+      vi.useFakeTimers();
+      vi.setSystemTime(new Date('2026-02-12T00:00:00Z'));
+
+      expect(optionValidators.scheduleTiming({ at: '1770854300' })).toBe(
+        'Schedule time must be in the future'
+      );
+
+      vi.useRealTimers();
+    });
+
+    it('rejects non-integer --after values', () => {
+      expect(optionValidators.scheduleTiming({ after: '1.5' })).toBe(
+        '--after must be a positive integer (minutes)'
+      );
+      expect(optionValidators.scheduleTiming({ after: '10minutes' })).toBe(
+        '--after must be a positive integer (minutes)'
+      );
+    });
+  });
+});

package/tests/utils/slack-api-client.test.ts

@@ -12,7 +12,8 @@ describe('SlackApiClient', () => {
     vi.clearAllMocks();
     mockWebClient = {
       chat: {
-        postMessage: vi.fn()
+        postMessage: vi.fn(),
+        scheduleMessage: vi.fn()
       },
       conversations: {
         list: vi.fn(),
@@ -84,6 +85,22 @@ describe('SlackApiClient', () => {
     });
   });
 
+  describe('scheduleMessage', () => {
+    it('should schedule message to channel', async () => {
+      const mockResponse = { ok: true, scheduled_message_id: 'Q123', post_at: 1770855000 };
+      vi.mocked(mockWebClient.chat.scheduleMessage).mockResolvedValue(mockResponse as any);
+
+      const result = await client.scheduleMessage('general', 'Hello, future!', 1770855000);
+
+      expect(mockWebClient.chat.scheduleMessage).toHaveBeenCalledWith({
+        channel: 'general',
+        text: 'Hello, future!',
+        post_at: 1770855000
+      });
+      expect(result).toEqual(mockResponse);
+    });
+  });
+
   describe('listChannels', () => {
     it('should list channels with default options', async () => {
       const mockChannels = [

package/tests/utils/slack-operations/message-operations.test.ts

@@ -12,6 +12,7 @@ vi.mock('@slack/web-api', () => ({
     },
     chat: {
       postMessage: vi.fn(),
+      scheduleMessage: vi.fn(),
     },
   })),
   LogLevel: {
@@ -31,6 +32,23 @@ describe('MessageOperations', () => {
     mockClient = (messageOps as any).client;
   });
 
+  describe('scheduleMessage', () => {
+    it('should call chat.scheduleMessage with post_at', async () => {
+      mockClient.chat.scheduleMessage.mockResolvedValue({
+        ok: true,
+        scheduled_message_id: 'Q123',
+      });
+
+      await messageOps.scheduleMessage('C1234567890', 'Hello', 1770855000);
+
+      expect(mockClient.chat.scheduleMessage).toHaveBeenCalledWith({
+        channel: 'C1234567890',
+        text: 'Hello',
+        post_at: 1770855000,
+      });
+    });
+  });
+
   describe('getHistory with mentions', () => {
     it('should fetch user info for mentioned users in message text', async () => {
       const mockMessages = [
@@ -123,4 +141,4 @@ describe('MessageOperations', () => {
       expect(result.users.get('U07L5D50RAL')).toBe('koguchi_s');
     });
   });
-});
+});

package/.eslintrc.json

@@ -1,25 +0,0 @@
-{
-  "parser": "@typescript-eslint/parser",
-  "extends": [
-    "eslint:recommended",
-    "plugin:@typescript-eslint/recommended",
-    "prettier"
-  ],
-  "plugins": ["@typescript-eslint"],
-  "parserOptions": {
-    "ecmaVersion": 2020,
-    "sourceType": "module",
-    "project": "./tsconfig.json"
-  },
-  "env": {
-    "node": true,
-    "es2020": true
-  },
-  "rules": {
-    "@typescript-eslint/explicit-function-return-type": "off",
-    "@typescript-eslint/no-explicit-any": "warn",
-    "@typescript-eslint/no-unused-vars": ["error", { "argsIgnorePattern": "^_" }],
-    "no-console": "off"
-  },
-  "ignorePatterns": ["dist", "node_modules", "coverage", "vitest.config.ts"]
-}

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

@@ -1,7 +0,0 @@
-export interface OutputFormatter<T> {
-  format(data: T[]): void;
-}
-
-export abstract class BaseFormatter<T> implements OutputFormatter<T> {
-  abstract format(data: T[]): void;
-}