@pionex/pionex-trade-mcp 0.2.14 → 0.2.16

package/dist/index.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { dirname as dirname2, join as join2 } from "path";
-import { fileURLToPath, pathToFileURL } from "url";
+import { parseArgs } from "util";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 
 // ../core/dist/index.js
 import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
@@ -695,6 +695,7 @@ function parse(toml, { maxDepth = 1e3, integersAsBigInt } = {}) {
 }
 
 // ../core/dist/index.js
+import crypto from "crypto";
 function configFilePath() {
   return join(homedir(), ".pionex", "config.toml");
 }
@@ -718,43 +719,707 @@ var CLIENT_NAMES = {
   openclaw: "OpenClaw (mcporter)"
 };
 var SUPPORTED_CLIENTS = Object.keys(CLIENT_NAMES);
-
-// src/index.ts
-var __dirname = dirname2(fileURLToPath(import.meta.url));
-function applyProfileToEnv(profile) {
-  if (!process.env.PIONEX_API_KEY && profile.api_key) {
-    process.env.PIONEX_API_KEY = profile.api_key;
+var PIONEX_API_DEFAULT_BASE_URL = "https://api.pionex.com";
+var MODULES = ["market", "account", "orders"];
+var DEFAULT_MODULES = ["market", "account", "orders"];
+var ConfigError = class extends Error {
+  suggestion;
+  constructor(message, suggestion) {
+    super(message);
+    this.name = "ConfigError";
+    this.suggestion = suggestion;
   }
-  if (!process.env.PIONEX_API_SECRET && profile.secret_key) {
-    process.env.PIONEX_API_SECRET = profile.secret_key;
+};
+var PionexApiError = class extends Error {
+  status;
+  endpoint;
+  responseText;
+  constructor(message, opts) {
+    super(message);
+    this.name = "PionexApiError";
+    this.status = opts?.status;
+    this.endpoint = opts?.endpoint;
+    this.responseText = opts?.responseText;
   }
-  if (!process.env.PIONEX_BASE_URL && profile.base_url) {
-    process.env.PIONEX_BASE_URL = profile.base_url;
+};
+function toToolErrorPayload(error) {
+  if (error instanceof ConfigError) {
+    return {
+      error: true,
+      type: "ConfigError",
+      message: error.message,
+      suggestion: error.suggestion
+    };
   }
+  if (error instanceof PionexApiError) {
+    return {
+      error: true,
+      type: "PionexApiError",
+      message: error.message,
+      status: error.status,
+      endpoint: error.endpoint,
+      responseText: error.responseText
+    };
+  }
+  const message = error instanceof Error ? error.message : String(error);
+  return { error: true, type: "Error", message };
+}
+function parseModuleList(rawModules) {
+  if (!rawModules || rawModules.trim().length === 0) return [...DEFAULT_MODULES];
+  const trimmed = rawModules.trim().toLowerCase();
+  if (trimmed === "all") return [...MODULES];
+  const requested = trimmed.split(",").map((x) => x.trim()).filter(Boolean);
+  if (requested.length === 0) return [...DEFAULT_MODULES];
+  const out = [];
+  for (const m of requested) {
+    if (!MODULES.includes(m)) {
+      throw new ConfigError(`Unknown module "${m}".`, `Use one of: ${MODULES.join(", ")} or "all".`);
+    }
+    out.push(m);
+  }
+  return Array.from(new Set(out));
+}
+function loadConfig(cli) {
+  const toml = readTomlProfile(cli.profile);
+  const apiKey = process.env.PIONEX_API_KEY?.trim() || toml.api_key;
+  const apiSecret = process.env.PIONEX_API_SECRET?.trim() || toml.secret_key;
+  const hasAuth = Boolean(apiKey && apiSecret);
+  const partialAuth = Boolean(apiKey) || Boolean(apiSecret);
+  if (partialAuth && !hasAuth) {
+    throw new ConfigError(
+      "Partial Pionex API credentials detected.",
+      "Set both PIONEX_API_KEY and PIONEX_API_SECRET (env vars or config.toml profile)."
+    );
+  }
+  const baseUrl = (cli.baseUrl?.trim() || process.env.PIONEX_BASE_URL?.trim() || toml.base_url || PIONEX_API_DEFAULT_BASE_URL).replace(/\/+$/, "");
+  if (!baseUrl.startsWith("http://") && !baseUrl.startsWith("https://")) {
+    throw new ConfigError(`Invalid base URL "${baseUrl}".`, "PIONEX_BASE_URL must start with http:// or https://");
+  }
+  return {
+    apiKey,
+    apiSecret,
+    hasAuth,
+    baseUrl,
+    modules: parseModuleList(cli.modules),
+    readOnly: cli.readOnly
+  };
+}
+function requireAuth(config) {
+  if (!config.apiKey || !config.apiSecret) {
+    throw new ConfigError(
+      "This operation requires authentication, but no Pionex API credentials were found.",
+      "Run 'pionex-ai-kit onboard' to create ~/.pionex/config.toml, or set PIONEX_API_KEY and PIONEX_API_SECRET."
+    );
+  }
+  return { apiKey: config.apiKey, apiSecret: config.apiSecret };
+}
+function buildQueryString(query) {
+  if (!query) return "";
+  const entries = Object.entries(query).filter(([, v]) => v !== void 0 && v !== null);
+  if (entries.length === 0) return "";
+  const params = new URLSearchParams();
+  for (const [k, v] of entries) params.set(k, String(v));
+  return params.toString();
+}
+function buildSignedRequest(config, method, path2, query, bodyJson) {
+  const { apiKey, apiSecret } = requireAuth(config);
+  const timestamp = Date.now().toString();
+  const params = { ...query, timestamp };
+  const sortedKeys = Object.keys(params).sort();
+  const queryString = sortedKeys.map((k) => `${k}=${params[k]}`).join("&");
+  const pathUrl = `${path2}?${queryString}`;
+  let payload = `${method}${pathUrl}`;
+  if (bodyJson != null) payload += bodyJson;
+  const signature = crypto.createHmac("sha256", apiSecret).update(payload).digest("hex");
+  const url = `${config.baseUrl}${pathUrl}`;
+  const headers = {
+    "PIONEX-KEY": apiKey,
+    "PIONEX-SIGNATURE": signature,
+    "Content-Type": "application/json"
+  };
+  return { url, headers, bodyJson };
+}
+async function readTextSafe(res) {
+  try {
+    return await res.text();
+  } catch {
+    return "";
+  }
+}
+var PionexRestClient = class {
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  async publicGet(path2, query = {}) {
+    const qs = buildQueryString(query);
+    const endpoint = qs ? `${path2}?${qs}` : path2;
+    const url = `${this.config.baseUrl}${endpoint}`;
+    const res = await fetch(url, { method: "GET", headers: { "Content-Type": "application/json" } });
+    if (!res.ok) {
+      const txt = await readTextSafe(res);
+      throw new PionexApiError(`HTTP ${res.status}: ${txt || res.statusText}`, { status: res.status, endpoint, responseText: txt });
+    }
+    const data = await res.json();
+    return { endpoint, requestTime: (/* @__PURE__ */ new Date()).toISOString(), data };
+  }
+  async signedGet(path2, query = {}) {
+    const { url, headers } = buildSignedRequest(this.config, "GET", path2, query, null);
+    const endpoint = `${path2}?${buildQueryString({ ...query, timestamp: "..." })}`;
+    const res = await fetch(url, { method: "GET", headers });
+    if (!res.ok) {
+      const txt = await readTextSafe(res);
+      throw new PionexApiError(`HTTP ${res.status}: ${txt || res.statusText}`, { status: res.status, endpoint: path2, responseText: txt });
+    }
+    const data = await res.json();
+    return { endpoint: path2, requestTime: (/* @__PURE__ */ new Date()).toISOString(), data };
+  }
+  async signedPost(path2, body) {
+    const bodyJson = JSON.stringify(body);
+    const { url, headers, bodyJson: bj } = buildSignedRequest(this.config, "POST", path2, {}, bodyJson);
+    const res = await fetch(url, { method: "POST", headers, body: bj ?? void 0 });
+    if (!res.ok) {
+      const txt = await readTextSafe(res);
+      throw new PionexApiError(`HTTP ${res.status}: ${txt || res.statusText}`, { status: res.status, endpoint: path2, responseText: txt });
+    }
+    const data = await res.json();
+    return { endpoint: path2, requestTime: (/* @__PURE__ */ new Date()).toISOString(), data };
+  }
+  async signedDelete(path2, body) {
+    const bodyJson = JSON.stringify(body);
+    const { url, headers, bodyJson: bj } = buildSignedRequest(this.config, "DELETE", path2, {}, bodyJson);
+    const res = await fetch(url, { method: "DELETE", headers, body: bj ?? void 0 });
+    if (!res.ok) {
+      const txt = await readTextSafe(res);
+      throw new PionexApiError(`HTTP ${res.status}: ${txt || res.statusText}`, { status: res.status, endpoint: path2, responseText: txt });
+    }
+    const data = await res.json();
+    return { endpoint: path2, requestTime: (/* @__PURE__ */ new Date()).toISOString(), data };
+  }
+};
+function registerMarketTools() {
+  return [
+    {
+      name: "pionex_market_get_depth",
+      module: "market",
+      isWrite: false,
+      description: "Get order book depth (bids and asks) for a symbol. Use for spread, liquidity, or best bid/ask.",
+      inputSchema: {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          symbol: { type: "string", description: "e.g. BTC_USDT" },
+          limit: { type: "integer", description: "Price levels (1-100), default 5" }
+        },
+        required: ["symbol"]
+      },
+      async handler(args, { client }) {
+        const symbol = String(args.symbol);
+        const limit = args.limit == null ? void 0 : Number(args.limit);
+        const q = { symbol };
+        if (limit != null && Number.isFinite(limit)) q.limit = limit;
+        return (await client.publicGet("/api/v1/market/depth", q)).data;
+      }
+    },
+    {
+      name: "pionex_market_get_trades",
+      module: "market",
+      isWrite: false,
+      description: "Get recent trades for a symbol. Use for latest price and volume.",
+      inputSchema: {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          symbol: { type: "string", description: "e.g. BTC_USDT" },
+          limit: { type: "integer", description: "Default 5 (1-100)" }
+        },
+        required: ["symbol"]
+      },
+      async handler(args, { client }) {
+        const symbol = String(args.symbol);
+        const limit = args.limit == null ? void 0 : Number(args.limit);
+        const q = { symbol };
+        if (limit != null && Number.isFinite(limit)) q.limit = limit;
+        return (await client.publicGet("/api/v1/market/trades", q)).data;
+      }
+    },
+    {
+      name: "pionex_market_get_symbol_info",
+      module: "market",
+      isWrite: false,
+      description: "Get symbol metadata (precision, min size, price limits). Call before placing orders to avoid amount/size filter errors.",
+      inputSchema: {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          symbols: {
+            type: "string",
+            description: 'Optional. One or more symbols, comma-separated, e.g. "BTC_USDT" or "BTC_USDT,ADA_USDT".'
+          },
+          type: {
+            type: "string",
+            enum: ["SPOT", "PERP"],
+            description: "Optional. If no symbols are specified, filter by type (default SPOT)."
+          }
+        }
+      },
+      async handler(args, { client }) {
+        const q = {};
+        if (args.symbols) q.symbols = String(args.symbols);
+        if (!args.symbols && args.type) q.type = String(args.type);
+        return (await client.publicGet("/api/v1/common/symbols", q)).data;
+      }
+    },
+    {
+      name: "pionex_market_get_tickers",
+      module: "market",
+      isWrite: false,
+      description: "Get 24-hour ticker(s): open, close, high, low, volume, amount, count. Optional symbol or type (SPOT/PERP).",
+      inputSchema: {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          symbol: { type: "string", description: "e.g. BTC_USDT; if omitted, returns all tickers filtered by type" },
+          type: { type: "string", enum: ["SPOT", "PERP"], description: "If symbol is not specified, filter by type." }
+        }
+      },
+      async handler(args, { client }) {
+        const q = {};
+        if (args.symbol) q.symbol = String(args.symbol);
+        if (args.type) q.type = String(args.type);
+        return (await client.publicGet("/api/v1/market/tickers", q)).data;
+      }
+    },
+    {
+      name: "pionex_market_get_klines",
+      module: "market",
+      isWrite: false,
+      description: "Get OHLCV klines (candlestick) for a symbol. Use for charts or historical price/volume.",
+      inputSchema: {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          symbol: { type: "string", description: "e.g. BTC_USDT" },
+          interval: { type: "string", enum: ["1M", "5M", "15M", "30M", "60M", "4H", "8H", "12H", "1D"], description: "Kline interval." },
+          endTime: { type: "integer", description: "End time in milliseconds." },
+          limit: { type: "integer", description: "Default 100 (1-500)." }
+        },
+        required: ["symbol", "interval"]
+      },
+      async handler(args, { client }) {
+        const symbol = String(args.symbol);
+        const interval = String(args.interval);
+        const q = { symbol, interval };
+        if (args.endTime != null) q.endTime = Number(args.endTime);
+        if (args.limit != null) q.limit = Number(args.limit);
+        return (await client.publicGet("/api/v1/market/klines", q)).data;
+      }
+    }
+  ];
+}
+function registerAccountTools() {
+  return [
+    {
+      name: "pionex_account_get_balance",
+      module: "account",
+      isWrite: false,
+      description: "Query spot account balances for all currencies. Requires API key and secret in ~/.pionex/config.toml or env.",
+      inputSchema: { type: "object", additionalProperties: false, properties: {} },
+      async handler(_args, { client }) {
+        return (await client.signedGet("/api/v1/account/balances")).data;
+      }
+    }
+  ];
+}
+function registerOrdersTools() {
+  return [
+    {
+      name: "pionex_orders_new_order",
+      module: "orders",
+      isWrite: true,
+      description: "Create a spot order on Pionex. LIMIT requires symbol/side/type=LIMIT/price/size. MARKET BUY requires amount (quote). MARKET SELL requires size (base).",
+      inputSchema: {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          symbol: { type: "string", description: "e.g. BTC_USDT" },
+          side: { type: "string", enum: ["BUY", "SELL"] },
+          type: { type: "string", enum: ["LIMIT", "MARKET"] },
+          clientOrderId: { type: "string", description: "Optional client order id (max 64 chars)" },
+          size: { type: "string", description: "Quantity; required for limit and market sell" },
+          price: { type: "string", description: "Required for limit order" },
+          amount: { type: "string", description: "Quote amount; required for market buy" },
+          IOC: { type: "boolean", description: "Immediate-or-cancel, default false" }
+        },
+        required: ["symbol", "side", "type"]
+      },
+      async handler(args, { client, config }) {
+        if (config.readOnly) {
+          throw new Error("Server is running in --read-only mode; order placement is disabled.");
+        }
+        const body = {};
+        if (args.symbol != null) body.symbol = String(args.symbol);
+        if (args.side != null) body.side = String(args.side);
+        if (args.type != null) body.type = String(args.type);
+        if (args.clientOrderId != null) body.clientOrderId = String(args.clientOrderId);
+        if (args.size != null) body.size = String(args.size);
+        if (args.price != null) body.price = String(args.price);
+        if (args.amount != null) body.amount = String(args.amount);
+        if (args.IOC != null) body.IOC = Boolean(args.IOC);
+        return (await client.signedPost("/api/v1/trade/order", body)).data;
+      }
+    },
+    {
+      name: "pionex_orders_get_order",
+      module: "orders",
+      isWrite: false,
+      description: "Get a single order by order ID.",
+      inputSchema: {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          symbol: { type: "string", description: "e.g. BTC_USDT" },
+          orderId: { type: "integer", description: "Order id" }
+        },
+        required: ["symbol", "orderId"]
+      },
+      async handler(args, { client }) {
+        const symbol = String(args.symbol);
+        const orderId = Number(args.orderId);
+        return (await client.signedGet("/api/v1/trade/order", { symbol, orderId })).data;
+      }
+    },
+    {
+      name: "pionex_orders_get_order_by_client_order_id",
+      module: "orders",
+      isWrite: false,
+      description: "Get a single order by client order ID.",
+      inputSchema: {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          symbol: { type: "string", description: "e.g. BTC_USDT" },
+          clientOrderId: { type: "string", description: "Client order id" }
+        },
+        required: ["symbol", "clientOrderId"]
+      },
+      async handler(args, { client }) {
+        const symbol = String(args.symbol);
+        const clientOrderId = String(args.clientOrderId);
+        return (await client.signedGet("/api/v1/trade/orderByClientOrderId", { symbol, clientOrderId })).data;
+      }
+    },
+    {
+      name: "pionex_orders_get_open_orders",
+      module: "orders",
+      isWrite: false,
+      description: "List open (unfilled) orders for a symbol.",
+      inputSchema: {
+        type: "object",
+        additionalProperties: false,
+        properties: { symbol: { type: "string", description: "e.g. BTC_USDT" } },
+        required: ["symbol"]
+      },
+      async handler(args, { client }) {
+        const symbol = String(args.symbol);
+        return (await client.signedGet("/api/v1/trade/openOrders", { symbol })).data;
+      }
+    },
+    {
+      name: "pionex_orders_get_all_orders",
+      module: "orders",
+      isWrite: false,
+      description: "List order history for a symbol (filled and cancelled), with optional limit.",
+      inputSchema: {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          symbol: { type: "string", description: "e.g. BTC_USDT" },
+          limit: { type: "integer", description: "Default 1 (1-100)" }
+        },
+        required: ["symbol"]
+      },
+      async handler(args, { client }) {
+        const symbol = String(args.symbol);
+        const q = { symbol };
+        if (args.limit != null) q.limit = Number(args.limit);
+        return (await client.signedGet("/api/v1/trade/allOrders", q)).data;
+      }
+    },
+    {
+      name: "pionex_orders_cancel_order",
+      module: "orders",
+      isWrite: true,
+      description: "Cancel an open order by order ID.",
+      inputSchema: {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          symbol: { type: "string", description: "e.g. BTC_USDT" },
+          orderId: { type: "integer", description: "Order id" }
+        },
+        required: ["symbol", "orderId"]
+      },
+      async handler(args, { client, config }) {
+        if (config.readOnly) {
+          throw new Error("Server is running in --read-only mode; order cancellation is disabled.");
+        }
+        const symbol = String(args.symbol);
+        const orderId = Number(args.orderId);
+        return (await client.signedDelete("/api/v1/trade/order", { symbol, orderId })).data;
+      }
+    },
+    {
+      name: "pionex_orders_get_fills",
+      module: "orders",
+      isWrite: false,
+      description: "Get filled trades (fills) for a symbol in a time range. Requires API key. Returns up to 100 latest fills.",
+      inputSchema: {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          symbol: { type: "string", description: "e.g. BTC_USDT" },
+          startTime: { type: "integer", description: "Start time in milliseconds." },
+          endTime: { type: "integer", description: "End time in milliseconds." }
+        },
+        required: ["symbol"]
+      },
+      async handler(args, { client }) {
+        const symbol = String(args.symbol);
+        const q = { symbol };
+        if (args.startTime != null) q.startTime = Number(args.startTime);
+        if (args.endTime != null) q.endTime = Number(args.endTime);
+        return (await client.signedGet("/api/v1/trade/fills", q)).data;
+      }
+    },
+    {
+      name: "pionex_orders_cancel_all_orders",
+      module: "orders",
+      isWrite: true,
+      description: "Cancel all open orders for a symbol.",
+      inputSchema: {
+        type: "object",
+        additionalProperties: false,
+        properties: { symbol: { type: "string", description: "e.g. BTC_USDT" } },
+        required: ["symbol"]
+      },
+      async handler(args, { client, config }) {
+        if (config.readOnly) {
+          throw new Error("Server is running in --read-only mode; cancel-all is disabled.");
+        }
+        const symbol = String(args.symbol);
+        return (await client.signedDelete("/api/v1/trade/allOrders", { symbol })).data;
+      }
+    }
+  ];
+}
+function allToolSpecs() {
+  return [...registerMarketTools(), ...registerAccountTools(), ...registerOrdersTools()];
+}
+function buildTools(config) {
+  const enabled = new Set(config.modules);
+  const tools = allToolSpecs().filter((t) => enabled.has(t.module));
+  if (!config.readOnly) return tools;
+  return tools.filter((t) => !t.isWrite);
+}
+function toMcpTool(tool) {
+  return {
+    name: tool.name,
+    description: tool.description,
+    inputSchema: tool.inputSchema,
+    annotations: {
+      readOnlyHint: !tool.isWrite,
+      destructiveHint: tool.isWrite,
+      idempotentHint: !tool.isWrite,
+      openWorldHint: false
+    }
+  };
 }
-async function main() {
-  if (process.argv[2] === "--help" || process.argv[2] === "-h") {
-    process.stdout.write(
-      `Usage: pionex-trade-mcp
 
-Starts the Pionex MCP server (stdio). Credentials are read from ~/.pionex/config.toml
-and/or the environment (PIONEX_API_KEY, PIONEX_API_SECRET, PIONEX_BASE_URL).
+// src/server.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+var SERVER_NAME = "pionex-trade-mcp";
+var SERVER_VERSION = "0.3.0";
+var SYSTEM_CAPABILITIES_TOOL_NAME = "system_get_capabilities";
+var SYSTEM_CAPABILITIES_TOOL = {
+  name: SYSTEM_CAPABILITIES_TOOL_NAME,
+  description: "Return machine-readable server capabilities and module availability for agent planning.",
+  inputSchema: { type: "object", additionalProperties: false },
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false
+  }
+};
+function buildCapabilitySnapshot(config) {
+  const enabledModules = new Set(config.modules);
+  const moduleAvailability = {};
+  for (const moduleId of MODULES) {
+    if (!enabledModules.has(moduleId)) {
+      moduleAvailability[moduleId] = { status: "disabled", reasonCode: "MODULE_FILTERED" };
+      continue;
+    }
+    if (moduleId === "market") {
+      moduleAvailability[moduleId] = { status: "enabled" };
+      continue;
+    }
+    if (!config.hasAuth) {
+      moduleAvailability[moduleId] = { status: "requires_auth", reasonCode: "AUTH_MISSING" };
+      continue;
+    }
+    moduleAvailability[moduleId] = { status: "enabled" };
+  }
+  return {
+    readOnly: config.readOnly,
+    hasAuth: config.hasAuth,
+    moduleAvailability
+  };
+}
+function successResult(toolName, data, snapshot) {
+  const payload = {
+    tool: toolName,
+    ok: true,
+    data,
+    capabilities: snapshot,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  return {
+    content: [{ type: "text", text: JSON.stringify(payload, null, 2) }],
+    structuredContent: payload
+  };
+}
+function errorResult(toolName, error, snapshot) {
+  const payload = toToolErrorPayload(error);
+  const structured = {
+    tool: toolName,
+    ...payload,
+    serverVersion: SERVER_VERSION,
+    capabilities: snapshot
+  };
+  return {
+    isError: true,
+    content: [{ type: "text", text: JSON.stringify(structured, null, 2) }],
+    structuredContent: structured
+  };
+}
+function createServer(config) {
+  const client = new PionexRestClient(config);
+  const tools = buildTools(config);
+  const toolMap = new Map(tools.map((t) => [t.name, t]));
+  const server = new Server(
+    { name: SERVER_NAME, version: SERVER_VERSION },
+    { capabilities: { tools: {} } }
+  );
+  server.setRequestHandler(ListToolsRequestSchema, async () => {
+    return { tools: [...tools.map(toMcpTool), SYSTEM_CAPABILITIES_TOOL] };
+  });
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const toolName = request.params.name;
+    const snapshot = buildCapabilitySnapshot(config);
+    if (toolName === SYSTEM_CAPABILITIES_TOOL_NAME) {
+      return successResult(
+        toolName,
+        {
+          server: { name: SERVER_NAME, version: SERVER_VERSION },
+          capabilities: snapshot
+        },
+        snapshot
+      );
+    }
+    const tool = toolMap.get(toolName);
+    if (!tool) {
+      return errorResult(toolName, new Error(`Tool "${toolName}" is not available in this server session.`), snapshot);
+    }
+    try {
+      const data = await tool.handler(request.params.arguments ?? {}, { config, client });
+      return successResult(toolName, data, snapshot);
+    } catch (e) {
+      return errorResult(toolName, e, snapshot);
+    }
+  });
+  return server;
+}
 
-To configure IDEs or agents (Cursor, Claude Desktop, Windsurf, VS Code, OpenClaw),
-use the companion CLI: pionex-ai-kit setup --mcp=pionex-trade-mcp --client <client>.
-`
-    );
+// src/index.ts
+function printHelp() {
+  process.stdout.write(`
+Usage: pionex-trade-mcp [options]
+
+Options:
+  --modules <list>     Comma-separated list of modules to load
+                       Available: market, account, orders
+                       Special: "all" loads all modules
+                       Default: market,account,orders
+
+  --profile <name>     Profile to load from ~/.pionex/config.toml
+                       Falls back to default_profile in config, then "default"
+  --base-url <url>     Override API base URL (otherwise env PIONEX_BASE_URL / toml / default)
+  --read-only          Expose only read/query tools and disable write operations
+  --help               Show this help message
+  --version            Show version
+
+Credentials (priority: env vars > ~/.pionex/config.toml > none):
+  PIONEX_API_KEY       Pionex API key
+  PIONEX_API_SECRET    Pionex API secret
+  PIONEX_BASE_URL      Optional API base URL override
+`);
+}
+function parseCli() {
+  const parsed = parseArgs({
+    options: {
+      modules: { type: "string" },
+      profile: { type: "string" },
+      "base-url": { type: "string" },
+      "read-only": { type: "boolean", default: false },
+      help: { type: "boolean", default: false },
+      version: { type: "boolean", default: false }
+    },
+    allowPositionals: false
+  });
+  return {
+    modules: parsed.values.modules,
+    profile: parsed.values.profile,
+    baseUrl: parsed.values["base-url"],
+    readOnly: parsed.values["read-only"] ?? false,
+    help: parsed.values.help ?? false,
+    version: parsed.values.version ?? false
+  };
+}
+async function main() {
+  const cli = parseCli();
+  if (cli.help) {
+    printHelp();
+    return;
+  }
+  if (cli.version) {
+    process.stdout.write(`pionex-trade-mcp
+`);
     return;
   }
-  const profile = readTomlProfile();
-  applyProfileToEnv(profile);
-  const runServerPath = join2(__dirname, "run-server.js");
-  await import(pathToFileURL(runServerPath).href);
+  const config = loadConfig({
+    modules: cli.modules,
+    profile: cli.profile,
+    baseUrl: cli.baseUrl,
+    readOnly: cli.readOnly
+  });
+  const server = createServer(config);
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
 }
-main().catch((err) => {
-  process.stderr.write(String(err) + "\n");
-  process.exit(1);
+main().catch((error) => {
+  const payload = toToolErrorPayload(error);
+  process.stderr.write(`${JSON.stringify(payload, null, 2)}
+`);
+  process.exitCode = 1;
 });
+export {
+  main
+};
 /*! Bundled license information:
 
 smol-toml/dist/error.js: