Aicoin Freqtrade

"""AiCoin Data SDK for Freqtrade Strategies (AiCoin Open API v3)
================================================================
Import this in your Freqtrade strategy to pull AiCoin's aggregated market data
from 200+ exchanges:

    from aicoin_data import AiCoinData

    ac = AiCoinData()                              # auto-loads API key from .env
    signal  = ac.whale_signal('BTC/USDT:USDT', 'binance')   # -1..+1
    ls      = ac.ls_ratio_norm()                            # 0..1
    funding = ac.funding_rate_pct('BTC/USDT:USDT', 'binance')  # percent
    bias    = ac.liq_bias('BTC/USDT:USDT', 'binance')          # -1..+1

The high-level helpers above return plain numbers ready to drop into a strategy.
For raw responses use ac.get('<endpoint>', {...}) — see catalog at
https://open.aicoin.com/api/v3/_catalog.

Built-in 5-min cache avoids hammering the API in live mode. In backtest mode
AiCoin real-time data is not available — strategies should fall back to standard
indicators (the helpers raise, strategies catch and use defaults).

Some endpoints need a paid AiCoin subscription — see https://www.aicoin.com/opendata.
"""
import hmac
import hashlib
import base64
import json
import os
import time
import random
import logging
from pathlib import Path
from urllib.request import urlopen, Request
from urllib.error import HTTPError
from urllib.parse import urlencode

logger = logging.getLogger(__name__)

# Freqtrade/CCXT exchange name -> AiCoin market slug (v3 normalizes okx internally).
EXCHANGE_MAP = {
    'binance': 'binance', 'okx': 'okx', 'bybit': 'bybit', 'bitget': 'bitget',
    'gate': 'gate', 'gateio': 'gate', 'htx': 'huobipro', 'huobi': 'huobipro',
    'kucoin': 'kucoin',
}

# Common base ticker -> AiCoin coin_key slug. Anything else is resolved live
# via /coins/search and cached.
COIN_KEY_MAP = {
    'btc': 'bitcoin', 'eth': 'ethereum', 'sol': 'solana', 'xrp': 'ripple',
    'doge': 'dogecoin', 'bnb': 'binancecoin', 'ada': 'cardano', 'ltc': 'litecoin',
    'link': 'chainlink', 'dot': 'polkadot', 'trx': 'tron', 'avax': 'avalanche',
    'sui': 'sui', 'apt': 'aptos', 'ton': 'toncoin', 'near': 'near',
    'op': 'optimism', 'arb': 'arbitrum', 'uni': 'uniswap', 'aave': 'aave',
    'pepe': 'pepe', 'hype': 'hyperliquid', 'wld': 'worldcoin',
}


class AiCoinError(Exception):
    """Raised when the AiCoin API returns an error or is unreachable."""


def ccxt_to_v3(pair: str, exchange: str = 'binance') -> dict:
    """CCXT pair + exchange -> partial v3 identity {market, contract_type, base}.

    'BTC/USDT:USDT' -> {'market': 'binance', 'contract_type': 'perpetual', 'base': 'btc'}
    'BTC/USDT'      -> {'market': 'binance', 'contract_type': 'spot',      'base': 'btc'}

    The coin_key still needs resolving — use AiCoinData._pair() which does both.
    """
    return {
        'market': EXCHANGE_MAP.get(exchange.lower(), exchange.lower()),
        'contract_type': 'perpetual' if ':' in pair else 'spot',
        'base': pair.split('/')[0].lower(),
    }


class AiCoinData:
    """AiCoin Open API v3 client for use inside Freqtrade strategies.

    - HMAC-SHA1 signed requests, 4 X-Aic-* headers (v3 auth).
    - Auto-loads the API key from .env files.
    - Built-in TTL cache (default 5 min) to avoid hammering the API.
    """

    _cache: dict = {}  # shared across instances

    def __init__(self, cache_ttl: int = 300):
        self.cache_ttl = cache_ttl
        self._load_env()
        self._setup_proxy()
        defaults = self._load_defaults()
        self.base = os.environ.get('AICOIN_BASE_URL', 'https://open.aicoin.com')
        self.key = os.environ.get('AICOIN_ACCESS_KEY_ID', defaults.get('accessKeyId', ''))
        self.secret = os.environ.get('AICOIN_ACCESS_SECRET', defaults.get('accessSecret', ''))

    # ── Setup helpers ──

    @staticmethod
    def _load_env():
        for f in (Path('/workspace/.env'),                        # 容器(Hermes/CC entrypoint 注入)
                  Path.home() / '.coinos' / '.env',               # 规范位置(coinos 文件夹), 与 JS loader 对齐
                  Path.cwd() / '.env',
                  Path.home() / '.openclaw' / 'workspace' / '.env',
                  Path.home() / '.openclaw' / '.env'):
            if not f.exists():
                continue
            try:
                for line in f.read_text().splitlines():
                    line = line.strip()
                    if not line or line.startswith('#'):
                        continue
                    eq = line.find('=')
                    if eq < 1:
                        continue
                    k, v = line[:eq].strip(), line[eq + 1:].strip()
                    if len(v) >= 2 and v[0] in ('"', "'") and v[-1] == v[0]:
                        v = v[1:-1]
                    os.environ.setdefault(k, v)
            except Exception:
                pass

    @staticmethod
    def _setup_proxy():
        proxy = (os.environ.get('PROXY_URL') or os.environ.get('HTTPS_PROXY')
                 or os.environ.get('https_proxy') or os.environ.get('HTTP_PROXY')
                 or os.environ.get('http_proxy'))
        if proxy and not proxy.startswith('socks'):
            os.environ.setdefault('HTTPS_PROXY', proxy)
            os.environ.setdefault('HTTP_PROXY', proxy)

    @staticmethod
    def _load_defaults() -> dict:
        p = Path(__file__).parent / 'defaults.json'
        try:
            return json.loads(p.read_text()) if p.exists() else {}
        except Exception:
            return {}

    # ── Auth + HTTP ──

    def _auth_headers(self) -> dict:
        nonce = '%016x' % random.getrandbits(64)
        ts = str(int(time.time()))
        s = f'AccessKeyId={self.key}&SignatureNonce={nonce}&Timestamp={ts}'
        h = hmac.new(self.secret.encode(), s.encode(), hashlib.sha1).hexdigest()
        return {
            'X-Aic-AccessKey-Id': self.key,
            'X-Aic-Signature-Nonce': nonce,
            'X-Aic-Timestamp': ts,
            'X-Aic-Signature': base64.b64encode(h.encode()).decode(),
            'User-Agent': 'AiCoin-Freqtrade/2.0',
        }

    def _call(self, method: str, path: str, params: dict = None):
        """Sign and send a v3 request. Returns the envelope's `data`, or raises."""
        full = '/api/v3/' + path.strip('/').replace('api/v3/', '', 1)
        headers = self._auth_headers()
        if method == 'GET':
            clean = {k: (','.join(map(str, v)) if isinstance(v, (list, tuple)) else v)
                     for k, v in (params or {}).items() if v not in (None, '')}
            qs = urlencode(clean)
            req = Request(self.base + full + (('?' + qs) if qs else ''), headers=headers)
        else:
            headers['Content-Type'] = 'application/json'
            req = Request(self.base + full, data=json.dumps(params or {}).encode(),
                          headers=headers, method='POST')
        try:
            with urlopen(req, timeout=30) as resp:
                body = json.loads(resp.read())
        except HTTPError as e:
            try:
                body = json.loads(e.read())
            except Exception:
                body = {}
            err = body.get('error') if isinstance(body.get('error'), dict) else {}
            raise AiCoinError(f"HTTP {e.code}: {err.get('message') or body.get('error') or e.reason}")
        except Exception as e:
            raise AiCoinError(str(e))
        if body.get('ok') is False:
            err = body.get('error') or {}
            raise AiCoinError(err.get('message') or err.get('code') or 'request failed')
        return body.get('data')

    def get(self, path: str, params: dict = None, cache_key: str = None):
        """GET any v3 endpoint. `path` is the bit after /api/v3/ (e.g. 'market/klines')."""
        if cache_key and self.cache_ttl > 0 and cache_key in self._cache:
            ts, data = self._cache[cache_key]
            if time.time() - ts < self.cache_ttl:
                return data
        data = self._call('GET', path, params)
        if cache_key and self.cache_ttl > 0:
            self._cache[cache_key] = (time.time(), data)
        return data

    def post(self, path: str, body: dict = None):
        """POST any v3 endpoint."""
        return self._call('POST', path, body)

    # ── Pair identity ──

    def _resolve_coin_key(self, ticker: str) -> str:
        t = ticker.lower()
        if t in COIN_KEY_MAP:
            return COIN_KEY_MAP[t]
        ck = self._cache.get(f'ck:{t}')
        if ck:
            return ck[1]
        try:
            data = self.get('coins/search', {'query': ticker, 'limit': 5})
            items = (data or {}).get('list') or (data or {}).get('items') or []
            for it in items:
                cand = it.get('coin_key') or it.get('coinKey') or it.get('key')
                if cand:
                    self._cache[f'ck:{t}'] = (time.time(), cand)
                    return cand
        except Exception:
            pass
        return t  # last resort

    def _pair(self, pair: str, exchange: str = 'binance') -> dict:
        """CCXT pair + exchange -> v3 query dict {coin_key, market, contract_type}."""
        v = ccxt_to_v3(pair, exchange)
        return {'coin_key': self._resolve_coin_key(v['base']),
                'market': v['market'], 'contract_type': v['contract_type']}

    # ── Raw data (return the v3 `data` payload) ──

    def coin_ticker(self, coin_keys: str):
        """Real-time prices. coin_keys: 'bitcoin' or 'bitcoin,ethereum'."""
        return self.get('coins/tickers', {'coin_key': coin_keys}, f'ticker:{coin_keys}')

    def klines(self, pair: str, exchange: str = 'binance', interval: str = '1h', limit: int = 100):
        """K-line data for a CCXT pair."""
        q = {**self._pair(pair, exchange), 'interval': interval, 'limit': limit}
        return self.get('market/klines', q, f'kline:{pair}:{interval}:{limit}')

    def funding_rate(self, pair: str, exchange: str = 'binance', limit: int = 20):
        """Funding-rate history (newest first). data.funding_rates[].close is the rate."""
        q = {**self._pair(pair, exchange), 'contract_type': 'perpetual', 'limit': limit}
        return self.get('derivatives/funding-rates', q, f'funding:{pair}:{limit}')

    def long_short_ratio(self):
        """Cross-exchange aggregated long/short ratio summary."""
        return self.get('derivatives/long-short-ratio/summary', cache_key='ls_ratio')

    def big_orders(self, pair: str, exchange: str = 'binance'):
        """Whale resting orders (order-book big bids/asks)."""
        q = self._pair(pair, exchange)
        return self.get('market/big-orders', q, f'big_orders:{pair}')

    def liquidation_map(self, pair: str, exchange: str = 'binance', window: str = '24h'):
        """Liquidation heatmap bucketed by leverage."""
        q = {**self._pair(pair, exchange), 'window': window}
        return self.get('derivatives/liquidations/map', q, f'liqmap:{pair}:{window}')

    def hl_whale_positions(self, coin: str = None):
        """Hyperliquid whale open positions. coin is the HL symbol, e.g. 'BTC'."""
        return self.get('hyperliquid/whales/open-positions',
                        {'coin': coin} if coin else {}, f'hl_whale:{coin}')

    def hl_taker_delta(self, coin: str, interval: str = '1h'):
        """Hyperliquid accumulated taker buy/sell delta."""
        return self.get('hyperliquid/accumulated-taker-delta',
                        {'coin': coin, 'interval': interval}, f'hl_taker:{coin}:{interval}')

    # ── High-level signals (plain numbers, ready for a strategy) ──

    def whale_signal(self, pair: str, exchange: str = 'binance') -> float:
        """Whale order-book pressure as -1 (selling/asks) .. +1 (buying/bids)."""
        data = self.big_orders(pair, exchange)
        items = (data or {}).get('items') or []
        buy = sum(float(o.get('high_turnover', 0) or 0) for o in items if o.get('depth_type') == 'bid')
        sell = sum(float(o.get('high_turnover', 0) or 0) for o in items if o.get('depth_type') == 'ask')
        total = buy + sell
        return (buy - sell) / total if total > 0 else 0.0

    def ls_ratio_norm(self) -> float:
        """Long/short ratio normalized to 0..1 ( >0.5 = more longs )."""
        data = self.long_short_ratio()
        detail = (((data or {}).get('summary') or {}).get('detail')) or {}
        ratio = float(detail.get('last', 1.0) or 1.0)
        return max(0.0, min(1.0, ratio / (1.0 + ratio)))

    def funding_rate_pct(self, pair: str, exchange: str = 'binance') -> float:
        """Latest funding rate as a percentage (e.g. 0.01 = 0.01%)."""
        data = self.funding_rate(pair, exchange, limit=5)
        rows = (data or {}).get('funding_rates') or []
        if not rows:
            raise AiCoinError('no funding-rate data')
        # v3 时序是升序(oldest-first,与 K 线一致),rows[0] 是窗口内**最旧**的一条。
        # 别假设顺序 —— 按时间字段取最大那条作为"最新";取不到时间字段才退回 rows[-1](升序末尾)。
        def _ts(r):
            for k in ('close_time', 'time', 'timestamp', 'ts', 'create_time', 'fundingTime'):
                v = r.get(k)
                if v is not None:
                    try:
                        return float(v)
                    except (TypeError, ValueError):
                        pass
            return None
        latest = max(rows, key=lambda r: (_ts(r) if _ts(r) is not None else float('-inf'))) \
            if any(_ts(r) is not None for r in rows) else rows[-1]
        return float(latest.get('close', 0) or 0) * 100

    def oi_trend(self, pair: str, exchange: str = 'binance'):
        """(is_rising, change_pct) for aggregated open interest.

        NOTE: v3's aggregated OI history is not wired yet (returns 501). This
        raises until the data source is connected — strategies should fall back.
        """
        q = {**self._pair(pair, exchange), 'interval': '15m', 'limit': 10}
        data = self.get('derivatives/open-interest/stablecoin-margin', q)
        rows = data if isinstance(data, list) else (data or {}).get('list') or []
        if len(rows) < 2:
            raise AiCoinError('no open-interest data')
        first = float(rows[0].get('open_interest', rows[0].get('value', 0)) or 0)
        last = float(rows[-1].get('open_interest', rows[-1].get('value', 0)) or 0)
        change = (last - first) / first * 100 if first > 0 else 0.0
        return (change > 3.0, change)

    def liq_bias(self, pair: str, exchange: str = 'binance') -> float:
        """Liquidation-map directional bias: -1 (long liqs dominate) .. +1 (short liqs dominate)."""
        data = self.liquidation_map(pair, exchange)
        data_map = (((data or {}).get('map') or {}).get('data_map')) or {}
        long_total = short_total = 0.0
        for bucket in data_map.values():
            long_total += sum(float(r[2]) for r in bucket.get('long', []) if len(r) >= 3)
            short_total += sum(float(r[2]) for r in bucket.get('short', []) if len(r) >= 3)
        total = long_total + short_total
        return (short_total - long_total) / total if total > 0 else 0.0

    # ── Cache ──

    def clear_cache(self):
        self._cache.clear()

    def set_cache_ttl(self, seconds: int):
        self.cache_ttl = seconds

// CoinClaw 三引擎(OpenClaw / Hermes / Claude Code)自动识别 helper.
//
// CoinClaw 把 freqtrade 起为 supervisord 管理的常驻 daemon, 端口 8080,
// Basic auth 用户名 'freqtrade', 密码写在容器内的 .ft_api_pass 文件.
// 三引擎的 workspace / userdir / strategy-path / config.json / .env 都
// 在不同位置, 但本 helper 屏蔽差异 — skill 脚本只关心 coinclawEnv() 返回值.
//
// 不在 CoinClaw 容器里运行(用户本地 macOS / Linux)时, coinclawEnv() 返回
// null, ft-deploy.mjs 会走 host 模式 (自己 git clone freqtrade + setup.sh).
import { existsSync, readFileSync } from 'node:fs';
import { resolve } from 'node:path';

// 三引擎的真实 daemon 路径(--strategy-path / --userdir / --config 等都来自
// image-*/freqtrade-launch.sh 或 image/freqtrade-wait.sh 的 exec 行).
const ENGINES = [
  {
    engine: 'hermes',
    workspaceRoot: '/workspace',
    skillsRoot: '/workspace/.hermes/skills',
    freqtradeUserdir: '/workspace/freqtrade',
    strategyPath: '/workspace/strategies',
    configPath: '/workspace/freqtrade/config.json',
    envFile: '/workspace/.env',
    ftPassFile: '/workspace/.ft_api_pass',
    sentinelFile: '/workspace/.hermes',
  },
  {
    engine: 'claude-code',
    workspaceRoot: '/workspace',
    skillsRoot: '/workspace/.claude/skills',
    freqtradeUserdir: '/workspace/freqtrade',
    strategyPath: '/workspace/strategies',
    configPath: '/workspace/freqtrade/config.json',
    envFile: '/workspace/.env',
    ftPassFile: '/workspace/.ft_api_pass',
    sentinelFile: '/workspace/.claude',
  },
  {
    engine: 'openclaw',
    workspaceRoot: '/home/node/.openclaw/workspace',
    skillsRoot: '/home/node/.openclaw/workspace/skills',
    freqtradeUserdir: '/home/node/.openclaw/workspace/freqtrade',
    strategyPath: '/home/node/.openclaw/workspace/strategies',
    configPath: '/home/node/.openclaw/workspace/freqtrade/config.json',
    envFile: '/home/node/.openclaw/workspace/.env',
    ftPassFile: '/home/node/.openclaw/workspace/.ft_api_pass',
    sentinelFile: '/home/node/.openclaw',
  },
];

let _cached;

export function coinclawEnv() {
  if (_cached !== undefined) return _cached;
  // Hermes 和 CC 共用 /workspace, 但 sentinelFile 区分: .hermes vs .claude.
  // 顺序很重要: 先匹配 .hermes (Hermes 启动时一定有 /workspace/.hermes/),
  // 再匹配 .claude (CC), 最后兜底到 OpenClaw.
  for (const env of ENGINES) {
    if (existsSync(env.sentinelFile) && existsSync(env.configPath)) {
      _cached = { ...env, ftApiUser: 'freqtrade', ftApiUrl: 'http://127.0.0.1:8080' };
      return _cached;
    }
  }
  // Hermes/CC 把 /workspace/.openclaw/workspace/.env 软链到 /workspace/.env,
  // 但 sentinel 是 .hermes/.claude 而不是 .openclaw — 不会误识别成 OpenClaw.
  _cached = null;
  return null;
}

// 读 ft_api_pass 文件. 三引擎的 entrypoint.sh 都在第一次启动写一次,
// PVC 持久化, 之后只读不写. 文件不存在 / 读失败都返回 null, 让 caller
// 退到 .env 里的 FREQTRADE_PASSWORD (或 host 模式生成的随机密码).
export function readFtApiPass(env = coinclawEnv()) {
  if (!env || !existsSync(env.ftPassFile)) return null;
  try {
    return readFileSync(env.ftPassFile, 'utf-8').trim() || null;
  } catch {
    return null;
  }
}

// 用户在 chat 里填的交易所 / AiCoin / DRY_RUN 等都写到 .env,
// 三引擎共用. Host 模式下回退到 cwd / ~/.openclaw/workspace/.env.
export function envFileCandidates() {
  const env = coinclawEnv();
  if (env) return [env.envFile];
  return [
    resolve(process.env.HOME || '', '.coinos', '.env'),   // 规范位置(coinos 文件夹)
    resolve(process.cwd(), '.env'),
    resolve(process.env.HOME || '', '.openclaw', 'workspace', '.env'),
    resolve(process.env.HOME || '', '.openclaw', '.env'),
    resolve(process.env.HOME || '', '.hermes', '.env'),
  ];
}

// 给 host 模式用. 在 CoinClaw 容器外, ft-deploy.mjs 自己 clone freqtrade
// 到 ~/.freqtrade, 写策略到 ~/.freqtrade/user_data/strategies — 老路径,
// 不动. 只在 coinclawEnv() === null 时调用.
export function hostModeFreqtradePaths() {
  const home = process.env.HOME || '';
  const ftDir = resolve(home, '.freqtrade');
  const userData = resolve(ftDir, 'user_data');
  return {
    ftDir,
    sourceDir: resolve(ftDir, 'source'),
    venvDir: resolve(ftDir, 'source', '.venv'),
    userdir: userData,
    strategyPath: resolve(userData, 'strategies'),
    configPath: resolve(userData, 'config.json'),
    pidFile: resolve(ftDir, 'freqtrade.pid'),
    logFile: resolve(ftDir, 'freqtrade.log'),
    ftBin: resolve(ftDir, 'source', '.venv', 'bin', 'freqtrade'),
  };
}

// 判断是否能 supervisorctl(只有在 coinclaw 容器里有). 用于 ft.mjs 的
// restart_daemon action — supervisorctl 走 unix socket, 路径见
// image-*/supervisord.conf. 三引擎的 socket 位置略不同, 这里用 socket
// 实际路径而不是 supervisorctl 的默认 search.
export function supervisorSocket() {
  const env = coinclawEnv();
  if (!env) return null;
  if (env.engine === 'openclaw') return '/tmp/supervisor.sock';
  // Hermes/CC: file=/workspace/supervisor.sock
  return '/workspace/supervisor.sock';
}

// 仅供测试: 强制清缓存. 生产代码不要调用.
export function _resetCacheForTesting() {
  _cached = undefined;
}

{
  "comment": "Public free-tier AiCoin API key. IP rate-limited. Users can replace with their own key via env vars.",
  "accessKeyId": "ronJ8uI0Yj2soAfGVs5H1YALUIINbE22",
  "accessSecret": "CWHZcH2us1CLSE7grroR1TpS0Z1JxTwU"
}

#!/usr/bin/env node
// Freqtrade REST API client — shared helper.
//
// 在 CoinClaw 三引擎(OpenClaw / Hermes / Claude Code)容器里,
// freqtrade 是 supervisord 管的常驻 daemon 跑在 :8080, Basic auth
// 用户名 'freqtrade', 密码写在容器内的 .ft_api_pass 文件 (PVC 持久化).
// 这个 helper 自动从那里读 — agent / skill 不需要在 .env 里再配
// FREQTRADE_USERNAME / FREQTRADE_PASSWORD. 用户也可以通过 .env 覆盖.
//
// 在容器外(用户本地 macOS / Linux), 退到 .env 里读 — 走老的 host 模式,
// ft-deploy.mjs deploy 时把 FREQTRADE_PASSWORD 写到 .env.
import { readFileSync, existsSync } from 'node:fs';
import { coinclawEnv, readFtApiPass, envFileCandidates } from './coinclaw-env.mjs';

// Auto-load .env files (CoinClaw 容器优先 /workspace/.env 或 OpenClaw 的等价路径).
function loadEnv() {
  for (const file of envFileCandidates()) {
    if (!existsSync(file)) continue;
    try {
      for (const line of readFileSync(file, 'utf-8').split('\n')) {
        const t = line.trim();
        if (!t || t.startsWith('#')) continue;
        const eq = t.indexOf('=');
        if (eq < 1) continue;
        const key = t.slice(0, eq).trim();
        let val = t.slice(eq + 1).trim();
        if ((val.startsWith('"') && val.endsWith('"')) || (val.startsWith("'") && val.endsWith("'"))) val = val.slice(1, -1);
        if (!process.env[key]) process.env[key] = val;
      }
    } catch {}
  }
}
loadEnv();

const env = coinclawEnv();

// 优先级有两条路径:
//   - CoinClaw 容器内 (env 非空): 信 daemon 真实密码 (.ft_api_pass 文件
//     + 容器 entrypoint 注入的 FT_API_USER), 完全忽略 .env 里的
//     FREQTRADE_USERNAME/PASSWORD. 后者可能是早期 ft-deploy.mjs deploy
//     流程 appendEnv 写的过时值, daemon 重启后密码会变, .env 没跟新 →
//     401. 端到端测试在 OpenClaw pod 重现过这个 bug.
//   - host 模式 (env=null): 信用户的 .env 配置, 因为本地 freqtrade 不是
//     supervisord 管的, 没有 .ft_api_pass 文件这个权威来源.
let BASE, USER, PASS;
if (env) {
  BASE = env.ftApiUrl;
  USER = env.ftApiUser;
  PASS = readFtApiPass(env) || '';
} else {
  BASE = process.env.FREQTRADE_URL || 'http://localhost:8080';
  USER = process.env.FREQTRADE_USERNAME || 'freqtrade';
  PASS = process.env.FREQTRADE_PASSWORD || '';
}

const auth = 'Basic ' + Buffer.from(`${USER}:${PASS}`).toString('base64');

export async function ftGet(path, params = {}) {
  const url = new URL(`/api/v1/${path}`, BASE);
  for (const [k, v] of Object.entries(params)) {
    if (v != null) url.searchParams.set(k, String(v));
  }
  const res = await fetch(url, { headers: { Authorization: auth }, signal: AbortSignal.timeout(30000) });
  if (!res.ok) throw new Error(`Freqtrade ${res.status}: ${await res.text()}`);
  return res.json();
}

export async function ftPost(path, body = {}) {
  const res = await fetch(new URL(`/api/v1/${path}`, BASE), {
    method: 'POST',
    headers: { Authorization: auth, 'Content-Type': 'application/json' },
    body: JSON.stringify(body),
    signal: AbortSignal.timeout(30000),
  });
  if (!res.ok) throw new Error(`Freqtrade ${res.status}: ${await res.text()}`);
  return res.json();
}

export async function ftDelete(path) {
  const res = await fetch(new URL(`/api/v1/${path}`, BASE), {
    method: 'DELETE',
    headers: { Authorization: auth },
    signal: AbortSignal.timeout(30000),
  });
  if (!res.ok) throw new Error(`Freqtrade ${res.status}: ${await res.text()}`);
  return res.json();
}

// CLI helper
export function ftCli(handlers) {
  const [action, ...rest] = process.argv.slice(2);
  if (!action || !handlers[action]) {
    console.log(`Usage: node <script> <action> [json-params]\nActions: ${Object.keys(handlers).join(', ')}`);
    process.exit(1);
  }
  let params = {};
  if (rest.length) {
    try {
      params = JSON.parse(rest.join(' '));
    } catch {
      console.log(JSON.stringify({ error: '参数不是合法 JSON: ' + rest.join(' '), hint: "参数要用 JSON 对象, 例: '{\"strategy\":\"MyStrat\"}'" }));
      process.exit(1);
    }
  }
  handlers[action](params).then(r => console.log(JSON.stringify(r, null, 2))).catch(e => {
    console.error(e.message); process.exit(1);
  });
}

// Strategy code generator (从 ft-deploy.mjs 抽出来, 单一职责).
//
// 用 indicators[] + aicoin_data[] + 可选的 entry_logic / exit_logic 拼出
// 一份 freqtrade IStrategy 子类 .py 文件文本. 选 indicator 就生成对应的
// pandas 计算块, 选 aicoin_data 就生成 _update_aicoin_data + 在 entry 加
// 对应的过滤条件.
//
// 为什么不用 freqtrade-templates: 这里的目标是给 agent / 用户低门槛快速
// 生成可跑的策略, 不希望 agent 还要 mkdir / cp template / search-replace.
// 内置生成器一次产出完整文件.

export const AVAILABLE_INDICATORS = [
  'rsi', 'bb', 'bollinger', 'ema', 'sma', 'macd',
  'stochastic', 'kdj', 'atr', 'adx', 'cci',
  'williams_r', 'willr', 'vwap', 'ichimoku',
  'volume_sma', 'volume', 'obv',
];

export const AVAILABLE_AICOIN_DATA = [
  'funding_rate (付费套餐)',
  'ls_ratio (付费套餐)',
  'big_orders (付费套餐)',
  'open_interest (v3 聚合 OI 历史暂未接通，会自动降级)',
  'liquidation_map (付费套餐)',
];

export const PAID_DATA = {
  funding_rate: '付费套餐',
  ls_ratio: '付费套餐',
  big_orders: '付费套餐',
  open_interest: '付费套餐（注意 v3 聚合 OI 历史暂未接通）',
  liquidation_map: '付费套餐',
};

export function buildStrategyCode(name, tf, desc, ds, indicators, entryLogic, exitLogic, direction = 'long') {
  const L = [];  // lines
  const has = (k) => ds.has(k);
  const any = ds.size > 0;

  const defaultIndicators = ['rsi', 'bb', 'ema', 'volume_sma'];
  const allIndicators = new Set(indicators && indicators.length ? indicators.map((i) => i.toLowerCase()) : defaultIndicators);
  const hasInd = (k) => allIndicators.has(k);

  L.push(`# ${name} - ${desc}`);
  if (any) L.push(`# AiCoin data: ${[...ds].join(', ')} (live/dry_run only)`);
  L.push(`# Indicators: ${[...allIndicators].join(', ')}`);
  L.push(`# Backtest: uses technical indicators only`);
  L.push(`#`);
  L.push(`from freqtrade.strategy import IStrategy, IntParameter, DecimalParameter`);
  L.push(`from pandas import DataFrame`);
  L.push(`import logging`);
  L.push(``);
  L.push(`logger = logging.getLogger(__name__)`);
  L.push(``);
  L.push(``);
  L.push(`class ${name}(IStrategy):`);
  L.push(`    INTERFACE_VERSION = 3`);
  L.push(`    timeframe = '${tf}'`);
  const canShort = direction === 'both' || direction === 'short';
  L.push(`    can_short = ${canShort ? 'True' : 'False'}`);
  L.push(``);
  L.push(`    minimal_roi = {"0": 0.05, "60": 0.03, "120": 0.01}`);
  L.push(`    stoploss = -0.05`);
  L.push(`    trailing_stop = True`);
  L.push(`    trailing_stop_positive = 0.02`);
  L.push(`    trailing_stop_positive_offset = 0.03`);
  L.push(``);
  L.push(`    # Hyperopt parameters`);
  if (hasInd('rsi')) {
    L.push(`    rsi_buy = IntParameter(20, 40, default=30, space='buy')`);
    L.push(`    rsi_sell = IntParameter(60, 80, default=70, space='sell')`);
  }
  if (hasInd('stochastic') || hasInd('kdj')) {
    L.push(`    stoch_buy = IntParameter(10, 30, default=20, space='buy')`);
    L.push(`    stoch_sell = IntParameter(70, 90, default=80, space='sell')`);
  }
  if (hasInd('cci')) {
    L.push(`    cci_buy = IntParameter(-200, -50, default=-100, space='buy')`);
    L.push(`    cci_sell = IntParameter(50, 200, default=100, space='sell')`);
  }
  if (hasInd('williams_r') || hasInd('willr')) {
    L.push(`    willr_buy = IntParameter(-90, -70, default=-80, space='buy')`);
    L.push(`    willr_sell = IntParameter(-30, -10, default=-20, space='sell')`);
  }
  if (has('funding_rate'))
    L.push(`    funding_threshold = DecimalParameter(0.005, 0.1, default=0.01, space='buy')`);
  L.push(``);

  if (any) {
    L.push(`    # AiCoin cached data (updated every 5 min in live mode)`);
    if (has('funding_rate'))     L.push(`    _ac_funding_rate = 0.0`);
    if (has('ls_ratio'))         L.push(`    _ac_ls_ratio = 0.5`);
    if (has('big_orders'))       L.push(`    _ac_whale_signal = 0.0`);
    if (has('open_interest'))    L.push(`    _ac_oi_rising = False`);
    if (has('liquidation_map'))  L.push(`    _ac_liq_bias = 0.0`);
    L.push(`    _ac_last_update = 0.0`);
    L.push(``);
  }

  L.push(`    def populate_indicators(self, dataframe: DataFrame, metadata: dict) -> DataFrame:`);

  if (hasInd('rsi')) {
    L.push(`        # RSI`);
    L.push(`        delta = dataframe['close'].diff()`);
    L.push(`        gain = delta.clip(lower=0).rolling(window=14).mean()`);
    L.push(`        loss = (-delta.clip(upper=0)).rolling(window=14).mean()`);
    L.push(`        rs = gain / loss`);
    L.push(`        dataframe['rsi'] = 100 - (100 / (1 + rs))`);
    L.push(``);
  }
  if (hasInd('bb') || hasInd('bollinger')) {
    L.push(`        # Bollinger Bands`);
    L.push(`        dataframe['bb_mid'] = dataframe['close'].rolling(window=20).mean()`);
    L.push(`        bb_std = dataframe['close'].rolling(window=20).std()`);
    L.push(`        dataframe['bb_upper'] = dataframe['bb_mid'] + 2 * bb_std`);
    L.push(`        dataframe['bb_lower'] = dataframe['bb_mid'] - 2 * bb_std`);
    L.push(``);
  }
  if (hasInd('ema')) {
    L.push(`        # EMA`);
    L.push(`        dataframe['ema_fast'] = dataframe['close'].ewm(span=8, adjust=False).mean()`);
    L.push(`        dataframe['ema_slow'] = dataframe['close'].ewm(span=21, adjust=False).mean()`);
    L.push(``);
  }
  if (hasInd('sma')) {
    L.push(`        # SMA`);
    L.push(`        dataframe['sma_short'] = dataframe['close'].rolling(window=10).mean()`);
    L.push(`        dataframe['sma_long'] = dataframe['close'].rolling(window=50).mean()`);
    L.push(``);
  }
  if (hasInd('macd')) {
    L.push(`        # MACD`);
    L.push(`        ema12 = dataframe['close'].ewm(span=12, adjust=False).mean()`);
    L.push(`        ema26 = dataframe['close'].ewm(span=26, adjust=False).mean()`);
    L.push(`        dataframe['macd'] = ema12 - ema26`);
    L.push(`        dataframe['macd_signal'] = dataframe['macd'].ewm(span=9, adjust=False).mean()`);
    L.push(`        dataframe['macd_hist'] = dataframe['macd'] - dataframe['macd_signal']`);
    L.push(``);
  }
  if (hasInd('stochastic') || hasInd('kdj')) {
    L.push(`        # Stochastic (KDJ)`);
    L.push(`        low14 = dataframe['low'].rolling(window=14).min()`);
    L.push(`        high14 = dataframe['high'].rolling(window=14).max()`);
    L.push(`        dataframe['stoch_k'] = 100 * (dataframe['close'] - low14) / (high14 - low14)`);
    L.push(`        dataframe['stoch_d'] = dataframe['stoch_k'].rolling(window=3).mean()`);
    L.push(`        dataframe['stoch_j'] = 3 * dataframe['stoch_k'] - 2 * dataframe['stoch_d']`);
    L.push(``);
  }
  if (hasInd('atr')) {
    L.push(`        # ATR (Average True Range)`);
    L.push(`        high_low = dataframe['high'] - dataframe['low']`);
    L.push(`        high_close = (dataframe['high'] - dataframe['close'].shift()).abs()`);
    L.push(`        low_close = (dataframe['low'] - dataframe['close'].shift()).abs()`);
    L.push(`        tr = high_low.combine(high_close, max).combine(low_close, max)`);
    L.push(`        dataframe['atr'] = tr.rolling(window=14).mean()`);
    L.push(``);
  }
  if (hasInd('adx')) {
    L.push(`        # ADX (Average Directional Index)`);
    L.push(`        plus_dm = dataframe['high'].diff().clip(lower=0)`);
    L.push(`        minus_dm = (-dataframe['low'].diff()).clip(lower=0)`);
    L.push(`        _tr = (dataframe['high'] - dataframe['low']).combine((dataframe['high'] - dataframe['close'].shift()).abs(), max).combine((dataframe['low'] - dataframe['close'].shift()).abs(), max)`);
    L.push(`        atr14 = _tr.rolling(window=14).mean()`);
    L.push(`        plus_di = 100 * plus_dm.rolling(window=14).mean() / atr14`);
    L.push(`        minus_di = 100 * minus_dm.rolling(window=14).mean() / atr14`);
    L.push(`        dx = 100 * (plus_di - minus_di).abs() / (plus_di + minus_di)`);
    L.push(`        dataframe['adx'] = dx.rolling(window=14).mean()`);
    L.push(`        dataframe['plus_di'] = plus_di`);
    L.push(`        dataframe['minus_di'] = minus_di`);
    L.push(``);
  }
  if (hasInd('cci')) {
    L.push(`        # CCI (Commodity Channel Index)`);
    L.push(`        tp = (dataframe['high'] + dataframe['low'] + dataframe['close']) / 3`);
    L.push(`        tp_sma = tp.rolling(window=20).mean()`);
    L.push(`        tp_mad = tp.rolling(window=20).apply(lambda x: (x - x.mean()).abs().mean(), raw=True)`);
    L.push(`        dataframe['cci'] = (tp - tp_sma) / (0.015 * tp_mad)`);
    L.push(``);
  }
  if (hasInd('williams_r') || hasInd('willr')) {
    L.push(`        # Williams %R`);
    L.push(`        high14_w = dataframe['high'].rolling(window=14).max()`);
    L.push(`        low14_w = dataframe['low'].rolling(window=14).min()`);
    L.push(`        dataframe['willr'] = -100 * (high14_w - dataframe['close']) / (high14_w - low14_w)`);
    L.push(``);
  }
  if (hasInd('vwap')) {
    L.push(`        # VWAP (approximation using cumulative)`);
    L.push(`        tp_v = (dataframe['high'] + dataframe['low'] + dataframe['close']) / 3`);
    L.push(`        cum_tpv = (tp_v * dataframe['volume']).rolling(window=20).sum()`);
    L.push(`        cum_vol = dataframe['volume'].rolling(window=20).sum()`);
    L.push(`        dataframe['vwap'] = cum_tpv / cum_vol`);
    L.push(``);
  }
  if (hasInd('ichimoku')) {
    L.push(`        # Ichimoku Cloud`);
    L.push(`        nine_high = dataframe['high'].rolling(window=9).max()`);
    L.push(`        nine_low = dataframe['low'].rolling(window=9).min()`);
    L.push(`        dataframe['tenkan'] = (nine_high + nine_low) / 2`);
    L.push(`        twentysix_high = dataframe['high'].rolling(window=26).max()`);
    L.push(`        twentysix_low = dataframe['low'].rolling(window=26).min()`);
    L.push(`        dataframe['kijun'] = (twentysix_high + twentysix_low) / 2`);
    L.push(`        dataframe['senkou_a'] = ((dataframe['tenkan'] + dataframe['kijun']) / 2).shift(26)`);
    L.push(`        fiftytwo_high = dataframe['high'].rolling(window=52).max()`);
    L.push(`        fiftytwo_low = dataframe['low'].rolling(window=52).min()`);
    L.push(`        dataframe['senkou_b'] = ((fiftytwo_high + fiftytwo_low) / 2).shift(26)`);
    L.push(``);
  }
  if (hasInd('volume_sma') || hasInd('volume')) {
    L.push(`        # Volume SMA`);
    L.push(`        dataframe['vol_sma'] = dataframe['volume'].rolling(window=20).mean()`);
  }
  if (hasInd('obv')) {
    L.push(`        # OBV (On Balance Volume)`);
    L.push(`        import numpy as np`);
    L.push(`        obv_sign = np.where(dataframe['close'] > dataframe['close'].shift(), 1, np.where(dataframe['close'] < dataframe['close'].shift(), -1, 0))`);
    L.push(`        dataframe['obv'] = (obv_sign * dataframe['volume']).cumsum()`);
    L.push(`        dataframe['obv_sma'] = dataframe['obv'].rolling(window=20).mean()`);
    L.push(``);
  }

  if (any) {
    L.push(``);
    L.push(`        # AiCoin data columns (default values for backtest)`);
    if (has('funding_rate')) {
      L.push(`        dataframe['funding_rate'] = 0.0`);
      L.push(`        dataframe['funding_extreme'] = 0`);
    }
    if (has('ls_ratio'))         L.push(`        dataframe['ls_ratio'] = 0.5`);
    if (has('big_orders'))       L.push(`        dataframe['whale_signal'] = 0.0`);
    if (has('open_interest'))    L.push(`        dataframe['oi_rising'] = 0`);
    if (has('liquidation_map'))  L.push(`        dataframe['liq_bias'] = 0.0`);
    L.push(``);
    L.push(`        if self.dp and self.dp.runmode.value in ('live', 'dry_run'):`);
    L.push(`            import time`);
    L.push(`            now = time.time()`);
    L.push(`            if now - self._ac_last_update > 300:`);
    L.push(`                self._update_aicoin_data(metadata)`);
    L.push(`                self._ac_last_update = now`);
    L.push(``);
    if (has('funding_rate')) {
      L.push(`            dataframe.iloc[-1, dataframe.columns.get_loc('funding_rate')] = self._ac_funding_rate`);
      L.push(`            t = self.funding_threshold.value`);
      L.push(`            if self._ac_funding_rate > t:`);
      L.push(`                dataframe.iloc[-1, dataframe.columns.get_loc('funding_extreme')] = 1`);
      L.push(`            elif self._ac_funding_rate < -t:`);
      L.push(`                dataframe.iloc[-1, dataframe.columns.get_loc('funding_extreme')] = -1`);
    }
    if (has('ls_ratio'))
      L.push(`            dataframe.iloc[-1, dataframe.columns.get_loc('ls_ratio')] = self._ac_ls_ratio`);
    if (has('big_orders'))
      L.push(`            dataframe.iloc[-1, dataframe.columns.get_loc('whale_signal')] = self._ac_whale_signal`);
    if (has('open_interest'))
      L.push(`            dataframe.iloc[-1, dataframe.columns.get_loc('oi_rising')] = 1 if self._ac_oi_rising else 0`);
    if (has('liquidation_map'))
      L.push(`            dataframe.iloc[-1, dataframe.columns.get_loc('liq_bias')] = self._ac_liq_bias`);
  }

  L.push(``);
  L.push(`        return dataframe`);
  L.push(``);

  if (any) {
    L.push(`    def _update_aicoin_data(self, metadata: dict):`);
    L.push(`        try:`);
    L.push(`            import sys, os`);
    L.push(`            _sd = os.path.dirname(os.path.abspath(__file__))`);
    L.push(`            if _sd not in sys.path:`);
    L.push(`                sys.path.insert(0, _sd)`);
    L.push(`            from aicoin_data import AiCoinData`);
    L.push(`            ac = AiCoinData(cache_ttl=300)`);
    L.push(`            pair = metadata.get('pair', 'BTC/USDT:USDT')`);
    L.push(`            exchange = self.config.get('exchange', {}).get('name', 'binance')`);
    L.push(``);

    if (has('funding_rate')) {
      L.push(`            try:`);
      L.push(`                self._ac_funding_rate = ac.funding_rate_pct(pair, exchange)`);
      L.push(`                logger.info(f"AiCoin funding rate for {pair}: {self._ac_funding_rate:.4f}%")`);
      L.push(`            except Exception as e:`);
      L.push(`                logger.debug(f"AiCoin funding_rate unavailable: {e}")`);
      L.push(``);
    }
    if (has('ls_ratio')) {
      L.push(`            try:`);
      L.push(`                self._ac_ls_ratio = ac.ls_ratio_norm()`);
      L.push(`                logger.info(f"AiCoin L/S ratio: {self._ac_ls_ratio:.2f}")`);
      L.push(`            except Exception as e:`);
      L.push(`                logger.debug(f"AiCoin ls_ratio unavailable: {e}")`);
      L.push(``);
    }
    if (has('big_orders')) {
      L.push(`            try:`);
      L.push(`                self._ac_whale_signal = ac.whale_signal(pair, exchange)`);
      L.push(`                logger.info(f"AiCoin whale signal for {pair}: {self._ac_whale_signal:.2f}")`);
      L.push(`            except Exception as e:`);
      L.push(`                logger.debug(f"AiCoin big_orders unavailable: {e}")`);
      L.push(``);
    }
    if (has('open_interest')) {
      L.push(`            try:`);
      L.push(`                self._ac_oi_rising, _chg = ac.oi_trend(pair, exchange)`);
      L.push(`                logger.info(f"AiCoin OI rising={self._ac_oi_rising} change={_chg:.2f}%")`);
      L.push(`            except Exception as e:`);
      L.push(`                logger.debug(f"AiCoin OI unavailable: {e}")`);
      L.push(``);
    }
    if (has('liquidation_map')) {
      L.push(`            try:`);
      L.push(`                self._ac_liq_bias = ac.liq_bias(pair, exchange)`);
      L.push(`                logger.info(f"AiCoin liq bias for {pair}: {self._ac_liq_bias:.2f}")`);
      L.push(`            except Exception as e:`);
      L.push(`                logger.debug(f"AiCoin liquidation_map unavailable: {e}")`);
      L.push(``);
    }

    L.push(`        except ImportError:`);
    L.push(`            logger.warning("aicoin_data module not found. Run ft-deploy.mjs to install.")`);
    L.push(`        except Exception as e:`);
    L.push(`            logger.warning(f"AiCoin data error: {e}")`);
    L.push(``);
  }

  // populate_entry_trend
  const longC = [];
  const shortC = [];

  if (entryLogic && entryLogic.long) {
    longC.push(`(${entryLogic.long})`);
    shortC.push(`(${entryLogic.short || entryLogic.long})`);
  } else {
    if (hasInd('rsi')) {
      longC.push("(dataframe['rsi'] < self.rsi_buy.value)");
      shortC.push("(dataframe['rsi'] > self.rsi_sell.value)");
    }
    if (hasInd('ema')) {
      longC.push("(dataframe['ema_fast'] > dataframe['ema_slow'])");
      shortC.push("(dataframe['ema_fast'] < dataframe['ema_slow'])");
    }
    if (hasInd('sma')) {
      longC.push("(dataframe['sma_short'] > dataframe['sma_long'])");
      shortC.push("(dataframe['sma_short'] < dataframe['sma_long'])");
    }
    if (hasInd('macd')) {
      longC.push("(dataframe['macd'] > dataframe['macd_signal'])");
      shortC.push("(dataframe['macd'] < dataframe['macd_signal'])");
    }
    if (hasInd('stochastic') || hasInd('kdj')) {
      longC.push("(dataframe['stoch_k'] < self.stoch_buy.value)");
      shortC.push("(dataframe['stoch_k'] > self.stoch_sell.value)");
    }
    if (hasInd('bb') || hasInd('bollinger')) {
      longC.push("(dataframe['close'] < dataframe['bb_lower'])");
      shortC.push("(dataframe['close'] > dataframe['bb_upper'])");
    }
    if (hasInd('cci')) {
      longC.push("(dataframe['cci'] < self.cci_buy.value)");
      shortC.push("(dataframe['cci'] > self.cci_sell.value)");
    }
    if (hasInd('williams_r') || hasInd('willr')) {
      longC.push("(dataframe['willr'] < self.willr_buy.value)");
      shortC.push("(dataframe['willr'] > self.willr_sell.value)");
    }
    if (hasInd('adx')) {
      longC.push("(dataframe['adx'] > 20) & (dataframe['plus_di'] > dataframe['minus_di'])");
      shortC.push("(dataframe['adx'] > 20) & (dataframe['minus_di'] > dataframe['plus_di'])");
    }
    if (hasInd('ichimoku')) {
      longC.push("(dataframe['close'] > dataframe['senkou_a']) & (dataframe['close'] > dataframe['senkou_b'])");
      shortC.push("(dataframe['close'] < dataframe['senkou_a']) & (dataframe['close'] < dataframe['senkou_b'])");
    }
    if (hasInd('vwap')) {
      longC.push("(dataframe['close'] < dataframe['vwap'])");
      shortC.push("(dataframe['close'] > dataframe['vwap'])");
    }
    if (hasInd('obv')) {
      longC.push("(dataframe['obv'] > dataframe['obv_sma'])");
      shortC.push("(dataframe['obv'] < dataframe['obv_sma'])");
    }
    if (hasInd('volume_sma') || hasInd('volume')) {
      longC.push("(dataframe['volume'] > dataframe['vol_sma'] * 0.5)");
      shortC.push("(dataframe['volume'] > dataframe['vol_sma'] * 0.5)");
    }
    if (longC.length === 0) {
      longC.push("(dataframe['volume'] > 0)");
      shortC.push("(dataframe['volume'] > 0)");
    }
  }

  if (has('funding_rate'))     { longC.push("(dataframe['funding_extreme'] <= 0)");  shortC.push("(dataframe['funding_extreme'] >= 0)"); }
  if (has('ls_ratio'))         { longC.push("(dataframe['ls_ratio'] <= 0.55)");      shortC.push("(dataframe['ls_ratio'] >= 0.45)"); }
  if (has('big_orders'))       { longC.push("(dataframe['whale_signal'] >= -0.3)");  shortC.push("(dataframe['whale_signal'] <= 0.3)"); }
  if (has('liquidation_map'))  { longC.push("(dataframe['liq_bias'] >= -0.3)");      shortC.push("(dataframe['liq_bias'] <= 0.3)"); }

  const doLong = direction === 'long' || direction === 'both';
  const doShort = direction === 'short' || direction === 'both';

  L.push(`    def populate_entry_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:`);
  if (doLong) {
    L.push(`        dataframe.loc[`);
    longC.forEach((c, i) => L.push(`            ${c}${i < longC.length - 1 ? ' &' : ','}`));
    L.push(`            'enter_long'] = 1`);
    L.push(``);
  }
  if (doShort) {
    L.push(`        dataframe.loc[`);
    shortC.forEach((c, i) => L.push(`            ${c}${i < shortC.length - 1 ? ' &' : ','}`));
    L.push(`            'enter_short'] = 1`);
    L.push(``);
  }
  L.push(`        return dataframe`);
  L.push(``);

  L.push(`    def populate_exit_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:`);
  if (exitLogic && exitLogic.long) {
    if (doLong) {
      L.push(`        dataframe.loc[`);
      L.push(`            (${exitLogic.long}),`);
      L.push(`            'exit_long'] = 1`);
    }
    if (doShort) {
      L.push(`        dataframe.loc[`);
      L.push(`            (${exitLogic.short || exitLogic.long}),`);
      L.push(`            'exit_short'] = 1`);
    }
  } else {
    if (hasInd('rsi')) {
      if (doLong) {
        L.push(`        dataframe.loc[`);
        L.push(`            (dataframe['rsi'] > 70),`);
        L.push(`            'exit_long'] = 1`);
      }
      if (doShort) {
        L.push(`        dataframe.loc[`);
        L.push(`            (dataframe['rsi'] < 30),`);
        L.push(`            'exit_short'] = 1`);
      }
    } else if (hasInd('stochastic') || hasInd('kdj')) {
      if (doLong) {
        L.push(`        dataframe.loc[`);
        L.push(`            (dataframe['stoch_k'] > 80),`);
        L.push(`            'exit_long'] = 1`);
      }
      if (doShort) {
        L.push(`        dataframe.loc[`);
        L.push(`            (dataframe['stoch_k'] < 20),`);
        L.push(`            'exit_short'] = 1`);
      }
    } else if (hasInd('cci')) {
      if (doLong) {
        L.push(`        dataframe.loc[`);
        L.push(`            (dataframe['cci'] > 150),`);
        L.push(`            'exit_long'] = 1`);
      }
      if (doShort) {
        L.push(`        dataframe.loc[`);
        L.push(`            (dataframe['cci'] < -150),`);
        L.push(`            'exit_short'] = 1`);
      }
    } else if (hasInd('macd')) {
      if (doLong) {
        L.push(`        dataframe.loc[`);
        L.push(`            (dataframe['macd'] < dataframe['macd_signal']),`);
        L.push(`            'exit_long'] = 1`);
      }
      if (doShort) {
        L.push(`        dataframe.loc[`);
        L.push(`            (dataframe['macd'] > dataframe['macd_signal']),`);
        L.push(`            'exit_short'] = 1`);
      }
    } else {
      L.push(`        dataframe.loc[`);
      L.push(`            (dataframe['volume'] > 0),  # exits handled by ROI/stoploss`);
      L.push(`            'exit_long'] = 0  # placeholder`);
      if (doShort) {
        L.push(`        dataframe.loc[`);
        L.push(`            (dataframe['volume'] > 0),`);
        L.push(`            'exit_short'] = 0`);
      }
    }
  }
  L.push(`        return dataframe`);
  L.push(``);

  return L.join('\n');
}

// 极简策略, 给 host 模式 deploy 没指定 strategy 时兜底.
export const SAMPLE_STRATEGY = `# Sample RSI + EMA strategy for Freqtrade
# Uses pure pandas — no TA-Lib C library required
from freqtrade.strategy import IStrategy
from pandas import DataFrame


class SampleStrategy(IStrategy):
    INTERFACE_VERSION = 3
    timeframe = '5m'
    can_short = True

    minimal_roi = {"0": 0.05, "30": 0.03, "60": 0.02, "120": 0.01}

    stoploss = -0.03
    trailing_stop = True
    trailing_stop_positive = 0.01
    trailing_stop_positive_offset = 0.02

    def populate_indicators(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
        # RSI (pure pandas, no talib)
        delta = dataframe['close'].diff()
        gain = delta.clip(lower=0).rolling(window=14).mean()
        loss = (-delta.clip(upper=0)).rolling(window=14).mean()
        rs = gain / loss
        dataframe['rsi'] = 100 - (100 / (1 + rs))

        # EMA (pure pandas)
        dataframe['ema_fast'] = dataframe['close'].ewm(span=8, adjust=False).mean()
        dataframe['ema_slow'] = dataframe['close'].ewm(span=21, adjust=False).mean()
        return dataframe

    def populate_entry_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
        dataframe.loc[
            (dataframe['rsi'] < 35) &
            (dataframe['ema_fast'] > dataframe['ema_slow']) &
            (dataframe['volume'] > 0),
            'enter_long'] = 1
        dataframe.loc[
            (dataframe['rsi'] > 65) &
            (dataframe['ema_fast'] < dataframe['ema_slow']) &
            (dataframe['volume'] > 0),
            'enter_short'] = 1
        return dataframe

    def populate_exit_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
        dataframe.loc[
            (dataframe['rsi'] > 70),
            'exit_long'] = 1
        dataframe.loc[
            (dataframe['rsi'] < 30),
            'exit_short'] = 1
        return dataframe
`;

{
  "name": "aicoin-freqtrade",
  "version": "3.5.2",
  "private": true,
  "type": "module"
}

#!/usr/bin/env node
// ft-deploy.mjs — strategy lifecycle, backtest, hyperopt.
//
// 两套运行模式自动切换:
//   - CoinClaw 容器内 (OpenClaw / Hermes / Claude Code): freqtrade 已是
//     supervisord 管的常驻 daemon, 本脚本"部署策略" = 写策略文件 +
//     改 config.strategy + 重启 daemon. 不再 git clone freqtrade,
//     不再 nohup 后台进程, 不跟 daemon 抢 8080 端口.
//   - host 模式 (用户本地 macOS / Linux): 沿用老路径, 自己 clone freqtrade,
//     起后台进程, 写 PID file. 这条路在 coinclaw 之外仍然有效.
//
// coinclaw 模式下 strategy / backtest / 配置变更 都通过容器里预装的
// freqtrade CLI + freqtrade REST API 完成, 跟 dashboard 看到的状态保持一致.
import {
  readFileSync, writeFileSync, existsSync, mkdirSync, copyFileSync,
  readdirSync, renameSync, chmodSync,
} from 'node:fs';
import { resolve, dirname } from 'node:path';
import { execSync } from 'node:child_process';
import { randomBytes } from 'node:crypto';
import { fileURLToPath } from 'node:url';

import {
  coinclawEnv, hostModeFreqtradePaths, envFileCandidates, supervisorSocket,
} from '../lib/coinclaw-env.mjs';
import { ftGet, ftPost } from '../lib/freqtrade-api.mjs';
import {
  buildStrategyCode, SAMPLE_STRATEGY,
  AVAILABLE_INDICATORS, AVAILABLE_AICOIN_DATA, PAID_DATA,
} from '../lib/strategy-builder.mjs';

const __dir = dirname(fileURLToPath(import.meta.url));

// ─── 模式 / 路径解析 ─────────────────────────────────────────────
const ENV = coinclawEnv();
const HOST = hostModeFreqtradePaths();

// 三引擎下 STRAT_DIR / USER_DATA / CONFIG_PATH 直接来自 daemon 启动参数,
// 跟 dashboard / freqtrade /api/v1/show_config 保持完全一致 — 不会出现
// "agent 写到 ~/.freqtrade/user_data/strategies/ 但 daemon 不读" 这种坑.
const STRAT_DIR  = ENV ? ENV.strategyPath      : HOST.strategyPath;
const USER_DATA  = ENV ? ENV.freqtradeUserdir  : HOST.userdir;
const CONFIG_PATH = ENV ? ENV.configPath       : HOST.configPath;
const ENV_FILE   = ENV ? ENV.envFile           : envFileCandidates()[0]; // host: ~/.coinos/.env(规范位置, 与读路径最高优先级一致)

// FT_BIN 解析顺序:
//   1. coinclaw 容器: 'freqtrade' — image PATH 上已经有 (entrypoint
//      ENV PATH 包含 /home/node/.freqtrade/source/.venv/bin 或者
//      ftuser 的 ~/.local/bin), 直接用最干净.
//   2. host 模式优先 `command -v freqtrade` — 用户本地已经装过的
//      系统 freqtrade (brew / uv / 系统包) 直接复用. 老版本 ft-deploy
//      会 git clone freqtrade 重装一次 setup.sh, 多等几分钟 + 多占
//      ~500MB. 见 commit 50011b8.
//   3. host fallback: ~/.freqtrade/source/.venv/bin/freqtrade — 真
//      没有时才走 setup.sh 装到 venv.
const FT_BIN = ENV ? 'freqtrade' : (() => {
  try {
    const sys = execSync('command -v freqtrade', { encoding: 'utf-8', stdio: ['ignore', 'pipe', 'ignore'] }).trim();
    if (sys && existsSync(sys)) return sys;
  } catch {}
  return HOST.ftBin;
})();

// ─── 通用辅助 ─────────────────────────────────────────────────────
function run(cmd, opts = {}) {
  return execSync(cmd, { encoding: 'utf-8', timeout: 600000, ...opts }).trim();
}

function hasCommand(cmd) {
  try { run(`which ${cmd}`); return true; } catch { return false; }
}

// 轻量 env 读取 — freqtrade-api.mjs 已经 loadEnv() 一次, 这里是为了 host
// 模式下的 detectExchange / appendEnv 等动作能拿到最新值.
function loadEnv() {
  for (const file of envFileCandidates()) {
    if (!existsSync(file)) continue;
    try {
      for (const line of readFileSync(file, 'utf-8').split('\n')) {
        const t = line.trim();
        if (!t || t.startsWith('#')) continue;
        const eq = t.indexOf('=');
        if (eq < 1) continue;
        const key = t.slice(0, eq).trim();
        let val = t.slice(eq + 1).trim();
        if ((val.startsWith('"') && val.endsWith('"')) || (val.startsWith("'") && val.endsWith("'"))) val = val.slice(1, -1);
        if (!process.env[key]) process.env[key] = val;
      }
    } catch {}
  }
}
loadEnv();

function appendEnv(key, val) {
  try { mkdirSync(dirname(ENV_FILE), { recursive: true }); } catch {} // ~/.coinos 可能还不存在
  if (!existsSync(ENV_FILE)) {
    writeFileSync(ENV_FILE, `${key}=${val}\n`);
    try { chmodSync(ENV_FILE, 0o600); } catch {}
    return;
  }
  const content = readFileSync(ENV_FILE, 'utf-8');
  const lines = content.split('\n');
  const idx = lines.findIndex((l) => l.trim().startsWith(`${key}=`));
  if (idx >= 0) {
    lines[idx] = `${key}=${val}`;
    writeFileSync(ENV_FILE, lines.join('\n'));
  } else {
    writeFileSync(ENV_FILE, content.trimEnd() + `\n${key}=${val}\n`);
  }
}

// 在三引擎容器里 .env 同时承载交易所 key + AiCoin key + DRY_RUN +
// SELECTED_EXCHANGE, agent 直接告诉用户去 EnvSection 改, 不在脚本里写.
// host 模式下沿用老的"自己 nohup freqtrade"流程, 才需要这个 detectExchange.
function detectExchange() {
  const exchanges = ['BINANCE', 'OKX', 'BYBIT', 'BITGET', 'GATE', 'HTX', 'KUCOIN', 'MEXC'];
  for (const ex of exchanges) {
    if (process.env[`${ex}_API_KEY`] && process.env[`${ex}_API_SECRET`]) {
      return {
        name: ex.toLowerCase(),
        key: process.env[`${ex}_API_KEY`],
        secret: process.env[`${ex}_API_SECRET`],
        password: process.env[`${ex}_PASSWORD`] || '',
      };
    }
  }
  return null;
}

// ─── coinclaw 模式: daemon 操作 ──────────────────────────────────
function readDaemonConfig() {
  return JSON.parse(readFileSync(CONFIG_PATH, 'utf-8'));
}

function writeDaemonConfig(cfg) {
  const bak = `${CONFIG_PATH}.bak`;
  copyFileSync(CONFIG_PATH, bak);
  try { chmodSync(bak, 0o600); } catch {}
  const tmp = `${CONFIG_PATH}.tmp.${process.pid}`;
  writeFileSync(tmp, JSON.stringify(cfg, null, 4) + '\n');
  try { chmodSync(tmp, 0o600); } catch {}
  renameSync(tmp, CONFIG_PATH);
  try { chmodSync(CONFIG_PATH, 0o600); } catch {}
}

function restartDaemon() {
  if (!ENV) throw new Error('restart daemon 仅在 coinclaw 容器内可用');
  const sock = supervisorSocket();
  try {
    execSync(`supervisorctl -s unix://${sock} restart freqtrade`, {
      stdio: 'pipe', timeout: 30000,
    });
    return { method: 'supervisorctl' };
  } catch (e) {
    try {
      const pid = run("pgrep -f 'freqtrade trade' | head -n1");
      if (pid) {
        process.kill(Number(pid), 'SIGTERM');
        return { method: 'kill+autorestart', pid: Number(pid) };
      }
    } catch {}
    throw new Error(`restart 失败: ${e.message}`);
  }
}

// 通过 dump+grep ps 拿 daemon 当前用的 strategy / pair_whitelist 等运行
// 时配置. /api/v1/show_config 是最稳的来源, 跟 freqtrade UI/dashboard 一致.
async function fetchDaemonState() {
  try {
    const cfg = await ftGet('show_config');
    return { online: true, ...cfg };
  } catch (e) {
    return { online: false, error: e.message };
  }
}

// ─── host 模式: 自己管 freqtrade 进程 ───────────────────────────
function getHostPid() {
  if (!HOST.pidFile || !existsSync(HOST.pidFile)) return null;
  const pid = readFileSync(HOST.pidFile, 'utf-8').trim();
  if (!pid) return null;
  try { process.kill(Number(pid), 0); return Number(pid); } catch { return null; }
}

function findPython() {
  const names = ['python3.13', 'python3.12', 'python3.11', 'python3'];
  const extraDirs = ['/opt/homebrew/bin', '/usr/local/bin', `${process.env.HOME}/.local/bin`];
  const candidates = [...names];
  for (const dir of extraDirs) {
    for (const n of names.slice(0, 3)) candidates.push(resolve(dir, n));
  }
  for (const bin of candidates) {
    try {
      const version = run(`${bin} --version`);
      const match = version.match(/(\d+)\.(\d+)/);
      if (match) {
        const major = Number(match[1]); const minor = Number(match[2]);
        if (major === 3 && minor >= 11) return { bin, major, minor, version };
      }
    } catch {}
  }
  return null;
}

function ensureModernPython() {
  let py = findPython();
  if (py) return py;

  if (process.platform === 'darwin') {
    try {
      const uvBin = resolve(process.env.HOME || '', '.local', 'bin', 'uv');
      if (!existsSync(uvBin)) {
        console.error('Installing uv (fast Python manager)...');
        run('curl -LsSf https://astral.sh/uv/install.sh | sh', { timeout: 60000 });
      }
      if (existsSync(uvBin)) {
        console.error('Installing Python 3.12 via uv...');
        run(`${uvBin} python install 3.12`, { timeout: 300000 });
        try {
          const pyPath = run(`${uvBin} python find 3.12`);
          if (pyPath) {
            const ver = run(`${pyPath} --version`);
            const m = ver.match(/(\d+)\.(\d+)/);
            if (m && Number(m[1]) === 3 && Number(m[2]) >= 11) {
              return { bin: pyPath, major: Number(m[1]), minor: Number(m[2]), version: ver };
            }
          }
        } catch {}
      }
    } catch (e) { console.error(`uv: ${e.message}`); }

    try {
      if (hasCommand('brew')) {
        console.error('Trying brew install python@3.12...');
        const brewEnv = { ...process.env, HOMEBREW_NO_AUTO_UPDATE: '1', HOMEBREW_NO_INSTALL_CLEANUP: '1' };
        run('brew install python@3.12', { timeout: 300000, env: brewEnv });
        py = findPython();
        if (py) return py;
      }
    } catch (e) { console.error(`brew: ${e.message}`); }
  }

  throw new Error('Python 3.11+ required. Install options:\n• curl -LsSf https://astral.sh/uv/install.sh | sh && uv python install 3.12\n• brew install python@3.12\n• https://www.python.org/downloads/');
}

function generateHostConfig(exchangeInfo, apiPassword, params = {}) {
  const config = {
    trading_mode: params.trading_mode || 'futures',
    margin_mode: params.margin_mode || 'isolated',
    max_open_trades: params.max_open_trades || 3,
    stake_currency: 'USDT',
    stake_amount: params.stake_amount || 'unlimited',
    tradable_balance_ratio: params.tradable_balance_ratio || 0.5,
    dry_run: params.dry_run !== false,
    dry_run_wallet: 1000,
    cancel_open_orders_on_exit: false,
    exchange: {
      name: exchangeInfo.name,
      key: exchangeInfo.key,
      secret: exchangeInfo.secret,
      ...(exchangeInfo.password ? { password: exchangeInfo.password } : {}),
      ccxt_config: {},
      ccxt_async_config: {},
      pair_whitelist: params.pairs || ['BTC/USDT:USDT', 'ETH/USDT:USDT'],
      pair_blacklist: [],
    },
    pairlists: [{ method: 'StaticPairList' }],
    entry_pricing: { price_side: 'same', use_order_book: true, order_book_top: 1 },
    exit_pricing: { price_side: 'same', use_order_book: true, order_book_top: 1 },
    api_server: {
      enabled: true,
      listen_ip_address: '127.0.0.1',
      listen_port: 8080,
      verbosity: 'error',
      enable_openapi: false,
      jwt_secret_key: randomBytes(16).toString('hex'),
      CORS_origins: [],
      // freqtrade 三引擎容器里 daemon user 都是 'freqtrade', host 模式跟齐 —
      // 老版本默认 'freqtrader' 跟容器不一致, 历史 bug.
      username: 'freqtrade',
      password: apiPassword,
    },
    bot_name: 'aicoin-freqtrade',
    initial_state: 'running',
    force_entry_enable: true,
    internals: { process_throttle_secs: 5 },
  };
  const proxyUrl = process.env.PROXY_URL || process.env.HTTPS_PROXY || process.env.HTTP_PROXY;
  if (proxyUrl) {
    config.exchange.ccxt_config.proxies = { https: proxyUrl, http: proxyUrl };
    config.exchange.ccxt_async_config.aiohttp_proxy = proxyUrl;
    config.exchange.enable_ws = false;
  }
  return config;
}

// ─── 公共: 复制 AiCoin SDK + 模板策略到 strategy 目录 ────────────
// 三引擎容器 image 已经在 build time 把 aicoin_data.py 复制到了 strategy
// 目录(image-*/Dockerfile + image/Dockerfile), 所以 coinclaw 模式下这一步
// 是幂等的 no-op, 但留着保证 host 模式 + agent 第一次 create_strategy 时
// 能拿到 SDK.
function ensureSdkAndTemplates() {
  mkdirSync(STRAT_DIR, { recursive: true });
  const skillDir = resolve(__dir, '..');
  const sdkSrc = resolve(skillDir, 'lib', 'aicoin_data.py');
  const defaultsSrc = resolve(skillDir, 'lib', 'defaults.json');
  const strategiesSrc = resolve(skillDir, 'strategies');

  if (existsSync(sdkSrc)) {
    const sdkDest = resolve(STRAT_DIR, 'aicoin_data.py');
    if (!existsSync(sdkDest)) copyFileSync(sdkSrc, sdkDest);
  }
  if (existsSync(defaultsSrc)) {
    const dDest = resolve(STRAT_DIR, 'defaults.json');
    if (!existsSync(dDest)) copyFileSync(defaultsSrc, dDest);
  }
  if (existsSync(strategiesSrc)) {
    for (const f of readdirSync(strategiesSrc)) {
      if (f.endsWith('.py')) {
        const dest = resolve(STRAT_DIR, f);
        if (!existsSync(dest)) copyFileSync(resolve(strategiesSrc, f), dest);
      }
    }
  }
}

// ─── Actions ─────────────────────────────────────────────────────
const actions = {
  // ── check ──────────────────────────────────────────────────────
  // coinclaw 模式: ping daemon + show_config + balance.
  // host 模式: 检查 python / git / freqtrade installed / pid.
  check: async () => {
    if (ENV) {
      const checks = { mode: 'coinclaw', engine: ENV.engine, paths: {
        userdir: USER_DATA, strategy_path: STRAT_DIR, config: CONFIG_PATH,
      }};
      const state = await fetchDaemonState();
      checks.daemon_online = state.online;
      if (state.online) {
        checks.strategy = state.strategy;
        checks.exchange = state.exchange;
        checks.dry_run = state.dry_run;
        checks.timeframe = state.timeframe;
        checks.trading_mode = state.trading_mode;
        try {
          const bal = await ftGet('balance');
          checks.total = bal.total;
          checks.starting_capital = bal.starting_capital;
          checks.stake_currency = bal.stake;
        } catch (e) { checks.balance_error = e.message; }
      } else {
        checks.note = '在 coinclaw 容器里 daemon 由 supervisord 管理, 它没起来通常是 cold-start 卡住或 config 写错; 看 /workspace/logs/freqtrade-error.log 或 /home/node/.openclaw/workspace/.freqtrade/logs/';
      }
      return checks;
    }
    // host mode
    const checks = { mode: 'host' };
    const py = findPython();
    checks.python = py ? `${py.version} (${py.bin})` : false;
    if (!py) {
      try {
        const v = run('python3 --version');
        checks.python_warning = `${v} found but Freqtrade requires 3.11+. Deploy will auto-install 3.12.`;
      } catch {}
    }
    checks.git = hasCommand('git');
    checks.source_cloned = existsSync(resolve(HOST.sourceDir, 'setup.sh'));
    checks.freqtrade_installed = existsSync(FT_BIN);
    if (checks.freqtrade_installed) {
      try { checks.freqtrade_version = run(`${FT_BIN} --version`); } catch {}
    }
    const ex = detectExchange();
    checks.exchange = ex ? { name: ex.name, configured: true } : { configured: false };
    const pid = getHostPid();
    checks.running = !!pid;
    if (pid) checks.pid = pid;
    checks.ready = (!!py || process.platform === 'darwin') && checks.git && checks.exchange?.configured;
    if (!checks.ready) {
      checks.missing = [];
      if (!py && process.platform !== 'darwin') checks.missing.push('Python 3.11+ not found');
      if (!checks.git) checks.missing.push('git not found');
      if (!checks.exchange?.configured) checks.missing.push('No exchange API keys in .env');
    }
    return checks;
  },

  // ── deploy ─────────────────────────────────────────────────────
  // coinclaw 模式: 写策略 (如果 caller 已 create_strategy 就是 no-op) +
  //   改 config.strategy + 重启 daemon. 不再 git clone, 不再 nohup.
  // host 模式: 沿用老路径 (clone + setup.sh + nohup).
  deploy: async (params = {}) => {
    if (ENV) {
      const strategy = params.strategy;
      if (!strategy) throw new Error('strategy 必填, 例: {"strategy":"MyStrat"}');
      const stratFile = resolve(STRAT_DIR, `${strategy}.py`);
      if (!existsSync(stratFile)) {
        throw new Error(`策略文件不存在: ${stratFile}. 先用 ft-deploy.mjs create_strategy 或 Write 工具写文件到 ${STRAT_DIR}/`);
      }
      const cfg = readDaemonConfig();
      const before = { strategy: cfg.strategy, dry_run: cfg.dry_run, pairs: cfg.exchange?.pair_whitelist };
      cfg.strategy = strategy;
      // 允许在 deploy 里同时改 dry_run / pairs / max_open_trades, 一次完成.
      if (typeof params.dry_run === 'boolean') cfg.dry_run = params.dry_run;
      if (Array.isArray(params.pairs) && params.pairs.length) {
        if (!cfg.exchange) cfg.exchange = {};
        cfg.exchange.pair_whitelist = params.pairs;
      }
      if (params.max_open_trades) cfg.max_open_trades = params.max_open_trades;
      writeDaemonConfig(cfg);
      const restart = restartDaemon();
      return {
        success: true, mode: 'coinclaw', engine: ENV.engine,
        strategy, before, restart,
        config_path: CONFIG_PATH, strategy_file: stratFile,
        note: '策略生效需 daemon 重启完成 (10-30s); dashboard 会自动刷新到新策略名',
        warning: cfg.dry_run === false
          ? '⚠️ 已切到实盘 — 真实交易, 真实亏损. 确认 .env 里交易所 key 正确, 余额可控.'
          : null,
      };
    }
    // host mode (老逻辑, 保留不动)
    const py = ensureModernPython();
    console.error(`Using ${py.version} (${py.bin})`);
    if (!hasCommand('git')) throw new Error('git not found.');
    let exchangeInfo = detectExchange();
    if (!exchangeInfo) {
      if (params.dry_run !== false) {
        const exName = params.exchange || 'binance';
        exchangeInfo = { name: exName, key: 'dry-run', secret: 'dry-run' };
        console.error(`No exchange API keys found — using dummy keys for dry-run (${exName})`);
      } else {
        throw new Error('No exchange API keys found in .env (required for live trading)');
      }
    }
    mkdirSync(STRAT_DIR, { recursive: true });
    ensureSdkAndTemplates();
    if (!existsSync(FT_BIN)) {
      if (!existsSync(resolve(HOST.sourceDir, 'setup.sh'))) {
        console.error('Cloning Freqtrade repository...');
        run(`git clone https://github.com/freqtrade/freqtrade.git ${HOST.sourceDir}`, { timeout: 120000 });
        run(`cd ${HOST.sourceDir} && git checkout stable`, { timeout: 30000 });
      }
      console.error('Running Freqtrade setup.sh (this may take a few minutes)...');
      const pyDir = dirname(py.bin);
      const setupEnv = { ...process.env, PATH: `${pyDir}:${process.env.PATH}` };
      run(`cd ${HOST.sourceDir} && ./setup.sh -i`, { timeout: 600000, env: setupEnv });
      if (!existsSync(FT_BIN)) throw new Error('Freqtrade installation failed.');
    }
    const apiPassword = randomBytes(8).toString('hex');
    const config = generateHostConfig(exchangeInfo, apiPassword, params);
    writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2));
    try { chmodSync(CONFIG_PATH, 0o600); } catch {} // config.json 含明文交易所 key/secret, 收紧权限
    const samplePath = resolve(STRAT_DIR, 'SampleStrategy.py');
    if (!existsSync(samplePath)) writeFileSync(samplePath, SAMPLE_STRATEGY);
    const oldPid = getHostPid();
    if (oldPid) { try { process.kill(oldPid, 'SIGTERM'); } catch {} }
    const strategy = params.strategy || 'SampleStrategy';
    const stratFile = resolve(STRAT_DIR, `${strategy}.py`);
    if (strategy !== 'SampleStrategy' && !existsSync(stratFile)) {
      throw new Error(`Strategy "${strategy}" not found at ${stratFile}. Use create_strategy first.`);
    }
    const proxyEnv = process.env.PROXY_URL || process.env.HTTPS_PROXY || process.env.HTTP_PROXY;
    const proxyPrefix = proxyEnv ? `env HTTPS_PROXY=${proxyEnv} HTTP_PROXY=${proxyEnv} ` : '';
    run(`nohup ${proxyPrefix}${FT_BIN} trade --config ${CONFIG_PATH} --strategy ${strategy} --userdir ${USER_DATA} > ${HOST.logFile} 2>&1 & echo $! > ${HOST.pidFile}`);
    let ready = false;
    for (let i = 0; i < 15; i++) {
      await new Promise((r) => setTimeout(r, 2000));
      const pid = getHostPid();
      if (pid) {
        try {
          const res = await fetch(`http://127.0.0.1:8080/api/v1/ping`, {
            headers: { Authorization: 'Basic ' + Buffer.from(`freqtrade:${apiPassword}`).toString('base64') },
            signal: AbortSignal.timeout(3000),
          });
          if (res.ok) { ready = true; break; }
        } catch {}
      }
    }
    appendEnv('FREQTRADE_URL', 'http://127.0.0.1:8080');
    appendEnv('FREQTRADE_USERNAME', 'freqtrade');
    appendEnv('FREQTRADE_PASSWORD', apiPassword);
    return {
      success: true, mode: 'host',
      exchange: exchangeInfo.name, strategy, dry_run: config.dry_run,
      pairs: config.exchange.pair_whitelist,
      api_url: 'http://127.0.0.1:8080', api_auth: 'stored in .env (FREQTRADE_PASSWORD)',
      pid: getHostPid(), ready, log_file: HOST.logFile, config_path: CONFIG_PATH,
      strategies_dir: STRAT_DIR,
      note: config.dry_run ? 'Running in DRY-RUN mode' : 'WARNING: Running in LIVE mode',
    };
  },

  // ── update ─────────────────────────────────────────────────────
  update: async () => {
    if (ENV) {
      return {
        skipped: true, mode: 'coinclaw',
        note: '在 coinclaw 容器里 freqtrade 由 image 预装, 升级请 helm upgrade 整个 instance (web 端有"升级"按钮), 不能在容器里 git pull',
      };
    }
    if (!existsSync(resolve(HOST.sourceDir, 'setup.sh'))) {
      return { error: 'Freqtrade not installed. Run deploy first.' };
    }
    const pid = getHostPid();
    if (pid) { try { process.kill(pid, 'SIGTERM'); } catch {} }
    console.error('Updating Freqtrade...');
    run(`cd ${HOST.sourceDir} && ./setup.sh -u`, { timeout: 600000 });
    return { updated: true, mode: 'host', note: 'Run start to restart Freqtrade.' };
  },

  // ── status ─────────────────────────────────────────────────────
  status: async () => {
    if (ENV) {
      const state = await fetchDaemonState();
      const result = { mode: 'coinclaw', engine: ENV.engine, ...state };
      // tail freqtrade 日志, 三引擎日志位置不同.
      const logCandidates = [
        '/workspace/logs/freqtrade.log',
        '/workspace/logs/freqtrade-error.log',
      ];
      for (const log of logCandidates) {
        if (existsSync(log)) {
          try { result.last_logs = run(`tail -10 ${log}`); break; } catch {}
        }
      }
      return result;
    }
    const pid = getHostPid();
    if (!pid) return { mode: 'host', running: false };
    let lastLogs = '';
    try { lastLogs = run(`tail -5 ${HOST.logFile} 2>/dev/null`); } catch {}
    return { mode: 'host', running: true, pid, log_file: HOST.logFile, last_logs: lastLogs };
  },

  // ── stop / start ───────────────────────────────────────────────
  // coinclaw 模式: supervisorctl. host 模式: SIGTERM pid.
  stop: async () => {
    if (ENV) {
      const sock = supervisorSocket();
      try {
        run(`supervisorctl -s unix://${sock} stop freqtrade`);
        return { stopped: true, mode: 'coinclaw', method: 'supervisorctl' };
      } catch (e) {
        return { stopped: false, error: e.message, note: 'supervisorctl 不可达, 试试 ft.mjs stop (REST)' };
      }
    }
    const pid = getHostPid();
    if (!pid) return { stopped: false, mode: 'host', reason: 'Not running' };
    try { process.kill(pid, 'SIGTERM'); } catch {}
    try { writeFileSync(HOST.pidFile, ''); } catch {}
    return { stopped: true, mode: 'host', pid };
  },

  start: async (params = {}) => {
    if (ENV) {
      const sock = supervisorSocket();
      try {
        run(`supervisorctl -s unix://${sock} start freqtrade`);
        return { started: true, mode: 'coinclaw', method: 'supervisorctl' };
      } catch (e) {
        return { started: false, error: e.message };
      }
    }
    if (getHostPid()) return { started: false, mode: 'host', reason: 'Already running' };
    if (!existsSync(FT_BIN)) throw new Error('Freqtrade not installed. Run deploy first.');
    if (!existsSync(CONFIG_PATH)) throw new Error('No config found. Run deploy first.');
    const strategy = params.strategy || 'SampleStrategy';
    const proxyUrl = process.env.PROXY_URL || process.env.HTTPS_PROXY || process.env.HTTP_PROXY;
    const proxyPrefix = proxyUrl ? `env HTTPS_PROXY=${proxyUrl} HTTP_PROXY=${proxyUrl} ` : '';
    run(`nohup ${proxyPrefix}${FT_BIN} trade --config ${CONFIG_PATH} --strategy ${strategy} --userdir ${USER_DATA} > ${HOST.logFile} 2>&1 & echo $! > ${HOST.pidFile}`);
    await new Promise((r) => setTimeout(r, 3000));
    return { started: true, mode: 'host', pid: getHostPid() };
  },

  // ── logs ───────────────────────────────────────────────────────
  // coinclaw 模式: tail /workspace/logs/freqtrade.log (supervisord 写在那).
  // host 模式: tail freqtrade.log.
  logs: async ({ lines = 50 } = {}) => {
    if (ENV) {
      for (const log of ['/workspace/logs/freqtrade.log', '/workspace/logs/freqtrade-error.log']) {
        if (existsSync(log)) {
          try { return { mode: 'coinclaw', log_file: log, logs: run(`tail -${lines} ${log}`) }; } catch {}
        }
      }
      return { mode: 'coinclaw', logs: '(no log file found in /workspace/logs)' };
    }
    try { return { mode: 'host', logs: run(`tail -${lines} ${HOST.logFile} 2>/dev/null`) }; }
    catch { return { mode: 'host', logs: 'No log file found' }; }
  },

  // ── backtest ───────────────────────────────────────────────────
  // 两边都用 freqtrade backtesting CLI; 区别只在路径.
  // coinclaw 模式跑 backtest 不影响 daemon: backtesting 走自己的进程,
  // 跟 daemon 共用 user_data 但不共用 :8080.
  backtest: async (params = {}) => {
    if (!existsSync(FT_BIN) && !ENV) throw new Error('Freqtrade not installed. Run deploy first.');
    if (!existsSync(CONFIG_PATH)) {
      mkdirSync(dirname(CONFIG_PATH), { recursive: true });
      const exchange = params.exchange || 'binance';
      const cfg = generateHostConfig(
        { name: exchange, key: 'backtest-only', secret: 'backtest-only' },
        randomBytes(8).toString('hex'),
        { dry_run: true, pairs: params.pairs || ['BTC/USDT:USDT'] },
      );
      writeFileSync(CONFIG_PATH, JSON.stringify(cfg, null, 2));
      console.error(`Auto-created backtest config (exchange: ${exchange})`);
    }
    const strategy = params.strategy || 'SampleStrategy';
    const stratFile = resolve(STRAT_DIR, `${strategy}.py`);
    if (!existsSync(stratFile)) {
      throw new Error(`Strategy "${strategy}" not found at ${stratFile}. Use create_strategy or list with strategy_list.`);
    }
    const timeframe = params.timeframe || '1h';
    const timerange = params.timerange || '';
    const timerangeArg = timerange ? ` --timerange ${timerange}` : '';
    const pairs = params.pairs;
    const pairsArg = pairs ? ` -p ${(Array.isArray(pairs) ? pairs : [pairs]).join(' ')}` : '';

    const proxyEnv = process.env.PROXY_URL || process.env.HTTPS_PROXY || process.env.HTTP_PROXY;
    const proxyPrefix = proxyEnv ? `env HTTPS_PROXY=${proxyEnv} HTTP_PROXY=${proxyEnv} ` : '';

    console.error('Downloading historical data...');
    try {
      run(
        `${proxyPrefix}${FT_BIN} download-data --config ${CONFIG_PATH} --timeframe ${timeframe}${timerangeArg}${pairsArg} --userdir ${USER_DATA}`,
        { timeout: 300000 }
      );
    } catch (e) {
      console.error(`Data download warning: ${e.message}`);
    }

    console.error(`Running backtest: strategy=${strategy}, timeframe=${timeframe}${timerange ? `, timerange=${timerange}` : ''}...`);
    const rawOutput = run(
      `${proxyPrefix}${FT_BIN} backtesting --config ${CONFIG_PATH} --strategy ${strategy} --strategy-path ${STRAT_DIR} --timeframe ${timeframe}${timerangeArg}${pairsArg} --userdir ${USER_DATA}`,
      { timeout: 600000 }
    );
    const output = rawOutput
      .split('\n')
      .filter((l) => !l.includes('INFO') || l.includes('TOTAL') || l.includes('Result') || l.includes('trades') || l.includes('Profit') || l.includes('Drawdown') || l.includes('Win') || l.includes('Avg'))
      .join('\n')
      .replace(/\b127\.0\.0\.1:\d+\b/g, '[local]')
      .replace(/https?:\/\/\d+\.\d+\.\d+\.\d+:\d+/g, '[proxy]');
    return { mode: ENV ? 'coinclaw' : 'host', strategy, timeframe, timerange: timerange || 'all available', output };
  },

  // ── download_data ──────────────────────────────────────────────
  download_data: async (params = {}) => {
    if (!existsSync(FT_BIN) && !ENV) throw new Error('Freqtrade not installed. Run deploy first.');
    if (!existsSync(CONFIG_PATH)) {
      mkdirSync(dirname(CONFIG_PATH), { recursive: true });
      const exchange = params.exchange || 'binance';
      const cfg = generateHostConfig(
        { name: exchange, key: 'download-only', secret: 'download-only' },
        randomBytes(8).toString('hex'),
        { dry_run: true, pairs: params.pairs || ['BTC/USDT:USDT'] },
      );
      writeFileSync(CONFIG_PATH, JSON.stringify(cfg, null, 2));
    }
    const timeframe = params.timeframe || '1h';
    const timerange = params.timerange || '';
    const timerangeArg = timerange ? ` --timerange ${timerange}` : '';

    const proxyEnv = process.env.PROXY_URL || process.env.HTTPS_PROXY || process.env.HTTP_PROXY;
    const proxyPrefix = proxyEnv ? `env HTTPS_PROXY=${proxyEnv} HTTP_PROXY=${proxyEnv} ` : '';

    console.error(`Downloading data: timeframe=${timeframe}${timerange ? `, timerange=${timerange}` : ''}...`);
    const output = run(
      `${proxyPrefix}${FT_BIN} download-data --config ${CONFIG_PATH} --timeframe ${timeframe}${timerangeArg} --userdir ${USER_DATA}`,
      { timeout: 300000 }
    );
    return { mode: ENV ? 'coinclaw' : 'host', timeframe, timerange: timerange || 'all available', output };
  },

  // ── hyperopt ───────────────────────────────────────────────────
  hyperopt: async (params = {}) => {
    if (!existsSync(FT_BIN) && !ENV) throw new Error('Freqtrade not installed.');
    if (!existsSync(CONFIG_PATH)) {
      mkdirSync(dirname(CONFIG_PATH), { recursive: true });
      const exchange = params.exchange || 'binance';
      const cfg = generateHostConfig(
        { name: exchange, key: 'hyperopt-only', secret: 'hyperopt-only' },
        randomBytes(8).toString('hex'),
        { dry_run: true, pairs: params.pairs || ['BTC/USDT:USDT'] },
      );
      writeFileSync(CONFIG_PATH, JSON.stringify(cfg, null, 2));
    }

    const strategy = params.strategy || 'SampleStrategy';
    const stratFile = resolve(STRAT_DIR, `${strategy}.py`);
    if (!existsSync(stratFile)) throw new Error(`Strategy "${strategy}" not found at ${stratFile}.`);
    const timeframe = params.timeframe || '1h';
    const timerange = params.timerange || '';
    const epochs = Math.min(Number(params.epochs) || 100, 500);
    const spaces = params.spaces || 'roi stoploss trailing buy sell';
    const jobs = Math.min(Number(params.jobs) || 1, 4);
    const lossFunc = params.loss || 'SharpeHyperOptLoss';
    const minTrades = params.min_trades || 20;
    const timerangeArg = timerange ? ` --timerange ${timerange}` : '';

    const proxyEnv = process.env.PROXY_URL || process.env.HTTPS_PROXY || process.env.HTTP_PROXY;
    const proxyPrefix = proxyEnv ? `env HTTPS_PROXY=${proxyEnv} HTTP_PROXY=${proxyEnv} ` : '';

    try {
      run(
        `${proxyPrefix}${FT_BIN} download-data --config ${CONFIG_PATH} --timeframe ${timeframe}${timerangeArg} --userdir ${USER_DATA}`,
        { timeout: 300000 }
      );
    } catch (e) { console.error(`Data download warning: ${e.message}`); }

    console.error(`Running hyperopt: strategy=${strategy}, epochs=${epochs}, jobs=${jobs}, spaces=${spaces}`);
    const output = run(
      `${proxyPrefix}${FT_BIN} hyperopt --config ${CONFIG_PATH} --strategy ${strategy} --strategy-path ${STRAT_DIR} --timeframe ${timeframe}${timerangeArg} --userdir ${USER_DATA} --hyperopt-loss ${lossFunc} --spaces ${spaces} --epochs ${epochs} -j ${jobs} --min-trades ${minTrades}`,
      { timeout: 1800000 }
    );

    return { mode: ENV ? 'coinclaw' : 'host', strategy, timeframe, epochs, spaces, jobs, loss_function: lossFunc, output };
  },

  // ── create_strategy ────────────────────────────────────────────
  // 写策略文件到 STRAT_DIR (三引擎下分别是 daemon 真读的路径).
  create_strategy: async (params = {}) => {
    let name = params.name;
    if (!name) throw new Error('name is required. Example: {"name":"MyStrategy","timeframe":"15m","indicators":["rsi","macd"],"aicoin_data":["funding_rate"]}');
    name = name.replace(/[^A-Za-z0-9_]/g, '');
    if (name && /^[a-z]/.test(name)) name = name[0].toUpperCase() + name.slice(1);
    if (!/^[A-Z][A-Za-z0-9_]+$/.test(name)) throw new Error('name must be a valid Python class name starting with uppercase (e.g. MyStrategy)');

    ensureSdkAndTemplates();
    const dest = resolve(STRAT_DIR, `${name}.py`);
    const tf = params.timeframe || '15m';
    const desc = params.description || 'Custom strategy';
    const ds = new Set(params.aicoin_data || []);
    const indicators = params.indicators || null;
    const entryLogic = params.entry_logic || null;
    const exitLogic = params.exit_logic || null;
    const direction = params.direction || 'long';

    if (!['long', 'short', 'both'].includes(direction)) {
      throw new Error(`direction must be "long", "short", or "both" (default: "long")`);
    }

    if (indicators) {
      const invalid = indicators.filter((i) => !AVAILABLE_INDICATORS.includes(i.toLowerCase()));
      if (invalid.length > 0) {
        throw new Error(`Unknown indicators: ${invalid.join(', ')}. Available: ${AVAILABLE_INDICATORS.join(', ')}`);
      }
    }

    const KEY = process.env.AICOIN_ACCESS_KEY_ID || '';
    const defaultKey = JSON.parse(readFileSync(resolve(__dir, '..', 'lib', 'defaults.json'), 'utf-8')).accessKeyId || '';
    const usingFreeKey = !KEY || KEY === defaultKey;
    const paidUsed = [...ds].filter((d) => d in PAID_DATA);

    const code = buildStrategyCode(name, tf, desc, ds, indicators, entryLogic, exitLogic, direction);
    writeFileSync(dest, code);

    const result = {
      success: true, strategy: name, file: dest,
      mode: ENV ? 'coinclaw' : 'host', engine: ENV ? ENV.engine : null,
      timeframe: tf, direction,
      indicators: indicators || ['rsi', 'bb', 'ema', 'volume_sma'],
      aicoin_data: [...ds],
      note: ds.size
        ? `Strategy uses AiCoin data (${[...ds].join(', ')}) in live/dry_run. Falls back to pure technical indicators in backtest.`
        : 'Pure technical indicator strategy. To add AiCoin data, pass aicoin_data array.',
      next: ENV
        ? `策略文件已写; 用 deploy {"strategy":"${name}"} 让常驻 daemon 切到这个策略 (会触发 ~30s 重启), 或先 backtest 验证`
        : `Use deploy {"strategy":"${name}"} to start in dry-run, or backtest first`,
      available_indicators: AVAILABLE_INDICATORS,
      available_aicoin_data: AVAILABLE_AICOIN_DATA,
    };

    if (usingFreeKey && paidUsed.length > 0) {
      result.warning = `PAID KEY REQUIRED — Strategy uses ${paidUsed.map((d) => `${d} (${PAID_DATA[d]})`).join(', ')} but no paid API key is configured. These data sources will silently fall back to defaults in live mode. Get key at https://www.aicoin.com/opendata → add AICOIN_ACCESS_KEY_ID & AICOIN_ACCESS_SECRET to .env.`;
    }

    return result;
  },

  // ── strategy_list ──────────────────────────────────────────────
  strategy_list: async () => {
    const files = [];
    if (existsSync(STRAT_DIR)) {
      for (const f of readdirSync(STRAT_DIR)) {
        if (f.endsWith('.py') && f !== '__init__.py' && f !== 'aicoin_data.py') {
          files.push(f.replace('.py', ''));
        }
      }
    }
    return { mode: ENV ? 'coinclaw' : 'host', strategies: files, path: STRAT_DIR };
  },

  // ── remove ─────────────────────────────────────────────────────
  remove: async () => {
    if (ENV) {
      return {
        skipped: true, mode: 'coinclaw',
        note: '在 coinclaw 容器里 freqtrade 是常驻 daemon, 不能 remove. 用 stop 停 daemon, 或 deploy {"strategy":"NoOpStrategy"} 切到空跑策略, 或在 web UI 删整个 instance',
      };
    }
    const pid = getHostPid();
    if (pid) { try { process.kill(pid, 'SIGTERM'); } catch {} }
    try { writeFileSync(HOST.pidFile, ''); } catch {}
    return { removed: true, mode: 'host', note: `Process stopped. Config preserved.` };
  },

  // ── backtest_results ───────────────────────────────────────────
  backtest_results: async () => {
    const resultsDir = resolve(USER_DATA, 'backtest_results');
    if (!existsSync(resultsDir)) return { mode: ENV ? 'coinclaw' : 'host', results: [], path: resultsDir };
    const files = readdirSync(resultsDir)
      .filter((f) => f.endsWith('.meta.json'))
      .map((f) => {
        try {
          const meta = JSON.parse(readFileSync(resolve(resultsDir, f), 'utf-8'));
          const strategy = Object.keys(meta)[0] || 'unknown';
          const info = meta[strategy] || {};
          return {
            file: f.replace('.meta.json', ''),
            strategy,
            timeframe: info.timeframe || '',
            start: info.backtest_start_ts ? new Date(info.backtest_start_ts * 1000).toISOString().slice(0, 10) : '',
            end: info.backtest_end_ts ? new Date(info.backtest_end_ts * 1000).toISOString().slice(0, 10) : '',
          };
        } catch { return null; }
      })
      .filter(Boolean)
      .sort((a, b) => b.file.localeCompare(a.file))
      .slice(0, 10);
    return { mode: ENV ? 'coinclaw' : 'host', results: files, path: resultsDir };
  },
};

// ─── CLI ─────────────────────────────────────────────────────────
const [action, ...rest] = process.argv.slice(2);
if (!action || !actions[action]) {
  console.log(`Usage: node ft-deploy.mjs <action> [json-params]\nActions: ${Object.keys(actions).join(', ')}`);
  process.exit(1);
}
let params = {};
if (rest.length) {
  try {
    params = JSON.parse(rest.join(' '));
  } catch {
    console.log(JSON.stringify({
      error: `参数不是合法 JSON: ${rest.join(' ')}`,
      hint: "参数要用 JSON 对象, 例: '{\"strategy\":\"MyStrat\"}'",
    }));
    process.exit(1);
  }
}
actions[action](params).then((r) => {
  // 提示 — 只在 host 模式 / 老用法时强调走脚本; coinclaw 模式 daemon 已经
  // 在 supervisord 管, 用户从 chat agent 调用脚本就是正确路径.
  if (!ENV) r._reminder = 'IMPORTANT: Always use ft-deploy.mjs for ALL Freqtrade operations. NEVER use Docker commands.';
  console.log(JSON.stringify(r, null, 2));
}).catch((e) => {
  console.error(e.message);
  process.exit(1);
});