inboxd 1.0.0 → 1.0.2

package/src/cli.js

@@ -1,11 +1,36 @@
 #!/usr/bin/env node
 
 const { program } = require('commander');
-const { getUnreadEmails, getEmailCount, trashEmails, getEmailById } = require('./gmail-monitor');
+const { getUnreadEmails, getEmailCount, trashEmails, getEmailById, untrashEmails } = 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');
+const { authorize, addAccount, getAccounts, getAccountEmail, removeAccount, removeAllAccounts, renameTokenFile, validateCredentialsFile, hasCredentials, isConfigured, installCredentials } = require('./gmail-auth');
+const { logDeletions, getRecentDeletions, getLogPath, readLog, removeLogEntries } = require('./deletion-log');
+const readline = require('readline');
+const path = require('path');
+const os = require('os');
+const fs = require('fs');
+
+/**
+ * Prompts user for input
+ */
+function prompt(rl, question) {
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      resolve(answer.trim());
+    });
+  });
+}
+
+/**
+ * Resolves a file path, expanding ~ to home directory
+ */
+function resolvePath(filePath) {
+  if (filePath.startsWith('~')) {
+    return path.join(os.homedir(), filePath.slice(1));
+  }
+  return path.resolve(filePath);
+}
 
 async function main() {
   const chalk = (await import('chalk')).default;
@@ -13,9 +38,169 @@ async function main() {
 
   program
     .name('inbox')
-    .description('Gmail monitoring CLI for Daily Assistant')
+    .description('Gmail monitoring CLI with multi-account support')
     .version('1.0.0');
 
+  // Setup command - interactive wizard for first-time users
+  program
+    .command('setup')
+    .description('Interactive setup wizard for first-time configuration')
+    .action(async () => {
+      const open = (await import('open')).default;
+
+      const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+      });
+
+      // Handle Ctrl+C gracefully
+      rl.on('close', () => {
+        // Only show message if we're exiting unexpectedly (not from normal flow)
+      });
+
+      process.on('SIGINT', () => {
+        console.log(chalk.gray('\n\nSetup cancelled.\n'));
+        rl.close();
+        process.exit(0);
+      });
+
+      try {
+        console.log(chalk.bold.cyan('\nWelcome to inboxd! Let\'s get you set up.\n'));
+
+        // Check if already configured
+        if (hasCredentials()) {
+          const accounts = getAccounts();
+          if (accounts.length > 0) {
+            console.log(chalk.yellow('You already have accounts configured:'));
+            accounts.forEach(a => console.log(chalk.gray(`  - ${a.name} (${a.email})`)));
+            console.log('');
+            const answer = await prompt(rl, chalk.white('Do you want to add another account? (y/N): '));
+            if (answer.toLowerCase() !== 'y' && answer.toLowerCase() !== 'yes') {
+              console.log(chalk.gray('\nSetup cancelled. Run "inbox summary" to check your inbox.\n'));
+              rl.close();
+              return;
+            }
+            // Skip credentials step, go directly to auth
+            console.log(chalk.cyan('\n🔐 Authenticate another Gmail account\n'));
+            const accountName = await prompt(rl, chalk.white('   What should we call this account? (e.g., work): '));
+            if (!accountName) {
+              console.log(chalk.yellow('Account name is required.'));
+              rl.close();
+              return;
+            }
+            rl.close();
+            console.log(chalk.gray('\n   A browser window will open for authorization...\n'));
+            await authorize(accountName);
+            const email = await getAccountEmail(accountName);
+            if (email) {
+              addAccount(accountName, email);
+              console.log(chalk.green(`\n   ✓ Authenticated as ${email}\n`));
+            }
+            console.log(chalk.bold.green('🎉 Setup complete! Try: inbox summary\n'));
+            return;
+          }
+        }
+
+        // Step 1: Google Cloud Console
+        console.log(chalk.cyan('📋 Step 1: Create Google Cloud Credentials\n'));
+        console.log(chalk.white('   You\'ll need to create OAuth credentials in Google Cloud Console.'));
+        console.log(chalk.white('   This is a one-time setup that takes about 5 minutes.\n'));
+        console.log(chalk.gray('   Quick guide:'));
+        console.log(chalk.gray('   1. Create a project (or select existing)'));
+        console.log(chalk.gray('   2. Enable the Gmail API'));
+        console.log(chalk.gray('   3. Configure OAuth consent screen'));
+        console.log(chalk.gray('      - Choose "External" user type'));
+        console.log(chalk.gray('      - Add your email as a test user'));
+        console.log(chalk.gray('   4. Create credentials → OAuth client ID → Desktop app'));
+        console.log(chalk.gray('   5. Download the JSON file\n'));
+
+        await prompt(rl, chalk.white('   Press Enter to open Google Cloud Console...'));
+
+        try {
+          await open('https://console.cloud.google.com/apis/credentials');
+          console.log(chalk.green('\n   ✓ Opened Google Cloud Console in your browser\n'));
+        } catch (_err) {
+          console.log(chalk.yellow('\n   Could not open browser automatically.'));
+          console.log(chalk.white('   Please visit: https://console.cloud.google.com/apis/credentials\n'));
+        }
+
+        // Step 2: Get credentials file
+        console.log(chalk.cyan('📁 Step 2: Provide your credentials file\n'));
+        console.log(chalk.gray('   After downloading, enter the path to the file.'));
+        console.log(chalk.gray('   Tip: You can drag and drop the file into this terminal.\n'));
+
+        let credentialsPath = '';
+        let validated = false;
+
+        while (!validated) {
+          const input = await prompt(rl, chalk.white('   Path to credentials file: '));
+
+          if (!input) {
+            console.log(chalk.yellow('   Please provide a file path.\n'));
+            continue;
+          }
+
+          credentialsPath = resolvePath(input.replace(/['"]/g, '').trim()); // Remove quotes from drag-drop
+
+          const validation = validateCredentialsFile(credentialsPath);
+          if (!validation.valid) {
+            console.log(chalk.red(`\n   ✗ ${validation.error}\n`));
+            const retry = await prompt(rl, chalk.white('   Try again? (Y/n): '));
+            if (retry.toLowerCase() === 'n' || retry.toLowerCase() === 'no') {
+              console.log(chalk.gray('\nSetup cancelled.\n'));
+              rl.close();
+              return;
+            }
+            continue;
+          }
+
+          validated = true;
+        }
+
+        // Install credentials
+        const destPath = installCredentials(credentialsPath);
+        console.log(chalk.green(`\n   ✓ Credentials saved to ${destPath}\n`));
+
+        // Step 3: Authenticate
+        console.log(chalk.cyan('🔐 Step 3: Authenticate your Gmail account\n'));
+        const accountName = await prompt(rl, chalk.white('   What should we call this account? (e.g., personal, work): '));
+
+        if (!accountName) {
+          console.log(chalk.yellow('   Using "default" as account name.'));
+        }
+
+        const finalAccountName = accountName || 'default';
+        rl.close();
+
+        console.log(chalk.gray('\n   A browser window will open for authorization...'));
+        console.log(chalk.gray('   Sign in and allow access to your Gmail.\n'));
+
+        await authorize(finalAccountName);
+        const email = await getAccountEmail(finalAccountName);
+
+        if (email) {
+          addAccount(finalAccountName, email);
+          console.log(chalk.green(`   ✓ Authenticated as ${email}\n`));
+        } else {
+          console.log(chalk.yellow('   Warning: Could not verify email address.\n'));
+        }
+
+        // Success
+        console.log(chalk.bold.green('🎉 You\'re all set!\n'));
+        console.log(chalk.white('   Try these commands:'));
+        console.log(chalk.cyan('     inbox summary') + chalk.gray('        - View your inbox'));
+        console.log(chalk.cyan('     inbox check') + chalk.gray('          - Check for new emails'));
+        console.log(chalk.cyan('     inbox auth -a work') + chalk.gray('   - Add another account'));
+        console.log(chalk.cyan('     inbox install-service') + chalk.gray(' - Enable background monitoring'));
+        console.log('');
+
+      } catch (error) {
+        rl.close();
+        console.error(chalk.red('\nSetup failed:'), error.message);
+        process.exit(1);
+      }
+    });
+
   program
     .command('auth')
     .description('Authenticate a Gmail account')
@@ -71,7 +256,7 @@ async function main() {
     .action(async () => {
       const accounts = getAccounts();
       if (accounts.length === 0) {
-        console.log(chalk.gray('No accounts configured. Run: inbox auth --account <name>'));
+        console.log(chalk.gray('No accounts configured. Run: inbox setup'));
         return;
       }
 
@@ -170,6 +355,7 @@ async function main() {
     .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')
+    .option('--json', 'Output as JSON')
     .action(async (options) => {
       try {
         const accounts = options.account === 'all'
@@ -180,6 +366,28 @@ async function main() {
           accounts.push('default');
         }
 
+        if (options.json) {
+          const result = {
+            accounts: [],
+            totalUnread: 0
+          };
+
+          for (const account of accounts) {
+            const count = await getEmailCount(account);
+            const accountInfo = getAccounts().find(a => a.name === account);
+
+            result.accounts.push({
+              name: account,
+              email: accountInfo?.email || account,
+              unreadCount: count
+            });
+            result.totalUnread += count;
+          }
+
+          console.log(JSON.stringify(result, null, 2));
+          return;
+        }
+
         const maxPerAccount = parseInt(options.count, 10);
         const sections = [];
 
@@ -265,6 +473,7 @@ async function main() {
     .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')
+    .option('--dry-run', 'Show what would be deleted without deleting')
     .action(async (options) => {
       try {
         const ids = options.ids.split(',').map(id => id.trim()).filter(Boolean);
@@ -309,7 +518,7 @@ async function main() {
         }
 
         // Show what will be deleted
-        if (!options.confirm) {
+        if (!options.confirm || options.dryRun) {
           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;
@@ -317,6 +526,12 @@ async function main() {
             console.log(chalk.white(`  ${from}`));
             console.log(chalk.gray(`    ${subject}\n`));
           });
+
+          if (options.dryRun) {
+            console.log(chalk.yellow(`\nDry run: ${emailsToDelete.length} email(s) would be deleted.`));
+            return;
+          }
+
           console.log(chalk.yellow(`\nThis will move ${emailsToDelete.length} email(s) to trash.`));
           console.log(chalk.gray('Use --confirm to skip this prompt.\n'));
         }
@@ -390,6 +605,199 @@ async function main() {
       console.log(chalk.gray(`\nLog file: ${getLogPath()}`));
     });
 
+  program
+    .command('restore')
+    .description('Restore deleted emails from trash')
+    .option('--ids <ids>', 'Comma-separated message IDs to restore')
+    .option('--last <number>', 'Restore the N most recent deletions', parseInt)
+    .action(async (options) => {
+      try {
+        let emailsToRestore = [];
+
+        // Scenario 1: Restore by explicit IDs
+        if (options.ids) {
+          const ids = options.ids.split(',').map(id => id.trim()).filter(Boolean);
+          const log = readLog();
+
+          for (const id of ids) {
+            // Find in log first to get the account
+            const entry = log.find(e => e.id === id);
+            if (entry) {
+              emailsToRestore.push(entry);
+            } else {
+              console.log(chalk.yellow(`Warning: ID ${id} not found in local deletion log.`));
+              console.log(chalk.gray(`Cannot determine account automatically. Please restore manually via Gmail web interface.`));
+            }
+          }
+        }
+        // Scenario 2: Restore last N items
+        else if (options.last) {
+          const count = options.last;
+          const deletions = getRecentDeletions(30); // Look back 30 days
+          // Sort by deletedAt desc just in case
+          deletions.sort((a, b) => new Date(b.deletedAt) - new Date(a.deletedAt));
+
+          emailsToRestore = deletions.slice(0, count);
+        } else {
+          console.log(chalk.red('Error: Must specify either --ids or --last'));
+          console.log(chalk.gray('Examples:'));
+          console.log(chalk.gray('  inbox restore --last 1'));
+          console.log(chalk.gray('  inbox restore --ids 12345,67890'));
+          return;
+        }
+
+        if (emailsToRestore.length === 0) {
+          console.log(chalk.yellow('No emails found to restore.'));
+          return;
+        }
+
+        console.log(chalk.cyan(`Attempting to restore ${emailsToRestore.length} email(s)...`));
+
+        // Group by account to batch API calls
+        const byAccount = {};
+        for (const email of emailsToRestore) {
+          if (!byAccount[email.account]) {
+            byAccount[email.account] = [];
+          }
+          byAccount[email.account].push(email);
+        }
+
+        const successfulIds = [];
+
+        for (const [account, emails] of Object.entries(byAccount)) {
+          const ids = emails.map(e => e.id);
+          console.log(chalk.gray(`Restoring ${ids.length} email(s) for account "${account}"...`));
+
+          const results = await untrashEmails(account, ids);
+
+          const succeeded = results.filter(r => r.success);
+          const failed = results.filter(r => !r.success);
+
+          if (succeeded.length > 0) {
+            console.log(chalk.green(`  ✓ Restored ${succeeded.length} email(s)`));
+            successfulIds.push(...succeeded.map(r => r.id));
+          }
+
+          if (failed.length > 0) {
+            console.log(chalk.red(`  ✗ Failed to restore ${failed.length} email(s)`));
+            failed.forEach(r => {
+              console.log(chalk.gray(`    - ID ${r.id}: ${r.error}`));
+            });
+          }
+        }
+
+        // Clean up log
+        if (successfulIds.length > 0) {
+          removeLogEntries(successfulIds);
+          console.log(chalk.gray(`\nRemoved ${successfulIds.length} entries from deletion log.`));
+        }
+
+      } catch (error) {
+        console.error(chalk.red('Error restoring emails:'), error.message);
+        process.exit(1);
+      }
+    });
+
+  program
+    .command('install-service')
+    .description('Install background service (launchd) for macOS')
+    .option('-i, --interval <minutes>', 'Check interval in minutes', '5')
+    .action(async (options) => {
+      // Platform check
+      if (process.platform !== 'darwin') {
+        console.log(chalk.red('\nError: install-service is only supported on macOS.'));
+        console.log(chalk.gray('This command uses launchd which is macOS-specific.\n'));
+        console.log(chalk.white('For other platforms, you can set up a cron job or scheduled task:'));
+        console.log(chalk.cyan(`  */5 * * * * ${process.execPath} ${path.resolve(__dirname, 'cli.js')} check --quiet`));
+        console.log('');
+        return;
+      }
+
+      const interval = parseInt(options.interval, 10);
+      const seconds = interval * 60;
+
+      // Determine paths
+      const nodePath = process.execPath;
+      const scriptPath = path.resolve(__dirname, 'cli.js');
+      const workingDir = path.resolve(__dirname, '..');
+      const plistName = 'com.danielparedes.inboxd.plist';
+      const homeDir = os.homedir();
+      const launchAgentsDir = path.join(homeDir, 'Library/LaunchAgents');
+      const plistPath = path.join(launchAgentsDir, plistName);
+
+      const plistContent = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>Label</key>
+    <string>com.danielparedes.inboxd</string>
+
+    <key>ProgramArguments</key>
+    <array>
+        <string>${nodePath}</string>
+        <string>${scriptPath}</string>
+        <string>check</string>
+        <string>--quiet</string>
+    </array>
+
+    <key>WorkingDirectory</key>
+    <string>${workingDir}</string>
+
+    <!-- Run every ${interval} minutes (${seconds} seconds) -->
+    <key>StartInterval</key>
+    <integer>${seconds}</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:/opt/homebrew/bin</string>
+    </dict>
+</dict>
+</plist>`;
+
+      try {
+        if (!fs.existsSync(launchAgentsDir)) {
+          fs.mkdirSync(launchAgentsDir, { recursive: true });
+        }
+
+        fs.writeFileSync(plistPath, plistContent);
+        console.log(chalk.green(`\nService configuration generated at: ${plistPath}`));
+        console.log(chalk.white('To enable the background service, run:'));
+        console.log(chalk.cyan(`  launchctl unload ${plistPath} 2>/dev/null`));
+        console.log(chalk.cyan(`  launchctl load ${plistPath}`));
+        console.log('');
+      } catch (error) {
+        console.error(chalk.red('Error creating service file:'), error.message);
+      }
+    });
+
+  // Handle unknown commands gracefully
+  program.on('command:*', (operands) => {
+    console.error(chalk.red(`\nUnknown command: ${operands[0]}`));
+    console.log(chalk.gray('Run "inbox --help" for available commands.\n'));
+    process.exit(1);
+  });
+
+  // Show helpful message for first-time users when no command is given
+  if (process.argv.length === 2) {
+    if (!isConfigured()) {
+      console.log(chalk.cyan('\nWelcome to inboxd!'));
+      console.log(chalk.white('Run ') + chalk.bold('inbox setup') + chalk.white(' to get started.\n'));
+      return;
+    }
+  }
+
   program.parse();
 }
 

package/src/deletion-log.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 LOG_DIR = path.join(os.homedir(), '.config', 'inboxd');
+const LOG_DIR = TOKEN_DIR;
 const LOG_FILE = path.join(LOG_DIR, 'deletion-log.json');
 
 /**
@@ -26,7 +27,7 @@ function readLog() {
   try {
     const content = fs.readFileSync(LOG_FILE, 'utf8');
     return JSON.parse(content);
-  } catch (err) {
+  } catch (_err) {
     return [];
   }
 }
@@ -52,7 +53,7 @@ function logDeletions(emails) {
     });
   }
 
-  fs.writeFileSync(LOG_FILE, JSON.stringify(log, null, 2));
+  atomicWriteJsonSync(LOG_FILE, log);
 }
 
 /**
@@ -79,9 +80,25 @@ function getLogPath() {
   return LOG_FILE;
 }
 
+/**
+ * Removes entries from the deletion log (e.g., after restoration)
+ * @param {Array<string>} ids - Array of message IDs to remove
+ */
+function removeLogEntries(ids) {
+  ensureLogDir();
+  const log = readLog();
+
+  const newLog = log.filter(entry => !ids.includes(entry.id));
+
+  if (log.length !== newLog.length) {
+    atomicWriteJsonSync(LOG_FILE, newLog);
+  }
+}
+
 module.exports = {
   logDeletions,
   getRecentDeletions,
   getLogPath,
   readLog,
+  removeLogEntries,
 };

package/src/gmail-auth.js

@@ -11,7 +11,18 @@ const TOKEN_DIR = process.env.INBOXD_TOKEN_DIR || path.join(os.homedir(), '.conf
 const ACCOUNTS_FILE = path.join(TOKEN_DIR, 'accounts.json');
 
 function getCredentialsPath() {
-  return process.env.GMAIL_CREDENTIALS_PATH || path.join(process.cwd(), 'credentials.json');
+  if (process.env.GMAIL_CREDENTIALS_PATH) {
+    return process.env.GMAIL_CREDENTIALS_PATH;
+  }
+
+  // Priority 1: Current directory (useful for development)
+  const localPath = path.join(process.cwd(), 'credentials.json');
+  if (fsSync.existsSync(localPath)) {
+    return localPath;
+  }
+
+  // Priority 2: Config directory (standard for npm global install)
+  return path.join(TOKEN_DIR, 'credentials.json');
 }
 
 function getTokenPath(account = 'default') {
@@ -23,7 +34,7 @@ function loadAccounts() {
     if (fsSync.existsSync(ACCOUNTS_FILE)) {
       return JSON.parse(fsSync.readFileSync(ACCOUNTS_FILE, 'utf8'));
     }
-  } catch (err) {}
+  } catch (_err) {}
   return { accounts: [], defaultAccount: null };
 }
 
@@ -112,13 +123,76 @@ function renameTokenFile(oldName, newName) {
   }
 }
 
+/**
+ * Validates a credentials.json file structure
+ * @param {string} filePath - Path to the credentials file
+ * @returns {{ valid: boolean, error?: string }} Validation result
+ */
+function validateCredentialsFile(filePath) {
+  if (!fsSync.existsSync(filePath)) {
+    return { valid: false, error: 'File not found' };
+  }
+
+  try {
+    const content = fsSync.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}` };
+  }
+}
+
+/**
+ * Checks if credentials are configured
+ * @returns {boolean}
+ */
+function hasCredentials() {
+  const credentialsPath = getCredentialsPath();
+  return fsSync.existsSync(credentialsPath);
+}
+
+/**
+ * Checks if any accounts are configured
+ * @returns {boolean}
+ */
+function isConfigured() {
+  return hasCredentials() && getAccounts().length > 0;
+}
+
+/**
+ * Copies a credentials file to the config directory
+ * @param {string} sourcePath - Source file path
+ */
+function installCredentials(sourcePath) {
+  fsSync.mkdirSync(TOKEN_DIR, { recursive: true });
+  const destPath = path.join(TOKEN_DIR, 'credentials.json');
+  fsSync.copyFileSync(sourcePath, destPath);
+  return destPath;
+}
+
 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) {
+  } catch (_err) {
     return null;
   }
 }
@@ -149,15 +223,15 @@ async function authorize(account = 'default') {
 
   try {
     await fs.access(credentialsPath);
-  } catch (err) {
+  } catch (_err) {
     throw new Error(
       `credentials.json not found at ${credentialsPath}\n\n` +
-      `To set up Gmail API access:\n` +
+      `Run 'inbox setup' to configure Gmail API access, or manually:\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`
+      `2. Create a project and enable the Gmail API\n` +
+      `3. Configure OAuth consent screen (add yourself as test user)\n` +
+      `4. Create OAuth credentials (Desktop app)\n` +
+      `5. Download and save to ~/.config/inboxd/credentials.json`
     );
   }
 
@@ -182,7 +256,7 @@ async function getAccountEmail(account = 'default') {
     const gmail = await getGmailClient(account);
     const profile = await gmail.users.getProfile({ userId: 'me' });
     return profile.data.emailAddress;
-  } catch (err) {
+  } catch (_err) {
     return null;
   }
 }
@@ -199,5 +273,9 @@ module.exports = {
   getDefaultAccount,
   getAccountEmail,
   renameTokenFile,
+  validateCredentialsFile,
+  hasCredentials,
+  isConfigured,
+  installCredentials,
   TOKEN_DIR,
 };