inboxd 1.0.0

package/com.danielparedes.inboxd.plist

@@ -0,0 +1,40 @@
+<?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

@@ -0,0 +1 @@
+{"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"]}}

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "inboxd",
+  "version": "1.0.0",
+  "description": "CLI assistant for Gmail monitoring with multi-account support and AI-ready JSON output",
+  "main": "src/cli.js",
+  "bin": {
+    "inbox": "src/cli.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/dparedesi/inboxd.git"
+  },
+  "scripts": {
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "inbox": "node src/cli.js"
+  },
+  "keywords": [
+    "gmail",
+    "cli",
+    "email",
+    "monitor",
+    "assistant",
+    "ai",
+    "agent",
+    "inbox",
+    "tool"
+  ],
+  "author": "Daniel Paredes",
+  "license": "MIT",
+  "type": "commonjs",
+  "dependencies": {
+    "@google-cloud/local-auth": "^3.0.1",
+    "boxen": "^8.0.1",
+    "chalk": "^5.6.2",
+    "commander": "^14.0.2",
+    "googleapis": "^169.0.0",
+    "node-notifier": "^10.0.1"
+  },
+  "devDependencies": {
+    "vitest": "^4.0.16"
+  }
+}

package/src/cli.js

@@ -0,0 +1,396 @@
+#!/usr/bin/env node
+
+const { program } = require('commander');
+const { getUnreadEmails, getEmailCount, trashEmails, getEmailById } = require('./gmail-monitor');
+const { getState, updateLastCheck, markEmailsSeen, getNewEmailIds, clearOldSeenEmails } = require('./state');
+const { notifyNewEmails } = require('./notifier');
+const { authorize, addAccount, getAccounts, getAccountEmail, getDefaultAccount, removeAccount, removeAllAccounts, renameTokenFile } = require('./gmail-auth');
+const { logDeletions, getRecentDeletions, getLogPath } = require('./deletion-log');
+
+async function main() {
+  const chalk = (await import('chalk')).default;
+  const boxen = (await import('boxen')).default;
+
+  program
+    .name('inbox')
+    .description('Gmail monitoring CLI for Daily Assistant')
+    .version('1.0.0');
+
+  program
+    .command('auth')
+    .description('Authenticate a Gmail account')
+    .option('-a, --account <name>', 'Account name (e.g., personal, work)')
+    .action(async (options) => {
+      try {
+        // If account name is provided, use it. Otherwise start with a temporary name
+        // that we'll swap for the email address later
+        const isExplicitAccount = !!options.account;
+        let accountName = options.account || `temp_${Date.now()}`;
+
+        console.log(chalk.cyan(`Authenticating...`));
+        console.log(chalk.gray('A browser window will open for you to authorize access.\n'));
+
+        await authorize(accountName);
+        const email = await getAccountEmail(accountName);
+
+        if (!email) {
+          throw new Error('Could not retrieve email address from the authenticated account.');
+        }
+
+        // If user didn't specify an account name, we use the email
+        if (!isExplicitAccount) {
+          // Check if this email is already registered
+          const accounts = getAccounts();
+          const existing = accounts.find(a => a.email === email);
+
+          if (existing) {
+            console.log(chalk.yellow(`Account already registered as "${existing.name}" (${email})`));
+            // Clean up the temporary token
+            removeAccount(accountName);
+            return;
+          }
+
+          // Rename the token file from temp to email
+          renameTokenFile(accountName, email);
+          accountName = email;
+        }
+
+        addAccount(accountName, email);
+        console.log(chalk.green(`Authentication successful!`));
+        console.log(chalk.white(`Account "${accountName}" linked to ${email}`));
+
+      } catch (error) {
+        console.error(chalk.red('Authentication failed:'), error.message);
+        process.exit(1);
+      }
+    });
+
+  program
+    .command('accounts')
+    .description('List all configured accounts')
+    .action(async () => {
+      const accounts = getAccounts();
+      if (accounts.length === 0) {
+        console.log(chalk.gray('No accounts configured. Run: inbox auth --account <name>'));
+        return;
+      }
+
+      console.log(chalk.bold('\nConfigured Accounts:\n'));
+      for (const acc of accounts) {
+        console.log(`  ${chalk.cyan(acc.name)} - ${acc.email || 'unknown email'}`);
+      }
+      console.log('');
+    });
+
+  program
+    .command('logout')
+    .description('Remove an account or all accounts')
+    .option('-a, --account <name>', 'Account to remove (or "all" to remove all)')
+    .option('--all', 'Remove all accounts')
+    .action(async (options) => {
+      if (options.all || options.account === 'all') {
+        const accounts = getAccounts();
+        if (accounts.length === 0) {
+          console.log(chalk.gray('No accounts to remove.'));
+          return;
+        }
+        removeAllAccounts();
+        console.log(chalk.green(`Removed ${accounts.length} account(s) and cleared all tokens.`));
+      } else if (options.account) {
+        const accounts = getAccounts();
+        const exists = accounts.find(a => a.name === options.account);
+        if (!exists) {
+          console.log(chalk.yellow(`Account "${options.account}" not found.`));
+          return;
+        }
+        removeAccount(options.account);
+        console.log(chalk.green(`Removed account "${options.account}"`));
+      } else {
+        console.log(chalk.gray('Usage: inbox logout --account <name> or inbox logout --all'));
+      }
+    });
+
+  program
+    .command('check')
+    .description('Check for new emails and send notifications')
+    .option('-a, --account <name>', 'Check specific account (or "all")', 'all')
+    .option('-q, --quiet', 'Suppress output, only send notifications')
+    .action(async (options) => {
+      try {
+        const accounts = options.account === 'all'
+          ? getAccounts().map(a => a.name)
+          : [options.account];
+
+        if (accounts.length === 0) {
+          accounts.push('default');
+        }
+
+        let totalNew = 0;
+        const allNewEmails = [];
+
+        for (const account of accounts) {
+          clearOldSeenEmails(7, account);
+
+          const emails = await getUnreadEmails(account, 20);
+          const newEmailIds = getNewEmailIds(emails.map((e) => e.id), account);
+          const newEmails = emails.filter((e) => newEmailIds.includes(e.id));
+
+          if (newEmails.length > 0) {
+            markEmailsSeen(newEmailIds, account);
+            allNewEmails.push(...newEmails.map(e => ({ ...e, account })));
+            totalNew += newEmails.length;
+          }
+
+          updateLastCheck(account);
+
+          if (!options.quiet && newEmails.length > 0) {
+            console.log(chalk.green(`[${account}] ${newEmails.length} new email(s)`));
+            newEmails.forEach((e) => {
+              console.log(chalk.white(`  - ${e.subject}`));
+              console.log(chalk.gray(`    From: ${e.from}`));
+            });
+          }
+        }
+
+        if (allNewEmails.length > 0) {
+          notifyNewEmails(allNewEmails);
+        }
+
+        if (!options.quiet && totalNew === 0) {
+          console.log(chalk.gray('No new emails since last check.'));
+        }
+      } catch (error) {
+        console.error(chalk.red('Error checking emails:'), error.message);
+        process.exit(1);
+      }
+    });
+
+  program
+    .command('summary')
+    .description('Show summary of unread emails')
+    .option('-a, --account <name>', 'Show specific account (or "all")', 'all')
+    .option('-n, --count <number>', 'Number of emails per account', '5')
+    .action(async (options) => {
+      try {
+        const accounts = options.account === 'all'
+          ? getAccounts().map(a => a.name)
+          : [options.account];
+
+        if (accounts.length === 0) {
+          accounts.push('default');
+        }
+
+        const maxPerAccount = parseInt(options.count, 10);
+        const sections = [];
+
+        for (const account of accounts) {
+          const count = await getEmailCount(account);
+          const emails = await getUnreadEmails(account, maxPerAccount);
+          const state = getState(account);
+          const lastCheckStr = state.lastCheck
+            ? new Date(state.lastCheck).toLocaleString()
+            : 'Never';
+
+          const accountInfo = getAccounts().find(a => a.name === account);
+          const label = accountInfo?.email || account;
+
+          let content = `${chalk.bold.cyan(label)} - ${count} unread\n`;
+          content += chalk.gray(`Last check: ${lastCheckStr}\n\n`);
+
+          if (emails.length > 0) {
+            content += emails.map((e) => {
+              const from = e.from.length > 35 ? e.from.substring(0, 32) + '...' : e.from;
+              const subject = e.subject.length > 50 ? e.subject.substring(0, 47) + '...' : e.subject;
+              return `${chalk.white(from)}\n  ${chalk.gray(subject)}`;
+            }).join('\n\n');
+          } else {
+            content += chalk.gray('No unread emails');
+          }
+
+          sections.push(content);
+        }
+
+        const output = boxen(sections.join('\n\n' + chalk.gray('─'.repeat(50)) + '\n\n'), {
+          padding: 1,
+          margin: 1,
+          borderStyle: 'round',
+          borderColor: 'cyan',
+          title: 'Inbox Summary',
+          titleAlignment: 'center',
+        });
+
+        console.log(output);
+      } catch (error) {
+        console.error(chalk.red('Error fetching summary:'), error.message);
+        process.exit(1);
+      }
+    });
+
+  program
+    .command('analyze')
+    .description('Output structured email data for AI analysis (unread only by default)')
+    .option('-a, --account <name>', 'Account to analyze (or "all")', 'all')
+    .option('-n, --count <number>', 'Number of emails to analyze per account', '20')
+    .option('--all', 'Include read and unread emails (default: unread only)')
+    .action(async (options) => {
+      try {
+        const accounts = options.account === 'all'
+          ? getAccounts().map(a => a.name)
+          : [options.account];
+
+        if (accounts.length === 0) {
+          accounts.push('default');
+        }
+
+        const maxPerAccount = parseInt(options.count, 10);
+        const includeRead = !!options.all;
+        const allEmails = [];
+
+        for (const account of accounts) {
+          const emails = await getUnreadEmails(account, maxPerAccount, includeRead);
+          allEmails.push(...emails);
+        }
+
+        // Output pure JSON for AI consumption
+        console.log(JSON.stringify(allEmails, null, 2));
+      } catch (error) {
+        console.error(JSON.stringify({ error: error.message }));
+        process.exit(1);
+      }
+    });
+
+  program
+    .command('delete')
+    .description('Move emails to trash')
+    .requiredOption('--ids <ids>', 'Comma-separated message IDs to delete')
+    .option('-a, --account <name>', 'Account name (required for single-account delete)')
+    .option('--confirm', 'Skip confirmation prompt')
+    .action(async (options) => {
+      try {
+        const ids = options.ids.split(',').map(id => id.trim()).filter(Boolean);
+
+        if (ids.length === 0) {
+          console.log(chalk.yellow('No message IDs provided.'));
+          return;
+        }
+
+        // Get account - if not specified, try to find from configured accounts
+        let account = options.account;
+        if (!account) {
+          const accounts = getAccounts();
+          if (accounts.length === 1) {
+            account = accounts[0].name;
+          } else if (accounts.length > 1) {
+            console.log(chalk.yellow('Multiple accounts configured. Please specify --account <name>'));
+            console.log(chalk.gray('Available accounts:'));
+            accounts.forEach(a => console.log(chalk.gray(`  - ${a.name}`)));
+            return;
+          } else {
+            account = 'default';
+          }
+        }
+
+        // Fetch email details for logging before deletion
+        console.log(chalk.cyan(`Fetching ${ids.length} email(s) for deletion...`));
+        const emailsToDelete = [];
+
+        for (const id of ids) {
+          const email = await getEmailById(account, id);
+          if (email) {
+            emailsToDelete.push(email);
+          } else {
+            console.log(chalk.yellow(`Could not find email with ID: ${id}`));
+          }
+        }
+
+        if (emailsToDelete.length === 0) {
+          console.log(chalk.yellow('No valid emails found to delete.'));
+          return;
+        }
+
+        // Show what will be deleted
+        if (!options.confirm) {
+          console.log(chalk.bold('\nEmails to be moved to trash:\n'));
+          emailsToDelete.forEach(e => {
+            const from = e.from.length > 40 ? e.from.substring(0, 37) + '...' : e.from;
+            const subject = e.subject.length > 50 ? e.subject.substring(0, 47) + '...' : e.subject;
+            console.log(chalk.white(`  ${from}`));
+            console.log(chalk.gray(`    ${subject}\n`));
+          });
+          console.log(chalk.yellow(`\nThis will move ${emailsToDelete.length} email(s) to trash.`));
+          console.log(chalk.gray('Use --confirm to skip this prompt.\n'));
+        }
+
+        // Log deletions BEFORE actually deleting
+        logDeletions(emailsToDelete);
+        console.log(chalk.gray(`Logged to: ${getLogPath()}`));
+
+        // Perform the deletion
+        const results = await trashEmails(account, emailsToDelete.map(e => e.id));
+
+        const succeeded = results.filter(r => r.success).length;
+        const failed = results.filter(r => !r.success).length;
+
+        if (succeeded > 0) {
+          console.log(chalk.green(`\nMoved ${succeeded} email(s) to trash.`));
+        }
+        if (failed > 0) {
+          console.log(chalk.red(`Failed to delete ${failed} email(s).`));
+          results.filter(r => !r.success).forEach(r => {
+            console.log(chalk.red(`  - ${r.id}: ${r.error}`));
+          });
+        }
+
+      } catch (error) {
+        if (error.message.includes('403') || error.code === 403) {
+          console.error(chalk.red('Permission denied. You may need to re-authenticate with updated scopes.'));
+          console.error(chalk.yellow('Run: node src/cli.js auth'));
+        } else {
+          console.error(chalk.red('Error deleting emails:'), error.message);
+        }
+        process.exit(1);
+      }
+    });
+
+  program
+    .command('deletion-log')
+    .description('View recent email deletions')
+    .option('-n, --days <number>', 'Show deletions from last N days', '30')
+    .action(async (options) => {
+      const days = parseInt(options.days, 10);
+      const deletions = getRecentDeletions(days);
+
+      if (deletions.length === 0) {
+        console.log(chalk.gray(`No deletions in the last ${days} days.`));
+        console.log(chalk.gray(`Log file: ${getLogPath()}`));
+        return;
+      }
+
+      console.log(chalk.bold(`\nDeletion Log (last ${days} days):\n`));
+
+      // Group by date
+      const byDate = {};
+      deletions.forEach(d => {
+        const date = new Date(d.deletedAt).toLocaleDateString();
+        if (!byDate[date]) byDate[date] = [];
+        byDate[date].push(d);
+      });
+
+      for (const [date, items] of Object.entries(byDate)) {
+        console.log(chalk.cyan(`${date} (${items.length} deleted)`));
+        items.forEach(d => {
+          const from = d.from.length > 35 ? d.from.substring(0, 32) + '...' : d.from;
+          const subject = d.subject.length > 45 ? d.subject.substring(0, 42) + '...' : d.subject;
+          console.log(chalk.white(`  ${from}`));
+          console.log(chalk.gray(`    ${subject}`));
+          console.log(chalk.gray(`    ID: ${d.id} | Account: ${d.account}\n`));
+        });
+      }
+
+      console.log(chalk.gray(`\nLog file: ${getLogPath()}`));
+    });
+
+  program.parse();
+}
+
+main().catch(console.error);

package/src/deletion-log.js

@@ -0,0 +1,87 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const LOG_DIR = path.join(os.homedir(), '.config', 'inboxd');
+const LOG_FILE = path.join(LOG_DIR, 'deletion-log.json');
+
+/**
+ * Ensures the log directory exists
+ */
+function ensureLogDir() {
+  if (!fs.existsSync(LOG_DIR)) {
+    fs.mkdirSync(LOG_DIR, { recursive: true });
+  }
+}
+
+/**
+ * Reads the current deletion log
+ * @returns {Array} Array of deletion entries
+ */
+function readLog() {
+  ensureLogDir();
+  if (!fs.existsSync(LOG_FILE)) {
+    return [];
+  }
+  try {
+    const content = fs.readFileSync(LOG_FILE, 'utf8');
+    return JSON.parse(content);
+  } catch (err) {
+    return [];
+  }
+}
+
+/**
+ * Logs deleted emails to the deletion log
+ * @param {Array} emails - Array of email objects with id, threadId, account, from, subject, snippet
+ */
+function logDeletions(emails) {
+  ensureLogDir();
+  const log = readLog();
+  const timestamp = new Date().toISOString();
+
+  for (const email of emails) {
+    log.push({
+      deletedAt: timestamp,
+      account: email.account,
+      id: email.id,
+      threadId: email.threadId,
+      from: email.from,
+      subject: email.subject,
+      snippet: email.snippet,
+    });
+  }
+
+  fs.writeFileSync(LOG_FILE, JSON.stringify(log, null, 2));
+}
+
+/**
+ * Gets recent deletions from the log
+ * @param {number} days - Number of days to look back (default: 30)
+ * @returns {Array} Array of deletion entries within the time range
+ */
+function getRecentDeletions(days = 30) {
+  const log = readLog();
+  const cutoff = new Date();
+  cutoff.setDate(cutoff.getDate() - days);
+
+  return log.filter((entry) => {
+    const deletedAt = new Date(entry.deletedAt);
+    return deletedAt >= cutoff;
+  });
+}
+
+/**
+ * Gets the path to the log file (for display purposes)
+ * @returns {string} The log file path
+ */
+function getLogPath() {
+  return LOG_FILE;
+}
+
+module.exports = {
+  logDeletions,
+  getRecentDeletions,
+  getLogPath,
+  readLog,
+};

package/src/gmail-auth.js

@@ -0,0 +1,203 @@
+const fs = require('fs').promises;
+const fsSync = require('fs');
+const path = require('path');
+const os = require('os');
+const { authenticate } = require('@google-cloud/local-auth');
+const { google } = require('googleapis');
+
+const SCOPES = ['https://www.googleapis.com/auth/gmail.modify'];
+
+const TOKEN_DIR = process.env.INBOXD_TOKEN_DIR || path.join(os.homedir(), '.config', 'inboxd');
+const ACCOUNTS_FILE = path.join(TOKEN_DIR, 'accounts.json');
+
+function getCredentialsPath() {
+  return process.env.GMAIL_CREDENTIALS_PATH || path.join(process.cwd(), 'credentials.json');
+}
+
+function getTokenPath(account = 'default') {
+  return path.join(TOKEN_DIR, `token-${account}.json`);
+}
+
+function loadAccounts() {
+  try {
+    if (fsSync.existsSync(ACCOUNTS_FILE)) {
+      return JSON.parse(fsSync.readFileSync(ACCOUNTS_FILE, 'utf8'));
+    }
+  } catch (err) {}
+  return { accounts: [], defaultAccount: null };
+}
+
+function saveAccounts(data) {
+  fsSync.mkdirSync(TOKEN_DIR, { recursive: true });
+  fsSync.writeFileSync(ACCOUNTS_FILE, JSON.stringify(data, null, 2));
+}
+
+function getAccounts() {
+  return loadAccounts().accounts;
+}
+
+function addAccount(name, email) {
+  const data = loadAccounts();
+  const existing = data.accounts.find(a => a.name === name);
+  if (existing) {
+    existing.email = email;
+  } else {
+    data.accounts.push({ name, email });
+  }
+  if (!data.defaultAccount) {
+    data.defaultAccount = name;
+  }
+  saveAccounts(data);
+}
+
+function getDefaultAccount() {
+  const data = loadAccounts();
+  return data.defaultAccount || (data.accounts[0]?.name) || 'default';
+}
+
+function removeAccount(name) {
+  const data = loadAccounts();
+  data.accounts = data.accounts.filter(a => a.name !== name);
+  if (data.defaultAccount === name) {
+    data.defaultAccount = data.accounts[0]?.name || null;
+  }
+  saveAccounts(data);
+
+  // Remove token file
+  const tokenPath = getTokenPath(name);
+  if (fsSync.existsSync(tokenPath)) {
+    fsSync.unlinkSync(tokenPath);
+  }
+
+  // Remove state file
+  const statePath = path.join(TOKEN_DIR, `state-${name}.json`);
+  if (fsSync.existsSync(statePath)) {
+    fsSync.unlinkSync(statePath);
+  }
+}
+
+function removeAllAccounts() {
+  const data = loadAccounts();
+  const accountNames = data.accounts.map(a => a.name);
+
+  for (const name of accountNames) {
+    const tokenPath = getTokenPath(name);
+    if (fsSync.existsSync(tokenPath)) {
+      fsSync.unlinkSync(tokenPath);
+    }
+    const statePath = path.join(TOKEN_DIR, `state-${name}.json`);
+    if (fsSync.existsSync(statePath)) {
+      fsSync.unlinkSync(statePath);
+    }
+  }
+
+  // Also clean up any legacy files
+  const legacyToken = path.join(TOKEN_DIR, 'token.json');
+  if (fsSync.existsSync(legacyToken)) {
+    fsSync.unlinkSync(legacyToken);
+  }
+  const legacyState = path.join(TOKEN_DIR, 'state.json');
+  if (fsSync.existsSync(legacyState)) {
+    fsSync.unlinkSync(legacyState);
+  }
+
+  saveAccounts({ accounts: [], defaultAccount: null });
+}
+
+function renameTokenFile(oldName, newName) {
+  const oldPath = getTokenPath(oldName);
+  const newPath = getTokenPath(newName);
+  if (fsSync.existsSync(oldPath)) {
+    fsSync.renameSync(oldPath, newPath);
+  }
+}
+
+async function loadSavedCredentialsIfExist(account = 'default') {
+  try {
+    const tokenPath = getTokenPath(account);
+    const content = await fs.readFile(tokenPath, 'utf8');
+    const credentials = JSON.parse(content);
+    return google.auth.fromJSON(credentials);
+  } catch (err) {
+    return null;
+  }
+}
+
+async function saveCredentials(client, account = 'default') {
+  const credentialsPath = getCredentialsPath();
+  const content = await fs.readFile(credentialsPath, 'utf8');
+  const keys = JSON.parse(content);
+  const key = keys.installed || keys.web;
+  const payload = JSON.stringify({
+    type: 'authorized_user',
+    client_id: key.client_id,
+    client_secret: key.client_secret,
+    refresh_token: client.credentials.refresh_token,
+  });
+
+  await fs.mkdir(TOKEN_DIR, { recursive: true });
+  await fs.writeFile(getTokenPath(account), payload);
+}
+
+async function authorize(account = 'default') {
+  let client = await loadSavedCredentialsIfExist(account);
+  if (client) {
+    return client;
+  }
+
+  const credentialsPath = getCredentialsPath();
+
+  try {
+    await fs.access(credentialsPath);
+  } catch (err) {
+    throw new Error(
+      `credentials.json not found at ${credentialsPath}\n\n` +
+      `To set up Gmail API access:\n` +
+      `1. Go to https://console.cloud.google.com/\n` +
+      `2. Create a new project\n` +
+      `3. Enable the Gmail API\n` +
+      `4. Create OAuth 2.0 credentials (Desktop app)\n` +
+      `5. Download and save as credentials.json in the project root`
+    );
+  }
+
+  client = await authenticate({
+    scopes: SCOPES,
+    keyfilePath: credentialsPath,
+  });
+
+  if (client.credentials) {
+    await saveCredentials(client, account);
+  }
+  return client;
+}
+
+async function getGmailClient(account = 'default') {
+  const auth = await authorize(account);
+  return google.gmail({ version: 'v1', auth });
+}
+
+async function getAccountEmail(account = 'default') {
+  try {
+    const gmail = await getGmailClient(account);
+    const profile = await gmail.users.getProfile({ userId: 'me' });
+    return profile.data.emailAddress;
+  } catch (err) {
+    return null;
+  }
+}
+
+module.exports = {
+  getGmailClient,
+  authorize,
+  getTokenPath,
+  getCredentialsPath,
+  getAccounts,
+  addAccount,
+  removeAccount,
+  removeAllAccounts,
+  getDefaultAccount,
+  getAccountEmail,
+  renameTokenFile,
+  TOKEN_DIR,
+};

package/src/gmail-monitor.js

@@ -0,0 +1,165 @@
+const { getGmailClient } = require('./gmail-auth');
+
+/**
+ * Executes an async operation with a single retry on network errors.
+ * Max 2 attempts total (initial + 1 retry).
+ * Delays 1 second before retry.
+ */
+async function withRetry(operation) {
+  try {
+    return await operation();
+  } catch (error) {
+    // Do not retry on auth errors
+    if (error.code === 401 || error.code === 403 || error.response?.status === 401 || error.response?.status === 403) {
+      throw error;
+    }
+
+    const networkErrors = ['ENOTFOUND', 'ETIMEDOUT', 'ECONNRESET', 'EAI_AGAIN'];
+    const isNetworkError = networkErrors.includes(error.code);
+    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();
+    }
+
+    throw error;
+  }
+}
+
+async function getUnreadEmails(account = 'default', maxResults = 20, includeRead = false) {
+  try {
+    const gmail = await getGmailClient(account);
+
+    const res = await withRetry(() => gmail.users.messages.list({
+      userId: 'me',
+      q: includeRead ? '' : 'is:unread',
+      maxResults,
+    }));
+
+    const messages = res.data.messages;
+    if (!messages || messages.length === 0) {
+      return [];
+    }
+
+    const emailPromises = messages.map(async (msg) => {
+      try {
+        const detail = await withRetry(() => gmail.users.messages.get({
+          userId: 'me',
+          id: msg.id,
+          format: 'metadata',
+          metadataHeaders: ['From', 'Subject', 'Date'],
+        }));
+
+        const headers = detail.data.payload.headers;
+        const getHeader = (name) => {
+          const header = headers.find((h) => h.name === name);
+          return header ? header.value : '';
+        };
+
+        return {
+          id: msg.id,
+          threadId: detail.data.threadId,
+          labelIds: detail.data.labelIds || [],
+          account,
+          from: getHeader('From'),
+          subject: getHeader('Subject'),
+          snippet: detail.data.snippet,
+          date: getHeader('Date'),
+        };
+      } catch (err) {
+        return null;
+      }
+    });
+
+    const results = await Promise.all(emailPromises);
+    return results.filter((email) => email !== null);
+  } catch (error) {
+    console.error(`Error in getUnreadEmails for ${account}:`, error.message);
+    return [];
+  }
+}
+
+async function getEmailCount(account = 'default') {
+  try {
+    const gmail = await getGmailClient(account);
+    const res = await withRetry(() => gmail.users.labels.get({
+      userId: 'me',
+      id: 'INBOX',
+    }));
+    return res.data.messagesUnread || 0;
+  } catch (error) {
+    console.error(`Error in getEmailCount for ${account}:`, error.message);
+    return 0;
+  }
+}
+
+/**
+ * Moves emails to trash
+ * @param {string} account - Account name
+ * @param {Array<string>} messageIds - Array of message IDs to trash
+ * @returns {Array<{id: string, success: boolean, error?: string}>} Results for each message
+ */
+async function trashEmails(account, messageIds) {
+  const gmail = await getGmailClient(account);
+  const results = [];
+
+  for (const id of messageIds) {
+    try {
+      await withRetry(() => gmail.users.messages.trash({
+        userId: 'me',
+        id: id,
+      }));
+      results.push({ id, success: true });
+    } catch (err) {
+      results.push({ id, success: false, error: err.message });
+    }
+  }
+
+  return results;
+}
+
+/**
+ * Gets email details by ID (for logging before deletion)
+ * @param {string} account - Account name
+ * @param {string} messageId - Message ID
+ * @returns {Object|null} Email object or null if not found
+ */
+async function getEmailById(account, messageId) {
+  try {
+    const gmail = await getGmailClient(account);
+    const detail = await withRetry(() => gmail.users.messages.get({
+      userId: 'me',
+      id: messageId,
+      format: 'metadata',
+      metadataHeaders: ['From', 'Subject', 'Date'],
+    }));
+
+    const headers = detail.data.payload.headers;
+    const getHeader = (name) => {
+      const header = headers.find((h) => h.name === name);
+      return header ? header.value : '';
+    };
+
+    return {
+      id: messageId,
+      threadId: detail.data.threadId,
+      labelIds: detail.data.labelIds || [],
+      account,
+      from: getHeader('From'),
+      subject: getHeader('Subject'),
+      snippet: detail.data.snippet,
+      date: getHeader('Date'),
+    };
+  } catch (err) {
+    return null;
+  }
+}
+
+module.exports = {
+  getUnreadEmails,
+  getEmailCount,
+  trashEmails,
+  getEmailById,
+};

package/src/notifier.js

@@ -0,0 +1,48 @@
+const notifier = require('node-notifier');
+
+function notify({ title, message, subtitle }) {
+  notifier.notify({
+    title: title || 'Inboxd',
+    message: message,
+    subtitle: subtitle || 'Inboxd',
+    sound: true,
+    wait: false
+  });
+}
+
+function extractSenderName(from) {
+  if (!from) return 'Unknown';
+  const match = from.match(/^"?(.*?)"?\s*<.*>$/);
+  return match ? match[1] : from.split('@')[0];
+}
+
+function notifyNewEmails(emails) {
+  if (!Array.isArray(emails) || emails.length === 0) {
+    return;
+  }
+
+  const count = emails.length;
+  const senders = emails.map(email => extractSenderName(email.from));
+
+  // Get first 3 unique senders for the preview
+  const uniqueSenders = [...new Set(senders)];
+  const previewSenders = uniqueSenders.slice(0, 3);
+
+  let message = `From: ${previewSenders.join(', ')}`;
+
+  if (uniqueSenders.length > 3) {
+    message += `, and ${uniqueSenders.length - 3} others`;
+  }
+
+  notify({
+    title: `${count} New Email${count === 1 ? '' : 's'}`,
+    message: message,
+    subtitle: 'Inboxd'
+  });
+}
+
+module.exports = {
+  notify,
+  notifyNewEmails,
+  extractSenderName
+};

package/src/state.js

@@ -0,0 +1,106 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const STATE_DIR = path.join(os.homedir(), '.config', 'inboxd');
+
+function getStatePath(account = 'default') {
+  return path.join(STATE_DIR, `state-${account}.json`);
+}
+
+function ensureDir() {
+  if (!fs.existsSync(STATE_DIR)) {
+    fs.mkdirSync(STATE_DIR, { recursive: true });
+  }
+}
+
+function loadState(account = 'default') {
+  try {
+    const statePath = getStatePath(account);
+    if (fs.existsSync(statePath)) {
+      const content = fs.readFileSync(statePath, 'utf8');
+      return JSON.parse(content);
+    }
+  } catch (error) {}
+  return {
+    lastCheck: null,
+    seenEmailIds: [],
+    lastNotifiedAt: null,
+  };
+}
+
+function saveState(state, account = 'default') {
+  ensureDir();
+  fs.writeFileSync(getStatePath(account), JSON.stringify(state, null, 2));
+}
+
+function getState(account = 'default') {
+  return loadState(account);
+}
+
+function updateLastCheck(account = 'default') {
+  const state = loadState(account);
+  state.lastCheck = Date.now();
+  saveState(state, account);
+}
+
+function markEmailsSeen(ids, account = 'default') {
+  if (!Array.isArray(ids) || ids.length === 0) return;
+
+  const state = loadState(account);
+  const seen = state.seenEmailIds || [];
+  const now = Date.now();
+
+  const existingIds = new Set(seen.map((item) => (typeof item === 'string' ? item : item.id)));
+
+  const newEntries = ids
+    .filter((id) => !existingIds.has(id))
+    .map((id) => ({ id, timestamp: now }));
+
+  if (newEntries.length > 0) {
+    state.seenEmailIds = [...seen, ...newEntries];
+    saveState(state, account);
+  }
+}
+
+function isEmailSeen(id, account = 'default') {
+  const state = loadState(account);
+  const seen = state.seenEmailIds || [];
+  return seen.some((item) => (typeof item === 'string' ? item === id : item.id === id));
+}
+
+function clearOldSeenEmails(olderThanDays = 7, account = 'default') {
+  const state = loadState(account);
+  const seen = state.seenEmailIds || [];
+  const cutoff = Date.now() - olderThanDays * 24 * 60 * 60 * 1000;
+
+  const filtered = seen.filter((item) => {
+    if (typeof item === 'string') return true;
+    return item.timestamp > cutoff;
+  });
+
+  if (filtered.length !== seen.length) {
+    state.seenEmailIds = filtered;
+    saveState(state, account);
+  }
+}
+
+function getNewEmailIds(emailIds, account = 'default') {
+  return emailIds.filter((id) => !isEmailSeen(id, account));
+}
+
+function updateLastNotifiedAt(account = 'default') {
+  const state = loadState(account);
+  state.lastNotifiedAt = Date.now();
+  saveState(state, account);
+}
+
+module.exports = {
+  getState,
+  updateLastCheck,
+  markEmailsSeen,
+  isEmailSeen,
+  clearOldSeenEmails,
+  getNewEmailIds,
+  updateLastNotifiedAt,
+};