@aicoin/aicoin-mcp 1.1.1 → 1.2.0

package/build/index.js

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { readFileSync } from "fs";
-import { fileURLToPath as fileURLToPath2 } from "url";
-import { dirname as dirname2, resolve } from "path";
+import { readFileSync as readFileSync2 } from "fs";
+import { fileURLToPath as fileURLToPath3 } from "url";
+import { dirname as dirname3, resolve as resolve3 } from "path";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 
@@ -44,12 +44,12 @@ var BROKER_CONFIG = {
     headers: {}
   },
   bybit: {
-    options: {},
-    headers: { Referer: "AiCoin" }
+    options: { brokerId: "AiCoin" },
+    headers: {}
   },
   bitget: {
-    options: {},
-    headers: { "X-CHANNEL-API-CODE": "tpequ" }
+    options: { broker: "tpequ" },
+    headers: {}
   },
   gate: {
     options: {},
@@ -600,7 +600,7 @@ function registerTradeTools(server2) {
   );
   server2.tool(
     "create_order",
-    "Place a new order (market or limit). For conditional SL/TP orders, use stop_loss_price or take_profit_price with type=market.",
+    "Place a new order (market or limit). Default returns a PREVIEW (confirmed=false). Set confirmed=true to actually execute. For conditional SL/TP orders, use stop_loss_price or take_profit_price with type=market.",
     {
       exchange: z2.string().describe("Exchange ID"),
       symbol: z2.string().describe("Trading pair, e.g. BTC/USDT"),
@@ -608,6 +608,7 @@ function registerTradeTools(server2) {
       side: z2.enum(["buy", "sell"]).describe("Order side"),
       amount: z2.number().positive().describe("Order amount"),
       price: z2.number().positive().optional().describe("Limit price (required for limit orders)"),
+      confirmed: z2.boolean().optional().default(false).describe("false (default) = preview only, true = execute order"),
       pos_side: z2.enum(["long", "short"]).optional().describe("Position side for hedge mode: long/short"),
       margin_mode: z2.enum(["cross", "isolated"]).optional().describe("Margin mode for derivatives: cross/isolated"),
       stop_loss_price: z2.number().positive().optional().describe("Stop-loss trigger price (creates conditional market order)"),
@@ -615,11 +616,47 @@ function registerTradeTools(server2) {
       reduce_only: z2.boolean().optional().describe("Reduce-only flag for closing positions (SL/TP orders)"),
       market_type: marketTypePrivateSchema
     },
-    async ({ exchange, symbol, type, side, amount, price, pos_side, margin_mode, stop_loss_price, take_profit_price, reduce_only, market_type }) => {
+    async ({ exchange, symbol, type, side, amount, price, confirmed, pos_side, margin_mode, stop_loss_price, take_profit_price, reduce_only, market_type }) => {
       try {
         if (type === "limit" && price == null) {
           return err("price is required for limit orders");
         }
+        if (!confirmed) {
+          const pub = getExchange(exchange, market_type, { skipAuth: true });
+          await pub.loadMarkets();
+          const mkt = pub.markets[symbol];
+          if (!mkt) return err(`Symbol '${symbol}' not found on ${exchange}`);
+          const ticker = await pub.fetchTicker(symbol);
+          const currentPrice = ticker.last ?? ticker.close ?? 0;
+          const orderPrice = type === "limit" ? price : currentPrice;
+          const contractSize = mkt.contractSize ?? 1;
+          const isDerivative = market_type && market_type !== "spot";
+          const amountInBase = isDerivative ? amount * contractSize : amount;
+          const notional = amountInBase * orderPrice;
+          const preview = {
+            _preview: true,
+            _confirm_hint: "Set confirmed=true to execute this order",
+            exchange,
+            symbol,
+            type,
+            side,
+            amount,
+            price: orderPrice,
+            current_price: currentPrice,
+            notional_value: `${notional.toFixed(2)} ${mkt.quote}`
+          };
+          if (isDerivative && contractSize !== 1) {
+            preview.contract_size = contractSize;
+            preview.amount_in_base = `${amountInBase} ${mkt.base}`;
+            preview.unit = `${amount} contracts \xD7 ${contractSize} ${mkt.base}/contract = ${amountInBase} ${mkt.base}`;
+          }
+          if (mkt.limits?.amount?.min) preview.min_amount = mkt.limits.amount.min;
+          if (stop_loss_price) preview.stop_loss_price = stop_loss_price;
+          if (take_profit_price) preview.take_profit_price = take_profit_price;
+          if (pos_side) preview.pos_side = pos_side;
+          if (reduce_only) preview.reduce_only = true;
+          return ok(preview);
+        }
         const ex = getExchange(exchange, market_type);
         const params = {};
         const isBinance = exchange?.toLowerCase().startsWith("binance");
@@ -3449,6 +3486,257 @@ function registerFreqtradeDevTools(server2) {
   );
 }
 
+// src/tools/ft-deploy.ts
+import { z as z11 } from "zod";
+import { execSync } from "child_process";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { dirname as dirname2, resolve } from "path";
+var __dir = dirname2(fileURLToPath2(import.meta.url));
+var SCRIPT = resolve(__dir, "..", "scripts", "ft-deploy.mjs");
+function registerFtDeployTools(server2) {
+  server2.tool(
+    "ft_deploy",
+    "Freqtrade one-click deployment & management.\n\u2022 check \u2014 verify Python, git, exchange keys, running status\n\u2022 deploy \u2014 full setup (clone, install, config, start). Params: dry_run, strategy, pairs, trading_mode\n\u2022 update \u2014 update Freqtrade via setup.sh\n\u2022 status \u2014 check if running, show last logs\n\u2022 start \u2014 start Freqtrade. Params: strategy\n\u2022 stop \u2014 stop Freqtrade\n\u2022 logs \u2014 view recent logs. Params: lines\n\u2022 backtest \u2014 run strategy backtest. Params: strategy, timeframe, timerange\n\u2022 download_data \u2014 download OHLCV data. Params: timeframe, timerange\n\u2022 remove \u2014 stop and remove (config preserved)",
+    {
+      action: z11.enum([
+        "check",
+        "deploy",
+        "update",
+        "status",
+        "start",
+        "stop",
+        "logs",
+        "backtest",
+        "download_data",
+        "remove"
+      ]).describe("Action to perform"),
+      strategy: z11.string().optional().describe("Strategy name (default: SampleStrategy)"),
+      timeframe: z11.string().optional().describe("For backtest/download_data: candle timeframe, e.g. 1h, 5m"),
+      timerange: z11.string().optional().describe("For backtest/download_data: date range, e.g. 20240101-20240601"),
+      dry_run: z11.boolean().optional().describe("For deploy: true=paper trading (default), false=live"),
+      pairs: z11.array(z11.string()).optional().describe('For deploy: trading pairs, e.g. ["BTC/USDT:USDT"]'),
+      trading_mode: z11.enum(["futures", "spot"]).optional().describe("For deploy: trading mode (default: futures)"),
+      lines: z11.number().optional().describe("For logs: number of lines to show (default: 50)")
+    },
+    async ({ action, strategy, timeframe, timerange, dry_run, pairs, trading_mode, lines }) => {
+      try {
+        const params = {};
+        if (strategy !== void 0) params.strategy = strategy;
+        if (timeframe !== void 0) params.timeframe = timeframe;
+        if (timerange !== void 0) params.timerange = timerange;
+        if (dry_run !== void 0) params.dry_run = dry_run;
+        if (pairs !== void 0) params.pairs = pairs;
+        if (trading_mode !== void 0) params.trading_mode = trading_mode;
+        if (lines !== void 0) params.lines = lines;
+        const paramsArg = Object.keys(params).length > 0 ? ` '${JSON.stringify(params)}'` : "";
+        const output = execSync(
+          `node ${SCRIPT} ${action}${paramsArg}`,
+          { encoding: "utf-8", timeout: 6e5 }
+        ).trim();
+        try {
+          return ok(JSON.parse(output));
+        } catch {
+          return ok({ output });
+        }
+      } catch (e) {
+        return err(e);
+      }
+    }
+  );
+}
+
+// src/tools/auto-trade.ts
+import { z as z12 } from "zod";
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import { resolve as resolve2 } from "path";
+var CONFIG_DIR = resolve2(process.env.HOME || "", ".aicoin-mcp");
+var CONFIG_PATH = resolve2(CONFIG_DIR, "trade-config.json");
+var DEFAULT_CONFIG = {
+  exchange: "okx",
+  symbol: "BTC/USDT:USDT",
+  market_type: "swap",
+  capital_pct: 0.5,
+  leverage: 20,
+  stop_loss_pct: 0.025,
+  take_profit_pct: 0.05
+};
+function loadConfig() {
+  if (existsSync(CONFIG_PATH)) {
+    try {
+      return { ...DEFAULT_CONFIG, ...JSON.parse(readFileSync(CONFIG_PATH, "utf-8")) };
+    } catch {
+    }
+  }
+  return { ...DEFAULT_CONFIG };
+}
+function saveConfig(cfg) {
+  mkdirSync(CONFIG_DIR, { recursive: true });
+  writeFileSync(CONFIG_PATH, JSON.stringify(cfg, null, 2));
+}
+function registerAutoTradeTools(server2) {
+  server2.tool(
+    "auto_trade",
+    "Automated trading with risk management. AI agent decides strategy, this tool executes.\n\u2022 setup \u2014 save trading config (exchange, symbol, leverage, SL/TP%)\n\u2022 status \u2014 show config + balance + positions + open orders\n\u2022 open \u2014 execute trade: calculate position \u2192 set leverage \u2192 market order \u2192 SL/TP. Requires: direction (long/short)\n\u2022 close \u2014 cancel open orders \u2192 close position",
+    {
+      action: z12.enum(["setup", "status", "open", "close"]).describe(
+        "setup: save config; status: show state; open: execute trade; close: close position"
+      ),
+      direction: z12.enum(["long", "short"]).optional().describe("REQUIRED for open. Trade direction decided by AI agent"),
+      exchange: z12.string().optional().describe("Exchange ID override"),
+      symbol: z12.string().optional().describe("Trading pair override, e.g. BTC/USDT:USDT"),
+      market_type: z12.enum(["spot", "future", "swap"]).optional().describe("Market type override"),
+      capital_pct: z12.number().min(0.01).max(1).optional().describe("Capital allocation ratio (0.01-1.0)"),
+      leverage: z12.number().int().min(1).max(125).optional().describe("Leverage multiplier"),
+      stop_loss_pct: z12.number().min(1e-3).max(0.5).optional().describe("Stop-loss percentage (e.g. 0.025 = 2.5%)"),
+      take_profit_pct: z12.number().min(1e-3).max(1).optional().describe("Take-profit percentage (e.g. 0.05 = 5%)")
+    },
+    async ({ action, direction, exchange, symbol, market_type, capital_pct, leverage, stop_loss_pct, take_profit_pct }) => {
+      try {
+        const overrides = {};
+        if (exchange !== void 0) overrides.exchange = exchange;
+        if (symbol !== void 0) overrides.symbol = symbol;
+        if (market_type !== void 0) overrides.market_type = market_type;
+        if (capital_pct !== void 0) overrides.capital_pct = capital_pct;
+        if (leverage !== void 0) overrides.leverage = leverage;
+        if (stop_loss_pct !== void 0) overrides.stop_loss_pct = stop_loss_pct;
+        if (take_profit_pct !== void 0) overrides.take_profit_pct = take_profit_pct;
+        const cfg = { ...loadConfig(), ...overrides };
+        switch (action) {
+          case "setup": {
+            saveConfig(cfg);
+            return ok({ saved: CONFIG_PATH, config: cfg });
+          }
+          case "status": {
+            const result = { config: cfg };
+            const ex = getExchange(cfg.exchange, cfg.market_type);
+            try {
+              const bal = await ex.fetchBalance();
+              const stablecoins = ["USDT", "USDC", "BUSD", "DAI", "TUSD", "FDUSD"];
+              const summary = {};
+              for (const [ccy, amt] of Object.entries(bal.total || {})) {
+                const total = Number(amt);
+                if (total <= 0) continue;
+                if (stablecoins.includes(ccy) && total < 0.01) continue;
+                if (!stablecoins.includes(ccy) && total < 1e-7) continue;
+                summary[ccy] = { free: bal.free?.[ccy], used: bal.used?.[ccy], total: bal.total?.[ccy] };
+              }
+              result.balance = summary;
+            } catch (e) {
+              result.balance = { error: e instanceof Error ? e.message : String(e) };
+            }
+            try {
+              result.positions = await ex.fetchPositions([cfg.symbol]);
+            } catch (e) {
+              result.positions = { error: e instanceof Error ? e.message : String(e) };
+            }
+            try {
+              result.open_orders = await ex.fetchOpenOrders(cfg.symbol);
+            } catch (e) {
+              result.open_orders = { error: e instanceof Error ? e.message : String(e) };
+            }
+            return ok(result);
+          }
+          case "open": {
+            if (!direction || !["long", "short"].includes(direction)) {
+              return err('Missing "direction": must be "long" or "short"');
+            }
+            const ex = getExchange(cfg.exchange, cfg.market_type);
+            const bal = await ex.fetchBalance();
+            const quote = cfg.symbol.split("/")[1]?.split(":")[0] || "USDT";
+            const available = Number(bal.free?.[quote] || 0);
+            if (available < 1) return err(`Insufficient ${quote} balance: ${available}`);
+            const ticker = await ex.fetchTicker(cfg.symbol);
+            const price = ticker.last ?? ticker.close ?? 0;
+            if (!price) return err("Could not fetch current price");
+            await ex.loadMarkets();
+            const mkt = ex.markets[cfg.symbol];
+            if (!mkt) return err(`Symbol '${cfg.symbol}' not found on ${cfg.exchange}`);
+            const contractSize = mkt.contractSize || 1;
+            const amountStep = mkt.precision?.amount || 0.01;
+            const amountMin = mkt.limits?.amount?.min || amountStep;
+            const capital = available * cfg.capital_pct;
+            const positionValue = capital * cfg.leverage;
+            const amountInBase = positionValue / price;
+            const rawAmount = cfg.market_type !== "spot" && contractSize ? amountInBase / contractSize : amountInBase;
+            const amount = Math.max(Math.floor(rawAmount / amountStep) * amountStep, amountMin);
+            if (amount * contractSize * price < 1) {
+              return err(`Position too small: ${amount} contracts \u2248 ${(amount * contractSize).toFixed(6)} ${mkt.base}`);
+            }
+            try {
+              await ex.setLeverage(cfg.leverage, cfg.symbol);
+            } catch {
+            }
+            const side = direction === "long" ? "buy" : "sell";
+            const order = await ex.createOrder(cfg.symbol, "market", side, amount);
+            const slPrice = direction === "long" ? price * (1 - cfg.stop_loss_pct) : price * (1 + cfg.stop_loss_pct);
+            const tpPrice = direction === "long" ? price * (1 + cfg.take_profit_pct) : price * (1 - cfg.take_profit_pct);
+            const closeSide = direction === "long" ? "sell" : "buy";
+            let sl, tp;
+            try {
+              sl = await ex.createOrder(cfg.symbol, "market", closeSide, amount, void 0, {
+                stopLossPrice: Number(slPrice.toPrecision(6)),
+                reduceOnly: true
+              });
+            } catch (e) {
+              sl = { error: e instanceof Error ? e.message : String(e) };
+            }
+            try {
+              tp = await ex.createOrder(cfg.symbol, "market", closeSide, amount, void 0, {
+                takeProfitPrice: Number(tpPrice.toPrecision(6)),
+                reduceOnly: true
+              });
+            } catch (e) {
+              tp = { error: e instanceof Error ? e.message : String(e) };
+            }
+            return ok({
+              direction,
+              amount,
+              amount_base: `${Number((amount * contractSize).toPrecision(4))} ${mkt.base}`,
+              contract_size: contractSize !== 1 ? `1 contract = ${contractSize} ${mkt.base}` : null,
+              entry_price: price,
+              stop_loss: Number(slPrice.toPrecision(6)),
+              take_profit: Number(tpPrice.toPrecision(6)),
+              order_id: order.id,
+              sl_order: sl?.id ?? sl?.error,
+              tp_order: tp?.id ?? tp?.error,
+              capital_used: capital.toFixed(2),
+              position_value: positionValue.toFixed(2)
+            });
+          }
+          case "close": {
+            const ex = getExchange(cfg.exchange, cfg.market_type);
+            try {
+              if (ex.has["cancelAllOrders"]) {
+                await ex.cancelAllOrders(cfg.symbol);
+              } else {
+                const open = await ex.fetchOpenOrders(cfg.symbol);
+                await Promise.allSettled(open.map((o) => ex.cancelOrder(o.id, cfg.symbol)));
+              }
+            } catch {
+            }
+            const positions = await ex.fetchPositions([cfg.symbol]);
+            const pos = positions.find(
+              (p) => p.symbol === cfg.symbol && Math.abs(Number(p.contracts || 0)) > 0
+            );
+            if (!pos) return ok({ closed: false, reason: "No open position" });
+            const amount = Math.abs(Number(pos.contracts));
+            const closeSide = Number(pos.contracts) > 0 ? "sell" : "buy";
+            const order = await ex.createOrder(cfg.symbol, "market", closeSide, amount);
+            return ok({
+              closed: true,
+              side: closeSide,
+              amount,
+              order_id: order.id
+            });
+          }
+        }
+      } catch (e) {
+        return err(e);
+      }
+    }
+  );
+}
+
 // src/tools/index.ts
 function registerAllTools(server2) {
   registerTradeTools(server2);
@@ -3460,13 +3748,15 @@ function registerAllTools(server2) {
   registerGuideTools(server2);
   registerFreqtradeTools(server2);
   registerFreqtradeDevTools(server2);
+  registerFtDeployTools(server2);
+  registerAutoTradeTools(server2);
 }
 
 // src/index.ts
-var __dirname = dirname2(fileURLToPath2(import.meta.url));
+var __dirname = dirname3(fileURLToPath3(import.meta.url));
 var pkg = JSON.parse(
-  readFileSync(
-    resolve(__dirname, "..", "package.json"),
+  readFileSync2(
+    resolve3(__dirname, "..", "package.json"),
     "utf-8"
   )
 );

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aicoin/aicoin-mcp",
-  "version": "1.1.1",
+  "version": "1.2.0",
   "description": "AiCoin MCP Server - unified crypto market data & trading via AiCoin API + CCXT",
   "main": "build/index.js",
   "type": "module",
@@ -9,6 +9,7 @@
   },
   "files": [
     "build",
+    "scripts",
     "python",
     "README.md",
     ".env.example"

package/scripts/ft-deploy.mjs

@@ -0,0 +1,433 @@
+#!/usr/bin/env node
+// Freqtrade One-Click Deployment via git clone + setup.sh (official method)
+// Reads exchange keys from env vars, creates config, starts as background process
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { execSync } from 'node:child_process';
+import { randomBytes } from 'node:crypto';
+
+const FT_DIR = resolve(process.env.HOME || '', '.freqtrade');
+const SRC_DIR = resolve(FT_DIR, 'source');
+const VENV_DIR = resolve(SRC_DIR, '.venv');
+const USER_DATA = resolve(FT_DIR, 'user_data');
+const STRAT_DIR = resolve(USER_DATA, 'strategies');
+const CONFIG_PATH = resolve(USER_DATA, 'config.json');
+const PID_FILE = resolve(FT_DIR, 'freqtrade.pid');
+const LOG_FILE = resolve(FT_DIR, 'freqtrade.log');
+const API_PORT = process.env.FREQTRADE_PORT || '8080';
+
+const FT_BIN = resolve(VENV_DIR, 'bin', 'freqtrade');
+
+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; }
+}
+
+// Find the best Python >= 3.11 (Freqtrade requirement)
+function findPython() {
+  for (const bin of ['python3.13', 'python3.12', 'python3.11', 'python3']) {
+    try {
+      const version = run(`${bin} --version`);
+      const match = version.match(/(\d+)\.(\d+)/);
+      if (match) {
+        const major = Number(match[1]), minor = Number(match[2]);
+        if (major === 3 && minor >= 11) return { bin, major, minor, version };
+      }
+    } catch {}
+  }
+  return null;
+}
+
+// Ensure Python 3.11+ is available (Freqtrade requirement)
+function ensureModernPython() {
+  let py = findPython();
+  if (py) return py;
+
+  // No Python 3.11+ found — try to install
+  if (process.platform === 'darwin') {
+    if (!hasCommand('brew')) {
+      throw new Error('Homebrew not found. Install: /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"');
+    }
+    console.error('Python 3.11+ not found. Installing Python 3.12 via Homebrew...');
+    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;
+  }
+
+  throw new Error('Python 3.11+ required. Install: brew install python@3.12 (macOS) or apt install python3.12 python3.12-venv (Linux)');
+}
+
+// ─── Exchange & config ───
+
+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}_SECRET`]) {
+      return {
+        name: ex.toLowerCase(),
+        key: process.env[`${ex}_API_KEY`],
+        secret: process.env[`${ex}_SECRET`],
+        password: process.env[`${ex}_PASSPHRASE`] || '',
+      };
+    }
+  }
+  return null;
+}
+
+function generateConfig(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: Number(API_PORT),
+      verbosity: 'error',
+      enable_openapi: false,
+      jwt_secret_key: randomBytes(16).toString('hex'),
+      CORS_origins: [],
+      username: 'freqtrader',
+      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;
+    // HTTP proxies don't support WebSocket — disable WS to force REST polling
+    config.exchange.enable_ws = false;
+  }
+  return config;
+}
+
+function getPid() {
+  if (!existsSync(PID_FILE)) return null;
+  const pid = readFileSync(PID_FILE, 'utf-8').trim();
+  if (!pid) return null;
+  try { process.kill(Number(pid), 0); return Number(pid); } catch { return null; }
+}
+
+// ─── Actions ───
+
+const actions = {
+  check: async () => {
+    const checks = {};
+    // Python — needs 3.11+
+    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 {}
+    }
+    // git
+    checks.git = hasCommand('git');
+    // Freqtrade source
+    checks.source_cloned = existsSync(resolve(SRC_DIR, 'setup.sh'));
+    // Freqtrade installed
+    checks.freqtrade_installed = existsSync(FT_BIN);
+    if (checks.freqtrade_installed) {
+      try { checks.freqtrade_version = run(`${FT_BIN} --version`); } catch {}
+    }
+    // Exchange keys
+    const ex = detectExchange();
+    checks.exchange = ex ? { name: ex.name, configured: true } : { configured: false };
+    // Running
+    const pid = getPid();
+    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: async (params = {}) => {
+    // 1. Ensure Python 3.11+ (auto-installs on macOS if needed)
+    const py = ensureModernPython();
+    console.error(`Using ${py.version} (${py.bin})`);
+
+    // 2. Ensure git
+    if (!hasCommand('git')) throw new Error('git not found. Install: apt install git (Linux) or xcode-select --install (macOS)');
+
+    // 3. Detect exchange
+    const exchangeInfo = detectExchange();
+    if (!exchangeInfo) throw new Error('No exchange API keys found in env');
+
+    // 4. Create directories
+    mkdirSync(STRAT_DIR, { recursive: true });
+
+    // 5. Clone + install Freqtrade via official setup.sh
+    if (!existsSync(FT_BIN)) {
+      if (!existsSync(resolve(SRC_DIR, 'setup.sh'))) {
+        console.error('Cloning Freqtrade repository...');
+        run(`git clone https://github.com/freqtrade/freqtrade.git ${SRC_DIR}`, { timeout: 120000 });
+        run(`cd ${SRC_DIR} && git checkout stable`, { timeout: 30000 });
+      }
+      console.error('Running Freqtrade setup.sh (this may take a few minutes)...');
+      run(`cd ${SRC_DIR} && ./setup.sh -i`, { timeout: 600000 });
+      if (!existsSync(FT_BIN)) {
+        throw new Error('Freqtrade installation failed. Check output above for errors.');
+      }
+    }
+
+    // 6. Generate config
+    const apiPassword = randomBytes(8).toString('hex');
+    const config = generateConfig(exchangeInfo, apiPassword, params);
+    writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2));
+
+    // 7. Create sample strategy if none exists
+    const samplePath = resolve(STRAT_DIR, 'SampleStrategy.py');
+    if (!existsSync(samplePath)) {
+      writeFileSync(samplePath, SAMPLE_STRATEGY);
+    }
+
+    // 8. Stop existing process
+    const oldPid = getPid();
+    if (oldPid) { try { process.kill(oldPid, 'SIGTERM'); } catch {} }
+
+    // 9. Start freqtrade as background process (with proxy env vars)
+    const strategy = params.strategy || 'SampleStrategy';
+    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} > ${LOG_FILE} 2>&1 & echo $! > ${PID_FILE}`);
+
+    // 10. Wait for startup
+    let ready = false;
+    for (let i = 0; i < 15; i++) {
+      await new Promise(r => setTimeout(r, 2000));
+      const pid = getPid();
+      if (pid) {
+        try {
+          const res = await fetch(`http://127.0.0.1:${API_PORT}/api/v1/ping`, {
+            headers: { Authorization: 'Basic ' + Buffer.from(`freqtrader:${apiPassword}`).toString('base64') },
+            signal: AbortSignal.timeout(3000),
+          });
+          if (res.ok) { ready = true; break; }
+        } catch {}
+      }
+    }
+
+    return {
+      success: true,
+      exchange: exchangeInfo.name,
+      strategy,
+      dry_run: config.dry_run,
+      pairs: config.exchange.pair_whitelist,
+      api_url: `http://127.0.0.1:${API_PORT}`,
+      api_password: apiPassword,
+      pid: getPid(),
+      ready,
+      log_file: LOG_FILE,
+      config_path: CONFIG_PATH,
+      strategies_dir: STRAT_DIR,
+      note: config.dry_run
+        ? 'Running in DRY-RUN mode (no real money). Use deploy with {"dry_run":false} for live trading.'
+        : 'WARNING: Running in LIVE mode with real money!',
+    };
+  },
+
+  update: async () => {
+    if (!existsSync(resolve(SRC_DIR, 'setup.sh'))) {
+      return { error: 'Freqtrade not installed. Run deploy first.' };
+    }
+    const pid = getPid();
+    if (pid) { try { process.kill(pid, 'SIGTERM'); } catch {} }
+    console.error('Updating Freqtrade...');
+    run(`cd ${SRC_DIR} && ./setup.sh -u`, { timeout: 600000 });
+    return { updated: true, note: 'Run start to restart Freqtrade.' };
+  },
+
+  status: async () => {
+    const pid = getPid();
+    if (!pid) return { running: false };
+    let lastLogs = '';
+    try { lastLogs = run(`tail -5 ${LOG_FILE} 2>/dev/null`); } catch {}
+    return { running: true, pid, log_file: LOG_FILE, last_logs: lastLogs };
+  },
+
+  stop: async () => {
+    const pid = getPid();
+    if (!pid) return { stopped: false, reason: 'Not running' };
+    try { process.kill(pid, 'SIGTERM'); } catch {}
+    try { writeFileSync(PID_FILE, ''); } catch {}
+    return { stopped: true, pid };
+  },
+
+  start: async (params = {}) => {
+    if (getPid()) return { started: false, 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} > ${LOG_FILE} 2>&1 & echo $! > ${PID_FILE}`);
+    await new Promise(r => setTimeout(r, 3000));
+    return { started: true, pid: getPid() };
+  },
+
+  logs: async (params = {}) => {
+    const lines = params.lines || 50;
+    try { return { logs: run(`tail -${lines} ${LOG_FILE} 2>/dev/null`) }; } catch { return { logs: 'No log file found' }; }
+  },
+
+  backtest: async (params = {}) => {
+    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 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 historical data...');
+    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 backtest: strategy=${strategy}, timeframe=${timeframe}${timerange ? `, timerange=${timerange}` : ''}...`);
+    const output = run(
+      `${proxyPrefix}${FT_BIN} backtesting --config ${CONFIG_PATH} --strategy ${strategy} --timeframe ${timeframe}${timerangeArg} --userdir ${USER_DATA}`,
+      { timeout: 600000 }
+    );
+    return { strategy, timeframe, timerange: timerange || 'all available', output };
+  },
+
+  download_data: async (params = {}) => {
+    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 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 { timeframe, timerange: timerange || 'all available', output };
+  },
+
+  remove: async () => {
+    const pid = getPid();
+    if (pid) { try { process.kill(pid, 'SIGTERM'); } catch {} }
+    try { writeFileSync(PID_FILE, ''); } catch {}
+    return { removed: true, note: `Process stopped. Config preserved at ${FT_DIR}. To fully remove: rm -rf ${FT_DIR}` };
+  },
+};
+
+// ─── Sample strategy (pure pandas, no TA-Lib dependency) ───
+
+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
+`;
+
+// ─── 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);
+}
+const params = rest.length ? JSON.parse(rest.join(' ')) : {};
+actions[action](params).then(r => {
+  r._reminder = 'IMPORTANT: Always use ft_deploy tool for ALL Freqtrade operations. NEVER use Docker commands.';
+  console.log(JSON.stringify(r, null, 2));
+}).catch(e => {
+  console.error(e.message);
+  process.exit(1);
+});