@striderlabs/mcp-chase 1.0.0

package/README.md

@@ -0,0 +1,100 @@
+# @striderlabs/mcp-chase
+
+MCP server for Chase Bank - let AI agents check accounts, view transactions, and manage finances.
+
+Built by [Strider Labs](https://striderlabs.ai) for the agentic commerce era.
+
+## Features
+
+- **Accounts** - View all checking, savings, credit, investment, and loan accounts
+- **Balances** - Get current and available balances
+- **Transactions** - View recent transaction history
+- **Bills** - See payees and scheduled payments
+- **Transfers** - View transfer history and preview new transfers
+- **Statements** - Access account statements
+- **Rewards** - Check Ultimate Rewards points and cash back
+
+## Installation
+
+```bash
+npm install @striderlabs/mcp-chase
+```
+
+## Usage with Claude Desktop
+
+Add to your `claude_desktop_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "chase": {
+      "command": "npx",
+      "args": ["@striderlabs/mcp-chase"]
+    }
+  }
+}
+```
+
+## Authentication
+
+This connector uses browser automation and requires stored cookies:
+
+1. Log in to Chase in your browser
+2. Export cookies to `~/.strider/chase/cookies.json`
+3. Use a browser extension like "Cookie-Editor" to export cookies in JSON format
+4. Note: Chase uses MFA - you may need to re-export cookies periodically
+
+## Security Notes
+
+- This connector operates in **read-only mode** for sensitive operations
+- Transfers and bill payments provide **preview only** with manual completion instructions
+- No actual financial transactions are executed by this connector
+- All credentials are stored locally in `~/.strider/chase/`
+
+## Available Tools
+
+| Tool | Description |
+|------|-------------|
+| `chase_auth_check` | Check login status |
+| `chase_auth_clear` | Clear stored session |
+| `chase_accounts` | List all accounts |
+| `chase_balance` | Get account balance |
+| `chase_transactions` | Get transaction history |
+| `chase_bills` | View bill pay payees |
+| `chase_transfers` | View transfer history |
+| `chase_statements` | Get account statements |
+| `chase_rewards` | Check rewards balance |
+| `chase_transfer_preview` | Preview a transfer (manual completion) |
+| `chase_bill_pay_preview` | Preview a bill payment (manual completion) |
+
+## Example
+
+```typescript
+// Check if logged in
+const auth = await chase_auth_check();
+
+// Get all accounts
+const accounts = await chase_accounts();
+
+// Get transactions for an account
+const txns = await chase_transactions({ accountId: accounts[0].id, limit: 10 });
+
+// Check rewards
+const rewards = await chase_rewards();
+```
+
+## Requirements
+
+- Node.js 18+
+- Chase bank account
+- Stored session cookies
+
+## License
+
+MIT - Strider Labs
+
+## Links
+
+- [Strider Labs](https://striderlabs.ai)
+- [GitHub](https://github.com/markswendsen-code/mcp-chase)
+- [npm](https://www.npmjs.com/package/@striderlabs/mcp-chase)

package/dist/auth.js

@@ -0,0 +1,72 @@
+/**
+ * Chase Bank Authentication Utilities
+ *
+ * Manages cookie storage and session persistence.
+ */
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+const COOKIES_DIR = path.join(os.homedir(), ".strider", "chase");
+const COOKIES_PATH = path.join(COOKIES_DIR, "cookies.json");
+/**
+ * Get the path to the cookies file
+ */
+export function getCookiesPath() {
+    return COOKIES_PATH;
+}
+/**
+ * Check if cookies file exists
+ */
+export function hasStoredCookies() {
+    return fs.existsSync(COOKIES_PATH);
+}
+/**
+ * Save cookies to disk
+ */
+export async function saveCookies(context) {
+    try {
+        if (!fs.existsSync(COOKIES_DIR)) {
+            fs.mkdirSync(COOKIES_DIR, { recursive: true });
+        }
+        const cookies = await context.cookies();
+        fs.writeFileSync(COOKIES_PATH, JSON.stringify(cookies, null, 2));
+    }
+    catch (error) {
+        console.error("Failed to save cookies:", error);
+    }
+}
+/**
+ * Load cookies from disk into context
+ */
+export async function loadCookies(context) {
+    try {
+        if (fs.existsSync(COOKIES_PATH)) {
+            const cookies = JSON.parse(fs.readFileSync(COOKIES_PATH, "utf-8"));
+            await context.addCookies(cookies);
+        }
+    }
+    catch (error) {
+        console.error("Failed to load cookies:", error);
+    }
+}
+/**
+ * Clear stored cookies
+ */
+export function clearCookies() {
+    try {
+        if (fs.existsSync(COOKIES_PATH)) {
+            fs.unlinkSync(COOKIES_PATH);
+        }
+    }
+    catch (error) {
+        console.error("Failed to clear cookies:", error);
+    }
+}
+/**
+ * Get current auth state
+ */
+export function getAuthState() {
+    return {
+        isLoggedIn: hasStoredCookies(),
+    };
+}

package/dist/browser.js

@@ -0,0 +1,394 @@
+/**
+ * Chase Bank Browser Automation
+ *
+ * Patchright-based stealth automation for Chase banking operations.
+ */
+import { chromium } from "patchright";
+import { saveCookies, loadCookies } from "./auth.js";
+const CHASE_BASE_URL = "https://www.chase.com";
+const DEFAULT_TIMEOUT = 60000;
+// Singleton browser instance
+let browser = null;
+let context = null;
+let page = null;
+/**
+ * Initialize browser with stealth settings
+ */
+async function initBrowser() {
+    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() {
+    await initBrowser();
+    if (!page)
+        throw new Error("Failed to initialize browser");
+    return page;
+}
+/**
+ * Clean up browser resources
+ */
+export async function cleanup() {
+    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() {
+    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() {
+    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() {
+    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';
+            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, limit = 25) {
+    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',
+                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) {
+    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() {
+    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';
+            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() {
+    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 = '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) {
+    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() {
+    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, toAccountId, amount) {
+    // 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, amount, date) {
+    // 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"
+            ]
+        }
+    };
+}