inboxd 1.0.12 → 1.1.0

package/tests/gmail-monitor.test.js

@@ -132,4 +132,297 @@ describe('Gmail Monitor Logic', () => {
       }
     });
   });
+
+  describe('Mark As Read Logic', () => {
+    it('should mark email as read by removing UNREAD label', async () => {
+      const mockGmail = {
+        users: {
+          messages: {
+            modify: vi.fn().mockResolvedValue({ data: { id: 'msg123', labelIds: ['INBOX'] } })
+          }
+        }
+      };
+
+      const messageIds = ['msg123'];
+      const results = [];
+
+      for (const id of messageIds) {
+        try {
+          await mockGmail.users.messages.modify({
+            userId: 'me',
+            id: id,
+            requestBody: { removeLabelIds: ['UNREAD'] }
+          });
+          results.push({ id, success: true });
+        } catch (err) {
+          results.push({ id, success: false, error: err.message });
+        }
+      }
+
+      expect(results).toHaveLength(1);
+      expect(results[0].success).toBe(true);
+      expect(mockGmail.users.messages.modify).toHaveBeenCalledWith({
+        userId: 'me',
+        id: 'msg123',
+        requestBody: { removeLabelIds: ['UNREAD'] }
+      });
+    });
+
+    it('should handle errors during mark as read', async () => {
+      const mockGmail = {
+        users: {
+          messages: {
+            modify: vi.fn().mockRejectedValue(new Error('API Error'))
+          }
+        }
+      };
+
+      const messageIds = ['msg123'];
+      const results = [];
+
+      for (const id of messageIds) {
+        try {
+          await mockGmail.users.messages.modify({
+            userId: 'me',
+            id: id,
+            requestBody: { removeLabelIds: ['UNREAD'] }
+          });
+          results.push({ id, success: true });
+        } catch (err) {
+          results.push({ id, success: false, error: err.message });
+        }
+      }
+
+      expect(results).toHaveLength(1);
+      expect(results[0].success).toBe(false);
+      expect(results[0].error).toBe('API Error');
+    });
+
+    it('should handle multiple message IDs for mark as read', async () => {
+      const mockModify = vi.fn()
+        .mockResolvedValueOnce({ data: { id: 'msg1' } })
+        .mockResolvedValueOnce({ data: { id: 'msg2' } })
+        .mockRejectedValueOnce(new Error('Not found'));
+
+      const mockGmail = {
+        users: { messages: { modify: mockModify } }
+      };
+
+      const messageIds = ['msg1', 'msg2', 'msg3'];
+      const results = [];
+
+      for (const id of messageIds) {
+        try {
+          await mockGmail.users.messages.modify({
+            userId: 'me',
+            id: id,
+            requestBody: { removeLabelIds: ['UNREAD'] }
+          });
+          results.push({ id, success: true });
+        } catch (err) {
+          results.push({ id, success: false, error: err.message });
+        }
+      }
+
+      expect(results).toHaveLength(3);
+      expect(results[0]).toEqual({ id: 'msg1', success: true });
+      expect(results[1]).toEqual({ id: 'msg2', success: true });
+      expect(results[2]).toEqual({ id: 'msg3', success: false, error: 'Not found' });
+    });
+  });
+
+  describe('Mark As Unread Logic', () => {
+    it('should mark email as unread by adding UNREAD label', async () => {
+      const mockGmail = {
+        users: {
+          messages: {
+            modify: vi.fn().mockResolvedValue({ data: { id: 'msg123', labelIds: ['INBOX', 'UNREAD'] } })
+          }
+        }
+      };
+
+      const messageIds = ['msg123'];
+      const results = [];
+
+      for (const id of messageIds) {
+        try {
+          await mockGmail.users.messages.modify({
+            userId: 'me',
+            id: id,
+            requestBody: { addLabelIds: ['UNREAD'] }
+          });
+          results.push({ id, success: true });
+        } catch (err) {
+          results.push({ id, success: false, error: err.message });
+        }
+      }
+
+      expect(results).toHaveLength(1);
+      expect(results[0].success).toBe(true);
+      expect(mockGmail.users.messages.modify).toHaveBeenCalledWith({
+        userId: 'me',
+        id: 'msg123',
+        requestBody: { addLabelIds: ['UNREAD'] }
+      });
+    });
+
+    it('should handle errors during mark as unread', async () => {
+      const mockGmail = {
+        users: {
+          messages: {
+            modify: vi.fn().mockRejectedValue(new Error('Permission denied'))
+          }
+        }
+      };
+
+      const messageIds = ['msg123'];
+      const results = [];
+
+      for (const id of messageIds) {
+        try {
+          await mockGmail.users.messages.modify({
+            userId: 'me',
+            id: id,
+            requestBody: { addLabelIds: ['UNREAD'] }
+          });
+          results.push({ id, success: true });
+        } catch (err) {
+          results.push({ id, success: false, error: err.message });
+        }
+      }
+
+      expect(results).toHaveLength(1);
+      expect(results[0].success).toBe(false);
+      expect(results[0].error).toBe('Permission denied');
+    });
+
+    it('should handle multiple message IDs for mark as unread', async () => {
+      const mockModify = vi.fn()
+        .mockResolvedValueOnce({ data: { id: 'msg1' } })
+        .mockRejectedValueOnce(new Error('Not found'))
+        .mockResolvedValueOnce({ data: { id: 'msg3' } });
+
+      const mockGmail = {
+        users: { messages: { modify: mockModify } }
+      };
+
+      const messageIds = ['msg1', 'msg2', 'msg3'];
+      const results = [];
+
+      for (const id of messageIds) {
+        try {
+          await mockGmail.users.messages.modify({
+            userId: 'me',
+            id: id,
+            requestBody: { addLabelIds: ['UNREAD'] }
+          });
+          results.push({ id, success: true });
+        } catch (err) {
+          results.push({ id, success: false, error: err.message });
+        }
+      }
+
+      expect(results).toHaveLength(3);
+      expect(results[0]).toEqual({ id: 'msg1', success: true });
+      expect(results[1]).toEqual({ id: 'msg2', success: false, error: 'Not found' });
+      expect(results[2]).toEqual({ id: 'msg3', success: true });
+    });
+  });
+
+  describe('Archive Emails Logic', () => {
+    it('should archive email by removing INBOX label', async () => {
+      const mockGmail = {
+        users: {
+          messages: {
+            modify: vi.fn().mockResolvedValue({ data: { id: 'msg123', labelIds: ['CATEGORY_UPDATES'] } })
+          }
+        }
+      };
+
+      const messageIds = ['msg123'];
+      const results = [];
+
+      for (const id of messageIds) {
+        try {
+          await mockGmail.users.messages.modify({
+            userId: 'me',
+            id: id,
+            requestBody: { removeLabelIds: ['INBOX'] }
+          });
+          results.push({ id, success: true });
+        } catch (err) {
+          results.push({ id, success: false, error: err.message });
+        }
+      }
+
+      expect(results).toHaveLength(1);
+      expect(results[0].success).toBe(true);
+      expect(mockGmail.users.messages.modify).toHaveBeenCalledWith({
+        userId: 'me',
+        id: 'msg123',
+        requestBody: { removeLabelIds: ['INBOX'] }
+      });
+    });
+
+    it('should handle errors during archive', async () => {
+      const mockGmail = {
+        users: {
+          messages: {
+            modify: vi.fn().mockRejectedValue(new Error('Rate limit exceeded'))
+          }
+        }
+      };
+
+      const messageIds = ['msg123'];
+      const results = [];
+
+      for (const id of messageIds) {
+        try {
+          await mockGmail.users.messages.modify({
+            userId: 'me',
+            id: id,
+            requestBody: { removeLabelIds: ['INBOX'] }
+          });
+          results.push({ id, success: true });
+        } catch (err) {
+          results.push({ id, success: false, error: err.message });
+        }
+      }
+
+      expect(results).toHaveLength(1);
+      expect(results[0].success).toBe(false);
+      expect(results[0].error).toBe('Rate limit exceeded');
+    });
+
+    it('should handle multiple message IDs for archive', async () => {
+      const mockModify = vi.fn()
+        .mockResolvedValueOnce({ data: { id: 'msg1' } })
+        .mockResolvedValueOnce({ data: { id: 'msg2' } });
+
+      const mockGmail = {
+        users: { messages: { modify: mockModify } }
+      };
+
+      const messageIds = ['msg1', 'msg2'];
+      const results = [];
+
+      for (const id of messageIds) {
+        try {
+          await mockGmail.users.messages.modify({
+            userId: 'me',
+            id: id,
+            requestBody: { removeLabelIds: ['INBOX'] }
+          });
+          results.push({ id, success: true });
+        } catch (err) {
+          results.push({ id, success: false, error: err.message });
+        }
+      }
+
+      expect(results).toHaveLength(2);
+      expect(results[0]).toEqual({ id: 'msg1', success: true });
+      expect(results[1]).toEqual({ id: 'msg2', success: true });
+      expect(mockModify).toHaveBeenCalledTimes(2);
+    });
+  });
 });

package/tests/install-service.test.js

@@ -0,0 +1,210 @@
+import { describe, it, expect } from 'vitest';
+import path from 'path';
+import os from 'os';
+
+// Test install-service logic for both macOS and Linux
+// Tests the service file generation without actually installing
+
+describe('Install Service Command', () => {
+  const homeDir = os.homedir();
+
+  describe('Platform detection', () => {
+    it('should recognize darwin as macOS', () => {
+      const platform = 'darwin';
+      expect(platform === 'darwin').toBe(true);
+    });
+
+    it('should recognize linux as Linux', () => {
+      const platform = 'linux';
+      expect(platform === 'linux').toBe(true);
+    });
+
+    it('should reject unsupported platforms', () => {
+      const platform = 'win32';
+      const isSupported = platform === 'darwin' || platform === 'linux';
+      expect(isSupported).toBe(false);
+    });
+  });
+
+  describe('macOS launchd configuration', () => {
+    const launchAgentsDir = path.join(homeDir, 'Library/LaunchAgents');
+    const plistName = 'com.danielparedes.inboxd.plist';
+    const plistPath = path.join(launchAgentsDir, plistName);
+
+    it('should use correct plist path', () => {
+      expect(plistPath).toContain('Library/LaunchAgents');
+      expect(plistPath).toContain('com.danielparedes.inboxd.plist');
+    });
+
+    it('should generate valid plist structure', () => {
+      const interval = 5;
+      const seconds = interval * 60;
+      const nodePath = '/usr/local/bin/node';
+      const scriptPath = '/path/to/cli.js';
+      const workingDir = '/path/to';
+
+      const plistContent = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>Label</key>
+    <string>com.danielparedes.inboxd</string>
+    <key>ProgramArguments</key>
+    <array>
+        <string>${nodePath}</string>
+        <string>${scriptPath}</string>
+        <string>check</string>
+        <string>--quiet</string>
+    </array>
+    <key>StartInterval</key>
+    <integer>${seconds}</integer>
+</dict>
+</plist>`;
+
+      expect(plistContent).toContain('com.danielparedes.inboxd');
+      expect(plistContent).toContain('<integer>300</integer>'); // 5 * 60
+      expect(plistContent).toContain('check');
+      expect(plistContent).toContain('--quiet');
+    });
+
+    it('should convert minutes to seconds', () => {
+      const intervalMinutes = 10;
+      const seconds = intervalMinutes * 60;
+      expect(seconds).toBe(600);
+    });
+  });
+
+  describe('Linux systemd configuration', () => {
+    const systemdUserDir = path.join(homeDir, '.config/systemd/user');
+    const servicePath = path.join(systemdUserDir, 'inboxd.service');
+    const timerPath = path.join(systemdUserDir, 'inboxd.timer');
+
+    it('should use correct systemd paths', () => {
+      expect(systemdUserDir).toContain('.config/systemd/user');
+      expect(servicePath).toContain('inboxd.service');
+      expect(timerPath).toContain('inboxd.timer');
+    });
+
+    it('should generate valid service unit', () => {
+      const nodePath = '/usr/bin/node';
+      const scriptPath = '/path/to/cli.js';
+      const workingDir = '/path/to';
+
+      const serviceContent = `[Unit]
+Description=inboxd - Gmail monitoring and notifications
+After=network-online.target
+Wants=network-online.target
+
+[Service]
+Type=oneshot
+ExecStart=${nodePath} ${scriptPath} check --quiet
+WorkingDirectory=${workingDir}
+Environment=PATH=/usr/local/bin:/usr/bin:/bin
+
+[Install]
+WantedBy=default.target
+`;
+
+      expect(serviceContent).toContain('[Unit]');
+      expect(serviceContent).toContain('[Service]');
+      expect(serviceContent).toContain('[Install]');
+      expect(serviceContent).toContain('Type=oneshot');
+      expect(serviceContent).toContain('check --quiet');
+    });
+
+    it('should generate valid timer unit', () => {
+      const interval = 5;
+
+      const timerContent = `[Unit]
+Description=Run inboxd every ${interval} minutes
+
+[Timer]
+OnBootSec=1min
+OnUnitActiveSec=${interval}min
+Persistent=true
+
+[Install]
+WantedBy=timers.target
+`;
+
+      expect(timerContent).toContain('[Unit]');
+      expect(timerContent).toContain('[Timer]');
+      expect(timerContent).toContain('[Install]');
+      expect(timerContent).toContain('OnUnitActiveSec=5min');
+      expect(timerContent).toContain('Persistent=true');
+    });
+
+    it('should use correct timer interval format', () => {
+      const intervals = [1, 5, 10, 15, 30];
+
+      intervals.forEach(interval => {
+        const timerInterval = `${interval}min`;
+        expect(timerInterval).toMatch(/^\d+min$/);
+      });
+    });
+  });
+
+  describe('Interval parsing', () => {
+    it('should parse interval option as integer', () => {
+      const optionValue = '10';
+      const interval = parseInt(optionValue, 10);
+      expect(interval).toBe(10);
+    });
+
+    it('should use default interval of 5 minutes', () => {
+      const defaultInterval = '5';
+      const interval = parseInt(defaultInterval, 10);
+      expect(interval).toBe(5);
+    });
+  });
+
+  describe('Uninstall logic', () => {
+    it('should identify service files for removal (macOS)', () => {
+      const plistPath = path.join(homeDir, 'Library/LaunchAgents/com.danielparedes.inboxd.plist');
+      expect(plistPath).toContain('com.danielparedes.inboxd.plist');
+    });
+
+    it('should identify service files for removal (Linux)', () => {
+      const servicePath = path.join(homeDir, '.config/systemd/user/inboxd.service');
+      const timerPath = path.join(homeDir, '.config/systemd/user/inboxd.timer');
+
+      expect(servicePath).toContain('inboxd.service');
+      expect(timerPath).toContain('inboxd.timer');
+    });
+
+    it('should track if files were removed', () => {
+      let removed = false;
+
+      // Simulate file removal
+      const files = [
+        { path: '/path/to/service', exists: true },
+        { path: '/path/to/timer', exists: true },
+      ];
+
+      files.forEach(file => {
+        if (file.exists) {
+          // fs.unlinkSync(file.path)
+          removed = true;
+        }
+      });
+
+      expect(removed).toBe(true);
+    });
+  });
+
+  describe('Path generation', () => {
+    it('should resolve script path correctly', () => {
+      // Simulates path.resolve(__dirname, 'cli.js')
+      const mockDirname = '/Users/test/inboxd/src';
+      const scriptPath = path.resolve(mockDirname, 'cli.js');
+      expect(scriptPath).toContain('cli.js');
+    });
+
+    it('should resolve working directory correctly', () => {
+      // Simulates path.resolve(__dirname, '..')
+      const mockDirname = '/Users/test/inboxd/src';
+      const workingDir = path.resolve(mockDirname, '..');
+      expect(workingDir).not.toContain('/src');
+    });
+  });
+});

package/tests/interactive-confirm.test.js

@@ -0,0 +1,175 @@
+import { describe, it, expect, vi } from 'vitest';
+
+// Test interactive confirmation logic for send/reply commands
+// Tests the prompt handling without actual readline interaction
+
+describe('Interactive Confirm', () => {
+  describe('Prompt function', () => {
+    // Mirrors the prompt function from cli.js
+    function prompt(rl, question) {
+      return new Promise((resolve) => {
+        rl.question(question, (answer) => {
+          resolve(answer.trim());
+        });
+      });
+    }
+
+    it('should resolve with user answer', async () => {
+      const mockRl = {
+        question: vi.fn((q, callback) => callback('yes')),
+      };
+
+      const answer = await prompt(mockRl, 'Confirm? ');
+      expect(answer).toBe('yes');
+    });
+
+    it('should trim whitespace from answer', async () => {
+      const mockRl = {
+        question: vi.fn((q, callback) => callback('  yes  ')),
+      };
+
+      const answer = await prompt(mockRl, 'Confirm? ');
+      expect(answer).toBe('yes');
+    });
+
+    it('should call question with provided prompt', async () => {
+      const mockRl = {
+        question: vi.fn((q, callback) => callback('y')),
+      };
+
+      await prompt(mockRl, 'Send this email? (y/N): ');
+      expect(mockRl.question).toHaveBeenCalledWith(
+        'Send this email? (y/N): ',
+        expect.any(Function)
+      );
+    });
+  });
+
+  describe('Answer validation for send', () => {
+    function isConfirmed(answer) {
+      return answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes';
+    }
+
+    it('should accept "y" as confirmation', () => {
+      expect(isConfirmed('y')).toBe(true);
+    });
+
+    it('should accept "Y" as confirmation (case-insensitive)', () => {
+      expect(isConfirmed('Y')).toBe(true);
+    });
+
+    it('should accept "yes" as confirmation', () => {
+      expect(isConfirmed('yes')).toBe(true);
+    });
+
+    it('should accept "YES" as confirmation (case-insensitive)', () => {
+      expect(isConfirmed('YES')).toBe(true);
+    });
+
+    it('should reject "n" as not confirmed', () => {
+      expect(isConfirmed('n')).toBe(false);
+    });
+
+    it('should reject "no" as not confirmed', () => {
+      expect(isConfirmed('no')).toBe(false);
+    });
+
+    it('should reject empty string as not confirmed', () => {
+      expect(isConfirmed('')).toBe(false);
+    });
+
+    it('should reject random input as not confirmed', () => {
+      expect(isConfirmed('maybe')).toBe(false);
+      expect(isConfirmed('okay')).toBe(false);
+      expect(isConfirmed('sure')).toBe(false);
+    });
+  });
+
+  describe('readline interface lifecycle', () => {
+    it('should close interface after getting answer', () => {
+      const mockRl = {
+        question: vi.fn((q, callback) => callback('y')),
+        close: vi.fn(),
+      };
+
+      // Simulate the pattern in cli.js
+      mockRl.question('Confirm?', () => {});
+      mockRl.close();
+
+      expect(mockRl.close).toHaveBeenCalled();
+    });
+  });
+
+  describe('--confirm flag behavior', () => {
+    it('should skip prompt when --confirm is provided', () => {
+      const options = { confirm: true };
+
+      if (options.confirm) {
+        // Skip prompt, proceed directly
+        expect(true).toBe(true);
+      }
+    });
+
+    it('should require prompt when --confirm is not provided', () => {
+      const options = { confirm: false };
+      const needsPrompt = !options.confirm;
+
+      expect(needsPrompt).toBe(true);
+    });
+
+    it('should require prompt when --confirm is undefined', () => {
+      const options = {};
+      const needsPrompt = !options.confirm;
+
+      expect(needsPrompt).toBe(true);
+    });
+  });
+
+  describe('Cancel behavior', () => {
+    it('should cancel when user answers "n"', () => {
+      const answer = 'n';
+      const shouldProceed = answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes';
+
+      expect(shouldProceed).toBe(false);
+    });
+
+    it('should cancel when user presses enter (empty)', () => {
+      const answer = '';
+      const shouldProceed = answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes';
+
+      expect(shouldProceed).toBe(false);
+    });
+  });
+
+  describe('Send command confirmation prompt', () => {
+    it('should use correct prompt message for send', () => {
+      const promptMessage = 'Send this email? (y/N): ';
+      expect(promptMessage).toContain('Send');
+      expect(promptMessage).toContain('y/N');
+    });
+  });
+
+  describe('Reply command confirmation prompt', () => {
+    it('should use correct prompt message for reply', () => {
+      const promptMessage = 'Send this reply? (y/N): ';
+      expect(promptMessage).toContain('reply');
+      expect(promptMessage).toContain('y/N');
+    });
+  });
+
+  describe('Integration with --dry-run', () => {
+    it('should not prompt when --dry-run is provided', () => {
+      const options = { dryRun: true, confirm: false };
+
+      // --dry-run takes precedence, no send happens
+      if (options.dryRun) {
+        // Preview only, skip confirmation
+        expect(true).toBe(true);
+        return;
+      }
+
+      // This line should not be reached
+      expect(false).toBe(true);
+    });
+  });
+});