inboxd 1.0.13 → 1.1.0

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

package/tests/json-output.test.js

@@ -0,0 +1,189 @@
+import { describe, it, expect } from 'vitest';
+
+// Test JSON output structures for commands that gained --json support
+// Validates the output format for AI agent consumption
+
+describe('JSON Output Formats', () => {
+  describe('inbox accounts --json', () => {
+    it('should output account list structure', () => {
+      const jsonOutput = {
+        accounts: [
+          { name: 'personal', email: 'user@gmail.com' },
+          { name: 'work', email: 'user@company.com' },
+        ],
+      };
+
+      expect(jsonOutput).toHaveProperty('accounts');
+      expect(Array.isArray(jsonOutput.accounts)).toBe(true);
+      expect(jsonOutput.accounts[0]).toHaveProperty('name');
+      expect(jsonOutput.accounts[0]).toHaveProperty('email');
+    });
+
+    it('should handle empty accounts list', () => {
+      const jsonOutput = {
+        accounts: [],
+      };
+
+      expect(jsonOutput.accounts).toEqual([]);
+    });
+  });
+
+  describe('inbox deletion-log --json', () => {
+    it('should output deletion log structure', () => {
+      const jsonOutput = {
+        days: 30,
+        count: 15,
+        logPath: '/Users/test/.config/inboxd/deletion-log.json',
+        deletions: [
+          {
+            deletedAt: '2026-01-03T15:45:00.000Z',
+            account: 'personal',
+            id: '19b84376ff5f5ed2',
+            threadId: '19b84376ff5f5ed2',
+            from: 'sender@example.com',
+            subject: 'Test Subject',
+            snippet: 'Email preview...',
+          },
+        ],
+      };
+
+      expect(jsonOutput).toHaveProperty('days');
+      expect(jsonOutput).toHaveProperty('count');
+      expect(jsonOutput).toHaveProperty('logPath');
+      expect(jsonOutput).toHaveProperty('deletions');
+      expect(Array.isArray(jsonOutput.deletions)).toBe(true);
+    });
+
+    it('should include all deletion entry fields', () => {
+      const deletion = {
+        deletedAt: '2026-01-03T15:45:00.000Z',
+        account: 'personal',
+        id: '19b84376ff5f5ed2',
+        threadId: '19b84376ff5f5ed2',
+        from: 'sender@example.com',
+        subject: 'Test Subject',
+        snippet: 'Email preview...',
+      };
+
+      expect(deletion).toHaveProperty('deletedAt');
+      expect(deletion).toHaveProperty('account');
+      expect(deletion).toHaveProperty('id');
+      expect(deletion).toHaveProperty('threadId');
+      expect(deletion).toHaveProperty('from');
+      expect(deletion).toHaveProperty('subject');
+      expect(deletion).toHaveProperty('snippet');
+    });
+  });
+
+  describe('inbox delete --dry-run --json', () => {
+    it('should output preview structure', () => {
+      const jsonOutput = {
+        dryRun: true,
+        count: 5,
+        emails: [
+          {
+            id: 'msg1',
+            account: 'personal',
+            from: 'sender@example.com',
+            subject: 'Test Subject',
+            date: 'Fri, 03 Jan 2026 10:30:00 -0800',
+          },
+        ],
+      };
+
+      expect(jsonOutput).toHaveProperty('dryRun');
+      expect(jsonOutput.dryRun).toBe(true);
+      expect(jsonOutput).toHaveProperty('count');
+      expect(jsonOutput).toHaveProperty('emails');
+      expect(Array.isArray(jsonOutput.emails)).toBe(true);
+    });
+
+    it('should include email details for each item', () => {
+      const email = {
+        id: 'msg1',
+        account: 'personal',
+        from: 'sender@example.com',
+        subject: 'Test Subject',
+        date: 'Fri, 03 Jan 2026 10:30:00 -0800',
+      };
+
+      expect(email).toHaveProperty('id');
+      expect(email).toHaveProperty('account');
+      expect(email).toHaveProperty('from');
+      expect(email).toHaveProperty('subject');
+      expect(email).toHaveProperty('date');
+    });
+
+    it('should handle empty preview', () => {
+      const jsonOutput = {
+        dryRun: true,
+        count: 0,
+        emails: [],
+      };
+
+      expect(jsonOutput.count).toBe(0);
+      expect(jsonOutput.emails).toEqual([]);
+    });
+  });
+
+  describe('inbox restore --json', () => {
+    it('should output restore results structure', () => {
+      const jsonOutput = {
+        restored: 3,
+        failed: 1,
+        results: [
+          { id: 'msg1', account: 'personal', from: 'a@b.com', subject: 'Test', success: true },
+          { id: 'msg2', account: 'work', from: 'c@d.com', subject: 'Test 2', success: false },
+        ],
+      };
+
+      expect(jsonOutput).toHaveProperty('restored');
+      expect(jsonOutput).toHaveProperty('failed');
+      expect(jsonOutput).toHaveProperty('results');
+      expect(Array.isArray(jsonOutput.results)).toBe(true);
+    });
+
+    it('should include success status for each result', () => {
+      const result = {
+        id: 'msg1',
+        account: 'personal',
+        from: 'a@b.com',
+        subject: 'Test',
+        success: true,
+      };
+
+      expect(result).toHaveProperty('success');
+      expect(typeof result.success).toBe('boolean');
+    });
+
+    it('should output error structure on failure', () => {
+      const jsonOutput = {
+        error: 'Must specify either --ids or --last',
+      };
+
+      expect(jsonOutput).toHaveProperty('error');
+      expect(typeof jsonOutput.error).toBe('string');
+    });
+  });
+
+  describe('JSON formatting', () => {
+    it('should produce valid JSON', () => {
+      const data = {
+        accounts: [{ name: 'test', email: 'test@example.com' }],
+      };
+
+      const jsonString = JSON.stringify(data, null, 2);
+      const parsed = JSON.parse(jsonString);
+
+      expect(parsed).toEqual(data);
+    });
+
+    it('should use 2-space indentation', () => {
+      const data = { key: 'value' };
+      const jsonString = JSON.stringify(data, null, 2);
+
+      expect(jsonString).toContain('\n');
+      expect(jsonString).toContain('  '); // 2-space indent
+    });
+  });
+});