inboxd 1.0.8 → 1.0.10

package/src/gmail-monitor.js

@@ -181,10 +181,119 @@ async function untrashEmails(account, messageIds) {
   return results;
 }
 
+/**
+ * Marks emails as read by removing the UNREAD label
+ * @param {string} account - Account name
+ * @param {Array<string>} messageIds - Array of message IDs to mark as read
+ * @returns {Array<{id: string, success: boolean, error?: string}>} Results for each message
+ */
+async function markAsRead(account, messageIds) {
+  const gmail = await getGmailClient(account);
+  const results = [];
+
+  for (const id of messageIds) {
+    try {
+      await withRetry(() => gmail.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 });
+    }
+  }
+
+  return results;
+}
+
+/**
+ * Archives emails by removing the INBOX label
+ * @param {string} account - Account name
+ * @param {Array<string>} messageIds - Array of message IDs to archive
+ * @returns {Array<{id: string, success: boolean, error?: string}>} Results for each message
+ */
+async function archiveEmails(account, messageIds) {
+  const gmail = await getGmailClient(account);
+  const results = [];
+
+  for (const id of messageIds) {
+    try {
+      await withRetry(() => gmail.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 });
+    }
+  }
+
+  return results;
+}
+
+/**
+ * Extracts the domain from a From header value
+ * @param {string} from - e.g., "Sender Name <sender@example.com>" or "sender@example.com"
+ * @returns {string} Normalized domain (e.g., "example.com") or lowercased from if no domain found
+ */
+function extractSenderDomain(from) {
+  if (!from) return '';
+  // Match email in angle brackets or bare email
+  const emailMatch = from.match(/<([^>]+)>/) || from.match(/([^\s]+@[^\s]+)/);
+  if (emailMatch) {
+    const email = emailMatch[1];
+    const domain = email.split('@')[1];
+    return domain ? domain.toLowerCase() : email.toLowerCase();
+  }
+  return from.toLowerCase();
+}
+
+/**
+ * Groups emails by sender domain
+ * @param {Array<Object>} emails - Array of email objects with from, id, subject, date, account
+ * @returns {{groups: Array<{sender: string, senderDisplay: string, count: number, emails: Array}>, totalCount: number}}
+ */
+function groupEmailsBySender(emails) {
+  const groups = {};
+
+  for (const email of emails) {
+    const domain = extractSenderDomain(email.from);
+    if (!groups[domain]) {
+      groups[domain] = {
+        sender: domain,
+        senderDisplay: email.from,
+        count: 0,
+        emails: [],
+      };
+    }
+    groups[domain].count++;
+    groups[domain].emails.push({
+      id: email.id,
+      subject: email.subject,
+      date: email.date,
+      account: email.account,
+    });
+  }
+
+  // Convert to array and sort by count descending
+  const groupArray = Object.values(groups).sort((a, b) => b.count - a.count);
+  return { groups: groupArray, totalCount: emails.length };
+}
+
 module.exports = {
   getUnreadEmails,
   getEmailCount,
   trashEmails,
   getEmailById,
   untrashEmails,
+  markAsRead,
+  archiveEmails,
+  extractSenderDomain,
+  groupEmailsBySender,
 };

package/src/skill-installer.js

@@ -0,0 +1,282 @@
+/**
+ * Skill Installer - Copies the inbox-assistant skill to ~/.claude/skills/
+ * Enables AI agents (like Claude Code) to use inboxd effectively.
+ *
+ * Safety features:
+ * - Source marker: Only manages skills with `source: inboxd` in front matter
+ * - Content hash: Detects changes without version numbers
+ * - Backup: Creates .backup before replacing modified files
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const crypto = require('crypto');
+
+const SKILL_NAME = 'inbox-assistant';
+const SOURCE_MARKER = 'inboxd';
+const SKILL_SOURCE_DIR = path.join(__dirname, '..', '.claude', 'skills', SKILL_NAME);
+const SKILL_DEST_DIR = path.join(os.homedir(), '.claude', 'skills', SKILL_NAME);
+
+/**
+ * Compute MD5 hash of file content
+ * @param {string} filePath - Path to file
+ * @returns {string|null} Hash string or null if file doesn't exist
+ */
+function getFileHash(filePath) {
+  try {
+    const content = fs.readFileSync(filePath, 'utf8');
+    return crypto.createHash('md5').update(content).digest('hex');
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Extract the source field from SKILL.md front matter
+ * @param {string} skillPath - Path to SKILL.md
+ * @returns {string|null} Source string or null if not found
+ */
+function getSkillSource(skillPath) {
+  try {
+    const content = fs.readFileSync(skillPath, 'utf8');
+    const match = content.match(/^---[\s\S]*?source:\s*["']?([^"'\n]+)["']?[\s\S]*?---/m);
+    return match ? match[1].trim() : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Create a backup of the skill file
+ * @param {string} skillDir - Directory containing SKILL.md
+ * @returns {{ success: boolean, tempPath: string|null, originalHash: string|null }} Backup result
+ */
+function createBackup(skillDir) {
+  const skillPath = path.join(skillDir, 'SKILL.md');
+  // Backup to parent directory to survive directory deletion
+  const backupPath = path.join(path.dirname(skillDir), `${SKILL_NAME}-SKILL.md.backup`);
+
+  try {
+    if (fs.existsSync(skillPath)) {
+      // Get hash of original before backup (for verification)
+      const originalHash = getFileHash(skillPath);
+      fs.copyFileSync(skillPath, backupPath);
+
+      // Verify backup was created with correct content
+      const backupHash = getFileHash(backupPath);
+      if (backupHash === originalHash) {
+        return { success: true, tempPath: backupPath, originalHash };
+      }
+      // Backup hash doesn't match - something went wrong
+      return { success: false, tempPath: null, originalHash: null };
+    }
+    return { success: false, tempPath: null, originalHash: null };
+  } catch {
+    return { success: false, tempPath: null, originalHash: null };
+  }
+}
+
+/**
+ * Move backup file into the skill directory after installation
+ * @param {string} tempBackupPath - Path to temporary backup in parent directory
+ * @param {string} skillDir - Skill directory to move backup into
+ * @returns {string|null} Final backup path or null if failed
+ */
+function moveBackupToSkillDir(tempBackupPath, skillDir) {
+  if (!tempBackupPath || !fs.existsSync(tempBackupPath)) {
+    return null;
+  }
+
+  const finalBackupPath = path.join(skillDir, 'SKILL.md.backup');
+
+  try {
+    fs.renameSync(tempBackupPath, finalBackupPath);
+    return finalBackupPath;
+  } catch {
+    // If rename fails (cross-device), try copy + delete
+    try {
+      fs.copyFileSync(tempBackupPath, finalBackupPath);
+      fs.unlinkSync(tempBackupPath);
+      return finalBackupPath;
+    } catch {
+      return null;
+    }
+  }
+}
+
+/**
+ * Check if the skill is already installed and get its status
+ * @returns {{ installed: boolean, currentHash: string|null, sourceHash: string|null, isOurs: boolean, source: string|null }}
+ */
+function getSkillStatus() {
+  const destSkillMd = path.join(SKILL_DEST_DIR, 'SKILL.md');
+  const sourceSkillMd = path.join(SKILL_SOURCE_DIR, 'SKILL.md');
+
+  const installed = fs.existsSync(destSkillMd);
+  const currentHash = installed ? getFileHash(destSkillMd) : null;
+  const sourceHash = getFileHash(sourceSkillMd);
+  const source = installed ? getSkillSource(destSkillMd) : null;
+  const isOurs = source === SOURCE_MARKER;
+
+  return { installed, currentHash, sourceHash, isOurs, source };
+}
+
+/**
+ * Check if an update is available
+ * @returns {{ updateAvailable: boolean, isOurs: boolean, hashMismatch: boolean }}
+ */
+function checkForUpdate() {
+  const status = getSkillStatus();
+
+  if (!status.installed) {
+    return { updateAvailable: false, isOurs: false, hashMismatch: false };
+  }
+
+  const hashMismatch = status.currentHash !== status.sourceHash;
+
+  return {
+    updateAvailable: status.isOurs && hashMismatch,
+    isOurs: status.isOurs,
+    hashMismatch
+  };
+}
+
+/**
+ * Copy directory recursively
+ * @param {string} src - Source directory
+ * @param {string} dest - Destination directory
+ */
+function copyDirSync(src, dest) {
+  fs.mkdirSync(dest, { recursive: true });
+
+  const entries = fs.readdirSync(src, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+
+    if (entry.isDirectory()) {
+      copyDirSync(srcPath, destPath);
+    } else {
+      fs.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+
+/**
+ * Install or update the skill
+ * @param {{ force?: boolean }} options - Installation options
+ * @returns {{ success: boolean, action: 'installed'|'updated'|'unchanged'|'skipped', reason?: string, backedUp?: boolean, backupPath?: string, path: string }}
+ */
+function installSkill(options = {}) {
+  const { force = false } = options;
+
+  // Ensure source exists
+  if (!fs.existsSync(SKILL_SOURCE_DIR)) {
+    throw new Error(`Skill source not found at ${SKILL_SOURCE_DIR}`);
+  }
+
+  const status = getSkillStatus();
+  const updateInfo = checkForUpdate();
+
+  // Check ownership if skill already exists
+  if (status.installed && !status.isOurs && !force) {
+    return {
+      success: false,
+      action: 'skipped',
+      reason: 'not_owned',
+      path: SKILL_DEST_DIR
+    };
+  }
+
+  // Check if already up-to-date
+  if (status.installed && status.isOurs && !updateInfo.hashMismatch) {
+    return {
+      success: true,
+      action: 'unchanged',
+      path: SKILL_DEST_DIR
+    };
+  }
+
+  // Ensure parent directory exists
+  const skillsDir = path.dirname(SKILL_DEST_DIR);
+  fs.mkdirSync(skillsDir, { recursive: true });
+
+  // Backup if replacing existing (user may have modified)
+  let backedUp = false;
+  let backupPath = null;
+  let backupResult = null;
+  if (status.installed) {
+    backupResult = createBackup(SKILL_DEST_DIR);
+
+    if (!backupResult.success) {
+      // Backup failed - don't proceed without protecting user's data
+      return {
+        success: false,
+        action: 'skipped',
+        reason: 'backup_failed',
+        path: SKILL_DEST_DIR
+      };
+    }
+
+    // Remove existing for clean update
+    fs.rmSync(SKILL_DEST_DIR, { recursive: true, force: true });
+  }
+
+  // Copy the skill directory
+  copyDirSync(SKILL_SOURCE_DIR, SKILL_DEST_DIR);
+
+  // Move backup into the new skill directory
+  if (backupResult && backupResult.tempPath) {
+    backupPath = moveBackupToSkillDir(backupResult.tempPath, SKILL_DEST_DIR);
+    backedUp = !!backupPath;
+
+    // Verify the backup still has the original content after move
+    if (backedUp && backupResult.originalHash) {
+      const movedBackupHash = getFileHash(backupPath);
+      if (movedBackupHash !== backupResult.originalHash) {
+        // Something went wrong during move - backup is corrupted
+        backedUp = false;
+      }
+    }
+  }
+
+  const action = status.installed ? 'updated' : 'installed';
+
+  return {
+    success: true,
+    action,
+    backedUp,
+    backupPath,
+    path: SKILL_DEST_DIR
+  };
+}
+
+/**
+ * Uninstall the skill
+ * @returns {{ success: boolean, existed: boolean }}
+ */
+function uninstallSkill() {
+  const existed = fs.existsSync(SKILL_DEST_DIR);
+
+  if (existed) {
+    fs.rmSync(SKILL_DEST_DIR, { recursive: true, force: true });
+  }
+
+  return { success: true, existed };
+}
+
+module.exports = {
+  SKILL_NAME,
+  SOURCE_MARKER,
+  SKILL_SOURCE_DIR,
+  SKILL_DEST_DIR,
+  getFileHash,
+  getSkillSource,
+  createBackup,
+  getSkillStatus,
+  checkForUpdate,
+  installSkill,
+  uninstallSkill
+};

package/tests/filter.test.js

@@ -0,0 +1,200 @@
+import { describe, it, expect } from 'vitest';
+
+// Test the email filtering logic used in inbox delete command
+// We test the logic patterns without importing the actual module
+
+describe('Email Filtering Logic', () => {
+  const testEmails = [
+    { id: '1', from: 'LinkedIn Jobs <jobs@linkedin.com>', subject: 'New jobs for you', account: 'personal' },
+    { id: '2', from: 'Jules Bot <jules@company.com>', subject: 'PR #42 ready for review', account: 'work' },
+    { id: '3', from: 'newsletter@techcrunch.com', subject: 'TechCrunch Weekly Digest', account: 'personal' },
+    { id: '4', from: 'Security Alert <security@bank.com>', subject: 'Unusual login detected', account: 'personal' },
+    { id: '5', from: 'LinkedIn <notifications@linkedin.com>', subject: 'You have 3 new messages', account: 'work' },
+    { id: '6', from: 'GitHub <noreply@github.com>', subject: 'PR Review requested', account: 'work' },
+  ];
+
+  /**
+   * Filter function matching the implementation in cli.js
+   */
+  function filterEmails(emails, senderPattern, matchPattern) {
+    return emails.filter(e => {
+      const matchesSender = !senderPattern ||
+        e.from.toLowerCase().includes(senderPattern.toLowerCase());
+      const matchesSubject = !matchPattern ||
+        e.subject.toLowerCase().includes(matchPattern.toLowerCase());
+      return matchesSender && matchesSubject;
+    });
+  }
+
+  describe('Sender filtering', () => {
+    it('should match case-insensitive substring in from field', () => {
+      const filtered = filterEmails(testEmails, 'linkedin', null);
+      expect(filtered).toHaveLength(2);
+      expect(filtered.map(e => e.id)).toEqual(['1', '5']);
+    });
+
+    it('should match partial sender names', () => {
+      const filtered = filterEmails(testEmails, 'jules', null);
+      expect(filtered).toHaveLength(1);
+      expect(filtered[0].id).toBe('2');
+    });
+
+    it('should match email domains', () => {
+      const filtered = filterEmails(testEmails, '@linkedin.com', null);
+      expect(filtered).toHaveLength(2);
+    });
+
+    it('should be case insensitive', () => {
+      const filtered = filterEmails(testEmails, 'LINKEDIN', null);
+      expect(filtered).toHaveLength(2);
+    });
+
+    it('should match partial email addresses', () => {
+      const filtered = filterEmails(testEmails, 'noreply', null);
+      expect(filtered).toHaveLength(1);
+      expect(filtered[0].id).toBe('6');
+    });
+  });
+
+  describe('Subject filtering', () => {
+    it('should match case-insensitive substring in subject', () => {
+      const filtered = filterEmails(testEmails, null, 'login');
+      expect(filtered).toHaveLength(1);
+      expect(filtered[0].id).toBe('4');
+    });
+
+    it('should match partial subject phrases', () => {
+      const filtered = filterEmails(testEmails, null, 'weekly');
+      expect(filtered).toHaveLength(1);
+      expect(filtered[0].id).toBe('3');
+    });
+
+    it('should match PR-related subjects', () => {
+      const filtered = filterEmails(testEmails, null, 'PR');
+      expect(filtered).toHaveLength(2);
+      expect(filtered.map(e => e.id).sort()).toEqual(['2', '6']);
+    });
+  });
+
+  describe('Combined filtering (AND logic)', () => {
+    it('should require both sender AND subject to match', () => {
+      const filtered = filterEmails(testEmails, 'linkedin', 'jobs');
+      expect(filtered).toHaveLength(1);
+      expect(filtered[0].id).toBe('1');
+    });
+
+    it('should return empty when no emails match both criteria', () => {
+      const filtered = filterEmails(testEmails, 'linkedin', 'security');
+      expect(filtered).toHaveLength(0);
+    });
+
+    it('should work with overlapping patterns', () => {
+      const filtered = filterEmails(testEmails, 'github', 'review');
+      expect(filtered).toHaveLength(1);
+      expect(filtered[0].id).toBe('6');
+    });
+  });
+
+  describe('No filter (passthrough)', () => {
+    it('should return all emails when no filters specified', () => {
+      const filtered = filterEmails(testEmails, null, null);
+      expect(filtered).toHaveLength(6);
+    });
+
+    it('should return all emails with empty string filters', () => {
+      const filtered = filterEmails(testEmails, '', '');
+      expect(filtered).toHaveLength(6);
+    });
+  });
+});
+
+describe('Safety Limit Logic', () => {
+  it('should enforce default limit of 50', () => {
+    const manyEmails = Array.from({ length: 100 }, (_, i) => ({
+      id: `msg${i}`,
+      from: 'spam@example.com',
+      subject: `Spam ${i}`,
+    }));
+    const limit = 50;
+    const limited = manyEmails.slice(0, limit);
+    expect(limited).toHaveLength(50);
+  });
+
+  it('should respect custom limit', () => {
+    const manyEmails = Array.from({ length: 100 }, (_, i) => ({
+      id: `msg${i}`,
+      from: 'spam@example.com',
+      subject: `Spam ${i}`,
+    }));
+    const limit = 25;
+    const limited = manyEmails.slice(0, limit);
+    expect(limited).toHaveLength(25);
+  });
+
+  it('should not truncate when under limit', () => {
+    const emails = Array.from({ length: 10 }, (_, i) => ({
+      id: `msg${i}`,
+      from: 'test@example.com',
+      subject: `Test ${i}`,
+    }));
+    const limit = 50;
+    const limited = emails.length > limit ? emails.slice(0, limit) : emails;
+    expect(limited).toHaveLength(10);
+  });
+});
+
+describe('Safety Warning Logic', () => {
+  function getWarnings(senderPattern, matchPattern, matchCount) {
+    const warnings = [];
+
+    if (senderPattern && senderPattern.length < 3) {
+      warnings.push(`Short sender pattern "${senderPattern}" may match broadly`);
+    }
+    if (matchPattern && matchPattern.length < 3) {
+      warnings.push(`Short subject pattern "${matchPattern}" may match broadly`);
+    }
+    if (matchCount > 100) {
+      warnings.push(`${matchCount} emails match - large batch deletion`);
+    }
+
+    return warnings;
+  }
+
+  it('should warn on short sender pattern', () => {
+    const warnings = getWarnings('ab', null, 5);
+    expect(warnings).toHaveLength(1);
+    expect(warnings[0]).toContain('Short sender pattern');
+  });
+
+  it('should warn on short subject pattern', () => {
+    const warnings = getWarnings(null, 're', 5);
+    expect(warnings).toHaveLength(1);
+    expect(warnings[0]).toContain('Short subject pattern');
+  });
+
+  it('should warn on large batch', () => {
+    const warnings = getWarnings('linkedin', null, 150);
+    expect(warnings).toHaveLength(1);
+    expect(warnings[0]).toContain('150 emails match');
+  });
+
+  it('should accumulate multiple warnings', () => {
+    const warnings = getWarnings('a', 'b', 200);
+    expect(warnings).toHaveLength(3);
+  });
+
+  it('should not warn for valid patterns and small batches', () => {
+    const warnings = getWarnings('linkedin', 'newsletter', 10);
+    expect(warnings).toHaveLength(0);
+  });
+
+  it('should allow exactly 3 char patterns without warning', () => {
+    const warnings = getWarnings('abc', 'def', 50);
+    expect(warnings).toHaveLength(0);
+  });
+
+  it('should allow exactly 100 matches without warning', () => {
+    const warnings = getWarnings('linkedin', null, 100);
+    expect(warnings).toHaveLength(0);
+  });
+});