@farazirfan/costar-server-executor 1.7.28 → 1.7.29

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@farazirfan/costar-server-executor",
-  "version": "1.7.28",
+  "version": "1.7.29",
   "description": "CoStar Server Executor - 24/7 autonomous agent in TypeScript (cloned from OpenClaw)",
   "type": "module",
   "main": "dist/index.js",

package/skills/trading/SKILL.md

@@ -19,12 +19,12 @@ Before ANY trading decision, read [LEARNING.md](LEARNING.md) first. It contains
 - Confluence over conviction — require 2-3 confirming signals, never trade on one
 - Process over outcome — good process matters more than any single result
 - Build, don't just log — every trade should leave behind infrastructure, not just notes
-- The internet is your edge — GitHub, expert blogs, papers, news, communities. Not just the 250 data APIs
+- The internet is your edge — GitHub, expert blogs, papers, news, communities. Not just the data APIs
 - Every request gets expert treatment — "buy BTC" gets the same depth of thinking as "grow my portfolio"
 
 ## Your Data Arsenal
 
-You have extensive financial APIs via `discover_data_api` and `fetch_api_data` covering real-time quotes, historical prices, technical indicators, fundamentals, news, institutional data, economic data, and screening.
+You have extensive financial APIs via `discover_data_api` and `fetch_api_data` covering real-time quotes, historical prices, technical indicators, fundamentals, news, institutional data, economic data, and screening. Outside of agent tools, use `python3 scripts/data-api.py` to call the same APIs from CLI, cron jobs, or other scripts (see below).
 
 But the APIs are just one corner. You also have `web_search`, `web_fetch`, and `browser` to access everything:
 - GitHub — open-source trading tools, indicators, backtesting frameworks, sentiment repos
@@ -123,7 +123,7 @@ Route execution to the appropriate platform:
 
 ### 10. Monitor
 
-Trail stop to breakeven after 1R profit. Never move stop away from entry. Watch for invalidation. If regime changes mid-trade, reassess.
+Create a live dashboard for this trade (see Trade Dashboards section below). Trail stop to breakeven after 1R profit. Never move stop away from entry. Watch for invalidation. If regime changes mid-trade, reassess. Update the dashboard with every significant change.
 
 ### 11. Post-Trade Evolution
 
@@ -192,6 +192,86 @@ See [references/risk-management.md](references/risk-management.md) for the compl
 
 Track your performance metrics and improve them over time. Document your risk approach in LEARNING.md. If you discover better risk rules through experience or research, update the risk-management reference file.
 
+## Trade Dashboards
+
+Every trade gets its own live dashboard. You build each one from scratch — the layout, the data, the visualizations, the update logic. No two dashboards should look the same because no two trades are the same.
+
+### You Own Everything
+
+`scripts/trade-dashboard-template.html` gives you a design system starter (Tailwind, dark theme, fonts, glass-card style) and an empty `<div id="app">`. That's it. The rest is yours:
+
+- **Build the entire HTML, CSS, and JS for each trade.** Add sections, remove sections, restructure everything. The template imposes zero constraints on layout, data format, or functionality.
+- **Add any CDN library** — Chart.js, D3, ApexCharts, Plotly, Three.js, Lightweight Charts, or anything else. Swap libraries between dashboards if one works better for a specific trade type.
+- **Fetch live data** — Use `fetch()` to hit external APIs, WebSocket for real-time streaming, or embed data directly. Pull from your data APIs, news sources, on-chain analytics, whatever the trade needs.
+- **Invent new visualizations** — Correlation heatmaps, multi-timeframe charts, order flow waterfalls, sentiment gauges, regime indicators, funding rate trackers, economic calendar overlays. If it helps monitor the trade, build it.
+- **Build custom interactivity** — Toggles, tabs, zoom controls, timeframe selectors, what-if scenarios. Make the dashboard a tool, not just a display.
+- **Update the template itself** — When you discover patterns that should apply to all future dashboards, improve the template. You own it.
+
+### Integrating Live Data
+
+Your dashboards should show real-time data. You have multiple ways to feed data into them:
+
+**Using your data APIs via `scripts/data-api.py`**
+
+`scripts/data-api.py` is a standalone Python client for the same backend that powers `discover_data_api` and `fetch_api_data`. Use it anywhere — CLI, cron jobs, dashboard data pipelines, other scripts:
+
+```bash
+# Discover APIs for a query
+python3 scripts/data-api.py search "Bitcoin price and volume"
+
+# Fetch data from a discovered API
+python3 scripts/data-api.py fetch FMP_QUOTE '{"symbol": "AAPL"}'
+python3 scripts/data-api.py fetch FMP_CRYPTO_QUOTE '{"symbol": "BTCUSD"}'
+
+# Discover + fetch in one shot
+python3 scripts/data-api.py get "current gold price"
+
+# Pipe raw data to a JSON file for dashboards
+python3 scripts/data-api.py fetch FMP_QUOTE '{"symbol": "AAPL"}' --raw > dashboards/data/aapl.json
+```
+
+It's also importable in other Python scripts:
+```python
+from data_api import search_apis, fetch_api
+apis = search_apis("Bitcoin technical indicators")
+data = fetch_api("FMP_CRYPTO_QUOTE", {"symbol": "BTCUSD"})
+```
+
+Use this to build data pipelines: cron runs `data-api.py` → writes JSON → dashboard reads it on reload. Or use `discover_data_api` in the agent to find vendor codes, then hardcode them into scripts that run independently.
+
+**Using any internet source**
+
+You are not limited to your data APIs. Find and integrate anything:
+- Free public APIs (CoinGecko, Yahoo Finance, Alpha Vantage, Binance, etc.) — call them directly via `fetch()` in the dashboard JS if they support CORS, or build a proxy script.
+- WebSocket feeds for real-time streaming (Binance WS, Coinbase WS, etc.) — connect directly from dashboard JS.
+- RSS feeds, news APIs, social sentiment APIs — fetch and render in the dashboard.
+- On-chain data providers (Glassnode, Dune, DefiLlama) — for crypto trades.
+- Build Python scripts that scrape, aggregate, or transform data from any source and output JSON for the dashboard to consume.
+
+**Data update patterns**
+
+Pick whatever pattern fits the trade:
+- **Embedded data** — You write the data directly into the HTML. Simplest. Update the file whenever data changes.
+- **Polling** — Dashboard JS uses `fetch()` on an interval to pull from an API or a local JSON file that a script keeps updated.
+- **WebSocket** — Dashboard JS connects to a streaming feed for real-time ticks. Best for active crypto/forex trades.
+- **Script pipeline** — A cron job runs a Python script that fetches data → writes a JSON file → dashboard reads the JSON file on reload.
+
+No restrictions. If a data source exists and would help monitor the trade, integrate it.
+
+### Workflow
+
+1. When opening a trade, create `dashboards/<asset>-<direction>-<date>.html` in your workspace. Start from the template or from scratch — your choice.
+2. Build the dashboard for this specific trade. Think about what information matters most for monitoring THIS trade.
+3. Serve dashboards with `python3 scripts/dashboard-server.py --dir dashboards/ --port 8500`. Use `cron` to keep it running.
+4. Update the dashboard as the trade evolves — new data, moved stops, new events, changed regime, anything. Rewrite entire sections if the trade context changes.
+5. When the trade closes, update the dashboard with final results. It stays as a historical record.
+
+### Scripts
+
+- `scripts/data-api.py` — Standalone client for hundreds of data APIs. Search, fetch, or auto-fetch from CLI. Importable in other Python scripts. Powers dashboard data pipelines.
+- `scripts/trade-dashboard-template.html` — Minimal design system skeleton. Tailwind + dark theme + fonts. Empty body. You build everything else.
+- `scripts/dashboard-server.py` — HTTP server for the dashboards directory with auto-generated index page.
+
 ## Key Principles
 
 - No FOMO — there is always another trade

package/skills/trading/scripts/dashboard-server.py

@@ -0,0 +1,191 @@
+#!/usr/bin/env python3
+"""
+Trade Dashboard Server — Serves per-trade HTML dashboards.
+
+Usage:
+  # Serve all dashboards in a directory
+  python3 dashboard-server.py --dir ./dashboards --port 8500
+
+  # Serve a single dashboard file
+  python3 dashboard-server.py --file ./dashboards/btc-long-2024-01-15.html --port 8500
+
+The server serves static HTML files. Each dashboard is a self-contained
+HTML file that the agent creates from the template and updates over time.
+
+Dashboard directory structure:
+  dashboards/
+    btc-long-2024-01-15.html
+    eurusd-short-2024-01-16.html
+    index.html  (auto-generated listing page)
+"""
+
+import argparse
+import http.server
+import json
+import os
+import sys
+from pathlib import Path
+from datetime import datetime
+
+
+def generate_index(dashboard_dir):
+    """Generate an index.html listing all trade dashboards."""
+    dashboards = []
+    for f in sorted(Path(dashboard_dir).glob("*.html")):
+        if f.name == "index.html":
+            continue
+        stat = f.stat()
+        # Try to extract trade data from the file
+        content = f.read_text(encoding="utf-8")
+        trade_info = {"file": f.name, "modified": datetime.fromtimestamp(stat.st_mtime).isoformat()}
+
+        # Extract trade data JSON if present
+        start = content.find('id="trade-data"')
+        if start != -1:
+            json_start = content.find("{", start)
+            json_end = content.find("</script>", json_start)
+            if json_start != -1 and json_end != -1:
+                try:
+                    data = json.loads(content[json_start:json_end])
+                    trade_info.update({
+                        "asset": data.get("asset", ""),
+                        "direction": data.get("direction", ""),
+                        "status": data.get("status", ""),
+                        "pnl": data.get("pnl_dollars", 0),
+                        "pnl_pct": data.get("pnl_percent", 0),
+                    })
+                except json.JSONDecodeError:
+                    pass
+
+        dashboards.append(trade_info)
+
+    html = f"""<!DOCTYPE html>
+<html lang="en" class="dark">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Trade Dashboards</title>
+  <script src="https://cdn.tailwindcss.com"></script>
+  <script>
+    tailwind.config = {{ darkMode: 'class' }}
+  </script>
+  <style>body {{ background: #0f1117; }}</style>
+</head>
+<body class="min-h-screen text-gray-100 p-8">
+  <div class="max-w-4xl mx-auto">
+    <h1 class="text-3xl font-bold mb-2">Trade Dashboards</h1>
+    <p class="text-gray-400 mb-8">Active and historical trade dashboards</p>
+    <div class="space-y-3">
+"""
+    for d in dashboards:
+        status_colors = {
+            "open": "bg-green-500",
+            "pending": "bg-amber-500",
+            "closed": "bg-gray-500",
+            "stopped": "bg-red-500",
+        }
+        dot_color = status_colors.get(d.get("status", ""), "bg-gray-500")
+        pnl = d.get("pnl", 0)
+        pnl_color = "text-green-400" if pnl >= 0 else "text-red-400"
+        pnl_str = f"+${pnl:,.2f}" if pnl >= 0 else f"-${abs(pnl):,.2f}"
+
+        direction = d.get("direction", "").upper()
+        dir_class = "bg-green-500/20 text-green-400" if direction == "LONG" else "bg-red-500/20 text-red-400" if direction == "SHORT" else ""
+
+        html += f"""
+      <a href="{d['file']}" class="block bg-gray-900/60 border border-gray-800 rounded-xl p-4 hover:border-gray-600 transition-colors">
+        <div class="flex items-center justify-between">
+          <div class="flex items-center gap-3">
+            <div class="w-2.5 h-2.5 rounded-full {dot_color}"></div>
+            <span class="font-semibold">{d.get('asset', d['file'])}</span>
+            {f'<span class="text-xs px-2 py-0.5 rounded {dir_class}">{direction}</span>' if direction else ''}
+          </div>
+          <div class="text-right">
+            <div class="{pnl_color} font-mono font-semibold">{pnl_str}</div>
+            <div class="text-xs text-gray-500">{d.get('status', 'unknown')}</div>
+          </div>
+        </div>
+      </a>
+"""
+
+    if not dashboards:
+        html += """
+      <div class="text-center text-gray-500 py-12">
+        <div class="text-4xl mb-3">📊</div>
+        <div>No trade dashboards yet. Dashboards appear here as trades are opened.</div>
+      </div>
+"""
+
+    html += f"""
+    </div>
+    <div class="text-center text-xs text-gray-600 mt-8">
+      {len(dashboards)} dashboard{'s' if len(dashboards) != 1 else ''} &mdash; Auto-refreshes every 30s
+    </div>
+  </div>
+  <script>setTimeout(() => location.reload(), 30000);</script>
+</body>
+</html>"""
+
+    index_path = Path(dashboard_dir) / "index.html"
+    index_path.write_text(html, encoding="utf-8")
+    return index_path
+
+
+class DashboardHandler(http.server.SimpleHTTPRequestHandler):
+    """Custom handler that auto-generates index and suppresses logs."""
+
+    def __init__(self, *args, directory=None, **kwargs):
+        super().__init__(*args, directory=directory, **kwargs)
+
+    def do_GET(self):
+        # Regenerate index on each request to root
+        if self.path in ("/", "/index.html"):
+            generate_index(self.directory)
+        super().do_GET()
+
+    def log_message(self, format, *args):
+        # Quieter logging
+        sys.stderr.write(f"[dashboard] {args[0]}\n")
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Trade Dashboard Server")
+    parser.add_argument("--dir", default="./dashboards", help="Directory containing dashboard HTML files")
+    parser.add_argument("--file", help="Serve a single dashboard file")
+    parser.add_argument("--port", type=int, default=8500, help="Port to serve on (default: 8500)")
+
+    args = parser.parse_args()
+
+    if args.file:
+        # Serve single file's parent directory
+        file_path = Path(args.file).resolve()
+        serve_dir = str(file_path.parent)
+    else:
+        serve_dir = str(Path(args.dir).resolve())
+
+    # Ensure directory exists
+    Path(serve_dir).mkdir(parents=True, exist_ok=True)
+
+    # Generate initial index
+    generate_index(serve_dir)
+
+    handler = lambda *a, **kw: DashboardHandler(*a, directory=serve_dir, **kw)
+
+    with http.server.HTTPServer(("0.0.0.0", args.port), handler) as httpd:
+        print(json.dumps({
+            "status": "running",
+            "port": args.port,
+            "directory": serve_dir,
+            "url": f"http://localhost:{args.port}",
+            "message": f"Dashboard server running on port {args.port}",
+        }, indent=2))
+        sys.stdout.flush()
+
+        try:
+            httpd.serve_forever()
+        except KeyboardInterrupt:
+            print("\nDashboard server stopped.")
+
+
+if __name__ == "__main__":
+    main()

package/skills/trading/scripts/data-api.py

@@ -0,0 +1,211 @@
+#!/usr/bin/env python3
+"""
+Data API Client — Search and fetch data from hundreds of APIs.
+
+Standalone CLI for the same backend that powers discover_data_api and
+fetch_api_data agent tools. Use this in scripts, cron jobs, dashboard
+data pipelines, or anywhere you need financial/market data outside
+the agent runtime.
+
+Usage:
+  # Discover APIs for a query
+  python3 data-api.py search "Bitcoin price and volume"
+  python3 data-api.py search "Apple stock technical indicators" --limit 10
+
+  # Fetch data from a discovered API
+  python3 data-api.py fetch FMP_QUOTE '{"symbol": "AAPL"}'
+  python3 data-api.py fetch FMP_CRYPTO_QUOTE '{"symbol": "BTCUSD"}'
+  python3 data-api.py fetch FMP_TECHNICAL_INDICATOR '{"symbol": "AAPL", "type": "rsi", "period": 14}'
+
+  # Discover + fetch in one shot (finds best API, calls it)
+  python3 data-api.py get "current Bitcoin price"
+  python3 data-api.py get "EUR/USD exchange rate"
+  python3 data-api.py get "S&P 500 fear and greed index"
+
+  # Output just the data (for piping to files or other scripts)
+  python3 data-api.py fetch FMP_QUOTE '{"symbol": "AAPL"}' --raw
+
+Importable:
+  from data_api import search_apis, fetch_api, auto_fetch
+  results = search_apis("Bitcoin price")
+  data = fetch_api("FMP_CRYPTO_QUOTE", {"symbol": "BTCUSD"})
+  data = auto_fetch("current gold price")
+
+Environment:
+  DATA_API_BASE_URL — Override backend URL (default: CoStar production backend)
+"""
+
+import argparse
+import json
+import os
+import sys
+import urllib.request
+import urllib.error
+
+DEFAULT_BASE_URL = "https://costar-backend-hetzner-production.up.railway.app"
+SEARCH_TIMEOUT = 30  # seconds
+FETCH_TIMEOUT = 60   # seconds
+
+
+def _get_base_url():
+    return os.environ.get("DATA_API_BASE_URL", DEFAULT_BASE_URL)
+
+
+def _post(url, payload, timeout):
+    """POST JSON and return parsed response."""
+    data = json.dumps(payload).encode("utf-8")
+    req = urllib.request.Request(
+        url,
+        data=data,
+        headers={"Content-Type": "application/json"},
+        method="POST",
+    )
+    try:
+        with urllib.request.urlopen(req, timeout=timeout) as resp:
+            return json.loads(resp.read().decode("utf-8"))
+    except urllib.error.HTTPError as e:
+        body = e.read().decode("utf-8", errors="replace")
+        return {"success": False, "error": f"HTTP {e.code}", "details": body}
+    except urllib.error.URLError as e:
+        return {"success": False, "error": f"Connection error: {e.reason}"}
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+# ─── Core Functions (importable) ─────────────────────────────────
+
+def search_apis(query, limit=5):
+    """
+    Search for APIs matching a natural language query.
+
+    Returns dict with 'apis' list. Each API has:
+      vendor_code, use_for, params, returns
+    """
+    base = _get_base_url()
+    result = _post(f"{base}/api/search", {"query": query, "limit": limit}, SEARCH_TIMEOUT)
+    return result
+
+
+def fetch_api(vendor_code, params=None):
+    """
+    Fetch data from an API by vendor_code.
+
+    Use search_apis() first to discover vendor_codes and required params.
+    """
+    base = _get_base_url()
+    result = _post(
+        f"{base}/api/proxy",
+        {"vendor_code": vendor_code, "params": params or {}},
+        FETCH_TIMEOUT,
+    )
+    # Unwrap: backend may nest data under 'data' key
+    if isinstance(result, dict) and "data" in result and result.get("success") is not False:
+        return result["data"]
+    return result
+
+
+def auto_fetch(query):
+    """
+    Discover + fetch in one call. Finds the best API for the query,
+    extracts likely params from the query context, and fetches data.
+
+    Returns the raw data from the best matching API.
+    """
+    # Step 1: Discover
+    discovery = search_apis(query, limit=3)
+    apis = discovery.get("apis", [])
+
+    if not apis:
+        return {"success": False, "error": "No APIs found for query", "query": query}
+
+    # Step 2: Pick the first (best) match
+    best = apis[0]
+    vendor_code = best["vendor_code"]
+    required_params = {}
+
+    # Try to extract params from the discovered API's param spec
+    param_spec = best.get("params", {})
+    if isinstance(param_spec, dict):
+        for key, info in param_spec.items():
+            if isinstance(info, dict) and info.get("required"):
+                # For required params, we include them with None
+                # The agent should fill these in — this is a best-effort helper
+                required_params[key] = info.get("default")
+
+    # Step 3: Fetch
+    data = fetch_api(vendor_code, required_params)
+
+    return {
+        "vendor_code": vendor_code,
+        "use_for": best.get("use_for", ""),
+        "params_used": required_params,
+        "data": data,
+    }
+
+
+# ─── CLI Commands ────────────────────────────────────────────────
+
+def cmd_search(args):
+    """Search for available APIs."""
+    result = search_apis(args.query, args.limit)
+    print(json.dumps(result, indent=2, default=str))
+
+
+def cmd_fetch(args):
+    """Fetch data from a specific API."""
+    params = json.loads(args.params) if args.params else {}
+    result = fetch_api(args.vendor_code, params)
+
+    if args.raw:
+        # Output just the data for piping
+        if isinstance(result, dict) and "data" in result:
+            print(json.dumps(result["data"], indent=2, default=str))
+        else:
+            print(json.dumps(result, indent=2, default=str))
+    else:
+        print(json.dumps(result, indent=2, default=str))
+
+
+def cmd_get(args):
+    """Discover + fetch in one shot."""
+    result = auto_fetch(args.query)
+    print(json.dumps(result, indent=2, default=str))
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Data API Client — Search and fetch from hundreds of APIs"
+    )
+    subparsers = parser.add_subparsers(dest="command", help="Command to run")
+
+    # search
+    search_p = subparsers.add_parser("search", help="Discover APIs for a query")
+    search_p.add_argument("query", help="Natural language description of data needed")
+    search_p.add_argument("--limit", type=int, default=5, help="Max APIs to return (1-10)")
+
+    # fetch
+    fetch_p = subparsers.add_parser("fetch", help="Fetch data from a specific API")
+    fetch_p.add_argument("vendor_code", help="API vendor code (e.g., FMP_QUOTE)")
+    fetch_p.add_argument("params", nargs="?", default="{}", help='JSON params (e.g., \'{"symbol": "AAPL"}\')')
+    fetch_p.add_argument("--raw", action="store_true", help="Output raw data only (for piping)")
+
+    # get (discover + fetch combined)
+    get_p = subparsers.add_parser("get", help="Discover and fetch in one shot")
+    get_p.add_argument("query", help="Natural language query (e.g., 'current Bitcoin price')")
+
+    args = parser.parse_args()
+
+    commands = {
+        "search": cmd_search,
+        "fetch": cmd_fetch,
+        "get": cmd_get,
+    }
+
+    if args.command in commands:
+        commands[args.command](args)
+    else:
+        parser.print_help()
+
+
+if __name__ == "__main__":
+    main()

package/skills/trading/scripts/trade-dashboard-template.html

@@ -0,0 +1,81 @@
+<!DOCTYPE html>
+<html lang="en" class="dark">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Trade Dashboard</title>
+
+  <!-- ═══════════════════════════════════════════════════════════════
+       DESIGN SYSTEM — CDN libraries and base styles.
+       Agent: add/remove/swap any library. These are just suggestions.
+       Examples: Chart.js, D3.js, ApexCharts, Plotly, Three.js, etc.
+       ═══════════════════════════════════════════════════════════════ -->
+  <script src="https://cdn.tailwindcss.com"></script>
+  <script src="https://cdn.jsdelivr.net/npm/lightweight-charts@4.1.0/dist/lightweight-charts.standalone.production.js"></script>
+  <script>
+    tailwind.config = {
+      darkMode: 'class',
+      theme: {
+        extend: {
+          colors: {
+            surface: { 1: '#0f1117', 2: '#161822', 3: '#1e2030' },
+            accent: { green: '#22c55e', red: '#ef4444', blue: '#3b82f6', amber: '#f59e0b' },
+          }
+        }
+      }
+    }
+  </script>
+  <style>
+    @import url('https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&family=JetBrains+Mono:wght@400;500&display=swap');
+    body { background: #0f1117; font-family: 'Inter', system-ui, sans-serif; }
+    .mono { font-family: 'JetBrains Mono', monospace; }
+    .glass { background: rgba(30, 32, 48, 0.6); backdrop-filter: blur(12px); border: 1px solid rgba(255,255,255,0.06); }
+  </style>
+</head>
+<body class="min-h-screen text-gray-100">
+
+  <!-- ═══════════════════════════════════════════════════════════════
+       THIS IS A MINIMAL SKELETON. NOT A FIXED STRUCTURE.
+
+       Agent: you own this file completely. For every trade:
+       - Build the HTML layout from scratch or reuse parts of this
+       - Add any sections, charts, data sources, widgets you want
+       - Add any CDN libraries you need in <head>
+       - Add inline <style> or Tailwind classes for custom styling
+       - Add <script> blocks for data fetching, rendering, interactivity
+       - Structure the data however makes sense for this trade
+       - Every dashboard should be unique to its trade
+
+       There are NO required sections, NO required data format,
+       NO required layout. Build what the trade needs.
+
+       DATA SOURCES — use any combination:
+       - Use discover_data_api to find vendor_codes, then build
+         Python scripts that call the backend proxy and output JSON
+         for the dashboard to consume (via fetch or file read).
+       - Call any public API directly via fetch() — CoinGecko,
+         Binance, Yahoo Finance, Alpha Vantage, DefiLlama, etc.
+       - Connect WebSocket feeds for real-time streaming —
+         Binance WS, Coinbase WS, forex feeds, etc.
+       - Build Python script pipelines (cron → script → JSON file
+         → dashboard reads on reload).
+       - Embed data directly in the HTML when you update the file.
+       - Find ANY data source from the internet and integrate it.
+       No restrictions on data sources or update patterns.
+
+       IDEAS (not requirements):
+       - Price charts (candlestick, line, area, heatmap)
+       - P&L tracking, risk gauges, progress bars
+       - News feeds, sentiment widgets, correlation matrices
+       - Order flow, volume profile, funding rates
+       - Economic calendar overlays, regime indicators
+       - Multiple timeframe views, comparison charts
+       - Any visualization that helps monitor this specific trade
+       ═══════════════════════════════════════════════════════════════ -->
+
+  <div id="app" class="max-w-7xl mx-auto px-4 py-6">
+    <!-- Agent: build your dashboard here -->
+  </div>
+
+</body>
+</html>