@urugus/slack-cli 0.2.9 → 0.2.11

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/utils/channel-resolver.test.ts

@@ -10,21 +10,21 @@ describe('ChannelResolver', () => {
     resolver = new ChannelResolver();
     mockChannels = [
       {
-        id: 'C123',
+        id: 'C1234567890',
         name: 'general',
         is_private: false,
         created: 1234567890,
         is_member: true,
       },
       {
-        id: 'C456',
+        id: 'C0987654321',
         name: 'random',
         is_private: false,
         created: 1234567890,
         is_member: true,
       },
       {
-        id: 'C789',
+        id: 'C1111111111',
         name: 'dev-team',
         is_private: false,
         created: 1234567890,
@@ -32,7 +32,7 @@ describe('ChannelResolver', () => {
         name_normalized: 'dev-team',
       },
       {
-        id: 'G123',
+        id: 'G1234567890',
         name: 'private-channel',
         is_private: true,
         created: 1234567890,
@@ -42,21 +42,18 @@ describe('ChannelResolver', () => {
   });
 
   describe('isChannelId', () => {
-    it('should identify channel IDs starting with C', () => {
-      expect(resolver.isChannelId('C123456')).toBe(true);
+    it('should identify channel IDs with valid format', () => {
+      expect(resolver.isChannelId('C1234567890')).toBe(true);
+      expect(resolver.isChannelId('D1234567890')).toBe(true);
+      expect(resolver.isChannelId('G1234567890')).toBe(true);
     });
 
-    it('should identify DM IDs starting with D', () => {
-      expect(resolver.isChannelId('D123456')).toBe(true);
-    });
-
-    it('should identify group IDs starting with G', () => {
-      expect(resolver.isChannelId('G123456')).toBe(true);
-    });
-
-    it('should return false for channel names', () => {
+    it('should return false for channel names or malformed IDs', () => {
       expect(resolver.isChannelId('general')).toBe(false);
       expect(resolver.isChannelId('#general')).toBe(false);
+      expect(resolver.isChannelId('General')).toBe(false);
+      expect(resolver.isChannelId('Dev')).toBe(false);
+      expect(resolver.isChannelId('C123')).toBe(false);
     });
   });
 
@@ -96,8 +93,8 @@ describe('ChannelResolver', () => {
     it('should limit results to specified count', () => {
       const manyChannels = [
         ...mockChannels,
-        { id: 'C999', name: 'general-2', is_private: false, created: 0 },
-        { id: 'C888', name: 'general-3', is_private: false, created: 0 },
+        { id: 'C9999999999', name: 'general-2', is_private: false, created: 0 },
+        { id: 'C8888888888', name: 'general-3', is_private: false, created: 0 },
       ];
       const result = resolver.getSimilarChannels('general', manyChannels, 2);
       expect(result).toHaveLength(2);
@@ -128,15 +125,22 @@ describe('ChannelResolver', () => {
   describe('resolveChannelId', () => {
     it('should return ID directly if already an ID', async () => {
       const getChannelsFn = vi.fn();
-      const result = await resolver.resolveChannelId('C123456', getChannelsFn);
-      expect(result).toBe('C123456');
+      const result = await resolver.resolveChannelId('C1234567890', getChannelsFn);
+      expect(result).toBe('C1234567890');
       expect(getChannelsFn).not.toHaveBeenCalled();
     });
 
     it('should resolve channel name to ID', async () => {
       const getChannelsFn = vi.fn().mockResolvedValue(mockChannels);
       const result = await resolver.resolveChannelId('general', getChannelsFn);
-      expect(result).toBe('C123');
+      expect(result).toBe('C1234567890');
+      expect(getChannelsFn).toHaveBeenCalled();
+    });
+
+    it('should resolve mixed-case channel names to ID', async () => {
+      const getChannelsFn = vi.fn().mockResolvedValue(mockChannels);
+      const result = await resolver.resolveChannelId('General', getChannelsFn);
+      expect(result).toBe('C1234567890');
       expect(getChannelsFn).toHaveBeenCalled();
     });
 
@@ -154,4 +158,4 @@ describe('ChannelResolver', () => {
       );
     });
   });
-});
+});

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)'
+      );
+    });
+  });
+});