ray-finance 0.1.0

package/dist/db/schema.js

@@ -0,0 +1,199 @@
+export function migrate(db) {
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS institutions (
+      item_id TEXT PRIMARY KEY,
+      access_token TEXT NOT NULL,
+      name TEXT NOT NULL,
+      products TEXT NOT NULL DEFAULT '[]',
+      cursor TEXT,
+      created_at TEXT DEFAULT (datetime('now'))
+    );
+
+    CREATE TABLE IF NOT EXISTS accounts (
+      account_id TEXT PRIMARY KEY,
+      item_id TEXT NOT NULL REFERENCES institutions(item_id),
+      name TEXT NOT NULL,
+      official_name TEXT,
+      type TEXT NOT NULL,
+      subtype TEXT,
+      mask TEXT,
+      current_balance REAL,
+      available_balance REAL,
+      currency TEXT,
+      hidden INTEGER DEFAULT 0,
+      updated_at TEXT DEFAULT (datetime('now'))
+    );
+
+    CREATE TABLE IF NOT EXISTS transactions (
+      transaction_id TEXT PRIMARY KEY,
+      account_id TEXT NOT NULL REFERENCES accounts(account_id),
+      amount REAL NOT NULL,
+      date TEXT NOT NULL,
+      name TEXT NOT NULL,
+      merchant_name TEXT,
+      category TEXT,
+      subcategory TEXT,
+      pending INTEGER DEFAULT 0,
+      iso_currency_code TEXT,
+      payment_channel TEXT,
+      logo_url TEXT,
+      website TEXT,
+      label TEXT,
+      note TEXT,
+      created_at TEXT DEFAULT (datetime('now'))
+    );
+
+    CREATE TABLE IF NOT EXISTS holdings (
+      holding_id INTEGER PRIMARY KEY AUTOINCREMENT,
+      account_id TEXT NOT NULL REFERENCES accounts(account_id),
+      security_id TEXT,
+      quantity REAL NOT NULL,
+      cost_basis REAL,
+      value REAL,
+      price REAL,
+      price_as_of TEXT,
+      updated_at TEXT DEFAULT (datetime('now')),
+      UNIQUE(account_id, security_id)
+    );
+
+    CREATE TABLE IF NOT EXISTS securities (
+      security_id TEXT PRIMARY KEY,
+      name TEXT,
+      ticker TEXT,
+      type TEXT,
+      close_price REAL,
+      close_price_as_of TEXT
+    );
+
+    CREATE TABLE IF NOT EXISTS liabilities (
+      liability_id INTEGER PRIMARY KEY AUTOINCREMENT,
+      account_id TEXT NOT NULL REFERENCES accounts(account_id),
+      type TEXT NOT NULL,
+      interest_rate REAL,
+      origination_date TEXT,
+      original_balance REAL,
+      current_balance REAL,
+      minimum_payment REAL,
+      next_payment_due TEXT,
+      updated_at TEXT DEFAULT (datetime('now')),
+      UNIQUE(account_id, type)
+    );
+
+    CREATE TABLE IF NOT EXISTS net_worth_history (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      date TEXT NOT NULL UNIQUE,
+      total_assets REAL NOT NULL,
+      total_liabilities REAL NOT NULL,
+      net_worth REAL NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS budgets (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      category TEXT NOT NULL,
+      monthly_limit REAL NOT NULL,
+      period TEXT DEFAULT 'monthly',
+      UNIQUE(category, period)
+    );
+
+    CREATE TABLE IF NOT EXISTS goals (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      name TEXT NOT NULL,
+      target_amount REAL NOT NULL,
+      current_amount REAL DEFAULT 0,
+      target_date TEXT,
+      status TEXT DEFAULT 'active'
+    );
+
+    CREATE TABLE IF NOT EXISTS recurring (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      merchant_name TEXT NOT NULL,
+      avg_amount REAL NOT NULL,
+      frequency TEXT NOT NULL,
+      category TEXT,
+      last_date TEXT,
+      account_id TEXT,
+      active INTEGER DEFAULT 1
+    );
+
+    CREATE TABLE IF NOT EXISTS daily_scores (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      date TEXT NOT NULL UNIQUE,
+      score INTEGER NOT NULL,
+      restaurant_count INTEGER DEFAULT 0,
+      shopping_count INTEGER DEFAULT 0,
+      food_spend REAL DEFAULT 0,
+      total_spend REAL DEFAULT 0,
+      zero_spend INTEGER DEFAULT 0,
+      no_restaurant_streak INTEGER DEFAULT 0,
+      no_shopping_streak INTEGER DEFAULT 0,
+      on_pace_streak INTEGER DEFAULT 0
+    );
+
+    CREATE TABLE IF NOT EXISTS achievements (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      key TEXT NOT NULL UNIQUE,
+      name TEXT NOT NULL,
+      description TEXT,
+      unlocked_at TEXT DEFAULT (datetime('now'))
+    );
+
+    CREATE TABLE IF NOT EXISTS settings (
+      key TEXT PRIMARY KEY,
+      value TEXT NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS recategorization_rules (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      match_field TEXT NOT NULL,
+      match_pattern TEXT NOT NULL,
+      target_category TEXT NOT NULL,
+      target_subcategory TEXT,
+      label TEXT
+    );
+
+    CREATE TABLE IF NOT EXISTS recurring_bills (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      name TEXT NOT NULL,
+      amount REAL NOT NULL,
+      day_of_month INTEGER,
+      type TEXT,
+      account_id TEXT
+    );
+
+    CREATE TABLE IF NOT EXISTS milestones (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      name TEXT NOT NULL,
+      target_date TEXT,
+      monthly_savings REAL,
+      description TEXT
+    );
+
+    CREATE TABLE IF NOT EXISTS conversation_history (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      role TEXT NOT NULL,
+      content TEXT NOT NULL,
+      created_at TEXT DEFAULT (datetime('now'))
+    );
+
+    CREATE TABLE IF NOT EXISTS memories (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      content TEXT NOT NULL,
+      category TEXT DEFAULT 'general',
+      created_at TEXT DEFAULT (datetime('now'))
+    );
+
+    CREATE TABLE IF NOT EXISTS ai_audit_log (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      tool_name TEXT NOT NULL,
+      input_params TEXT,
+      result_summary TEXT,
+      tokens_used INTEGER,
+      created_at TEXT DEFAULT (datetime('now'))
+    );
+  `);
+    // Migrate: rename goals.deadline -> target_date for existing databases
+    const goalCols = db.prepare(`PRAGMA table_info(goals)`).all();
+    if (goalCols.some(c => c.name === "deadline") && !goalCols.some(c => c.name === "target_date")) {
+        db.exec(`ALTER TABLE goals RENAME COLUMN deadline TO target_date`);
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/index.js

@@ -0,0 +1 @@
+export {};

package/dist/plaid/client.d.ts

@@ -0,0 +1,2 @@
+import { PlaidApi } from "plaid";
+export declare const plaidClient: PlaidApi;

package/dist/plaid/client.js

@@ -0,0 +1,22 @@
+import { Configuration, PlaidApi, PlaidEnvironments } from "plaid";
+import { config, useManaged, RAY_PROXY_BASE } from "../config.js";
+function buildPlaidConfig() {
+    if (useManaged()) {
+        return new Configuration({
+            basePath: `${RAY_PROXY_BASE}/plaid`,
+            baseOptions: {
+                headers: { Authorization: `Bearer ${config.rayApiKey}` },
+            },
+        });
+    }
+    return new Configuration({
+        basePath: PlaidEnvironments[config.plaidEnv],
+        baseOptions: {
+            headers: {
+                "PLAID-CLIENT-ID": config.plaidClientId,
+                "PLAID-SECRET": config.plaidSecret,
+            },
+        },
+    });
+}
+export const plaidClient = new PlaidApi(buildPlaidConfig());

package/dist/plaid/link.d.ts

@@ -0,0 +1,8 @@
+import { Products } from "plaid";
+/** Create a link token for initializing Plaid Link */
+export declare function createLinkToken(products?: Products[]): Promise<string>;
+/** Exchange a public token from Plaid Link for an access token */
+export declare function exchangeToken(publicToken: string): Promise<{
+    accessToken: string;
+    itemId: string;
+}>;

package/dist/plaid/link.js

@@ -0,0 +1,23 @@
+import { plaidClient } from "./client.js";
+import { CountryCode, Products } from "plaid";
+/** Create a link token for initializing Plaid Link */
+export async function createLinkToken(products = [Products.Transactions]) {
+    const resp = await plaidClient.linkTokenCreate({
+        user: { client_user_id: "ray-user" },
+        client_name: "Ray Finance",
+        products,
+        country_codes: [CountryCode.Us],
+        language: "en",
+    });
+    return resp.data.link_token;
+}
+/** Exchange a public token from Plaid Link for an access token */
+export async function exchangeToken(publicToken) {
+    const resp = await plaidClient.itemPublicTokenExchange({
+        public_token: publicToken,
+    });
+    return {
+        accessToken: resp.data.access_token,
+        itemId: resp.data.item_id,
+    };
+}

package/dist/plaid/sync.d.ts

@@ -0,0 +1,18 @@
+import type BetterSqlite3 from "libsql";
+type Database = BetterSqlite3.Database;
+/** Sync transactions for an institution using Plaid's sync endpoint */
+export declare function syncTransactions(db: Database, itemId: string, accessToken: string, cursor: string | null): Promise<{
+    added: number;
+    modified: number;
+    removed: number;
+}>;
+/** Sync account balances */
+export declare function syncBalances(db: Database, accessToken: string): Promise<number>;
+/** Sync investment holdings + securities */
+export declare function syncInvestments(db: Database, accessToken: string): Promise<{
+    securities: number;
+    holdings: number;
+}>;
+/** Sync liabilities (credit, mortgage, student) */
+export declare function syncLiabilities(db: Database, accessToken: string): Promise<string>;
+export {};

package/dist/plaid/sync.js

@@ -0,0 +1,186 @@
+import { plaidClient } from "./client.js";
+/** Sync transactions for an institution using Plaid's sync endpoint */
+export async function syncTransactions(db, itemId, accessToken, cursor) {
+    let hasMore = true;
+    let nextCursor = cursor || undefined;
+    let added = [];
+    let modified = [];
+    let removed = [];
+    while (hasMore) {
+        const resp = await plaidClient.transactionsSync({
+            access_token: accessToken,
+            cursor: nextCursor,
+        });
+        added = added.concat(resp.data.added);
+        modified = modified.concat(resp.data.modified);
+        removed = removed.concat(resp.data.removed);
+        hasMore = resp.data.has_more;
+        nextCursor = resp.data.next_cursor;
+    }
+    const upsertTx = db.prepare(`
+    INSERT INTO transactions (transaction_id, account_id, amount, date, name, merchant_name, category, subcategory, pending, iso_currency_code, payment_channel)
+    VALUES (@transaction_id, @account_id, @amount, @date, @name, @merchant_name, @category, @subcategory, @pending, @iso_currency_code, @payment_channel)
+    ON CONFLICT(transaction_id) DO UPDATE SET
+      amount=excluded.amount, date=excluded.date, name=excluded.name,
+      merchant_name=excluded.merchant_name, category=excluded.category,
+      subcategory=excluded.subcategory, pending=excluded.pending,
+      payment_channel=excluded.payment_channel
+  `);
+    const deleteTx = db.prepare(`DELETE FROM transactions WHERE transaction_id = ?`);
+    const insertMany = db.transaction(() => {
+        for (const t of [...added, ...modified]) {
+            const cats = t.personal_finance_category;
+            upsertTx.run({
+                transaction_id: t.transaction_id,
+                account_id: t.account_id,
+                amount: t.amount,
+                date: t.date,
+                name: t.name,
+                merchant_name: t.merchant_name || null,
+                category: cats?.primary || null,
+                subcategory: cats?.detailed || null,
+                pending: t.pending ? 1 : 0,
+                iso_currency_code: t.iso_currency_code || "USD",
+                payment_channel: t.payment_channel || null,
+            });
+        }
+        for (const r of removed) {
+            deleteTx.run(r.transaction_id);
+        }
+    });
+    insertMany();
+    // Update cursor
+    db.prepare(`UPDATE institutions SET cursor = ? WHERE item_id = ?`).run(nextCursor, itemId);
+    return { added: added.length, modified: modified.length, removed: removed.length };
+}
+/** Sync account balances */
+export async function syncBalances(db, accessToken) {
+    const resp = await plaidClient.accountsGet({ access_token: accessToken });
+    const upsert = db.prepare(`
+    INSERT INTO accounts (account_id, item_id, name, official_name, type, subtype, mask, current_balance, available_balance, currency, updated_at)
+    VALUES (@account_id, @item_id, @name, @official_name, @type, @subtype, @mask, @current_balance, @available_balance, @currency, datetime('now'))
+    ON CONFLICT(account_id) DO UPDATE SET
+      name=excluded.name, official_name=excluded.official_name,
+      current_balance=excluded.current_balance, available_balance=excluded.available_balance,
+      updated_at=datetime('now')
+  `);
+    const itemId = resp.data.item.item_id;
+    const insertMany = db.transaction(() => {
+        for (const a of resp.data.accounts) {
+            upsert.run({
+                account_id: a.account_id,
+                item_id: itemId,
+                name: a.name,
+                official_name: a.official_name || null,
+                type: a.type,
+                subtype: a.subtype || null,
+                mask: a.mask || null,
+                current_balance: a.balances.current,
+                available_balance: a.balances.available,
+                currency: a.balances.iso_currency_code || "USD",
+            });
+        }
+    });
+    insertMany();
+    return resp.data.accounts.length;
+}
+/** Sync investment holdings + securities */
+export async function syncInvestments(db, accessToken) {
+    const resp = await plaidClient.investmentsHoldingsGet({
+        access_token: accessToken,
+    });
+    const upsertSecurity = db.prepare(`
+    INSERT INTO securities (security_id, ticker, name, type, close_price, close_price_as_of)
+    VALUES (@security_id, @ticker, @name, @type, @close_price, @close_price_as_of)
+    ON CONFLICT(security_id) DO UPDATE SET
+      close_price=excluded.close_price, close_price_as_of=excluded.close_price_as_of
+  `);
+    const upsertHolding = db.prepare(`
+    INSERT INTO holdings (account_id, security_id, quantity, cost_basis, value, price, price_as_of, updated_at)
+    VALUES (@account_id, @security_id, @quantity, @cost_basis, @value, @price, @price_as_of, datetime('now'))
+    ON CONFLICT(account_id, security_id) DO UPDATE SET
+      quantity=excluded.quantity, cost_basis=excluded.cost_basis,
+      value=excluded.value, price=excluded.price,
+      price_as_of=excluded.price_as_of, updated_at=datetime('now')
+  `);
+    const insertMany = db.transaction(() => {
+        for (const s of resp.data.securities) {
+            upsertSecurity.run({
+                security_id: s.security_id,
+                ticker: s.ticker_symbol || null,
+                name: s.name || "Unknown",
+                type: s.type || null,
+                close_price: s.close_price || null,
+                close_price_as_of: s.close_price_as_of || null,
+            });
+        }
+        for (const h of resp.data.holdings) {
+            upsertHolding.run({
+                account_id: h.account_id,
+                security_id: h.security_id,
+                quantity: h.quantity,
+                cost_basis: h.cost_basis || null,
+                value: h.institution_value,
+                price: h.institution_price,
+                price_as_of: h.institution_price_as_of || null,
+            });
+        }
+    });
+    insertMany();
+    return { securities: resp.data.securities.length, holdings: resp.data.holdings.length };
+}
+/** Sync liabilities (credit, mortgage, student) */
+export async function syncLiabilities(db, accessToken) {
+    const resp = await plaidClient.liabilitiesGet({ access_token: accessToken });
+    const upsert = db.prepare(`
+    INSERT INTO liabilities (account_id, type, interest_rate, origination_date, original_balance, current_balance, minimum_payment, next_payment_due, updated_at)
+    VALUES (@account_id, @type, @interest_rate, @origination_date, @original_balance, @current_balance, @minimum_payment, @next_payment_due, datetime('now'))
+    ON CONFLICT(account_id, type) DO UPDATE SET
+      interest_rate=excluded.interest_rate, current_balance=excluded.current_balance,
+      minimum_payment=excluded.minimum_payment, next_payment_due=excluded.next_payment_due,
+      updated_at=datetime('now')
+  `);
+    const insertMany = db.transaction(() => {
+        const credit = resp.data.liabilities.credit || [];
+        for (const c of credit) {
+            upsert.run({
+                account_id: c.account_id,
+                type: "credit",
+                interest_rate: c.aprs?.[0]?.apr_percentage || null,
+                origination_date: null,
+                original_balance: null,
+                current_balance: c.last_statement_balance,
+                minimum_payment: c.minimum_payment_amount,
+                next_payment_due: c.next_payment_due_date || null,
+            });
+        }
+        const mortgage = resp.data.liabilities.mortgage || [];
+        for (const m of mortgage) {
+            upsert.run({
+                account_id: m.account_id,
+                type: "mortgage",
+                interest_rate: m.interest_rate?.percentage || null,
+                origination_date: m.origination_date || null,
+                original_balance: m.origination_principal_amount || null,
+                current_balance: m.last_payment_amount || null,
+                minimum_payment: m.last_payment_amount || null,
+                next_payment_due: m.next_payment_due_date || null,
+            });
+        }
+        const student = resp.data.liabilities.student || [];
+        for (const s of student) {
+            upsert.run({
+                account_id: s.account_id,
+                type: "student",
+                interest_rate: s.interest_rate_percentage || null,
+                origination_date: s.origination_date || null,
+                original_balance: s.origination_principal_amount || null,
+                current_balance: s.last_payment_amount || null,
+                minimum_payment: s.minimum_payment_amount || null,
+                next_payment_due: s.next_payment_due_date || null,
+            });
+        }
+    });
+    insertMany();
+    return "ok";
+}

package/dist/public/link.html

@@ -0,0 +1,184 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <link rel="icon" href="/favicon.png">
+  <title>Ray — Connect Account</title>
+  <style>
+    * { margin: 0; padding: 0; box-sizing: border-box; -webkit-font-smoothing: antialiased; -moz-osx-font-smoothing: grayscale; }
+    body {
+      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', system-ui, sans-serif;
+      background: #fafaf9;
+      color: #1c1917;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      min-height: 100vh;
+      padding: 24px;
+    }
+    .card {
+      background: #fff;
+      border: 1px solid rgba(214, 211, 209, 0.6);
+      border-radius: 16px;
+      padding: 48px 40px;
+      max-width: 400px;
+      width: 100%;
+      text-align: center;
+    }
+    .logo { margin-bottom: 32px; }
+    .logo img { height: 24px; }
+    h1 { font-size: 20px; font-weight: 600; margin-bottom: 8px; color: #1c1917; }
+    p { font-size: 15px; color: #78716c; margin-bottom: 24px; line-height: 1.6; }
+    button {
+      background: #1c1917;
+      color: #fff;
+      border: none;
+      padding: 14px 32px;
+      border-radius: 9999px;
+      font-size: 15px;
+      font-weight: 500;
+      cursor: pointer;
+      width: 100%;
+      transition: background 0.2s;
+    }
+    button:hover { background: #292524; }
+    button:disabled { background: #d6d3d1; cursor: not-allowed; }
+    .success { color: #6ab318; font-weight: 600; }
+    .error { color: #dc3545; font-size: 14px; margin-top: 16px; }
+    .checkmark {
+      width: 48px;
+      height: 48px;
+      border: 2.5px solid #6ab318;
+      border-radius: 50%;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      margin: 0 auto 20px;
+    }
+    .checkmark svg {
+      width: 24px;
+      height: 24px;
+      stroke: #6ab318;
+      fill: none;
+      stroke-width: 2.5;
+      stroke-linecap: round;
+      stroke-linejoin: round;
+    }
+    .institution-logo {
+      width: 64px;
+      height: 64px;
+      border-radius: 16px;
+      object-fit: contain;
+      margin-bottom: 16px;
+    }
+    .spinner {
+      display: inline-block;
+      width: 20px;
+      height: 20px;
+      border: 2px solid #d6d3d1;
+      border-top-color: #78716c;
+      border-radius: 50%;
+      animation: spin 0.6s linear infinite;
+      margin-bottom: 16px;
+    }
+    @keyframes spin { to { transform: rotate(360deg); } }
+  </style>
+</head>
+<body>
+  <div class="card">
+    <div class="logo"><img src="/ray-logo-dark.png" alt="Ray"></div>
+    <div id="connect-view">
+      <div class="spinner"></div>
+      <p>Opening Plaid...</p>
+      <div id="error" class="error" style="display:none"></div>
+    </div>
+    <div id="success-view" style="display:none">
+      <div class="checkmark"><svg viewBox="0 0 24 24"><polyline points="4 12 10 18 20 6"/></svg></div>
+      <img id="institution-logo" class="institution-logo" style="display:none" alt="">
+      <h1 class="success" id="success-title">Account Connected</h1>
+      <p>Your account has been linked and your transactions are syncing. All data is stored locally on your machine and never leaves your device. You can close this page and return to your terminal.</p>
+    </div>
+  </div>
+
+  <script src="https://cdn.plaid.com/link/v2/stable/link-initialize.js"></script>
+  <script>
+    const sessionId = window.location.pathname.split('/link/')[1];
+    let linkHandler = null;
+
+    async function initPlaid() {
+      // Wait for Plaid SDK to load
+      if (typeof Plaid === 'undefined') {
+        let attempts = 0;
+        await new Promise((resolve, reject) => {
+          const check = setInterval(() => {
+            if (typeof Plaid !== 'undefined') { clearInterval(check); resolve(); }
+            else if (++attempts > 50) { clearInterval(check); reject(new Error('Failed to load Plaid SDK. Check your ad blocker or network connection.')); }
+          }, 100);
+        });
+      }
+      try {
+        const res = await fetch('/api/link-token', {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({ session_id: sessionId }),
+        });
+        if (!res.ok) {
+          const data = await res.json().catch(() => ({}));
+          throw new Error(data.error || 'Failed to connect. Please run "ray link" again.');
+        }
+        const { link_token } = await res.json();
+
+        linkHandler = Plaid.create({
+          token: link_token,
+          onSuccess: async (publicToken, metadata) => {
+            document.getElementById('connect-view').innerHTML = '<p>Linking your account...</p>';
+            try {
+              const resp = await fetch('/api/exchange', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                  public_token: publicToken,
+                  session_id: sessionId,
+                  institution_name: metadata.institution?.name || 'Bank Account',
+                  institution_id: metadata.institution?.institution_id || null,
+                }),
+              });
+              if (!resp.ok) throw new Error('Exchange failed');
+              const result = await resp.json();
+              document.getElementById('connect-view').style.display = 'none';
+              document.getElementById('success-view').style.display = 'block';
+              const instName = result.institution_name || metadata.institution?.name;
+              if (instName) {
+                document.getElementById('success-title').textContent = instName + ' Connected';
+              }
+              if (result.institution_logo) {
+                const logoEl = document.getElementById('institution-logo');
+                logoEl.src = 'data:image/png;base64,' + result.institution_logo;
+                logoEl.style.display = 'inline-block';
+              }
+            } catch (e) {
+              showError('Failed to link account. Please try again with "ray link".');
+            }
+          },
+          onExit: (err) => {
+            if (err) showError('Connection cancelled. You can try again.');
+          },
+        });
+        // Auto-open Plaid Link
+        linkHandler.open();
+      } catch (e) {
+        showError(e.message || 'This link has expired. Please run "ray link" again.');
+      }
+    }
+
+    function showError(msg) {
+      const el = document.getElementById('error');
+      el.textContent = msg;
+      el.style.display = 'block';
+    }
+
+    initPlaid();
+  </script>
+</body>
+</html>