opentradex 0.1.0 → 0.1.3

package/.env.example

@@ -1,8 +1,47 @@
-KALSHI_API_KEY_ID=
-KALSHI_PRIVATE_KEY_PATH=
-KALSHI_USE_DEMO=true
-APIFY_API_TOKEN=
+# Welcome to OpenTradex
+# Our implementation. Your strategy.
+
+# Runtime profile
+OPENTRADEX_RUNTIME=claude-code
+OPENTRADEX_PACKAGE_MANAGER=npm
+OPENTRADEX_EXECUTION_MODE=paper
+OPENTRADEX_PRIMARY_MARKET=kalshi
+OPENTRADEX_ENABLED_MARKETS=kalshi
+OPENTRADEX_ENABLED_INTEGRATIONS=apify,rss
+OPENTRADEX_LIVE_EXECUTION_MARKET=kalshi
+NEWS_PROVIDER=apify,rss
+
+# Risk configuration
 BANKROLL=30.00
 MIN_EDGE=0.10
 MAX_POSITION_PCT=0.30
 CYCLE_INTERVAL=900
+LIVE_TRADING=false
+
+# Kalshi
+KALSHI_API_KEY_ID=
+KALSHI_PRIVATE_KEY_PATH=
+KALSHI_USE_DEMO=true
+
+# Polymarket
+POLYMARKET_GAMMA_URL=https://gamma-api.polymarket.com
+POLYMARKET_WALLET_ADDRESS=
+POLYMARKET_PRIVATE_KEY=
+
+# TradingView
+TRADINGVIEW_USERNAME=
+TRADINGVIEW_PASSWORD=
+TRADINGVIEW_WATCHLIST=SPY,QQQ,BTCUSD,NQ1!
+
+# Robinhood and Groww
+ROBINHOOD_USERNAME=
+ROBINHOOD_PASSWORD=
+ROBINHOOD_MFA_CODE=
+GROWW_ACCESS_TOKEN=
+
+# Optional LLM provider secrets
+OPENAI_API_KEY=
+GEMINI_API_KEY=
+
+# Data integrations
+APIFY_API_TOKEN=

package/README.md

@@ -1,35 +1,67 @@
-# Open Trademaxxxing
+# OpenTradex
 
-**An autonomous AI agent that trades prediction markets by reading the news before the crowd.**
+**Our implementation. Your strategy.**
+
+OpenTradex is an open-source onboarding and execution layer for AI-assisted trading workflows. It helps you choose a runtime, wire market rails, connect optional data APIs, and launch a live dashboard without pretending to own your strategy.
 
 Preferred setup: run `opentradex onboard`.
 
 ## Install
 
-OpenClaw-style first run flow:
+Welcome to OpenTradex:
 
 ```bash
-# install from npm
-npm install -g opentradex
-
-# guided setup
+# npm
+npm install -g opentradex@latest
 opentradex onboard
 ```
 
-`opentradex onboard` creates a workspace, writes `.env`, optionally installs the Python and dashboard dependencies, and saves your default workspace in `~/.opentradex/config.json`.
+Alternative entry points:
+
+```bash
+# npx
+npx opentradex@latest onboard
+
+# bunx
+bunx opentradex@latest onboard
+
+# curl bootstrap
+curl -fsSL https://opentradex.vercel.app/install.sh | bash
+```
 
-You can also use `npx opentradex onboard` if you do not want a global install.
+`opentradex onboard` creates a workspace, writes a grouped `.env`, saves an `opentradex.config.json` workspace profile, optionally installs Python and web dependencies, and stores your default workspace in `~/.opentradex/config.json`.
+
+During onboarding you can choose:
+
+- Your agent runtime profile
+- Your primary market rail
+- Extra rails like `polymarket`, `tradingview`, `robinhood`, or `groww`
+- Optional data integrations like `apify`, `rss`, `reddit`, `twitter`, `truthsocial`, and `tiktok`
+- Your package manager for local web workflows
 
 ### CLI Commands
 
 ```bash
 opentradex onboard                     # guided setup
-opentradex doctor                      # verify Claude, Python, npm, and env config
+opentradex doctor                      # verify runtime, packages, env config, and rails
+opentradex providers                   # show supported runtime, market, and data rails
 opentradex start                       # run the continuous trading loop
 opentradex cycle --rationale "..."     # run one cycle or research a thesis
 opentradex web                         # launch the Next.js dashboard
 ```
 
+## Current Rail Support
+
+| Rail | Current role |
+|---|---|
+| Kalshi | Best live execution path |
+| Polymarket | Public market discovery and comparison |
+| TradingView | Watchlist and chart context |
+| Robinhood | Broker profile placeholder |
+| Groww | Broker profile placeholder |
+
+Kalshi is still the strongest live execution rail today. The others are intentionally exposed as discovery/profile rails so you can build the workflow now and decide later what deserves real execution adapters.
+
 ---
 
 ## How It Works
@@ -229,7 +261,7 @@ cd web && npm run dev
 # → http://localhost:3000
 ```
 
-If you want the simpler package flow instead, use `npm install -g opentradex` and then `opentradex onboard`.
+If you want the simpler package flow instead, use `npm install -g opentradex@latest` and then `opentradex onboard`.
 
 ## Stack
 

package/gossip/polymarket.py

@@ -0,0 +1,196 @@
+"""
+Polymarket discovery rail.
+
+CLI usage:
+    python3 gossip/polymarket.py scan --limit 40
+    python3 gossip/polymarket.py search "bitcoin"
+    python3 gossip/polymarket.py market <id-or-slug>
+
+This module intentionally focuses on public Gamma API discovery so the agent can
+compare Polymarket pricing with other rails without requiring a wallet up front.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import sys
+from pathlib import Path
+from urllib.parse import urlencode
+from urllib.request import Request, urlopen
+
+from dotenv import load_dotenv
+
+load_dotenv(Path(__file__).resolve().parent.parent / ".env")
+
+BASE_URL = os.getenv("POLYMARKET_GAMMA_URL", "https://gamma-api.polymarket.com").rstrip("/")
+
+
+def log(message: str) -> None:
+    print(message, file=sys.stderr)
+
+
+async def api_get(path: str, params: dict | None = None):
+    url = f"{BASE_URL}{path}"
+    if params:
+        url = f"{url}?{urlencode(params)}"
+
+    request = Request(
+        url,
+        headers={
+            "User-Agent": "OpenTradex/0.1 (+https://github.com/deonmenezes/open-trademaxxxing)",
+            "Accept": "application/json",
+        },
+    )
+
+    with urlopen(request, timeout=20) as response:
+        return json.loads(response.read().decode("utf-8"))
+
+
+def parse_outcome_prices(raw_prices: str | list | None) -> tuple[float | None, float | None]:
+    if not raw_prices:
+        return None, None
+
+    prices = raw_prices
+    if isinstance(raw_prices, str):
+        try:
+            prices = json.loads(raw_prices)
+        except json.JSONDecodeError:
+            return None, None
+
+    if not isinstance(prices, list) or len(prices) < 2:
+        return None, None
+
+    try:
+        return float(prices[0]), float(prices[1])
+    except (TypeError, ValueError):
+        return None, None
+
+
+def simplify_market(market: dict) -> dict:
+    yes_price, no_price = parse_outcome_prices(market.get("outcomePrices"))
+    event_title = ""
+    if market.get("events"):
+        event_title = market["events"][0].get("title", "")
+
+    return {
+        "id": market.get("id"),
+        "slug": market.get("slug"),
+        "question": market.get("question"),
+        "event_title": event_title,
+        "description": market.get("description", "")[:700],
+        "end_date": market.get("endDate"),
+        "yes_price": yes_price,
+        "no_price": no_price,
+        "volume": float(market.get("volumeNum") or market.get("volume") or 0),
+        "liquidity": float(market.get("liquidityNum") or market.get("liquidity") or 0),
+        "volume_24h": float(market.get("volume24hr") or 0),
+        "active": bool(market.get("active")),
+        "closed": bool(market.get("closed")),
+        "accepting_orders": bool(market.get("acceptingOrders")),
+        "url": f"https://polymarket.com/event/{market.get('slug')}" if market.get("slug") else "",
+    }
+
+
+async def scan_markets(limit: int = 40, min_volume: float = 1000, min_liquidity: float = 1000) -> list[dict]:
+    data = await api_get(
+        "/markets",
+        {
+            "active": "true",
+            "closed": "false",
+            "limit": max(limit * 3, 120),
+        },
+    )
+    markets = [simplify_market(m) for m in data]
+    filtered = [
+        market
+        for market in markets
+        if market["volume"] >= min_volume and market["liquidity"] >= min_liquidity
+    ]
+    filtered.sort(key=lambda market: market["volume"], reverse=True)
+    return filtered[:limit]
+
+
+async def search_markets(query: str, limit: int = 20) -> list[dict]:
+    data = await api_get(
+        "/markets",
+        {
+            "active": "true",
+            "closed": "false",
+            "limit": 300,
+        },
+    )
+    needle = query.lower()
+    matched = []
+    for market in data:
+        haystack = " ".join(
+            [
+                str(market.get("question", "")),
+                str(market.get("description", "")),
+                str(market.get("slug", "")),
+                str(market.get("groupItemTitle", "")),
+            ]
+        ).lower()
+        if needle in haystack:
+            matched.append(simplify_market(market))
+
+    matched.sort(key=lambda market: (market["volume"], market["liquidity"]), reverse=True)
+    return matched[:limit]
+
+
+async def get_market(identifier: str) -> dict | None:
+    data = await api_get(
+        "/markets",
+        {
+            "active": "true",
+            "closed": "false",
+            "limit": 500,
+        },
+    )
+    for market in data:
+        if str(market.get("id")) == identifier or market.get("slug") == identifier:
+            return simplify_market(market)
+    return None
+
+
+async def main_async():
+    parser = argparse.ArgumentParser(description="Polymarket discovery rail")
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    scan_parser = subparsers.add_parser("scan")
+    scan_parser.add_argument("--limit", type=int, default=40)
+    scan_parser.add_argument("--min-volume", type=float, default=1000)
+    scan_parser.add_argument("--min-liquidity", type=float, default=1000)
+
+    search_parser = subparsers.add_parser("search")
+    search_parser.add_argument("query", type=str)
+    search_parser.add_argument("--limit", type=int, default=20)
+
+    market_parser = subparsers.add_parser("market")
+    market_parser.add_argument("identifier", type=str)
+
+    args = parser.parse_args()
+
+    if args.command == "scan":
+        result = await scan_markets(args.limit, args.min_volume, args.min_liquidity)
+        print(json.dumps(result, indent=2))
+        return
+
+    if args.command == "search":
+        result = await search_markets(args.query, args.limit)
+        print(json.dumps(result, indent=2))
+        return
+
+    result = await get_market(args.identifier)
+    if result is None:
+        log(f"No Polymarket market found for {args.identifier}")
+        print(json.dumps({"error": "market_not_found", "identifier": args.identifier}, indent=2))
+        return
+    print(json.dumps(result, indent=2))
+
+
+if __name__ == "__main__":
+    import asyncio
+
+    asyncio.run(main_async())

package/main.py

@@ -1,5 +1,5 @@
 """
-Open Trademaxxxing - agent orchestrator.
+OpenTradex - agent orchestrator.
 
 Spawns Claude Code as a subprocess. The agent reads SOUL.md for personality,
 uses tools directly (web search, Apify, Kalshi API), and persists state to SQLite.
@@ -31,8 +31,77 @@ PROJECT_DIR = Path(__file__).resolve().parent
 DATA_DIR = PROJECT_DIR / "data"
 SESSION_FILE = DATA_DIR / "session_id.txt"
 
-# The agent prompt: agentic, not scripted. Agent uses its own tools.
-CYCLE_PROMPT = """Read SOUL.md for your identity and strategy principles.
+
+def parse_csv_env(name: str, fallback: str = "") -> list[str]:
+    raw = os.getenv(name, fallback)
+    return [item.strip().lower() for item in raw.split(",") if item.strip()]
+
+
+def build_runtime_context() -> str:
+    runtime = os.getenv("OPENTRADEX_RUNTIME", "claude-code")
+    primary_market = os.getenv("OPENTRADEX_PRIMARY_MARKET", "kalshi")
+    enabled_markets = parse_csv_env("OPENTRADEX_ENABLED_MARKETS", primary_market)
+    integrations = parse_csv_env("OPENTRADEX_ENABLED_INTEGRATIONS", "apify,rss")
+
+    lines = [
+        "Workspace profile:",
+        f"- Runtime profile: {runtime}",
+        f"- Primary market: {primary_market}",
+        f"- Enabled market rails: {', '.join(enabled_markets)}",
+        f"- Enabled data integrations: {', '.join(integrations)}",
+        "- Use only the rails enabled in this workspace.",
+        "- Live execution is currently routed through Kalshi only. Other rails are for discovery, research, and cross-market context unless explicitly extended.",
+        "",
+        "Available market/data rails for this workspace:",
+    ]
+
+    if "kalshi" in enabled_markets:
+        lines.extend(
+            [
+                "- Kalshi discovery and execution:",
+                "  `PYTHONPATH=. python3 gossip/kalshi.py quick --limit 60`",
+                "  `PYTHONPATH=. python3 gossip/kalshi.py search \"specific topic\"`",
+                "  `PYTHONPATH=. python3 gossip/trader.py trade TICKER --side yes/no --estimate 0.XX --confidence high/medium --reasoning \"...\"`",
+            ]
+        )
+
+    if "polymarket" in enabled_markets:
+        lines.extend(
+            [
+                "- Polymarket discovery rail:",
+                "  `PYTHONPATH=. python3 gossip/polymarket.py scan --limit 40`",
+                "  `PYTHONPATH=. python3 gossip/polymarket.py search \"specific topic\"`",
+                "  Use Polymarket for cross-market validation, sentiment, and mispricing comparisons.",
+            ]
+        )
+
+    if "tradingview" in enabled_markets:
+        lines.extend(
+            [
+                "- TradingView watchlist rail:",
+                "  Read `TRADINGVIEW_WATCHLIST` from `.env` and use it to focus macro/equity/crypto research.",
+                "  Treat this as a watchlist/context source unless a dedicated adapter is added.",
+            ]
+        )
+
+    if "robinhood" in enabled_markets:
+        lines.append("- Robinhood is enabled as a broker profile placeholder. Use it for planning and watchlist context unless you add a dedicated execution adapter.")
+
+    if "groww" in enabled_markets:
+        lines.append("- Groww is enabled as a broker profile placeholder. Use it for planning and watchlist context unless you add a dedicated execution adapter.")
+
+    if "apify" in integrations:
+        lines.append("- Apify-backed news scraping is available through `PYTHONPATH=. python3 gossip/news.py --keywords \"...\"`.")
+    if "rss" in integrations:
+        lines.append("- RSS/live news fallbacks are enabled through the web dashboard and news routes.")
+
+    return "\n".join(lines)
+
+
+def build_cycle_prompt() -> str:
+    return f"""{build_runtime_context()}
+
+Read SOUL.md for your identity and strategy principles.
 Read data/strategy_notes.md for lessons from past sessions.
 Check data/user_rationales.json for any pending user theses to research.
 
@@ -48,43 +117,45 @@ Then run a full trading cycle:
    Review each open position's unrealized P&L and current market price vs your entry.
 
 3. POSITION REVIEW — for each open position:
-   - If current price moved significantly toward your thesis (e.g. YES at 95c+ when you entered at 82c), consider selling now to lock profit vs waiting for settlement.
-   - If thesis has weakened or news contradicts it, EXIT: `PYTHONPATH=. python3 gossip/trader.py exit TICKER --reasoning "..."`
+   - If current price moved significantly toward your thesis, consider selling now to lock profit vs waiting for settlement.
+   - If thesis has weakened or news contradicts it, EXIT: `PYTHONPATH=. python3 gossip/trader.py exit TICKER --reasoning "..."`.
    - If thesis still holds and edge remains, HOLD.
    - Use web search to verify — don't just check prices, check if the underlying event happened.
 
 4. MARKET DISCOVERY — use targeted searches, not just broad scans:
-   - `PYTHONPATH=. python3 gossip/kalshi.py quick --limit 60` for broad overview
-   - `PYTHONPATH=. python3 gossip/kalshi.py search "specific topic"` for targeted lookups
-   - Focus on categories where news creates edge: Politics, Economics, Macro events
-   - Search for current events you already know about from news/web search
-   - Skip sports, entertainment, and illiquid markets (volume < 500, spread > 15c)
+   - Use the enabled market rails above.
+   - Focus on categories where news creates edge: Politics, Economics, Macro events, liquid crypto and cross-market event contracts.
+   - Search for current events you already know about from news/web search.
+   - Skip thin or noisy setups unless the edge is exceptional.
 
 5. RESEARCH — pick 3-5 promising markets:
-   - Use web search to find relevant news and primary sources
-   - Use `PYTHONPATH=. python3 gossip/news.py --keywords "..."` for broader news scraping
-   - Estimate the true probability based on evidence
-   - Look for near-arbitrage: events that already happened but market hasn't caught up
+   - Use web search to find relevant news and primary sources.
+   - Use `PYTHONPATH=. python3 gossip/news.py --keywords "..."` for broader news scraping.
+   - Use Polymarket or watchlist rails for comparison when they are enabled.
+   - Estimate the true probability based on evidence.
+   - Look for near-arbitrage: events that already happened but markets have not caught up.
 
 6. TRADE if you find edge > 10pp with clear reasoning:
    Before executing, answer in one line: "Evidence type: [hard/soft/speculation]. Weakest assumption: [X]."
    If the evidence is speculation, PASS unless edge is overwhelming (>25pp).
-   If you can't name what would make you wrong, your thesis isn't specific enough — PASS.
-   `PYTHONPATH=. python3 gossip/trader.py trade TICKER --side yes/no --estimate 0.XX --confidence high/medium --reasoning "..."`
+   If you cannot name what would make you wrong, your thesis is not specific enough — PASS.
+   Only route live orders through supported execution rails.
 
 7. Update data/strategy_notes.md with what you learned this cycle.
 
 EXECUTION DISCIPLINE:
-- Be decisive. Research → conclude → act. Don't loop endlessly.
+- Be decisive. Research -> conclude -> act. Do not loop endlessly.
 - For each market: reach a YES/NO/PASS decision within 2-3 tool calls.
-- Evaluate 3-5 markets per cycle, trade the best 1-2. Don't try to cover everything.
-- If you can't find edge after 5 minutes on a market, pass and move on.
+- Evaluate 3-5 markets per cycle, trade the best 1-2. Do not try to cover everything.
+- If you cannot find edge after 5 minutes on a market, pass and move on.
 - Write your conclusion even when you pass — future cycles benefit from it.
 """
 
 
 def build_rationale_prompt(rationale: str) -> str:
-    return f"""Read SOUL.md for your identity and strategy principles.
+    return f"""{build_runtime_context()}
+
+Read SOUL.md for your identity and strategy principles.
 
 A user has submitted this thesis for you to research and potentially trade on:
 
@@ -100,7 +171,7 @@ Your job:
 7. Update data/strategy_notes.md if you learned something new.
 
 Check portfolio first: `PYTHONPATH=. python3 gossip/trader.py portfolio`
-Scan markets: `PYTHONPATH=. python3 gossip/kalshi.py scan` or `PYTHONPATH=. python3 gossip/kalshi.py search "relevant keywords"`
+Scan markets using the enabled rails above. Use Kalshi for execution and Polymarket/watchlist rails for comparison where available.
 """
 
 
@@ -115,6 +186,7 @@ def write_status(status: str, **extra) -> None:
 
 def run_agent(prompt: str, timeout: int = 600) -> dict:
     """Spawn Claude Code as a subprocess. Stream output to live log file."""
+    configured_runtime = os.getenv("OPENTRADEX_RUNTIME", "claude-code")
     cmd = [
         "claude",
         "--print", "-",
@@ -132,7 +204,7 @@ def run_agent(prompt: str, timeout: int = 600) -> dict:
     DATA_DIR.mkdir(parents=True, exist_ok=True)
     # Clear live log for this cycle
     LIVE_LOG.write_text("")
-    write_status("running")
+    write_status("running", configured_runtime=configured_runtime, runner="claude-code")
 
     start = time.time()
     session_id = None
@@ -241,7 +313,7 @@ def _now() -> str:
 
 
 def main():
-    parser = argparse.ArgumentParser(description="Open Trademaxxxing agent")
+    parser = argparse.ArgumentParser(description="OpenTradex agent")
     parser.add_argument("--loop", action="store_true", help="Run continuously")
     parser.add_argument("--interval", type=int, default=None, help="Cycle interval in seconds")
     parser.add_argument("--prompt", type=str, default=None, help="Custom prompt")
@@ -251,18 +323,24 @@ def main():
 
     args = parser.parse_args()
     interval = args.interval or int(os.getenv("CYCLE_INTERVAL", "900"))
+    configured_runtime = os.getenv("OPENTRADEX_RUNTIME", "claude-code")
 
     if args.rationale:
         submit_rationale(args.rationale)
         prompt = build_rationale_prompt(args.rationale)
     else:
-        prompt = args.prompt or CYCLE_PROMPT
+        prompt = args.prompt or build_cycle_prompt()
 
     if args.dry_run:
         print(prompt)
         return
 
-    print(f"[Open Trademaxxxing] Starting agent", file=sys.stderr)
+    print(f"[OpenTradex] Starting agent", file=sys.stderr)
+    if configured_runtime != "claude-code":
+        print(
+            f"  Runtime profile: {configured_runtime} (executing with Claude Code runner)",
+            file=sys.stderr,
+        )
     print(f"  Mode: {'loop (' + str(interval) + 's)' if args.loop else 'single cycle'}", file=sys.stderr)
 
     while True:

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "opentradex",
-  "version": "0.1.0",
-  "description": "OpenTradex CLI and onboarding flow for Open Trademaxxxing.",
+  "version": "0.1.3",
+  "description": "OpenTradex CLI, onboarding flow, and market-rail toolkit for AI-assisted trading workflows.",
   "type": "module",
   "bin": {
     "opentradex": "./bin/opentradex.mjs"
@@ -13,6 +13,7 @@
   "files": [
     "bin/",
     "src/",
+    "scripts/",
     ".env.example",
     "README.md",
     "CLAUDE.md",
@@ -30,7 +31,7 @@
   ],
   "scripts": {
     "opentradex": "node ./bin/opentradex.mjs",
-    "test:cli": "node ./bin/opentradex.mjs --help && node ./bin/opentradex.mjs doctor --workspace ."
+    "test:cli": "node ./bin/opentradex.mjs --help && node ./bin/opentradex.mjs providers && node ./bin/opentradex.mjs doctor --workspace ."
   },
   "keywords": [
     "kalshi",
@@ -43,5 +44,8 @@
   "engines": {
     "node": ">=22.0.0"
   },
-  "license": "UNLICENSED"
+  "license": "UNLICENSED",
+  "publishConfig": {
+    "access": "public"
+  }
 }

package/scripts/install.ps1

@@ -0,0 +1,25 @@
+$ErrorActionPreference = "Stop"
+
+$workspace = if ($env:OPENTRADEX_WORKSPACE) { $env:OPENTRADEX_WORKSPACE } else { Join-Path $HOME "opentradex" }
+$packageManager = if ($env:OPENTRADEX_PACKAGE_MANAGER) { $env:OPENTRADEX_PACKAGE_MANAGER } else { "npm" }
+
+Write-Host "Welcome to OpenTradex"
+Write-Host "Our implementation. Your strategy."
+Write-Host ""
+
+if (-not (Get-Command node -ErrorAction SilentlyContinue)) {
+  throw "Node.js 22+ is required before running this installer."
+}
+
+if ($packageManager -eq "bun" -and -not (Get-Command bun -ErrorAction SilentlyContinue)) {
+  Write-Host "Bun is not installed, so this installer is falling back to npm."
+  $packageManager = "npm"
+}
+
+if ($packageManager -eq "bun") {
+  bun add -g opentradex@latest
+} else {
+  npm install -g opentradex@latest
+}
+
+opentradex onboard --workspace $workspace

package/scripts/install.sh

@@ -0,0 +1,29 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+WORKSPACE="${OPENTRADEX_WORKSPACE:-$HOME/opentradex}"
+PACKAGE_MANAGER="${OPENTRADEX_PACKAGE_MANAGER:-npm}"
+
+echo "Welcome to OpenTradex"
+echo "Our implementation. Your strategy."
+echo
+
+if ! command -v node >/dev/null 2>&1; then
+  echo "Node.js is required. Install Node.js 22+ and rerun this installer."
+  exit 1
+fi
+
+if [[ "$PACKAGE_MANAGER" == "bun" ]]; then
+  if ! command -v bun >/dev/null 2>&1; then
+    echo "Bun is not installed, so this installer is falling back to npm."
+    PACKAGE_MANAGER="npm"
+  fi
+fi
+
+if [[ "$PACKAGE_MANAGER" == "bun" ]]; then
+  bun add -g opentradex@latest
+else
+  npm install -g opentradex@latest
+fi
+
+opentradex onboard --workspace "$WORKSPACE"