@superpack/crypto-price 0.0.2

package/README.md

@@ -0,0 +1,55 @@
+# openclaw-crypto-price
+
+Live cryptocurrency prices for OpenClaw via `/price` command. Runs deterministically — no LLM invocation.
+
+## Usage
+
+```
+/price              # All default coins (BTC, PAXG, XMR, ZANO)
+/price btc xmr      # Specific coins
+/price bitcoin      # Aliases work too
+```
+
+## Supported Coins
+
+| Symbol | Name      | Aliases            |
+|--------|-----------|--------------------|
+| BTC    | Bitcoin   | bitcoin, btc       |
+| PAXG   | PAX Gold  | pax-gold, paxg     |
+| XMR    | Monero    | monero, xmr        |
+| ZANO   | Zano      | zano               |
+
+## Installation
+
+Add to your `openclaw.json`:
+
+```json
+{
+  "plugins": {
+    "allow": ["openclaw-crypto-price"]
+  }
+}
+```
+
+Optional config to override default coins:
+
+```json
+{
+  "plugins": {
+    "config": {
+      "openclaw-crypto-price": {
+        "coins": ["BTC", "XMR"]
+      }
+    }
+  }
+}
+```
+
+## Requirements
+
+- Python 3.6+
+- Internet access (fetches from CryptoCompare API)
+
+## Data Source
+
+[CryptoCompare](https://www.cryptocompare.com/) public API — no API key required.

package/openclaw.plugin.json

@@ -0,0 +1,16 @@
+{
+  "id": "openclaw-crypto-price",
+  "name": "OpenClaw Crypto Price",
+  "description": "Live cryptocurrency prices via /price command. No LLM invocation — runs deterministically.",
+  "configSchema": {
+    "type": "object",
+    "additionalProperties": false,
+    "properties": {
+      "coins": {
+        "type": "array",
+        "items": { "type": "string" },
+        "description": "Default coins to show when /price is called with no arguments. Defaults to [\"BTC\", \"PAXG\", \"XMR\", \"ZANO\"]."
+      }
+    }
+  }
+}

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@superpack/crypto-price",
+  "version": "0.0.2",
+  "description": "Demo Plugin for OpenClaw Superpack. Adds /price to get crypto prices.",
+  "type": "module",
+  "license": "MIT",
+  "author": "Rob Vella <me@robvella.com>",
+  "scripts": {
+    "lint": "eslint src --ext .ts",
+    "price": "python3 scripts/get_price.py"
+  },
+  "devDependencies": {
+    "@typescript-eslint/eslint-plugin": "^8",
+    "@typescript-eslint/parser": "^8",
+    "eslint": "^9"
+  },
+  "keywords": [
+    "openclaw",
+    "crypto",
+    "bitcoin",
+    "price",
+    "plugin"
+  ],
+  "openclaw": {
+    "extensions": [
+      "./src/index.ts"
+    ]
+  },
+  "files": [
+    "src/",
+    "scripts/",
+    "openclaw.plugin.json",
+    "README.md"
+  ]
+}

package/scripts/get_price.py

@@ -0,0 +1,193 @@
+#!/usr/bin/env python3
+"""Fetch cryptocurrency prices from CryptoCompare API.
+Supports: BTC (Bitcoin), PAXG (Paxos Gold), XMR (Monero), ZANO (Zano)
+"""
+import json
+import urllib.request
+import urllib.error
+from typing import Dict, Union, Optional, List
+
+CRYPTOCOMPARE_API = "https://min-api.cryptocompare.com/data/pricemultifull"
+
+# Symbol mapping for display names
+COIN_NAMES = {
+    'BTC': 'Bitcoin',
+    'PAXG': 'PAX Gold',
+    'XMR': 'Monero',
+    'ZANO': 'Zano',
+}
+
+# Symbol aliases
+SYMBOL_ALIASES = {
+    'bitcoin': 'BTC',
+    'btc': 'BTC',
+    'pax-gold': 'PAXG',
+    'paxg': 'PAXG',
+    'monero': 'XMR',
+    'xmr': 'XMR',
+    'zano': 'ZANO',
+}
+
+DEFAULT_COINS = ['BTC', 'PAXG', 'XMR', 'ZANO']
+
+
+def fetch_all_coins(fsyms: List[str] = None, tsyms: str = "USD") -> Optional[Dict]:
+    """Fetch market data for multiple coins from CryptoCompare."""
+    if fsyms is None:
+        fsyms = DEFAULT_COINS
+
+    symbols = ','.join(fsyms)
+    url = f"{CRYPTOCOMPARE_API}?fsyms={symbols}&tsyms={tsyms}"
+
+    try:
+        req = urllib.request.Request(
+            url,
+            headers={
+                "Accept": "application/json",
+                "User-Agent": "Mozilla/5.0 (OpenClaw Bot)"
+            }
+        )
+
+        with urllib.request.urlopen(req, timeout=30) as response:
+            return json.loads(response.read().decode('utf-8'))
+    except (urllib.error.URLError, json.JSONDecodeError) as e:
+        print(f"Error fetching data: {e}")
+        return None
+
+
+def parse_coin_data(raw_data: Dict, symbol: str, tsym: str = "USD") -> Optional[Dict[str, Union[float, int]]]:
+    """Parse raw API response for a specific coin."""
+    try:
+        coin_raw = raw_data['RAW'][symbol][tsym]
+        return {
+            'symbol': symbol,
+            'name': COIN_NAMES.get(symbol, symbol),
+            'price_usd': coin_raw['PRICE'],
+            'change_24h': coin_raw['CHANGEPCT24HOUR'],
+            'market_cap': coin_raw.get('MKTCAP', 0),
+            'volume_24h': coin_raw.get('VOLUME24HOURTO', 0),
+            'high_24h': coin_raw.get('HIGH24HOUR', 0),
+            'low_24h': coin_raw.get('LOW24HOUR', 0),
+        }
+    except (KeyError, TypeError):
+        return None
+
+
+def get_all_coins(fsyms: List[str] = None, tsyms: str = "USD") -> Dict[str, Optional[Dict]]:
+    """Fetch and parse data for multiple coins."""
+    raw = fetch_all_coins(fsyms, tsyms)
+    if not raw or 'RAW' not in raw:
+        return {sym: None for sym in (fsyms or DEFAULT_COINS)}
+
+    results = {}
+    for sym in (fsyms or DEFAULT_COINS):
+        results[sym] = parse_coin_data(raw, sym, tsyms)
+    return results
+
+
+def get_coin_data(symbol: str, tsyms: str = "USD") -> Optional[Dict[str, Union[float, int]]]:
+    """Fetch data for a single coin."""
+    sym = resolve_symbol(symbol)
+    if not sym:
+        return None
+
+    raw = fetch_all_coins([sym], tsyms)
+    if not raw:
+        return None
+
+    return parse_coin_data(raw, sym, tsyms)
+
+
+def get_coin_price(symbol: str, tsyms: str = "USD") -> Optional[float]:
+    """Get just the price for a specific coin."""
+    data = get_coin_data(symbol, tsyms)
+    return data['price_usd'] if data else None
+
+
+def resolve_symbol(symbol_or_name: str) -> Optional[str]:
+    """Resolve common symbol or name to standard symbol."""
+    upper = symbol_or_name.upper()
+    if upper in COIN_NAMES:
+        return upper
+    return SYMBOL_ALIASES.get(symbol_or_name.lower())
+
+
+def format_price(price: float) -> str:
+    """Format price with commas and appropriate decimals."""
+    if price >= 1000:
+        return f"${price:,.2f}"
+    elif price >= 1:
+        return f"${price:,.4f}"
+    else:
+        return f"${price:,.6f}"
+
+
+def format_market_cap(market_cap: float) -> str:
+    """Format market cap in trillions/billions/millions."""
+    if market_cap >= 1e12:
+        return f"${market_cap/1e12:.2f}T"
+    elif market_cap >= 1e9:
+        return f"${market_cap/1e9:.2f}B"
+    elif market_cap >= 1e6:
+        return f"${market_cap/1e6:.2f}M"
+    else:
+        return f"${market_cap:,.0f}"
+
+
+def format_volume(volume: float) -> str:
+    """Format volume in billions/millions."""
+    if volume >= 1e9:
+        return f"${volume/1e9:.2f}B"
+    elif volume >= 1e6:
+        return f"${volume/1e6:.2f}M"
+    else:
+        return f"${volume:,.0f}"
+
+
+def print_coin(data: Dict) -> None:
+    """Print formatted coin data."""
+    if not data:
+        return
+    name = data.get('name', data['symbol'])
+    print(f"\n{name} ({data['symbol']})")
+    print(f"  Price: {format_price(data['price_usd'])}")
+    print(f"  24h Change: {data['change_24h']:+.2f}%")
+    print(f"  Market Cap: {format_market_cap(data['market_cap'])}")
+    print(f"  24h Volume: {format_volume(data['volume_24h'])}")
+    print(f"  24h High: {format_price(data['high_24h'])}")
+    print(f"  24h Low: {format_price(data['low_24h'])}")
+
+
+# Backwards compatibility aliases
+get_btc_data = lambda tsyms="USD": get_coin_data('BTC', tsyms)
+get_btc_price = lambda tsyms="USD": get_coin_price('BTC', tsyms)
+
+
+if __name__ == "__main__":
+    import sys
+
+    # Check for command line arguments
+    if len(sys.argv) > 1:
+        # Parse requested coins
+        requested = []
+        for arg in sys.argv[1:]:
+            sym = resolve_symbol(arg)
+            if sym:
+                requested.append(sym)
+            else:
+                print(f"Unknown coin: {arg}")
+        coins_to_fetch = requested if requested else DEFAULT_COINS
+    else:
+        coins_to_fetch = DEFAULT_COINS
+
+    # Fetch and display
+    print("Cryptocurrency Prices (USD)")
+    print("=" * 40)
+
+    results = get_all_coins(coins_to_fetch)
+    for sym in coins_to_fetch:
+        data = results.get(sym)
+        if data:
+            print_coin(data)
+        else:
+            print(f"\nFailed to fetch {sym}")

package/src/index.ts

@@ -0,0 +1,51 @@
+import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
+import { execFile } from "node:child_process";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const SCRIPT_PATH = join(__dirname, "get_price.py");
+
+function runPriceScript(args: string[]): Promise<string> {
+  return new Promise((resolve, reject) => {
+    execFile("python3", [SCRIPT_PATH, ...args], { timeout: 15_000 }, (err, stdout, stderr) => {
+      if (err) {
+        reject(new Error(stderr?.trim() || err.message));
+        return;
+      }
+      resolve(stdout.trim());
+    });
+  });
+}
+
+const plugin = {
+  id: "openclaw-crypto-price",
+  name: "OpenClaw Crypto Price",
+  description: "Live cryptocurrency prices via /price command",
+  register(api: OpenClawPluginApi) {
+    const cfg = api.pluginConfig as Record<string, unknown> | undefined;
+    const defaultCoins = (cfg?.coins as string[]) ?? [];
+
+    api.registerCommand({
+      name: "price",
+      description: "Fetch live cryptocurrency prices (BTC, PAXG, XMR, ZANO)",
+      acceptsArgs: true,
+      requireAuth: false,
+      handler: async (ctx) => {
+        const userArgs = ctx.args?.trim() ?? "";
+        const args = userArgs.length > 0
+          ? userArgs.split(/\s+/)
+          : defaultCoins;
+
+        try {
+          const output = await runPriceScript(args);
+          return { text: output || "No data returned." };
+        } catch (err) {
+          return { text: `Error fetching prices: ${String(err)}` };
+        }
+      },
+    });
+  },
+};
+
+export default plugin;