inboxd 1.0.0 → 1.0.3

package/tests/gmail-monitor.test.js

@@ -0,0 +1,135 @@
+import { describe, it, expect, vi } from 'vitest';
+
+// Don't import gmail-monitor at all - just test the logic patterns it uses
+// This avoids loading the real gmail-auth which triggers browser auth
+
+describe('Gmail Monitor Logic', () => {
+  describe('Email Parsing Logic', () => {
+    it('should extract headers correctly', () => {
+      const headers = [
+        { name: 'From', value: 'sender@example.com' },
+        { name: 'Subject', value: 'Test Subject' },
+        { name: 'Date', value: 'Mon, 1 Jan 2024 10:00:00 +0000' },
+      ];
+      const getHeader = (name) => {
+        const header = headers.find((h) => h.name === name);
+        return header ? header.value : '';
+      };
+      expect(getHeader('From')).toBe('sender@example.com');
+      expect(getHeader('Subject')).toBe('Test Subject');
+      expect(getHeader('Date')).toBe('Mon, 1 Jan 2024 10:00:00 +0000');
+      expect(getHeader('NonExistent')).toBe('');
+    });
+  });
+
+  describe('Untrash Operation Logic', () => {
+    it('should handle successful untrash results', async () => {
+      // Simulate the untrash logic without importing the real module
+      const mockGmail = {
+        users: {
+          messages: {
+            untrash: vi.fn().mockResolvedValue({ data: { id: 'msg123', labelIds: ['INBOX'] } })
+          }
+        }
+      };
+
+      // This is the logic from untrashEmails
+      const messageIds = ['msg123'];
+      const results = [];
+
+      for (const id of messageIds) {
+        try {
+          await mockGmail.users.messages.untrash({ userId: 'me', id });
+          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(results[0].id).toBe('msg123');
+      expect(mockGmail.users.messages.untrash).toHaveBeenCalledWith({
+        userId: 'me',
+        id: 'msg123'
+      });
+    });
+
+    it('should handle errors during untrash', async () => {
+      const mockGmail = {
+        users: {
+          messages: {
+            untrash: vi.fn().mockRejectedValue(new Error('API Error'))
+          }
+        }
+      };
+
+      const messageIds = ['msg123'];
+      const results = [];
+
+      for (const id of messageIds) {
+        try {
+          await mockGmail.users.messages.untrash({ userId: 'me', id });
+          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', async () => {
+      const mockUntrash = vi.fn()
+        .mockResolvedValueOnce({ data: { id: 'msg1' } })
+        .mockResolvedValueOnce({ data: { id: 'msg2' } })
+        .mockRejectedValueOnce(new Error('Not found'));
+
+      const mockGmail = {
+        users: { messages: { untrash: mockUntrash } }
+      };
+
+      const messageIds = ['msg1', 'msg2', 'msg3'];
+      const results = [];
+
+      for (const id of messageIds) {
+        try {
+          await mockGmail.users.messages.untrash({ userId: 'me', id });
+          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('Retry Logic', () => {
+    it('should retry on network errors', async () => {
+      // Test the withRetry pattern
+      const networkErrors = ['ENOTFOUND', 'ETIMEDOUT', 'ECONNRESET', 'EAI_AGAIN'];
+
+      for (const code of networkErrors) {
+        const error = new Error('Network error');
+        error.code = code;
+
+        expect(networkErrors.includes(error.code)).toBe(true);
+      }
+    });
+
+    it('should not retry on auth errors', () => {
+      const authCodes = [401, 403];
+
+      for (const code of authCodes) {
+        // Auth errors should not trigger retry
+        expect(authCodes.includes(code)).toBe(true);
+      }
+    });
+  });
+});

package/tests/notifier.test.js

@@ -0,0 +1,27 @@
+import { describe, it, expect } from 'vitest';
+import { extractSenderName } from '../src/notifier';
+
+describe('Notifier', () => {
+  describe('extractSenderName', () => {
+    it('should extract name from "Name <email>" format', () => {
+      expect(extractSenderName('John Doe <john@example.com>')).toBe('John Doe');
+    });
+
+    it('should extract name from quoted format', () => {
+      expect(extractSenderName('"Jane Smith" <jane@example.com>')).toBe('Jane Smith');
+    });
+
+    it('should handle email-only format', () => {
+      expect(extractSenderName('user@example.com')).toBe('user');
+    });
+
+    it('should handle undefined/null', () => {
+      expect(extractSenderName(undefined)).toBe('Unknown');
+      expect(extractSenderName(null)).toBe('Unknown');
+    });
+
+    it('should handle complex names', () => {
+      expect(extractSenderName('Dr. John Smith Jr. <john@hospital.com>')).toBe('Dr. John Smith Jr.');
+    });
+  });
+});

package/tests/setup.js

@@ -0,0 +1,16 @@
+import { vi, beforeAll } from 'vitest';
+
+// Mock modules using __mocks__ directory (no factory = uses manual mock)
+vi.mock('@google-cloud/local-auth');
+vi.mock('googleapis');
+vi.mock('open', () => ({ default: vi.fn() }));
+vi.mock('node-notifier', () => ({ notify: vi.fn() }));
+
+// Also mock fs.promises.access to prevent "credentials.json not found" errors
+// which would trigger the authenticate flow
+beforeAll(() => {
+  // Prevent any process from spawning browsers
+  vi.stubGlobal('open', vi.fn());
+});
+
+console.log('Global Google/Open mocks applied');

package/tests/setup.test.js

@@ -0,0 +1,214 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+// Use a test-specific directory
+const TEST_DIR = path.join(os.tmpdir(), 'inboxd-setup-test-' + Date.now());
+
+describe('Credentials Validation', () => {
+  beforeEach(() => {
+    fs.mkdirSync(TEST_DIR, { recursive: true });
+  });
+
+  afterEach(() => {
+    fs.rmSync(TEST_DIR, { recursive: true, force: true });
+  });
+
+  describe('validateCredentialsFile', () => {
+    // Import the function dynamically to avoid mocking issues
+    const validateCredentialsFile = (filePath) => {
+      if (!fs.existsSync(filePath)) {
+        return { valid: false, error: 'File not found' };
+      }
+
+      try {
+        const content = fs.readFileSync(filePath, 'utf8');
+        const json = JSON.parse(content);
+
+        if (!json.installed && !json.web) {
+          return {
+            valid: false,
+            error: 'Invalid format: missing "installed" or "web" key. Make sure you downloaded OAuth Desktop app credentials.',
+          };
+        }
+
+        const key = json.installed || json.web;
+        if (!key.client_id || !key.client_secret) {
+          return {
+            valid: false,
+            error: 'Invalid format: missing client_id or client_secret',
+          };
+        }
+
+        return { valid: true };
+      } catch (err) {
+        return { valid: false, error: `Invalid JSON: ${err.message}` };
+      }
+    };
+
+    it('should return error for non-existent file', () => {
+      const result = validateCredentialsFile('/nonexistent/path.json');
+      expect(result.valid).toBe(false);
+      expect(result.error).toBe('File not found');
+    });
+
+    it('should return error for invalid JSON', () => {
+      const filePath = path.join(TEST_DIR, 'invalid.json');
+      fs.writeFileSync(filePath, 'not valid json');
+
+      const result = validateCredentialsFile(filePath);
+      expect(result.valid).toBe(false);
+      expect(result.error).toContain('Invalid JSON');
+    });
+
+    it('should return error for JSON without installed or web key', () => {
+      const filePath = path.join(TEST_DIR, 'missing-key.json');
+      fs.writeFileSync(filePath, JSON.stringify({ foo: 'bar' }));
+
+      const result = validateCredentialsFile(filePath);
+      expect(result.valid).toBe(false);
+      expect(result.error).toContain('missing "installed" or "web" key');
+    });
+
+    it('should return error for missing client_id', () => {
+      const filePath = path.join(TEST_DIR, 'missing-client-id.json');
+      fs.writeFileSync(filePath, JSON.stringify({
+        installed: { client_secret: 'secret' }
+      }));
+
+      const result = validateCredentialsFile(filePath);
+      expect(result.valid).toBe(false);
+      expect(result.error).toContain('missing client_id or client_secret');
+    });
+
+    it('should return error for missing client_secret', () => {
+      const filePath = path.join(TEST_DIR, 'missing-client-secret.json');
+      fs.writeFileSync(filePath, JSON.stringify({
+        installed: { client_id: 'id' }
+      }));
+
+      const result = validateCredentialsFile(filePath);
+      expect(result.valid).toBe(false);
+      expect(result.error).toContain('missing client_id or client_secret');
+    });
+
+    it('should validate correct installed credentials', () => {
+      const filePath = path.join(TEST_DIR, 'valid-installed.json');
+      fs.writeFileSync(filePath, JSON.stringify({
+        installed: {
+          client_id: 'test-client-id.apps.googleusercontent.com',
+          client_secret: 'test-secret',
+          redirect_uris: ['http://localhost']
+        }
+      }));
+
+      const result = validateCredentialsFile(filePath);
+      expect(result.valid).toBe(true);
+      expect(result.error).toBeUndefined();
+    });
+
+    it('should validate correct web credentials', () => {
+      const filePath = path.join(TEST_DIR, 'valid-web.json');
+      fs.writeFileSync(filePath, JSON.stringify({
+        web: {
+          client_id: 'test-client-id.apps.googleusercontent.com',
+          client_secret: 'test-secret'
+        }
+      }));
+
+      const result = validateCredentialsFile(filePath);
+      expect(result.valid).toBe(true);
+    });
+  });
+});
+
+describe('Path Resolution', () => {
+  const resolvePath = (filePath) => {
+    if (filePath.startsWith('~')) {
+      return path.join(os.homedir(), filePath.slice(1));
+    }
+    return path.resolve(filePath);
+  };
+
+  it('should expand ~ to home directory', () => {
+    const result = resolvePath('~/Documents/test.json');
+    expect(result).toBe(path.join(os.homedir(), 'Documents/test.json'));
+  });
+
+  it('should expand ~/ correctly', () => {
+    const result = resolvePath('~/test.json');
+    expect(result).toBe(path.join(os.homedir(), 'test.json'));
+  });
+
+  it('should resolve relative paths', () => {
+    const result = resolvePath('./test.json');
+    expect(result).toBe(path.resolve('./test.json'));
+  });
+
+  it('should keep absolute paths unchanged', () => {
+    const result = resolvePath('/absolute/path/test.json');
+    expect(result).toBe('/absolute/path/test.json');
+  });
+
+  it('should handle paths with spaces', () => {
+    const result = resolvePath('~/My Documents/test file.json');
+    expect(result).toBe(path.join(os.homedir(), 'My Documents/test file.json'));
+  });
+
+  it('should handle quoted paths from drag-drop', () => {
+    // Simulate drag-drop which may add quotes
+    const input = '"/Users/test/My Documents/creds.json"';
+    const cleaned = input.replace(/['"]/g, '').trim();
+    expect(cleaned).toBe('/Users/test/My Documents/creds.json');
+  });
+});
+
+describe('Install Credentials', () => {
+  beforeEach(() => {
+    fs.mkdirSync(TEST_DIR, { recursive: true });
+  });
+
+  afterEach(() => {
+    fs.rmSync(TEST_DIR, { recursive: true, force: true });
+  });
+
+  it('should copy credentials file to destination', () => {
+    const sourcePath = path.join(TEST_DIR, 'source-creds.json');
+    const destDir = path.join(TEST_DIR, 'config');
+    const destPath = path.join(destDir, 'credentials.json');
+
+    // Create source file
+    const content = JSON.stringify({
+      installed: { client_id: 'id', client_secret: 'secret' }
+    });
+    fs.writeFileSync(sourcePath, content);
+
+    // Simulate installCredentials
+    fs.mkdirSync(destDir, { recursive: true });
+    fs.copyFileSync(sourcePath, destPath);
+
+    expect(fs.existsSync(destPath)).toBe(true);
+    expect(fs.readFileSync(destPath, 'utf8')).toBe(content);
+  });
+});
+
+describe('Platform Detection', () => {
+  it('should correctly identify darwin as macOS', () => {
+    const isMacOS = process.platform === 'darwin';
+    // This test documents the expected behavior
+    expect(typeof isMacOS).toBe('boolean');
+  });
+
+  it('should provide alternative instructions for non-macOS', () => {
+    const platform = 'linux';
+    const isMacOS = platform === 'darwin';
+
+    if (!isMacOS) {
+      // Should suggest cron as alternative
+      const cronExample = '*/5 * * * * /path/to/node /path/to/inbox check --quiet';
+      expect(cronExample).toContain('* * *');
+      expect(cronExample).toContain('check --quiet');
+    }
+  });
+});

package/tests/state-multiacccount.test.js

@@ -0,0 +1,91 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+const TEST_DIR = path.join(os.tmpdir(), 'inboxd-state-test-' + Date.now());
+
+describe('State Management - Multi-Account', () => {
+  beforeEach(() => {
+    fs.mkdirSync(TEST_DIR, { recursive: true });
+  });
+
+  afterEach(() => {
+    fs.rmSync(TEST_DIR, { recursive: true, force: true });
+  });
+
+  describe('Per-Account State Files', () => {
+    it('should generate unique state paths per account', () => {
+      const getStatePath = (account) => path.join(TEST_DIR, `state-${account}.json`);
+
+      expect(getStatePath('default')).toContain('state-default.json');
+      expect(getStatePath('work')).toContain('state-work.json');
+      expect(getStatePath('personal')).toContain('state-personal.json');
+    });
+
+    it('should isolate state between accounts', () => {
+      const states = {
+        work: { seenEmailIds: [{ id: 'work1', timestamp: Date.now() }] },
+        personal: { seenEmailIds: [{ id: 'personal1', timestamp: Date.now() }] },
+      };
+
+      // Write state files
+      for (const [account, state] of Object.entries(states)) {
+        const statePath = path.join(TEST_DIR, `state-${account}.json`);
+        fs.writeFileSync(statePath, JSON.stringify(state));
+      }
+
+      // Read and verify isolation
+      const workState = JSON.parse(fs.readFileSync(path.join(TEST_DIR, 'state-work.json'), 'utf8'));
+      const personalState = JSON.parse(fs.readFileSync(path.join(TEST_DIR, 'state-personal.json'), 'utf8'));
+
+      expect(workState.seenEmailIds[0].id).toBe('work1');
+      expect(personalState.seenEmailIds[0].id).toBe('personal1');
+    });
+  });
+
+  describe('Seen Email Tracking', () => {
+    it('should track email IDs with timestamps', () => {
+      const now = Date.now();
+      const seenEntry = { id: 'email123', timestamp: now };
+
+      expect(seenEntry).toHaveProperty('id');
+      expect(seenEntry).toHaveProperty('timestamp');
+      expect(seenEntry.timestamp).toBeGreaterThan(0);
+    });
+
+    it('should identify new vs seen emails', () => {
+      const seenIds = [
+        { id: 'seen1', timestamp: Date.now() },
+        { id: 'seen2', timestamp: Date.now() },
+      ];
+
+      const incomingIds = ['seen1', 'new1', 'new2'];
+
+      const isEmailSeen = (id) => seenIds.some(item => item.id === id);
+      const newEmails = incomingIds.filter(id => !isEmailSeen(id));
+
+      expect(newEmails).toEqual(['new1', 'new2']);
+    });
+
+    it('should prune old seen emails', () => {
+      const now = Date.now();
+      const sevenDaysAgo = now - (7 * 24 * 60 * 60 * 1000);
+      const tenDaysAgo = now - (10 * 24 * 60 * 60 * 1000);
+
+      const seenIds = [
+        { id: 'recent', timestamp: now },
+        { id: 'weekOld', timestamp: sevenDaysAgo + 1000 },
+        { id: 'tooOld', timestamp: tenDaysAgo },
+      ];
+
+      const cutoff = now - (7 * 24 * 60 * 60 * 1000);
+      const filtered = seenIds.filter(item => item.timestamp > cutoff);
+
+      expect(filtered).toHaveLength(2);
+      expect(filtered.map(i => i.id)).toContain('recent');
+      expect(filtered.map(i => i.id)).toContain('weekOld');
+      expect(filtered.map(i => i.id)).not.toContain('tooOld');
+    });
+  });
+});

package/tests/state.test.js

@@ -0,0 +1,66 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+// Mock the state module
+vi.mock('../src/state', () => {
+  let state = {
+    lastCheck: null,
+    seenEmailIds: [],
+    lastNotifiedAt: null,
+  };
+
+  return {
+    getState: vi.fn(() => ({ ...state })),
+    updateLastCheck: vi.fn(() => {
+      state.lastCheck = Date.now();
+    }),
+    markEmailsSeen: vi.fn((ids) => {
+      const now = Date.now();
+      ids.forEach((id) => {
+        if (!state.seenEmailIds.some((item) => item.id === id)) {
+          state.seenEmailIds.push({ id, timestamp: now });
+        }
+      });
+    }),
+    isEmailSeen: vi.fn((id) => {
+      return state.seenEmailIds.some((item) => item.id === id);
+    }),
+    clearOldSeenEmails: vi.fn(),
+    getNewEmailIds: vi.fn((ids) => {
+      return ids.filter((id) => !state.seenEmailIds.some((item) => item.id === id));
+    }),
+    __resetState: () => {
+      state = { lastCheck: null, seenEmailIds: [], lastNotifiedAt: null };
+    },
+  };
+});
+
+describe('State Management', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('should track seen email IDs', async () => {
+    const { markEmailsSeen, getNewEmailIds } = await import('../src/state');
+
+    const emailIds = ['email1', 'email2', 'email3'];
+
+    // Initially none should be seen
+    const newIds = getNewEmailIds(emailIds);
+    expect(newIds).toEqual(emailIds);
+
+    // Mark some as seen
+    markEmailsSeen(['email1', 'email2']);
+
+    // Now only email3 should be new
+    const afterMark = getNewEmailIds(emailIds);
+    expect(afterMark).toEqual(['email3']);
+  });
+
+  it('should update last check timestamp', async () => {
+    const { updateLastCheck } = await import('../src/state');
+
+    updateLastCheck();
+
+    expect(updateLastCheck).toHaveBeenCalled();
+  });
+});

package/vitest.config.js

@@ -0,0 +1,13 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    setupFiles: ['./tests/setup.js'],
+    globals: true,
+    environment: 'node',
+    // Ensure mocks in __mocks__ folder are used automatically
+    deps: {
+      interopDefault: true,
+    },
+  },
+});

package/com.danielparedes.inboxd.plist

@@ -1,40 +0,0 @@
-<?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>/usr/local/bin/node</string>
-        <string>/Users/danielparedes/Documents/Github/inboxd/src/cli.js</string>
-        <string>check</string>
-        <string>--quiet</string>
-    </array>
-
-    <key>WorkingDirectory</key>
-    <string>/Users/danielparedes/Documents/Github/inboxd</string>
-
-    <!-- Run every 5 minutes (300 seconds) -->
-    <key>StartInterval</key>
-    <integer>300</integer>
-
-    <!-- Run immediately when loaded -->
-    <key>RunAtLoad</key>
-    <true/>
-
-    <!-- Logging -->
-    <key>StandardOutPath</key>
-    <string>/tmp/inboxd.log</string>
-    <key>StandardErrorPath</key>
-    <string>/tmp/inboxd.error.log</string>
-
-    <!-- Environment variables -->
-    <key>EnvironmentVariables</key>
-    <dict>
-        <key>PATH</key>
-        <string>/usr/local/bin:/usr/bin:/bin</string>
-    </dict>
-</dict>
-</plist>

package/credentials.json

@@ -1 +0,0 @@
-{"installed":{"client_id":"670632438932-arhht2o3bp94r0ug45o2accmu084eqfu.apps.googleusercontent.com","project_id":"daily-assistant-483211","auth_uri":"https://accounts.google.com/o/oauth2/auth","token_uri":"https://oauth2.googleapis.com/token","auth_provider_x509_cert_url":"https://www.googleapis.com/oauth2/v1/certs","client_secret":"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","redirect_uris":["http://localhost"]}}