@striderlabs/mcp-chase 1.0.0

package/src/browser.ts

@@ -0,0 +1,530 @@
+/**
+ * Chase Bank Browser Automation
+ * 
+ * Patchright-based stealth automation for Chase banking operations.
+ */
+
+import { chromium, Browser, BrowserContext, Page } from "patchright";
+import { saveCookies, loadCookies, AuthState } from "./auth.js";
+
+const CHASE_BASE_URL = "https://www.chase.com";
+const DEFAULT_TIMEOUT = 60000;
+
+// Singleton browser instance
+let browser: Browser | null = null;
+let context: BrowserContext | null = null;
+let page: Page | null = null;
+
+export interface Account {
+  id: string;
+  name: string;
+  type: "checking" | "savings" | "credit" | "investment" | "loan";
+  balance: number;
+  availableBalance?: number;
+  accountNumber?: string;
+  lastFour?: string;
+}
+
+export interface Transaction {
+  id: string;
+  date: string;
+  description: string;
+  amount: number;
+  type: "credit" | "debit";
+  category?: string;
+  pending: boolean;
+  merchant?: string;
+}
+
+export interface Bill {
+  id: string;
+  payee: string;
+  amount: number;
+  dueDate: string;
+  status: "scheduled" | "paid" | "overdue";
+  autopay: boolean;
+}
+
+export interface Transfer {
+  id: string;
+  fromAccount: string;
+  toAccount: string;
+  amount: number;
+  date: string;
+  status: "pending" | "completed" | "failed";
+}
+
+export interface Statement {
+  id: string;
+  accountId: string;
+  period: string;
+  date: string;
+  downloadUrl?: string;
+}
+
+export interface RewardsInfo {
+  pointsBalance: number;
+  cashBackBalance: number;
+  pendingRewards: number;
+  tier?: string;
+}
+
+/**
+ * Initialize browser with stealth settings
+ */
+async function initBrowser(): Promise<void> {
+  if (browser) return;
+
+  browser = await chromium.launch({
+    headless: true,
+    args: [
+      "--disable-blink-features=AutomationControlled",
+      "--no-sandbox",
+      "--disable-setuid-sandbox",
+      "--disable-web-security",
+      "--disable-features=IsolateOrigins,site-per-process",
+    ],
+  });
+
+  context = await browser.newContext({
+    userAgent:
+      "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36",
+    viewport: { width: 1280, height: 800 },
+    locale: "en-US",
+    timezoneId: "America/Los_Angeles",
+  });
+
+  // Load saved cookies
+  await loadCookies(context);
+
+  page = await context.newPage();
+  page.setDefaultTimeout(DEFAULT_TIMEOUT);
+}
+
+/**
+ * Get the current page, initializing if needed
+ */
+async function getPage(): Promise<Page> {
+  await initBrowser();
+  if (!page) throw new Error("Failed to initialize browser");
+  return page;
+}
+
+/**
+ * Clean up browser resources
+ */
+export async function cleanup(): Promise<void> {
+  if (context) {
+    await saveCookies(context);
+  }
+  if (browser) {
+    await browser.close();
+    browser = null;
+    context = null;
+    page = null;
+  }
+}
+
+/**
+ * Get Chase login URL and instructions
+ */
+export async function getLoginUrl(): Promise<{ url: string; instructions: string }> {
+  return {
+    url: "https://secure.chase.com/web/auth/dashboard",
+    instructions:
+      "Please log in to Chase in a browser, then export your cookies to ~/.strider/chase/cookies.json. Use a browser extension like 'Cookie-Editor' to export cookies in JSON format. Note: Chase uses MFA, so you may need to re-export cookies after each session.",
+  };
+}
+
+/**
+ * Check authentication status
+ */
+export async function checkAuth(): Promise<AuthState> {
+  try {
+    const p = await getPage();
+    await p.goto(`${CHASE_BASE_URL}/web/auth/dashboard`, { waitUntil: "networkidle" });
+    
+    // Check if we're on the dashboard or redirected to login
+    const currentUrl = p.url();
+    
+    if (currentUrl.includes("/auth/logon") || currentUrl.includes("/login")) {
+      return { isLoggedIn: false };
+    }
+    
+    // Try to get account holder name
+    const holderName = await p.$eval(
+      '.mds-header-user-name, .account-holder-name, [data-testid="user-greeting"]',
+      (el) => el.textContent?.trim() || "",
+    ).catch(() => "");
+    
+    return {
+      isLoggedIn: true,
+      accountHolder: holderName || undefined,
+    };
+  } catch (error) {
+    return { isLoggedIn: false };
+  }
+}
+
+/**
+ * Get all accounts
+ */
+export async function getAccounts(): Promise<{ success: boolean; accounts?: Account[]; error?: string }> {
+  try {
+    const p = await getPage();
+    await p.goto(`${CHASE_BASE_URL}/web/auth/dashboard`, { waitUntil: "networkidle" });
+    
+    await p.waitForTimeout(2000);
+    
+    const accounts = await p.$$eval(
+      '.account-tile, .account-card, [data-testid="account-tile"]',
+      (elements) =>
+        elements.map((el, index) => {
+          const nameEl = el.querySelector('.account-name, .tile-header, h3');
+          const balanceEl = el.querySelector('.account-balance, .balance, [data-testid="balance"]');
+          const lastFourEl = el.querySelector('.account-last-four, .masked-number');
+          const typeEl = el.querySelector('.account-type');
+          
+          const name = nameEl?.textContent?.trim() || `Account ${index + 1}`;
+          const balanceText = balanceEl?.textContent?.trim() || '0';
+          const balance = parseFloat(balanceText.replace(/[$,]/g, '')) || 0;
+          const lastFour = lastFourEl?.textContent?.trim().replace(/[^0-9]/g, '').slice(-4) || undefined;
+          
+          let type: 'checking' | 'savings' | 'credit' | 'investment' | 'loan' = 'checking';
+          const typeText = (typeEl?.textContent || name).toLowerCase();
+          if (typeText.includes('saving')) type = 'savings';
+          else if (typeText.includes('credit') || typeText.includes('card')) type = 'credit';
+          else if (typeText.includes('invest') || typeText.includes('brokerage')) type = 'investment';
+          else if (typeText.includes('loan') || typeText.includes('mortgage') || typeText.includes('auto')) type = 'loan';
+          
+          return {
+            id: el.getAttribute('data-account-id') || `account-${index}`,
+            name,
+            type,
+            balance,
+            lastFour,
+          };
+        }),
+    );
+    
+    return { success: true, accounts };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : "Failed to get accounts",
+    };
+  }
+}
+
+/**
+ * Get account transactions
+ */
+export async function getTransactions(
+  accountId: string,
+  limit: number = 25
+): Promise<{ success: boolean; transactions?: Transaction[]; error?: string }> {
+  try {
+    const p = await getPage();
+    
+    // Navigate to account details
+    await p.goto(`${CHASE_BASE_URL}/web/auth/dashboard`, { waitUntil: "networkidle" });
+    await p.waitForTimeout(1000);
+    
+    // Click on the account
+    const accountTile = await p.$(`[data-account-id="${accountId}"], .account-tile:nth-child(${parseInt(accountId.replace('account-', '')) + 1})`);
+    if (accountTile) {
+      await accountTile.click();
+      await p.waitForNavigation({ waitUntil: "networkidle" }).catch(() => {});
+    }
+    
+    await p.waitForTimeout(2000);
+    
+    const transactions = await p.$$eval(
+      '.transaction-row, .activity-row, [data-testid="transaction"]',
+      (elements, maxItems) =>
+        elements.slice(0, maxItems).map((el, index) => {
+          const dateEl = el.querySelector('.transaction-date, .date, td:first-child');
+          const descEl = el.querySelector('.transaction-description, .description, .merchant-name');
+          const amountEl = el.querySelector('.transaction-amount, .amount');
+          const pendingEl = el.querySelector('.pending, .pending-badge');
+          const categoryEl = el.querySelector('.category, .transaction-category');
+          
+          const amountText = amountEl?.textContent?.trim() || '0';
+          const amount = Math.abs(parseFloat(amountText.replace(/[$,]/g, ''))) || 0;
+          const isCredit = amountText.includes('+') || el.classList.contains('credit');
+          
+          return {
+            id: el.getAttribute('data-transaction-id') || `txn-${index}`,
+            date: dateEl?.textContent?.trim() || '',
+            description: descEl?.textContent?.trim() || 'Unknown',
+            amount,
+            type: isCredit ? 'credit' : 'debit' as 'credit' | 'debit',
+            category: categoryEl?.textContent?.trim() || undefined,
+            pending: !!pendingEl,
+          };
+        }),
+      limit
+    );
+    
+    return { success: true, transactions };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : "Failed to get transactions",
+    };
+  }
+}
+
+/**
+ * Get account balance
+ */
+export async function getBalance(accountId: string): Promise<{ success: boolean; balance?: number; availableBalance?: number; error?: string }> {
+  try {
+    const accountsResult = await getAccounts();
+    if (!accountsResult.success || !accountsResult.accounts) {
+      return { success: false, error: "Failed to get accounts" };
+    }
+    
+    const account = accountsResult.accounts.find(a => a.id === accountId);
+    if (!account) {
+      return { success: false, error: `Account not found: ${accountId}` };
+    }
+    
+    return {
+      success: true,
+      balance: account.balance,
+      availableBalance: account.availableBalance || account.balance,
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : "Failed to get balance",
+    };
+  }
+}
+
+/**
+ * Get bills/payees
+ */
+export async function getBills(): Promise<{ success: boolean; bills?: Bill[]; error?: string }> {
+  try {
+    const p = await getPage();
+    await p.goto(`${CHASE_BASE_URL}/web/auth/billpay`, { waitUntil: "networkidle" });
+    
+    await p.waitForTimeout(2000);
+    
+    const bills = await p.$$eval(
+      '.payee-row, .bill-row, [data-testid="payee"]',
+      (elements) =>
+        elements.map((el, index) => {
+          const payeeEl = el.querySelector('.payee-name, .name');
+          const amountEl = el.querySelector('.amount, .payment-amount');
+          const dueDateEl = el.querySelector('.due-date, .date');
+          const statusEl = el.querySelector('.status, .payment-status');
+          const autopayEl = el.querySelector('.autopay, .auto-pay-enabled');
+          
+          const amountText = amountEl?.textContent?.trim() || '0';
+          const amount = parseFloat(amountText.replace(/[$,]/g, '')) || 0;
+          
+          let status: 'scheduled' | 'paid' | 'overdue' = 'scheduled';
+          const statusText = statusEl?.textContent?.toLowerCase() || '';
+          if (statusText.includes('paid')) status = 'paid';
+          else if (statusText.includes('overdue') || statusText.includes('past due')) status = 'overdue';
+          
+          return {
+            id: el.getAttribute('data-payee-id') || `bill-${index}`,
+            payee: payeeEl?.textContent?.trim() || 'Unknown Payee',
+            amount,
+            dueDate: dueDateEl?.textContent?.trim() || '',
+            status,
+            autopay: !!autopayEl,
+          };
+        }),
+    );
+    
+    return { success: true, bills };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : "Failed to get bills",
+    };
+  }
+}
+
+/**
+ * Get transfer history
+ */
+export async function getTransfers(): Promise<{ success: boolean; transfers?: Transfer[]; error?: string }> {
+  try {
+    const p = await getPage();
+    await p.goto(`${CHASE_BASE_URL}/web/auth/transfer`, { waitUntil: "networkidle" });
+    
+    await p.waitForTimeout(2000);
+    
+    const transfers = await p.$$eval(
+      '.transfer-row, .activity-row, [data-testid="transfer"]',
+      (elements) =>
+        elements.slice(0, 20).map((el, index) => {
+          const fromEl = el.querySelector('.from-account, .source');
+          const toEl = el.querySelector('.to-account, .destination');
+          const amountEl = el.querySelector('.amount');
+          const dateEl = el.querySelector('.date, .transfer-date');
+          const statusEl = el.querySelector('.status');
+          
+          const amountText = amountEl?.textContent?.trim() || '0';
+          const amount = parseFloat(amountText.replace(/[$,]/g, '')) || 0;
+          
+          let status: 'pending' | 'completed' | 'failed' = 'completed';
+          const statusText = statusEl?.textContent?.toLowerCase() || '';
+          if (statusText.includes('pending')) status = 'pending';
+          else if (statusText.includes('failed') || statusText.includes('cancelled')) status = 'failed';
+          
+          return {
+            id: el.getAttribute('data-transfer-id') || `transfer-${index}`,
+            fromAccount: fromEl?.textContent?.trim() || 'Unknown',
+            toAccount: toEl?.textContent?.trim() || 'Unknown',
+            amount,
+            date: dateEl?.textContent?.trim() || '',
+            status,
+          };
+        }),
+    );
+    
+    return { success: true, transfers };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : "Failed to get transfers",
+    };
+  }
+}
+
+/**
+ * Get statements
+ */
+export async function getStatements(accountId: string): Promise<{ success: boolean; statements?: Statement[]; error?: string }> {
+  try {
+    const p = await getPage();
+    
+    // Navigate to account and then statements
+    await p.goto(`${CHASE_BASE_URL}/web/auth/dashboard`, { waitUntil: "networkidle" });
+    await p.waitForTimeout(1000);
+    
+    // This would need to navigate to the specific account's statements section
+    // For now, return a message about navigation
+    
+    const statements = await p.$$eval(
+      '.statement-row, [data-testid="statement"]',
+      (elements, acctId) =>
+        elements.slice(0, 12).map((el, index) => {
+          const periodEl = el.querySelector('.period, .statement-period');
+          const dateEl = el.querySelector('.date, .statement-date');
+          
+          return {
+            id: el.getAttribute('data-statement-id') || `stmt-${index}`,
+            accountId: acctId,
+            period: periodEl?.textContent?.trim() || '',
+            date: dateEl?.textContent?.trim() || '',
+          };
+        }),
+      accountId
+    );
+    
+    return { success: true, statements };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : "Failed to get statements",
+    };
+  }
+}
+
+/**
+ * Get rewards/points info
+ */
+export async function getRewards(): Promise<{ success: boolean; rewards?: RewardsInfo; error?: string }> {
+  try {
+    const p = await getPage();
+    await p.goto(`${CHASE_BASE_URL}/web/auth/dashboard`, { waitUntil: "networkidle" });
+    
+    await p.waitForTimeout(2000);
+    
+    const rewards = await p.evaluate(() => {
+      const pointsEl = document.querySelector('.points-balance, .ultimate-rewards, [data-testid="points"]');
+      const cashBackEl = document.querySelector('.cash-back-balance, [data-testid="cashback"]');
+      const tierEl = document.querySelector('.rewards-tier, .membership-level');
+      
+      const pointsText = pointsEl?.textContent?.trim() || '0';
+      const cashBackText = cashBackEl?.textContent?.trim() || '0';
+      
+      return {
+        pointsBalance: parseInt(pointsText.replace(/[^0-9]/g, '')) || 0,
+        cashBackBalance: parseFloat(cashBackText.replace(/[$,]/g, '')) || 0,
+        pendingRewards: 0,
+        tier: tierEl?.textContent?.trim() || undefined,
+      };
+    });
+    
+    return { success: true, rewards };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : "Failed to get rewards",
+    };
+  }
+}
+
+/**
+ * Initiate a transfer (preview only - does not execute)
+ */
+export async function initiateTransfer(
+  fromAccountId: string,
+  toAccountId: string,
+  amount: number
+): Promise<{ success: boolean; preview?: object; error?: string }> {
+  // For security, this only provides a preview and instructions
+  // The actual transfer would need to be confirmed by the user
+  return {
+    success: true,
+    preview: {
+      fromAccountId,
+      toAccountId,
+      amount,
+      message: "For security reasons, transfers must be completed manually in Chase. Navigate to Transfers in your Chase account to complete this transfer.",
+      instructions: [
+        "1. Log in to Chase.com or Chase mobile app",
+        "2. Go to 'Pay & Transfer' > 'Transfers'",
+        "3. Select your from and to accounts",
+        `4. Enter amount: $${amount.toFixed(2)}`,
+        "5. Review and confirm the transfer"
+      ]
+    }
+  };
+}
+
+/**
+ * Pay a bill (preview only - does not execute)
+ */
+export async function payBill(
+  payeeId: string,
+  amount: number,
+  date?: string
+): Promise<{ success: boolean; preview?: object; error?: string }> {
+  // For security, this only provides a preview and instructions
+  return {
+    success: true,
+    preview: {
+      payeeId,
+      amount,
+      scheduledDate: date || "Immediately",
+      message: "For security reasons, bill payments must be completed manually in Chase.",
+      instructions: [
+        "1. Log in to Chase.com or Chase mobile app",
+        "2. Go to 'Pay & Transfer' > 'Pay Bills'",
+        "3. Select the payee",
+        `4. Enter amount: $${amount.toFixed(2)}`,
+        "5. Choose payment date and confirm"
+      ]
+    }
+  };
+}