prod plaidInfo

app.py

@@ -1,9 +1,8 @@
 from dotenv import load_dotenv
 load_dotenv()
 
-from fastapi.responses import StreamingResponse
+from fastapi.responses import StreamingResponse, HTMLResponse
 import json
-from fastapi.responses import HTMLResponse
 import requests
 from fastapi import FastAPI, HTTPException, Depends
 from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
@@ -11,7 +10,7 @@ from fastapi.middleware.cors import CORSMiddleware
 from pydantic import BaseModel
 from fiscal import get_answer, clear_memory, stream_answer
 from auth import verify_token
-from plaid_client import get_financial_snapshot
+from plaid_client import get_financial_snapshot, create_link_token, exchange_public_token
 import os
 
 app = FastAPI(title="FISCAL API")
@@ -26,18 +25,47 @@ app.add_middleware(
 security = HTTPBearer()
 SANDBOX_ACCESS_TOKEN = os.environ["PLAID_ACCESS_TOKEN"]
 
+SUPABASE_URL = os.environ.get("SUPABASE_URL", "")
+SERVICE_KEY = os.environ.get("SUPABASE_SERVICE_KEY", "")
+SUPABASE_HEADERS = {
+    "apikey": SERVICE_KEY,
+    "Authorization": f"Bearer {SERVICE_KEY}",
+    "Content-Type": "application/json"
+}
+
 class ChatRequest(BaseModel):
     message: str
 
 class ChatResponse(BaseModel):
     answer: str
 
+class LinkTokenResponse(BaseModel):
+    link_token: str
+
+class ExchangeTokenRequest(BaseModel):
+    public_token: str
+
+
+def get_user_access_token(user_id: str) -> str:
+    """Fetch user's real Plaid access token from Supabase, fallback to sandbox."""
+    try:
+        resp = requests.get(
+            f"{SUPABASE_URL}/rest/v1/bank_connections?user_id=eq.{user_id}&limit=1",
+            headers=SUPABASE_HEADERS
+        )
+        connections = resp.json()
+        if connections:
+            return connections[0]["plaid_access_token"]
+    except Exception as e:
+        print(f"Could not fetch user token: {e}")
+    return SANDBOX_ACCESS_TOKEN
 
 
 @app.get("/health")
 def health():
     return {"status": "ok", "service": "FISCAL"}
 
+
 @app.post("/chat", response_model=ChatResponse)
 def chat(
     request: ChatRequest,
@@ -47,16 +75,17 @@ def chat(
     if not user:
         raise HTTPException(status_code=401, detail="Invalid or expired token")
 
-    financial_context = get_financial_snapshot(SANDBOX_ACCESS_TOKEN)
+    access_token = get_user_access_token(user["sub"])
+    financial_context = get_financial_snapshot(access_token)
 
     answer = get_answer(
         message=request.message,
         user_id=user["sub"],
         financial_context=financial_context,
     )
-
     return ChatResponse(answer=answer)
 
+
 @app.post("/reset")
 def reset(credentials: HTTPAuthorizationCredentials = Depends(security)):
     user = verify_token(credentials.credentials)
@@ -77,7 +106,8 @@ def chat_stream(
 
     financial_context = ""
     try:
-        financial_context = get_financial_snapshot(SANDBOX_ACCESS_TOKEN)
+        access_token = get_user_access_token(user["sub"])
+        financial_context = get_financial_snapshot(access_token)
         financial_context = financial_context.replace("{", "(").replace("}", ")")
     except Exception as e:
         financial_context = "Bank data temporarily unavailable."
@@ -88,15 +118,54 @@ def chat_stream(
             user_id=user["sub"],
             financial_context=financial_context,
         ):
-            # Send each chunk as a Server-Sent Event
             yield f"data: {json.dumps({'chunk': chunk})}\n\n"
         yield "data: [DONE]\n\n"
 
     return StreamingResponse(generate(), media_type="text/event-stream")
 
 
+@app.post("/plaid/create_link_token", response_model=LinkTokenResponse)
+def plaid_create_link_token(
+    credentials: HTTPAuthorizationCredentials = Depends(security),
+):
+    user = verify_token(credentials.credentials)
+    if not user:
+        raise HTTPException(status_code=401, detail="Unauthorized")
+    try:
+        token = create_link_token(user["sub"])
+        return LinkTokenResponse(link_token=token)
+    except Exception as e:
+        print(f"Link token error: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
 
 
+@app.post("/plaid/exchange_token")
+def plaid_exchange_token(
+    request: ExchangeTokenRequest,
+    credentials: HTTPAuthorizationCredentials = Depends(security),
+):
+    user = verify_token(credentials.credentials)
+    if not user:
+        raise HTTPException(status_code=401, detail="Unauthorized")
+    try:
+        access_token = exchange_public_token(request.public_token)
+
+        # Save to Supabase
+        requests.post(
+            f"{SUPABASE_URL}/rest/v1/bank_connections",
+            headers=SUPABASE_HEADERS,
+            json={
+                "user_id": user["sub"],
+                "plaid_access_token": access_token,
+                "institution_name": "Connected Bank",
+                "connected_at": "now()"
+            }
+        )
+        return {"status": "connected"}
+    except Exception as e:
+        print(f"Exchange token error: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
 
 @app.delete("/account")
 def delete_account(
@@ -107,37 +176,22 @@ def delete_account(
         raise HTTPException(status_code=401, detail="Unauthorized")
 
     user_id = user["sub"]
-    supabase_url = os.environ.get("SUPABASE_URL", "")
-    service_key = os.environ.get("SUPABASE_SERVICE_KEY", "")
-
-    headers = {
-        "apikey": service_key,
-        "Authorization": f"Bearer {service_key}",
-        "Content-Type": "application/json"
-    }
 
     try:
-        # 1. Delete bank connections
         requests.delete(
-            f"{supabase_url}/rest/v1/bank_connections?user_id=eq.{user_id}",
-            headers=headers
+            f"{SUPABASE_URL}/rest/v1/bank_connections?user_id=eq.{user_id}",
+            headers=SUPABASE_HEADERS
         )
-
-        # 2. Delete profile
         requests.delete(
-            f"{supabase_url}/rest/v1/profiles?id=eq.{user_id}",
-            headers=headers
+            f"{SUPABASE_URL}/rest/v1/profiles?id=eq.{user_id}",
+            headers=SUPABASE_HEADERS
         )
-
-        # 3. Delete auth user via Admin API
         response = requests.delete(
-            f"{supabase_url}/auth/v1/admin/users/{user_id}",
-            headers=headers
+            f"{SUPABASE_URL}/auth/v1/admin/users/{user_id}",
+            headers=SUPABASE_HEADERS
         )
-
         if response.status_code not in [200, 204]:
             raise Exception(f"Auth delete failed: {response.text}")
-
         return {"status": "account deleted"}
 
     except Exception as e:
@@ -175,22 +229,16 @@ def privacy_policy():
     <body style="font-family: sans-serif; max-width: 700px; margin: 50px auto; padding: 20px; line-height: 1.6;">
         <h1>FISCAL Privacy Policy</h1>
         <p><strong>Last updated: May 2026</strong></p>
-
         <h2>Information We Collect</h2>
         <p>We collect your email address and a hashed password to create and manage your account.</p>
-
         <h2>Financial Data</h2>
         <p>With your permission, FISCAL accesses your bank account data via Plaid to provide personalized financial advice. This data is processed ephemerally — it is never stored in our databases and is only used in the moment to generate your AI response.</p>
-
         <h2>How We Use Your Data</h2>
         <p>Your financial data is shared with our AI provider (Featherless AI) solely to generate your personalized financial responses. It is not stored, sold, or used for advertising.</p>
-
         <h2>Data Storage</h2>
         <p>We store only your email address and account credentials securely via Supabase. Chat messages and financial data are never stored.</p>
-
         <h2>Data Deletion</h2>
         <p>You can delete your account and all associated data at any time from within the FISCAL app under Options → Delete Account.</p>
-
         <h2>Contact</h2>
         <p>For privacy questions, contact us at mjproductions594@gmail.com</p>
     </body>

plaid_client.py

@@ -1,118 +1,19 @@
-import os
-from datetime import date, timedelta
-from plaid.api import plaid_api
-from plaid.configuration import Configuration
-from plaid.api_client import ApiClient
-from plaid.model.products import Products
-from plaid.model.country_code import CountryCode
-from plaid.model.accounts_balance_get_request import AccountsBalanceGetRequest
-from plaid.model.transactions_get_request import TransactionsGetRequest
-from plaid.model.transactions_get_request_options import TransactionsGetRequestOptions
-
-# ---------- Client setup ----------
-
-def _make_client():
-    env = os.environ.get("PLAID_ENV", "sandbox")
-    host = {
-        "sandbox":     "https://sandbox.plaid.com",
-        "development": "https://development.plaid.com",
-        "production":  "https://production.plaid.com",
-    }[env]
-
-    config = Configuration(
-        host=host,
-        api_key={
-        "clientId": os.environ["PLAID_CLIENT_ID"],   # reads from .env
-        "secret":   os.environ["PLAID_SECRET"]
-        }
+from plaid.model.link_token_create_request import LinkTokenCreateRequest
+from plaid.model.link_token_create_request_user import LinkTokenCreateRequestUser
+from plaid.model.item_public_token_exchange_request import ItemPublicTokenExchangeRequest
+
+def create_link_token(user_id: str) -> str:
+    request = LinkTokenCreateRequest(
+        user=LinkTokenCreateRequestUser(client_user_id=user_id),
+        client_name="FISCAL",
+        products=[Products("transactions")],
+        country_codes=[CountryCode("CA")],
+        language="en",
     )
-    return plaid_api.PlaidApi(ApiClient(config))
-
-plaid_client = _make_client()
-
-
-# ---------- Balances ----------
-
-def get_balances(access_token: str) -> str:
-    """Returns formatted balance snapshot for the LLM prompt."""
-    request = AccountsBalanceGetRequest(access_token=access_token)
-    response = plaid_client.accounts_balance_get(request)
-
-    lines = ["USER'S CURRENT ACCOUNT BALANCES:"]
-    for account in response['accounts']:
-        name     = account['name']
-        subtype  = account['subtype']       # 'checking', 'credit card', etc.
-        current  = account['balances']['current']
-        
-        if subtype == 'credit card':
-            limit     = account['balances']['limit'] or 0
-            available = account['balances']['available'] or (limit - current)
-            lines.append(
-                f"- {name} (Visa/Credit): "
-                f"${current:.2f} owing, ${available:.2f} available"
-            )
-        else:
-            lines.append(f"- {name} (Chequing): ${current:.2f}")
-
-    return "\n".join(lines)
-
-
-# ---------- Transactions ----------
-
-def get_transactions(access_token: str, days: int = 30) -> str:
-    """Returns formatted transaction summary for the LLM prompt."""
-    end_date   = date.today()
-    start_date = end_date - timedelta(days=days)
-
-    request = TransactionsGetRequest(
-        access_token=access_token,
-        start_date=start_date,
-        end_date=end_date,
-        options=TransactionsGetRequestOptions(
-            count=100,
-            include_personal_finance_category=True
-        )
-    )
-    response = plaid_client.transactions_get(request)
-    transactions = response['transactions']
-
-    if not transactions:
-        return "No transactions found in the last 30 days."
-
-    # Python does the math — never let the LLM calculate
-    category_totals: dict[str, float] = {}
-    for txn in transactions:
-        if txn['amount'] <= 0:
-            continue   # skip deposits/refunds
-        category = txn.get('personal_finance_category', {}).get('primary', 'OTHER')
-        category_totals[category] = category_totals.get(category, 0) + txn['amount']
-
-    # Format for prompt
-    lines = [f"SPENDING SUMMARY (last {days} days):"]
-    for category, total in sorted(category_totals.items(), key=lambda x: -x[1]):
-        readable = category.replace("_", " ").title()
-        lines.append(f"- {readable}: ${total:.2f}")
-
-    lines.append(f"\nTotal spent: ${sum(category_totals.values()):.2f}")
-    lines.append(f"\nRECENT TRANSACTIONS (last 10):")
-    for txn in transactions[:10]:
-        lines.append(
-            f"- {txn['date']}  {txn['name']:<30}  ${txn['amount']:.2f}"
-        )
-
-    return "\n".join(lines)
-
-
-# ---------- Combined snapshot ----------
+    response = plaid_client.link_token_create(request)
+    return response["link_token"]
 
-def get_financial_snapshot(access_token: str) -> str:
-    """
-    Returns full financial context string to inject into the LLM prompt.
-    Combines balances + transaction summary.
-    """
-    try:
-        balances     = get_balances(access_token)
-        transactions = get_transactions(access_token)
-        return f"{balances}\n\n{transactions}"
-    except Exception as e:
-        return f"Unable to fetch account data: {str(e)}"
+def exchange_public_token(public_token: str) -> str:
+    request = ItemPublicTokenExchangeRequest(public_token=public_token)
+    response = plaid_client.item_public_token_exchange(request)
+    return response["access_token"]