inboxd 1.0.0 → 1.0.3

package/src/gmail-monitor.js

@@ -19,9 +19,8 @@ async function withRetry(operation) {
     const isServerError = error.response?.status >= 500;
 
     if (isNetworkError || isServerError) {
-      // console.log('Retrying operation due to error:', error.message);
       await new Promise((resolve) => setTimeout(resolve, 1000));
-      return await operation();
+      return operation();
     }
 
     throw error;
@@ -68,7 +67,7 @@ async function getUnreadEmails(account = 'default', maxResults = 20, includeRead
           snippet: detail.data.snippet,
           date: getHeader('Date'),
         };
-      } catch (err) {
+      } catch (_err) {
         return null;
       }
     });
@@ -152,14 +151,40 @@ async function getEmailById(account, messageId) {
       snippet: detail.data.snippet,
       date: getHeader('Date'),
     };
-  } catch (err) {
+  } catch (_err) {
     return null;
   }
 }
 
+/**
+ * Restores emails from trash (untrash)
+ * @param {string} account - Account name
+ * @param {Array<string>} messageIds - Array of message IDs to restore
+ * @returns {Array<{id: string, success: boolean, error?: string}>} Results for each message
+ */
+async function untrashEmails(account, messageIds) {
+  const gmail = await getGmailClient(account);
+  const results = [];
+
+  for (const id of messageIds) {
+    try {
+      await withRetry(() => gmail.users.messages.untrash({
+        userId: 'me',
+        id: id,
+      }));
+      results.push({ id, success: true });
+    } catch (err) {
+      results.push({ id, success: false, error: err.message });
+    }
+  }
+
+  return results;
+}
+
 module.exports = {
   getUnreadEmails,
   getEmailCount,
   trashEmails,
   getEmailById,
+  untrashEmails,
 };

package/src/state.js

@@ -1,8 +1,9 @@
 const fs = require('fs');
 const path = require('path');
-const os = require('os');
+const { TOKEN_DIR } = require('./gmail-auth');
+const { atomicWriteJsonSync } = require('./utils');
 
-const STATE_DIR = path.join(os.homedir(), '.config', 'inboxd');
+const STATE_DIR = TOKEN_DIR;
 
 function getStatePath(account = 'default') {
   return path.join(STATE_DIR, `state-${account}.json`);
@@ -21,7 +22,7 @@ function loadState(account = 'default') {
       const content = fs.readFileSync(statePath, 'utf8');
       return JSON.parse(content);
     }
-  } catch (error) {}
+  } catch (_error) {}
   return {
     lastCheck: null,
     seenEmailIds: [],
@@ -31,7 +32,7 @@ function loadState(account = 'default') {
 
 function saveState(state, account = 'default') {
   ensureDir();
-  fs.writeFileSync(getStatePath(account), JSON.stringify(state, null, 2));
+  atomicWriteJsonSync(getStatePath(account), state);
 }
 
 function getState(account = 'default') {

package/src/types.js

@@ -0,0 +1,45 @@
+/**
+ * Type definitions for inboxd data structures.
+ * This file contains JSDoc @typedef definitions for data shapes used in the project.
+ * It helps with type hinting and documentation.
+ */
+
+/**
+ * @typedef {Object} Account
+ * @property {string} name - Unique account identifier (e.g., "work", "personal")
+ * @property {string} email - Gmail address for this account
+ */
+
+/**
+ * @typedef {Object} AccountState
+ * @property {string[]} seenEmailIds - Array of email IDs already processed
+ * @property {string|null} lastCheck - ISO timestamp of last check
+ * @property {string|null} lastNotifiedAt - ISO timestamp of last notification
+ */
+
+/**
+ * @typedef {Object} DeletionEntry
+ * @property {string} id - Email message ID
+ * @property {string} threadId - Thread ID
+ * @property {string} subject - Email subject
+ * @property {string} from - Sender
+ * @property {string} account - Account name that owns this email
+ * @property {string} deletedAt - ISO timestamp
+ */
+
+/**
+ * @typedef {Object} Email
+ * @property {string} id - Message ID
+ * @property {string} threadId - Thread ID
+ * @property {string} subject - Email subject
+ * @property {string} from - Sender
+ * @property {string} snippet - Preview text
+ * @property {string} date - Date string
+ */
+
+/**
+ * @typedef {Object} Credentials
+ * @property {{client_id: string, client_secret: string, redirect_uris: string[]}} installed - OAuth client config
+ */
+
+module.exports = {};

package/src/utils.js

@@ -0,0 +1,30 @@
+/**
+ * Utility functions for inboxd
+ */
+const fs = require('fs');
+
+/**
+ * Writes data to a file atomically (write to temp, then rename)
+ * This prevents data corruption if the process crashes during write.
+ * @param {string} filePath - Target file path
+ * @param {string} data - Data to write
+ */
+function atomicWriteSync(filePath, data) {
+  const tmpPath = `${filePath}.tmp`;
+  fs.writeFileSync(tmpPath, data);
+  fs.renameSync(tmpPath, filePath);
+}
+
+/**
+ * Writes JSON data to a file atomically with pretty formatting
+ * @param {string} filePath - Target file path
+ * @param {*} data - Data to serialize as JSON
+ */
+function atomicWriteJsonSync(filePath, data) {
+  atomicWriteSync(filePath, JSON.stringify(data, null, 2));
+}
+
+module.exports = {
+  atomicWriteSync,
+  atomicWriteJsonSync,
+};

package/tests/analyze.test.js

@@ -0,0 +1,165 @@
+import { describe, it, expect } from 'vitest';
+
+describe('Analyze Command', () => {
+  describe('Email data structure', () => {
+    it('should include labelIds and threadId in email objects', () => {
+      const email = {
+        id: 'msg123',
+        threadId: 'thread456',
+        labelIds: ['UNREAD', 'CATEGORY_PROMOTIONS'],
+        account: 'personal',
+        from: 'promo@store.com',
+        subject: 'Sale ends today!',
+        snippet: 'Don\'t miss out on 50% off...',
+        date: '2026-01-03',
+      };
+
+      expect(email.threadId).toBe('thread456');
+      expect(email.labelIds).toContain('CATEGORY_PROMOTIONS');
+      expect(email.labelIds).toContain('UNREAD');
+    });
+
+    it('should handle emails without labelIds gracefully', () => {
+      const email = {
+        id: 'msg123',
+        threadId: 'thread456',
+        labelIds: [],
+        account: 'work',
+        from: 'boss@company.com',
+        subject: 'Meeting tomorrow',
+        snippet: 'Can we sync up...',
+        date: '2026-01-03',
+      };
+
+      expect(email.labelIds).toEqual([]);
+      expect(Array.isArray(email.labelIds)).toBe(true);
+    });
+  });
+
+  describe('JSON output format', () => {
+    it('should produce valid JSON array', () => {
+      const emails = [
+        {
+          id: 'msg1',
+          threadId: 'thread1',
+          labelIds: ['UNREAD', 'INBOX'],
+          account: 'personal',
+          from: 'friend@example.com',
+          subject: 'Hello!',
+          snippet: 'How are you doing?',
+          date: '2026-01-03',
+        },
+        {
+          id: 'msg2',
+          threadId: 'thread2',
+          labelIds: ['UNREAD', 'CATEGORY_UPDATES'],
+          account: 'work',
+          from: 'github@notifications.com',
+          subject: 'PR merged',
+          snippet: 'Your pull request was merged...',
+          date: '2026-01-03',
+        },
+      ];
+
+      const jsonOutput = JSON.stringify(emails, null, 2);
+      const parsed = JSON.parse(jsonOutput);
+
+      expect(Array.isArray(parsed)).toBe(true);
+      expect(parsed).toHaveLength(2);
+      expect(parsed[0].id).toBe('msg1');
+      expect(parsed[1].labelIds).toContain('CATEGORY_UPDATES');
+    });
+
+    it('should include all required fields for AI analysis', () => {
+      const email = {
+        id: 'msg123',
+        threadId: 'thread456',
+        labelIds: ['UNREAD', 'INBOX'],
+        account: 'dparedesi@uni.pe',
+        from: 'LinkedIn <jobs@linkedin.com>',
+        subject: 'New job matches for you',
+        snippet: 'Director of Engineering at...',
+        date: 'Fri, 03 Jan 2026 10:00:00 +0000',
+      };
+
+      // All fields needed for categorization
+      expect(email).toHaveProperty('from');
+      expect(email).toHaveProperty('subject');
+      expect(email).toHaveProperty('snippet');
+      expect(email).toHaveProperty('labelIds');
+      expect(email).toHaveProperty('account');
+    });
+  });
+
+  describe('Count limiting', () => {
+    it('should respect max count parameter', () => {
+      const allEmails = Array.from({ length: 50 }, (_, i) => ({
+        id: `msg${i}`,
+        threadId: `thread${i}`,
+        labelIds: ['UNREAD'],
+        account: 'test',
+        from: `sender${i}@example.com`,
+        subject: `Email ${i}`,
+        snippet: `Content ${i}`,
+        date: '2026-01-03',
+      }));
+
+      const maxCount = 20;
+      const limitedEmails = allEmails.slice(0, maxCount);
+
+      expect(limitedEmails).toHaveLength(20);
+      expect(limitedEmails[0].id).toBe('msg0');
+      expect(limitedEmails[19].id).toBe('msg19');
+    });
+  });
+
+  describe('Account filtering', () => {
+    it('should filter emails by account', () => {
+      const allEmails = [
+        { id: '1', account: 'personal', subject: 'Personal' },
+        { id: '2', account: 'work', subject: 'Work' },
+        { id: '3', account: 'personal', subject: 'Personal 2' },
+        { id: '4', account: 'other', subject: 'Other' },
+      ];
+
+      const workEmails = allEmails.filter(e => e.account === 'work');
+      const personalEmails = allEmails.filter(e => e.account === 'personal');
+
+      expect(workEmails).toHaveLength(1);
+      expect(personalEmails).toHaveLength(2);
+    });
+  });
+
+  describe('Gmail label categorization hints', () => {
+    it('should identify promotional emails by labelIds', () => {
+      const email = {
+        labelIds: ['UNREAD', 'CATEGORY_PROMOTIONS'],
+      };
+
+      const isPromo = email.labelIds.includes('CATEGORY_PROMOTIONS');
+      expect(isPromo).toBe(true);
+    });
+
+    it('should identify update emails by labelIds', () => {
+      const email = {
+        labelIds: ['UNREAD', 'CATEGORY_UPDATES'],
+      };
+
+      const isUpdate = email.labelIds.includes('CATEGORY_UPDATES');
+      expect(isUpdate).toBe(true);
+    });
+
+    it('should identify primary inbox emails', () => {
+      const email = {
+        labelIds: ['UNREAD', 'INBOX'],
+      };
+
+      const isPrimary = email.labelIds.includes('INBOX') &&
+        !email.labelIds.includes('CATEGORY_PROMOTIONS') &&
+        !email.labelIds.includes('CATEGORY_UPDATES') &&
+        !email.labelIds.includes('CATEGORY_SOCIAL');
+
+      expect(isPrimary).toBe(true);
+    });
+  });
+});

package/tests/deletion-log.test.js

@@ -0,0 +1,171 @@
+import { describe, it, expect } from 'vitest';
+import path from 'path';
+import os from 'os';
+
+// Test the logic patterns used by deletion-log without importing the real module
+// This avoids issues with fs mocking in CommonJS modules
+
+describe('Deletion Log', () => {
+  const LOG_DIR = path.join(os.homedir(), '.config', 'inboxd');
+  const LOG_FILE = path.join(LOG_DIR, 'deletion-log.json');
+
+  describe('Log entry structure', () => {
+    it('should have required fields for recovery', () => {
+      const logEntry = {
+        deletedAt: '2026-01-03T15:45:00.000Z',
+        account: 'dparedesi@uni.pe',
+        id: '19b84376ff5f5ed2',
+        threadId: '19b84376ff5f5ed2',
+        from: 'L&G Pensions <clientservices@pensions.landg.com>',
+        subject: 'Daniel, choose or review your beneficiary',
+        snippet: 'Take charge of tomorrow...',
+      };
+
+      expect(logEntry).toHaveProperty('deletedAt');
+      expect(logEntry).toHaveProperty('account');
+      expect(logEntry).toHaveProperty('id');
+      expect(logEntry).toHaveProperty('threadId');
+      expect(logEntry).toHaveProperty('from');
+      expect(logEntry).toHaveProperty('subject');
+      expect(logEntry).toHaveProperty('snippet');
+    });
+
+    it('should include ISO timestamp', () => {
+      const timestamp = new Date().toISOString();
+      expect(timestamp).toMatch(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/);
+    });
+  });
+
+  describe('Log filtering', () => {
+    it('should filter entries by date range', () => {
+      const now = new Date();
+      const tenDaysAgo = new Date(now);
+      tenDaysAgo.setDate(tenDaysAgo.getDate() - 10);
+      const fortyDaysAgo = new Date(now);
+      fortyDaysAgo.setDate(fortyDaysAgo.getDate() - 40);
+
+      const entries = [
+        { deletedAt: now.toISOString(), id: 'recent' },
+        { deletedAt: tenDaysAgo.toISOString(), id: 'ten-days' },
+        { deletedAt: fortyDaysAgo.toISOString(), id: 'forty-days' },
+      ];
+
+      const cutoff = new Date();
+      cutoff.setDate(cutoff.getDate() - 30);
+
+      const recentEntries = entries.filter((e) => new Date(e.deletedAt) >= cutoff);
+
+      expect(recentEntries).toHaveLength(2);
+      expect(recentEntries.map(e => e.id)).toContain('recent');
+      expect(recentEntries.map(e => e.id)).toContain('ten-days');
+      expect(recentEntries.map(e => e.id)).not.toContain('forty-days');
+    });
+  });
+
+  describe('Log path', () => {
+    it('should use correct log directory path', () => {
+      expect(LOG_DIR).toContain('.config');
+      expect(LOG_DIR).toContain('inboxd');
+    });
+
+    it('should use correct log file name', () => {
+      expect(LOG_FILE).toContain('deletion-log.json');
+    });
+  });
+
+  describe('Batch logging', () => {
+    it('should handle multiple emails in one log operation', () => {
+      const emails = [
+        { id: '1', account: 'test', from: 'a@b.com', subject: 'A', snippet: 'a', threadId: '1' },
+        { id: '2', account: 'test', from: 'c@d.com', subject: 'B', snippet: 'b', threadId: '2' },
+        { id: '3', account: 'test', from: 'e@f.com', subject: 'C', snippet: 'c', threadId: '3' },
+      ];
+
+      const timestamp = new Date().toISOString();
+      const logEntries = emails.map(email => ({
+        deletedAt: timestamp,
+        ...email,
+      }));
+
+      expect(logEntries).toHaveLength(3);
+      expect(logEntries[0].id).toBe('1');
+      expect(logEntries[2].id).toBe('3');
+    });
+  });
+
+  describe('Empty log handling', () => {
+    it('should return empty array for empty log', () => {
+      const emptyLog = [];
+      expect(emptyLog).toHaveLength(0);
+      expect(Array.isArray(emptyLog)).toBe(true);
+    });
+
+    it('should handle missing log file gracefully', () => {
+      // Simulate the readLog behavior when file doesn't exist
+      const readLogSafe = (fileExists, fileContent) => {
+        if (!fileExists) return [];
+        try {
+          return JSON.parse(fileContent);
+        } catch {
+          return [];
+        }
+      };
+
+      expect(readLogSafe(false, '')).toEqual([]);
+      expect(readLogSafe(true, 'invalid json')).toEqual([]);
+      expect(readLogSafe(true, '[]')).toEqual([]);
+    });
+  });
+
+  describe('Log removal logic', () => {
+    it('should remove entries by id', () => {
+      const log = [
+        { id: '1', account: 'test' },
+        { id: '2', account: 'test' },
+        { id: '3', account: 'test' },
+      ];
+
+      const idsToRemove = ['2'];
+      const newLog = log.filter(entry => !idsToRemove.includes(entry.id));
+
+      expect(newLog).toHaveLength(2);
+      expect(newLog.find(e => e.id === '2')).toBeUndefined();
+      expect(newLog.find(e => e.id === '1')).toBeDefined();
+      expect(newLog.find(e => e.id === '3')).toBeDefined();
+    });
+
+    it('should detect when entries were removed', () => {
+      const log = [{ id: '1' }, { id: '2' }];
+      const idsToRemove = ['2'];
+      const newLog = log.filter(entry => !idsToRemove.includes(entry.id));
+
+      // This is the condition used in removeLogEntries to decide whether to write
+      const entriesWereRemoved = log.length !== newLog.length;
+      expect(entriesWereRemoved).toBe(true);
+    });
+
+    it('should not detect removal for non-existent ids', () => {
+      const log = [{ id: '1' }];
+      const idsToRemove = ['999'];
+      const newLog = log.filter(entry => !idsToRemove.includes(entry.id));
+
+      const entriesWereRemoved = log.length !== newLog.length;
+      expect(entriesWereRemoved).toBe(false);
+    });
+
+    it('should handle removing multiple entries', () => {
+      const log = [
+        { id: '1' },
+        { id: '2' },
+        { id: '3' },
+        { id: '4' },
+      ];
+
+      const idsToRemove = ['1', '3'];
+      const newLog = log.filter(entry => !idsToRemove.includes(entry.id));
+
+      expect(newLog).toHaveLength(2);
+      expect(newLog.map(e => e.id)).toEqual(['2', '4']);
+    });
+  });
+});

package/tests/gmail-auth.test.js

@@ -0,0 +1,77 @@
+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 to avoid touching real config
+const TEST_DIR = path.join(os.tmpdir(), 'inboxd-test-' + Date.now());
+
+describe('Gmail Auth Module', () => {
+  beforeEach(() => {
+    fs.mkdirSync(TEST_DIR, { recursive: true });
+  });
+
+  afterEach(() => {
+    fs.rmSync(TEST_DIR, { recursive: true, force: true });
+  });
+
+  describe('Account Management', () => {
+    it('should generate correct token paths for different accounts', async () => {
+      // We test the path generation logic
+      const defaultPath = `token-default.json`;
+      const workPath = `token-work.json`;
+      const personalPath = `token-personal.json`;
+
+      expect(defaultPath).toBe('token-default.json');
+      expect(workPath).toBe('token-work.json');
+      expect(personalPath).toBe('token-personal.json');
+    });
+
+    it('should handle account names with special characters', () => {
+      const safeName = (name) => name.replace(/[^a-zA-Z0-9-_]/g, '_');
+
+      expect(safeName('my-work')).toBe('my-work');
+      expect(safeName('personal_email')).toBe('personal_email');
+      expect(safeName('test account')).toBe('test_account');
+    });
+  });
+
+  describe('Credentials Path', () => {
+    it('should use environment variable if set', () => {
+      const envPath = '/custom/path/credentials.json';
+      const getPath = (envVar) => envVar || 'credentials.json';
+
+      expect(getPath(envPath)).toBe(envPath);
+      expect(getPath(undefined)).toBe('credentials.json');
+    });
+  });
+});
+
+describe('Accounts Data Structure', () => {
+  it('should have correct structure for accounts list', () => {
+    const accountsData = {
+      accounts: [
+        { name: 'default', email: 'user@gmail.com' },
+        { name: 'work', email: 'user@company.com' },
+      ],
+      defaultAccount: 'default',
+    };
+
+    expect(accountsData.accounts).toHaveLength(2);
+    expect(accountsData.accounts[0]).toHaveProperty('name');
+    expect(accountsData.accounts[0]).toHaveProperty('email');
+    expect(accountsData.defaultAccount).toBe('default');
+  });
+
+  it('should find account by name', () => {
+    const accounts = [
+      { name: 'default', email: 'user@gmail.com' },
+      { name: 'work', email: 'user@company.com' },
+    ];
+
+    const findAccount = (name) => accounts.find(a => a.name === name);
+
+    expect(findAccount('work')).toEqual({ name: 'work', email: 'user@company.com' });
+    expect(findAccount('nonexistent')).toBeUndefined();
+  });
+});