@striderlabs/mcp-chase 1.0.0

package/dist/index.js

@@ -0,0 +1,398 @@
+#!/usr/bin/env node
+/**
+ * Strider Labs Chase Bank MCP Server
+ *
+ * MCP server that gives AI agents the ability to check accounts,
+ * view transactions, and manage banking operations.
+ * https://striderlabs.ai
+ */
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+import { checkAuth, getAccounts, getTransactions, getBalance, getBills, getTransfers, getStatements, getRewards, initiateTransfer, payBill, getLoginUrl, cleanup, } from "./browser.js";
+import { hasStoredCookies, clearCookies, getCookiesPath } from "./auth.js";
+// Initialize server
+const server = new Server({
+    name: "strider-chase",
+    version: "1.0.0",
+}, {
+    capabilities: {
+        tools: {},
+    },
+});
+// Tool definitions
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+    return {
+        tools: [
+            {
+                name: "chase_auth_check",
+                description: "Check if user is logged in to Chase. Returns login status and instructions if not authenticated. Call this before any other Chase operations.",
+                inputSchema: {
+                    type: "object",
+                    properties: {},
+                },
+            },
+            {
+                name: "chase_auth_clear",
+                description: "Clear stored Chase session cookies. Use this to log out or reset authentication state.",
+                inputSchema: {
+                    type: "object",
+                    properties: {},
+                },
+            },
+            {
+                name: "chase_accounts",
+                description: "Get all Chase accounts - checking, savings, credit cards, investments, and loans.",
+                inputSchema: {
+                    type: "object",
+                    properties: {},
+                },
+            },
+            {
+                name: "chase_balance",
+                description: "Get the current balance for a specific account.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        accountId: {
+                            type: "string",
+                            description: "The account ID to check balance for",
+                        },
+                    },
+                    required: ["accountId"],
+                },
+            },
+            {
+                name: "chase_transactions",
+                description: "Get recent transactions for an account.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        accountId: {
+                            type: "string",
+                            description: "The account ID to get transactions for",
+                        },
+                        limit: {
+                            type: "number",
+                            description: "Maximum number of transactions to return (default: 25)",
+                        },
+                    },
+                    required: ["accountId"],
+                },
+            },
+            {
+                name: "chase_bills",
+                description: "Get bills and payees set up in Chase Bill Pay.",
+                inputSchema: {
+                    type: "object",
+                    properties: {},
+                },
+            },
+            {
+                name: "chase_transfers",
+                description: "Get recent transfer history.",
+                inputSchema: {
+                    type: "object",
+                    properties: {},
+                },
+            },
+            {
+                name: "chase_statements",
+                description: "Get available statements for an account.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        accountId: {
+                            type: "string",
+                            description: "The account ID to get statements for",
+                        },
+                    },
+                    required: ["accountId"],
+                },
+            },
+            {
+                name: "chase_rewards",
+                description: "Get Ultimate Rewards points and cash back balance.",
+                inputSchema: {
+                    type: "object",
+                    properties: {},
+                },
+            },
+            {
+                name: "chase_transfer_preview",
+                description: "Preview a transfer between accounts. Does NOT execute the transfer - provides instructions for completing it manually.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        fromAccountId: {
+                            type: "string",
+                            description: "Source account ID",
+                        },
+                        toAccountId: {
+                            type: "string",
+                            description: "Destination account ID",
+                        },
+                        amount: {
+                            type: "number",
+                            description: "Amount to transfer",
+                        },
+                    },
+                    required: ["fromAccountId", "toAccountId", "amount"],
+                },
+            },
+            {
+                name: "chase_bill_pay_preview",
+                description: "Preview a bill payment. Does NOT execute the payment - provides instructions for completing it manually.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        payeeId: {
+                            type: "string",
+                            description: "Payee ID to pay",
+                        },
+                        amount: {
+                            type: "number",
+                            description: "Amount to pay",
+                        },
+                        date: {
+                            type: "string",
+                            description: "Payment date (optional, defaults to immediately)",
+                        },
+                    },
+                    required: ["payeeId", "amount"],
+                },
+            },
+        ],
+    };
+});
+// Tool execution
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    try {
+        switch (name) {
+            case "chase_auth_check": {
+                const hasCookies = hasStoredCookies();
+                if (!hasCookies) {
+                    const loginInfo = await getLoginUrl();
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: JSON.stringify({
+                                    success: true,
+                                    isLoggedIn: false,
+                                    message: "Not logged in to Chase.",
+                                    loginUrl: loginInfo.url,
+                                    instructions: loginInfo.instructions,
+                                    cookiesPath: getCookiesPath(),
+                                }),
+                            },
+                        ],
+                    };
+                }
+                const authState = await checkAuth();
+                if (!authState.isLoggedIn) {
+                    const loginInfo = await getLoginUrl();
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: JSON.stringify({
+                                    success: true,
+                                    isLoggedIn: false,
+                                    message: "Session expired. Please log in again.",
+                                    loginUrl: loginInfo.url,
+                                    instructions: loginInfo.instructions,
+                                }),
+                            },
+                        ],
+                    };
+                }
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({
+                                success: true,
+                                isLoggedIn: true,
+                                message: "Logged in to Chase.",
+                                accountHolder: authState.accountHolder,
+                            }),
+                        },
+                    ],
+                };
+            }
+            case "chase_auth_clear": {
+                clearCookies();
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({
+                                success: true,
+                                message: "Chase session cleared. You will need to log in again.",
+                            }),
+                        },
+                    ],
+                };
+            }
+            case "chase_accounts": {
+                const result = await getAccounts();
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify(result),
+                        },
+                    ],
+                    isError: !result.success,
+                };
+            }
+            case "chase_balance": {
+                const { accountId } = args;
+                const result = await getBalance(accountId);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify(result),
+                        },
+                    ],
+                    isError: !result.success,
+                };
+            }
+            case "chase_transactions": {
+                const { accountId, limit } = args;
+                const result = await getTransactions(accountId, limit);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify(result),
+                        },
+                    ],
+                    isError: !result.success,
+                };
+            }
+            case "chase_bills": {
+                const result = await getBills();
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify(result),
+                        },
+                    ],
+                    isError: !result.success,
+                };
+            }
+            case "chase_transfers": {
+                const result = await getTransfers();
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify(result),
+                        },
+                    ],
+                    isError: !result.success,
+                };
+            }
+            case "chase_statements": {
+                const { accountId } = args;
+                const result = await getStatements(accountId);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify(result),
+                        },
+                    ],
+                    isError: !result.success,
+                };
+            }
+            case "chase_rewards": {
+                const result = await getRewards();
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify(result),
+                        },
+                    ],
+                    isError: !result.success,
+                };
+            }
+            case "chase_transfer_preview": {
+                const { fromAccountId, toAccountId, amount } = args;
+                const result = await initiateTransfer(fromAccountId, toAccountId, amount);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify(result),
+                        },
+                    ],
+                    isError: !result.success,
+                };
+            }
+            case "chase_bill_pay_preview": {
+                const { payeeId, amount, date } = args;
+                const result = await payBill(payeeId, amount, date);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify(result),
+                        },
+                    ],
+                    isError: !result.success,
+                };
+            }
+            default:
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({
+                                success: false,
+                                error: `Unknown tool: ${name}`,
+                            }),
+                        },
+                    ],
+                    isError: true,
+                };
+        }
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : "Unknown error";
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        success: false,
+                        error: errorMessage,
+                    }),
+                },
+            ],
+            isError: true,
+        };
+    }
+});
+// Cleanup on exit
+process.on("SIGINT", async () => {
+    await cleanup();
+    process.exit(0);
+});
+process.on("SIGTERM", async () => {
+    await cleanup();
+    process.exit(0);
+});
+// Start server
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error("Strider Chase MCP server running");
+}
+main().catch(console.error);

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@striderlabs/mcp-chase",
+  "version": "1.0.0",
+  "description": "MCP server for Chase Bank - let AI agents check accounts and manage finances",
+  "main": "dist/index.js",
+  "bin": {
+    "striderlabs-mcp-chase": "dist/index.js"
+  },
+  "type": "module",
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js"
+  },
+  "keywords": [
+    "mcp",
+    "chase",
+    "banking",
+    "finance",
+    "ai-agent",
+    "strider",
+    "model-context-protocol"
+  ],
+  "author": "Strider Labs <hello@striderlabs.ai>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/markswendsen-code/mcp-chase"
+  },
+  "homepage": "https://striderlabs.ai",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "patchright": "^1.58.2"
+  },
+  "devDependencies": {
+    "@types/node": "^20.11.0",
+    "typescript": "^5.3.3"
+  },
+  "mcpName": "io.github.markswendsen-code/chase"
+}

package/server.json

@@ -0,0 +1,20 @@
+{
+  "$schema": "https://static.modelcontextprotocol.io/schemas/2025-12-11/server.schema.json",
+  "name": "io.github.markswendsen-code/chase",
+  "description": "MCP server for Chase Bank - let AI agents check accounts and manage finances",
+  "repository": {
+    "url": "https://github.com/markswendsen-code/mcp-chase",
+    "source": "github"
+  },
+  "version": "1.0.0",
+  "packages": [
+    {
+      "registryType": "npm",
+      "identifier": "@striderlabs/mcp-chase",
+      "version": "1.0.0",
+      "transport": {
+        "type": "stdio"
+      }
+    }
+  ]
+}

package/src/auth.ts

@@ -0,0 +1,83 @@
+/**
+ * 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";
+import { BrowserContext } from "patchright";
+
+const COOKIES_DIR = path.join(os.homedir(), ".strider", "chase");
+const COOKIES_PATH = path.join(COOKIES_DIR, "cookies.json");
+
+export interface AuthState {
+  isLoggedIn: boolean;
+  accountHolder?: string;
+}
+
+/**
+ * Get the path to the cookies file
+ */
+export function getCookiesPath(): string {
+  return COOKIES_PATH;
+}
+
+/**
+ * Check if cookies file exists
+ */
+export function hasStoredCookies(): boolean {
+  return fs.existsSync(COOKIES_PATH);
+}
+
+/**
+ * Save cookies to disk
+ */
+export async function saveCookies(context: BrowserContext): Promise<void> {
+  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: BrowserContext): Promise<void> {
+  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(): void {
+  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(): AuthState {
+  return {
+    isLoggedIn: hasStoredCookies(),
+  };
+}