| """EveryDollar source-grounded, zero-remote-runtime offline clone.""" |
|
|
| from __future__ import annotations |
|
|
| import hmac |
| import html |
| import os |
| from pathlib import Path |
| from typing import Any, Callable |
|
|
| from fastapi import FastAPI, Request |
| from fastapi.responses import HTMLResponse, JSONResponse, Response |
| from starlette.staticfiles import StaticFiles |
|
|
| from backend import store |
| from websitebench.local_clone_auth import AuthError |
|
|
|
|
| SITE_ID = "everydollar" |
| ROOT = Path(__file__).resolve().parent |
| STATIC = ROOT / "static" |
| INDEX = ROOT / "frontend" / "index.html" |
| ADMIN_TOKEN = os.environ.get("WEBSITEBENCH_EVERYDOLLAR_ADMIN_TOKEN", "everydollar-local-reset-token") |
| KNOWN_PATHS = { |
| "/", "/money/everydollar", "/app", "/app/", "/app/budget", "/app/transactions", |
| "/app/goals", "/app/insights", "/app/settings", "/app/help", "/app/sign-in", |
| "/app/roadmap", "/app/paycheck-planning", "/app/localproviders", "/app/learn", |
| "/app/coaching", "/app/my-feed", "/app/sign-out", |
| "/app/sign-up", "/app/forgot-password", |
| "/company/terms-of-use", "/company/privacy-policy", |
| } |
|
|
| app = FastAPI(title="EveryDollar offline clone", docs_url=None, redoc_url=None, openapi_url=None) |
| app.mount("/static", StaticFiles(directory=str(STATIC)), name="static") |
|
|
| CONTENT_SECURITY_POLICY = ( |
| "default-src 'self'; img-src 'self' data:; style-src 'self' 'unsafe-inline'; " |
| "script-src 'self'; connect-src 'self'; font-src 'self' data:; frame-ancestors 'none'; " |
| "base-uri 'self'; form-action 'self'" |
| ) |
|
|
|
|
| @app.middleware("http") |
| async def security_headers(request: Request, call_next: Callable[..., Any]): |
| response = await call_next(request) |
| response.headers["Content-Security-Policy"] = CONTENT_SECURITY_POLICY |
| response.headers["Referrer-Policy"] = "no-referrer" |
| response.headers["X-Content-Type-Options"] = "nosniff" |
| response.headers["X-Frame-Options"] = "DENY" |
| return response |
|
|
|
|
| def _cookies(request: Request) -> tuple[str, str, dict[str, Any]]: |
| actor = request.cookies.get("wb_everydollar_actor") or store.new_actor() |
| token, session = store.ensure_auth_session(request.cookies.get("wb_everydollar_auth")) |
| return actor, token, session |
|
|
|
|
| def _attach(response: Response, request: Request, actor: str, token: str) -> Response: |
| secure = request.url.scheme == "https" |
| response.set_cookie("wb_everydollar_actor", actor, httponly=True, samesite="lax", secure=secure, max_age=2592000) |
| response.set_cookie("wb_everydollar_auth", token, httponly=True, samesite="lax", secure=secure, max_age=2592000) |
| return response |
|
|
|
|
| def _json(payload: Any, request: Request, actor: str, token: str, status: int = 200) -> JSONResponse: |
| return _attach(JSONResponse(payload, status_code=status), request, actor, token) |
|
|
|
|
| async def _body(request: Request) -> dict[str, Any]: |
| try: |
| value = await request.json() |
| except Exception: |
| return {} |
| return value if isinstance(value, dict) else {} |
|
|
|
|
| def _account(session: dict[str, Any]) -> dict[str, Any] | None: |
| value = session.get("account") |
| return value if isinstance(value, dict) else None |
|
|
|
|
| @app.get("/healthz", include_in_schema=False) |
| def healthz() -> dict[str, Any]: |
| return {"ok": True, "site_id": SITE_ID} |
|
|
|
|
| @app.post("/__admin/reset", include_in_schema=False) |
| async def admin_reset(request: Request) -> JSONResponse: |
| if not hmac.compare_digest(request.headers.get("X-WebsiteBench-Admin-Token", ""), ADMIN_TOKEN): |
| return JSONResponse({"error": "forbidden"}, status_code=403) |
| store.reset() |
| return JSONResponse({"reset": True, "site_id": SITE_ID}) |
|
|
|
|
| @app.get("/api/bootstrap", include_in_schema=False) |
| async def bootstrap(request: Request, month: str | None = None) -> JSONResponse: |
| actor, token, session = _cookies(request) |
| try: |
| payload = store.snapshot(actor, _account(session), month) |
| except ValueError as exc: |
| return _json({"error": str(exc)}, request, actor, token, 422) |
| return _json(payload, request, actor, token) |
|
|
|
|
| @app.post("/api/budget/items", include_in_schema=False) |
| async def add_item(request: Request) -> JSONResponse: |
| actor, token, session = _cookies(request) |
| try: |
| value = store.add_item(actor, _account(session), await _body(request)) |
| except (ValueError, TypeError) as exc: |
| return _json({"error": str(exc)}, request, actor, token, 422) |
| return _json(value, request, actor, token, 201) |
|
|
|
|
| @app.patch("/api/budget/items/{item_id}", include_in_schema=False) |
| async def update_item(item_id: str, request: Request) -> JSONResponse: |
| actor, token, session = _cookies(request) |
| try: |
| value = store.update_item(actor, _account(session), item_id, await _body(request)) |
| except PermissionError as exc: |
| return _json({"error": str(exc)}, request, actor, token, 404) |
| except (ValueError, TypeError) as exc: |
| return _json({"error": str(exc)}, request, actor, token, 422) |
| return _json(value, request, actor, token) |
|
|
|
|
| @app.delete("/api/budget/items/{item_id}", include_in_schema=False) |
| async def delete_item(item_id: str, request: Request) -> JSONResponse: |
| actor, token, session = _cookies(request) |
| try: |
| value = store.delete_item(actor, _account(session), item_id) |
| except PermissionError as exc: |
| return _json({"error": str(exc)}, request, actor, token, 404) |
| return _json(value, request, actor, token) |
|
|
|
|
| @app.post("/api/budget/items/{item_id}/move", include_in_schema=False) |
| async def move_item(item_id: str, request: Request) -> JSONResponse: |
| actor, token, session = _cookies(request) |
| body = await _body(request) |
| try: |
| value = store.move_item(actor, _account(session), item_id, str(body.get("direction", ""))) |
| except PermissionError as exc: |
| return _json({"error": str(exc)}, request, actor, token, 404) |
| except ValueError as exc: |
| return _json({"error": str(exc)}, request, actor, token, 422) |
| return _json(value, request, actor, token) |
|
|
|
|
| @app.post("/api/transactions", include_in_schema=False) |
| async def add_transaction(request: Request) -> JSONResponse: |
| actor, token, session = _cookies(request) |
| try: |
| value = store.add_transaction(actor, _account(session), await _body(request)) |
| except PermissionError as exc: |
| return _json({"error": str(exc)}, request, actor, token, 403) |
| except (ValueError, TypeError) as exc: |
| return _json({"error": str(exc)}, request, actor, token, 422) |
| return _json(value, request, actor, token, 201) |
|
|
|
|
| @app.delete("/api/transactions/{transaction_id}", include_in_schema=False) |
| async def delete_transaction(transaction_id: str, request: Request) -> JSONResponse: |
| actor, token, session = _cookies(request) |
| try: |
| value = store.delete_transaction(actor, _account(session), transaction_id) |
| except PermissionError as exc: |
| return _json({"error": str(exc)}, request, actor, token, 404) |
| return _json(value, request, actor, token) |
|
|
|
|
| @app.patch("/api/transactions/{transaction_id}", include_in_schema=False) |
| async def update_transaction(transaction_id: str, request: Request) -> JSONResponse: |
| actor, token, session = _cookies(request) |
| try: |
| value = store.update_transaction(actor, _account(session), transaction_id, await _body(request)) |
| except PermissionError as exc: |
| return _json({"error": str(exc)}, request, actor, token, 404) |
| except (ValueError, TypeError) as exc: |
| return _json({"error": str(exc)}, request, actor, token, 422) |
| return _json(value, request, actor, token) |
|
|
|
|
| @app.post("/api/months/copy", include_in_schema=False) |
| async def copy_month(request: Request) -> JSONResponse: |
| actor, token, session = _cookies(request) |
| body = await _body(request) |
| try: |
| value = store.copy_month(actor, _account(session), str(body.get("source", "")), str(body.get("target", ""))) |
| except ValueError as exc: |
| return _json({"error": str(exc)}, request, actor, token, 422) |
| return _json(value, request, actor, token, 201) |
|
|
|
|
| @app.post("/api/goals", include_in_schema=False) |
| async def add_goal(request: Request) -> JSONResponse: |
| actor, token, session = _cookies(request) |
| try: |
| value = store.save_goal(actor, _account(session), await _body(request)) |
| except (ValueError, TypeError) as exc: |
| return _json({"error": str(exc)}, request, actor, token, 422) |
| return _json(value, request, actor, token, 201) |
|
|
|
|
| @app.patch("/api/goals/{goal_id}", include_in_schema=False) |
| async def update_goal(goal_id: str, request: Request) -> JSONResponse: |
| actor, token, session = _cookies(request) |
| try: |
| value = store.update_goal(actor, _account(session), goal_id, await _body(request)) |
| except PermissionError as exc: |
| return _json({"error": str(exc)}, request, actor, token, 404) |
| except (ValueError, TypeError) as exc: |
| return _json({"error": str(exc)}, request, actor, token, 422) |
| return _json(value, request, actor, token) |
|
|
|
|
| @app.post("/api/preferences", include_in_schema=False) |
| async def preferences(request: Request) -> JSONResponse: |
| actor, token, session = _cookies(request) |
| value = store.save_preferences(actor, _account(session), await _body(request)) |
| return _json(value, request, actor, token) |
|
|
|
|
| @app.post("/api/auth/register", include_in_schema=False) |
| async def register(request: Request) -> JSONResponse: |
| actor, token, _ = _cookies(request) |
| body = await _body(request) |
| try: |
| created = store.register(str(body.get("email", "")), str(body.get("display_name", "")), str(body.get("password", ""))) |
| signed = store.sign_in(token, str(body.get("email", "")), str(body.get("password", ""))) |
| store.transfer_budget(actor, created["subject_id"]) |
| except (AuthError, ValueError) as exc: |
| return _json({"error": str(exc)}, request, actor, token, 422) |
| return _json({"account": signed["account"], "verification": "Local demo account verified without external email."}, request, actor, signed["session_token"], 201) |
|
|
|
|
| @app.post("/api/auth/login", include_in_schema=False) |
| async def login(request: Request) -> JSONResponse: |
| actor, token, _ = _cookies(request) |
| body = await _body(request) |
| try: |
| signed = store.sign_in(token, str(body.get("email", "")), str(body.get("password", ""))) |
| store.transfer_budget(actor, signed["account"]["subject_id"]) |
| except AuthError: |
| return _json({"error": "Email or password is incorrect."}, request, actor, token, 401) |
| return _json({"account": signed["account"]}, request, actor, signed["session_token"]) |
|
|
|
|
| @app.post("/api/auth/logout", include_in_schema=False) |
| async def logout(request: Request) -> JSONResponse: |
| actor, token, _ = _cookies(request) |
| store.sign_out(token) |
| new_token, _ = store.ensure_auth_session(None) |
| return _json({"signed_out": True}, request, actor, new_token) |
|
|
|
|
| @app.post("/api/auth/recovery-preview", include_in_schema=False) |
| async def recovery_preview(request: Request) -> JSONResponse: |
| actor, token, _ = _cookies(request) |
| email_address = str((await _body(request)).get("email", "")).strip() |
| if not email_address or "@" not in email_address: |
| return _json({"error": "Enter a valid email address."}, request, actor, token, 422) |
| return _json({"sent": False, "message": "No email was sent. This offline preview shows the recovery flow without external effects."}, request, actor, token) |
|
|
|
|
| @app.get("/{path:path}", include_in_schema=False) |
| async def page(path: str, request: Request) -> HTMLResponse: |
| pathname = "/" + path |
| status = 200 if pathname in KNOWN_PATHS else 404 |
| body = INDEX.read_text(encoding="utf-8") |
| route_marker = html.escape(pathname, quote=True) |
| body = body.replace("<body>", f'<body data-route="{route_marker}"><p hidden data-route-announcer>EveryDollar route {route_marker}</p>', 1) |
| return HTMLResponse(body, status_code=status) |
|
|
