pkg-track 1.0.0

package/src/db.js

@@ -0,0 +1,189 @@
+const Database = require('better-sqlite3');
+const path = require('path');
+const os = require('os');
+const fs = require('fs');
+
+const DB_DIR = path.join(os.homedir(), '.pkg-tracker');
+const DB_PATH = path.join(DB_DIR, 'packages.db');
+
+// Ensure directory exists with secure permissions (user only)
+if (!fs.existsSync(DB_DIR)) {
+  fs.mkdirSync(DB_DIR, { recursive: true, mode: 0o700 });
+}
+
+const db = new Database(DB_PATH);
+
+// Initialize schema
+db.exec(`
+  CREATE TABLE IF NOT EXISTS packages (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    tracking_number TEXT UNIQUE NOT NULL,
+    carrier TEXT,
+    retailer TEXT,
+    description TEXT,
+    status TEXT DEFAULT 'pending',
+    expected_delivery TEXT,
+    shipped_date INTEGER,
+    last_email_date INTEGER,
+    last_updated INTEGER DEFAULT (strftime('%s', 'now')),
+    created_at INTEGER DEFAULT (strftime('%s', 'now')),
+    delivered_at INTEGER,
+    email_id TEXT
+  );
+
+  CREATE INDEX IF NOT EXISTS idx_tracking ON packages(tracking_number);
+  CREATE INDEX IF NOT EXISTS idx_status ON packages(status);
+  CREATE INDEX IF NOT EXISTS idx_delivered ON packages(delivered_at);
+`);
+
+// Migration: Add new columns if they don't exist
+function migrateSchema() {
+  const columns = db.prepare("PRAGMA table_info(packages)").all();
+  const columnNames = columns.map(c => c.name);
+  
+  if (!columnNames.includes('shipped_date')) {
+    db.exec('ALTER TABLE packages ADD COLUMN shipped_date INTEGER');
+    console.log('Migration: Added shipped_date column');
+  }
+  
+  if (!columnNames.includes('last_email_date')) {
+    db.exec('ALTER TABLE packages ADD COLUMN last_email_date INTEGER');
+    console.log('Migration: Added last_email_date column');
+  }
+}
+
+migrateSchema();
+
+/**
+ * Insert or update a package
+ */
+function upsertPackage(data) {
+  // Auto-infer status based on shipped date if provided
+  if (data.shippedDate && !data.status) {
+    data.status = inferStatus(data.shippedDate);
+  }
+  
+  const stmt = db.prepare(`
+    INSERT INTO packages (tracking_number, carrier, retailer, description, email_id, shipped_date, last_email_date, status)
+    VALUES (@trackingNumber, @carrier, @retailer, @description, @emailId, @shippedDate, @lastEmailDate, @status)
+    ON CONFLICT(tracking_number) DO UPDATE SET
+      carrier = COALESCE(@carrier, carrier),
+      retailer = COALESCE(@retailer, retailer),
+      description = COALESCE(@description, description),
+      shipped_date = COALESCE(@shippedDate, shipped_date),
+      last_email_date = COALESCE(@lastEmailDate, last_email_date),
+      status = COALESCE(@status, status),
+      email_id = @emailId,
+      last_updated = strftime('%s', 'now')
+    RETURNING *
+  `);
+  
+  return stmt.get(data);
+}
+
+/**
+ * Infer package status based on shipped date
+ */
+function inferStatus(shippedDateTimestamp) {
+  if (!shippedDateTimestamp) return 'pending';
+  
+  const now = Math.floor(Date.now() / 1000);
+  const daysSinceShipped = (now - shippedDateTimestamp) / (24 * 60 * 60);
+  
+  if (daysSinceShipped < 1) {
+    return 'pending';
+  } else if (daysSinceShipped < 7) {
+    return 'in_transit';
+  } else if (daysSinceShipped < 14) {
+    return 'delayed';
+  } else {
+    return 'delivered'; // Assume delivered after 2 weeks
+  }
+}
+
+/**
+ * Get all packages
+ */
+function getAllPackages(includeDelivered = false) {
+  let query = 'SELECT * FROM packages';
+  
+  if (!includeDelivered) {
+    query += ' WHERE delivered_at IS NULL';
+  }
+  
+  query += ' ORDER BY created_at DESC';
+  
+  return db.prepare(query).all();
+}
+
+/**
+ * Get package by tracking number
+ */
+function getPackage(trackingNumber) {
+  return db.prepare('SELECT * FROM packages WHERE tracking_number = ?').get(trackingNumber);
+}
+
+/**
+ * Update package status
+ */
+function updatePackageStatus(trackingNumber, status, expectedDelivery = null) {
+  const updates = { status };
+  
+  if (status === 'delivered') {
+    updates.delivered_at = Math.floor(Date.now() / 1000);
+  }
+  
+  if (expectedDelivery) {
+    updates.expected_delivery = expectedDelivery;
+  }
+  
+  const fields = Object.keys(updates).map(k => `${k} = @${k}`).join(', ');
+  const stmt = db.prepare(`
+    UPDATE packages 
+    SET ${fields}, last_updated = strftime('%s', 'now')
+    WHERE tracking_number = @trackingNumber
+  `);
+  
+  return stmt.run({ ...updates, trackingNumber });
+}
+
+/**
+ * Delete a package
+ */
+function deletePackage(trackingNumber) {
+  return db.prepare('DELETE FROM packages WHERE tracking_number = ?').run(trackingNumber);
+}
+
+/**
+ * Delete packages by carrier
+ */
+function deletePackagesByCarrier(carriers) {
+  const placeholders = carriers.map(() => '?').join(',');
+  const stmt = db.prepare(`DELETE FROM packages WHERE carrier IN (${placeholders})`);
+  return stmt.run(...carriers);
+}
+
+/**
+ * Get package stats (only for supported carriers)
+ */
+function getStats() {
+  const SUPPORTED = ['UPS', 'FedEx', 'USPS', 'Amazon Logistics'];
+  const placeholders = SUPPORTED.map(() => '?').join(',');
+  
+  const total = db.prepare(`SELECT COUNT(*) as count FROM packages WHERE carrier IN (${placeholders})`).get(...SUPPORTED).count;
+  const delivered = db.prepare(`SELECT COUNT(*) as count FROM packages WHERE carrier IN (${placeholders}) AND delivered_at IS NOT NULL`).get(...SUPPORTED).count;
+  const inTransit = db.prepare(`SELECT COUNT(*) as count FROM packages WHERE carrier IN (${placeholders}) AND status = ? AND delivered_at IS NULL`).get(...SUPPORTED, 'in_transit').count;
+  
+  return { total, delivered, inTransit, pending: total - delivered - inTransit };
+}
+
+module.exports = {
+  upsertPackage,
+  getAllPackages,
+  getPackage,
+  updatePackageStatus,
+  deletePackage,
+  deletePackagesByCarrier,
+  getStats,
+  db
+};

package/src/gmail.js

@@ -0,0 +1,371 @@
+const { google } = require('googleapis');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const open = require('open');
+const chalk = require('chalk');
+const ora = require('ora');
+const http = require('http');
+const url = require('url');
+const { extractTrackingNumbers, detectRetailer, extractShippedDate, extractProductDetails } = require('./parser');
+const { upsertPackage } = require('./db');
+
+const CONFIG_DIR = path.join(os.homedir(), '.pkg-tracker');
+const TOKEN_PATH = path.join(CONFIG_DIR, 'gmail-token.json');
+const CREDENTIALS_PATH = path.join(CONFIG_DIR, 'credentials.json');
+
+const SCOPES = ['https://www.googleapis.com/auth/gmail.readonly'];
+
+/**
+ * Initialize Gmail OAuth
+ */
+async function initGmail() {
+  console.log(chalk.blue('\n📧 Gmail OAuth Setup\n'));
+  console.log(chalk.gray('Secure, read-only access to scan your email for shipping confirmations'));
+  console.log(chalk.gray('Your credentials are stored locally - no data leaves your computer\n'));
+  
+  // Check if credentials exist
+  if (!fs.existsSync(CREDENTIALS_PATH)) {
+    console.log(chalk.yellow('⚠️  Gmail OAuth credentials not found.'));
+    console.log('\nTo set up Gmail access:');
+    console.log('1. Go to https://console.cloud.google.com/apis/credentials');
+    console.log('2. Create OAuth 2.0 Client ID (Desktop app)');
+    console.log('3. Download the JSON file');
+    console.log(`4. Save it as: ${CREDENTIALS_PATH}\n`);
+    
+    // Ensure directory exists with secure permissions
+    if (!fs.existsSync(CONFIG_DIR)) {
+      fs.mkdirSync(CONFIG_DIR, { recursive: true, mode: 0o700 });
+    }
+    
+    throw new Error('Please set up Gmail credentials first');
+  }
+  
+  const credentials = JSON.parse(fs.readFileSync(CREDENTIALS_PATH, 'utf8'));
+  const { client_secret, client_id, redirect_uris } = credentials.installed || credentials.web;
+  
+  // Parse the redirect URI to get the port
+  const redirectUri = redirect_uris[0];
+  const redirectUrl = new URL(redirectUri);
+  const port = parseInt(redirectUrl.port) || 3000;
+  
+  const oAuth2Client = new google.auth.OAuth2(client_id, client_secret, redirectUri);
+  
+  // Generate auth URL
+  const authUrl = oAuth2Client.generateAuthUrl({
+    access_type: 'offline',
+    scope: SCOPES,
+  });
+  
+  console.log(chalk.blue('Opening browser for Gmail authorization...'));
+  console.log(chalk.gray(`Starting local server on port ${port}...\n`));
+  
+  // Create a promise that resolves when we get the code
+  const code = await new Promise((resolve, reject) => {
+    const server = http.createServer(async (req, res) => {
+      try {
+        console.log(chalk.gray(`Received request: ${req.url}`));
+        const queryParams = url.parse(req.url, true).query;
+        
+        if (queryParams.code) {
+          // Send success page
+          res.writeHead(200, { 'Content-Type': 'text/html' });
+          res.end(`
+            <!DOCTYPE html>
+            <html>
+              <head>
+                <meta charset="UTF-8">
+                <title>Authorization Successful</title>
+                <style>
+                  body {
+                    font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif;
+                    display: flex;
+                    align-items: center;
+                    justify-content: center;
+                    height: 100vh;
+                    margin: 0;
+                    background: #f5f5f5;
+                  }
+                  .container {
+                    text-align: center;
+                    background: white;
+                    padding: 3rem;
+                    border-radius: 12px;
+                    box-shadow: 0 4px 12px rgba(0,0,0,0.1);
+                  }
+                  h1 { color: #22c55e; margin: 0 0 1rem; }
+                  p { color: #666; margin: 0; }
+                </style>
+              </head>
+              <body>
+                <div class="container">
+                  <h1>✓ Authorization Successful!</h1>
+                  <p>You can close this window and return to the terminal.</p>
+                </div>
+              </body>
+            </html>
+          `);
+          
+          console.log(chalk.green('\n✓ Received authorization code'));
+          
+          // Give time for response to be sent
+          setTimeout(() => {
+            server.close();
+            resolve(queryParams.code);
+          }, 100);
+        } else if (queryParams.error) {
+          res.writeHead(400, { 'Content-Type': 'text/html' });
+          res.end(`
+            <!DOCTYPE html>
+            <html>
+              <head>
+                <meta charset="UTF-8">
+                <title>Authorization Failed</title>
+                <style>
+                  body {
+                    font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif;
+                    display: flex;
+                    align-items: center;
+                    justify-content: center;
+                    height: 100vh;
+                    margin: 0;
+                    background: #f5f5f5;
+                  }
+                  .container {
+                    text-align: center;
+                    background: white;
+                    padding: 3rem;
+                    border-radius: 12px;
+                    box-shadow: 0 4px 12px rgba(0,0,0,0.1);
+                  }
+                  h1 { color: #ef4444; margin: 0 0 1rem; }
+                  p { color: #666; margin: 0; }
+                </style>
+              </head>
+              <body>
+                <div class="container">
+                  <h1>✗ Authorization Failed</h1>
+                  <p>Error: ${queryParams.error}</p>
+                </div>
+              </body>
+            </html>
+          `);
+          
+          setTimeout(() => {
+            server.close();
+            reject(new Error(`OAuth error: ${queryParams.error}`));
+          }, 100);
+        }
+      } catch (err) {
+        server.close();
+        reject(err);
+      }
+    });
+    
+    // Handle server errors
+    server.on('error', (err) => {
+      if (err.code === 'EADDRINUSE') {
+        console.log(chalk.red(`\n✗ Port ${port} is already in use`));
+        console.log(chalk.yellow('Please close any other applications using this port and try again.\n'));
+      }
+      reject(err);
+    });
+    
+    server.listen(port, '127.0.0.1', () => {
+      console.log(chalk.green(`✓ Server listening on http://127.0.0.1:${port}`));
+      console.log(chalk.gray('Opening browser...\n'));
+      
+      // Wait a bit for server to be fully ready, then open browser
+      setTimeout(() => {
+        open(authUrl);
+      }, 500);
+    });
+    
+    // Timeout after 5 minutes
+    setTimeout(() => {
+      server.close();
+      reject(new Error('Authorization timeout - no response received after 5 minutes'));
+    }, 5 * 60 * 1000);
+  });
+  
+  const { tokens } = await oAuth2Client.getToken(code);
+  oAuth2Client.setCredentials(tokens);
+  
+  // Save token with secure permissions (user read/write only)
+  fs.writeFileSync(TOKEN_PATH, JSON.stringify(tokens), { mode: 0o600 });
+  console.log(chalk.green('\n✓ Gmail access granted and saved!'));
+}
+
+/**
+ * Get authorized Gmail client
+ */
+function getGmailClient() {
+  if (!fs.existsSync(CREDENTIALS_PATH)) {
+    throw new Error('Gmail credentials not found. Run `pkg init` first.');
+  }
+  
+  if (!fs.existsSync(TOKEN_PATH)) {
+    throw new Error('Gmail not authorized. Run `pkg init` first.');
+  }
+  
+  const credentials = JSON.parse(fs.readFileSync(CREDENTIALS_PATH, 'utf8'));
+  const tokens = JSON.parse(fs.readFileSync(TOKEN_PATH, 'utf8'));
+  
+  const { client_secret, client_id, redirect_uris } = credentials.installed || credentials.web;
+  const oAuth2Client = new google.auth.OAuth2(client_id, client_secret, redirect_uris[0]);
+  
+  oAuth2Client.setCredentials(tokens);
+  
+  return google.gmail({ version: 'v1', auth: oAuth2Client });
+}
+
+/**
+ * Sync packages from Gmail
+ */
+async function syncPackages(days = 30) {
+  console.log(chalk.blue('\n📧 Gmail Package Scanner\n'));
+  console.log(chalk.gray('Securely scanning your Gmail for shipping confirmations...'));
+  console.log(chalk.gray(`Searching the last ${days} days for packages from UPS, FedEx, USPS, and Amazon`));
+  console.log(chalk.gray('💡 Tip: Use --days <number> to customize the date range (max 30 days)\n'));
+  
+  const spinner = ora('Scanning Gmail for shipping confirmations...').start();
+  
+  try {
+    const gmail = getGmailClient();
+    
+    // Expanded search for shipping-related emails
+    // Search both subject and body for common shipping terms
+    const query = `(
+      shipped OR 
+      "has shipped" OR 
+      tracking OR 
+      delivered OR 
+      "out for delivery" OR 
+      "order confirmation" OR 
+      "shipment confirmation" OR 
+      "your order" OR 
+      "on its way" OR 
+      "package update" OR
+      "delivery update" OR
+      "1Z" OR
+      "TBA" OR
+      "fedex" OR
+      "usps" OR
+      "ups" OR
+      "amazon"
+    ) newer_than:${days}d`.replace(/\s+/g, ' ');
+    
+    console.log(chalk.gray(`\nSearch query: ${query.substring(0, 100)}...`));
+    
+    const response = await gmail.users.messages.list({
+      userId: 'me',
+      q: query,
+      maxResults: 200, // Increased from 100
+    });
+    
+    const messages = response.data.messages || [];
+    
+    if (messages.length === 0) {
+      spinner.succeed(chalk.yellow('No shipping emails found'));
+      return;
+    }
+    
+    spinner.text = `Found ${messages.length} emails, extracting tracking numbers...`;
+    console.log(chalk.gray(`Processing ${messages.length} emails (last ${days} days)...\n`));
+    
+    let foundCount = 0;
+    let emailsWithTracking = 0;
+    const skippedEmails = [];
+    
+    for (const message of messages) {
+      const msg = await gmail.users.messages.get({
+        userId: 'me',
+        id: message.id,
+        format: 'full',
+      });
+      
+      // Extract headers
+      const headers = msg.data.payload.headers;
+      const subject = headers.find(h => h.name === 'Subject')?.value || '';
+      const from = headers.find(h => h.name === 'From')?.value || '';
+      const date = headers.find(h => h.name === 'Date')?.value || '';
+      
+      // Get email body
+      let body = '';
+      if (msg.data.payload.body.data) {
+        body = Buffer.from(msg.data.payload.body.data, 'base64').toString();
+      } else if (msg.data.payload.parts) {
+        const textPart = msg.data.payload.parts.find(p => p.mimeType === 'text/plain');
+        if (textPart && textPart.body.data) {
+          body = Buffer.from(textPart.body.data, 'base64').toString();
+        }
+      }
+      
+      // Extract tracking numbers
+      const trackingNumbers = extractTrackingNumbers(subject + ' ' + body);
+      
+      if (trackingNumbers.length > 0) {
+        emailsWithTracking++;
+        const emailData = { from, subject, body, date };
+        const retailer = detectRetailer(emailData);
+        const shippedDate = extractShippedDate(emailData);
+        const productDetails = extractProductDetails(emailData);
+        
+        // Parse email date to timestamp
+        let emailTimestamp = null;
+        try {
+          if (date) {
+            emailTimestamp = Math.floor(new Date(date).getTime() / 1000);
+          }
+        } catch (e) {
+          // Use current time if parsing fails
+          emailTimestamp = Math.floor(Date.now() / 1000);
+        }
+        
+        for (const { trackingNumber, carrier } of trackingNumbers) {
+          upsertPackage({
+            trackingNumber,
+            carrier,
+            retailer,
+            description: productDetails,
+            emailId: message.id,
+            shippedDate,
+            lastEmailDate: emailTimestamp,
+          });
+          foundCount++;
+        }
+      } else {
+        // Track emails without tracking numbers for debugging
+        skippedEmails.push({ subject, from });
+      }
+    }
+    
+    spinner.succeed(chalk.green(`✓ Found ${foundCount} tracking numbers from ${emailsWithTracking}/${messages.length} emails`));
+    
+    if (foundCount > 0) {
+      console.log(chalk.gray(`\n💡 Run ${chalk.cyan('pkg open')} to track your packages\n`));
+    }
+    
+    // Show sample of skipped emails if verbose
+    if (skippedEmails.length > 0 && skippedEmails.length < 10) {
+      console.log(chalk.yellow(`⚠️  ${skippedEmails.length} emails had no tracking numbers:`));
+      skippedEmails.forEach(({ subject, from }) => {
+        console.log(chalk.gray(`  - ${subject.substring(0, 60)}...`));
+        console.log(chalk.gray(`    from: ${from.substring(0, 40)}`));
+      });
+      console.log();
+    } else if (skippedEmails.length >= 10) {
+      console.log(chalk.gray(`${skippedEmails.length} emails had no tracking numbers (likely order confirmations)\n`));
+    }
+    
+  } catch (error) {
+    spinner.fail(chalk.red('Failed to sync'));
+    throw error;
+  }
+}
+
+module.exports = {
+  initGmail,
+  syncPackages,
+  getGmailClient,
+};