@pionex/pionex-ai-kit 0.2.17 → 0.2.19

package/dist/index.js

@@ -2,6 +2,7 @@
 
 // src/index.ts
 import { createInterface } from "readline";
+import { basename } from "path";
 
 // ../core/dist/index.js
 import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
@@ -839,6 +840,7 @@ import * as fs from "fs";
 import * as path from "path";
 import * as os from "os";
 import { execFileSync } from "child_process";
+import crypto from "crypto";
 function configFilePath() {
   return join(homedir(), ".pionex", "config.toml");
 }
@@ -848,6 +850,11 @@ function readFullConfig() {
   const raw = readFileSync(path2, "utf-8");
   return parse(raw);
 }
+function readTomlProfile(profileName) {
+  const config = readFullConfig();
+  const name = profileName ?? config.default_profile ?? "default";
+  return config.profiles?.[name] ?? {};
+}
 function writeFullConfig(config) {
   const path2 = configFilePath();
   const dir = dirname(path2);
@@ -979,6 +986,513 @@ function runSetup(options) {
 `
   );
 }
+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;
+  }
+};
+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;
+  }
+};
+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 createToolRunner(client, config) {
+  const fullConfig = { ...config, modules: [...MODULES] };
+  const toolMap = new Map(allToolSpecs().map((t) => [t.name, t]));
+  return async (toolName, args) => {
+    const tool = toolMap.get(toolName);
+    if (!tool) throw new Error(`Unknown tool: ${toolName}`);
+    const data = await tool.handler(args, { config: fullConfig, client });
+    return { endpoint: toolName, requestTime: (/* @__PURE__ */ new Date()).toISOString(), data };
+  };
+}
 
 // src/index.ts
 var DEFAULT_PROFILE_NAME = "pionx-prod";
@@ -1093,25 +1607,236 @@ function cmdSetup(argv) {
   }
   runSetup({ client: normalizedClient });
 }
-function main() {
-  const cmd = process.argv[2];
-  if (cmd === "onboard") {
-    cmdOnboard().catch((e) => {
-      process.stderr.write(String(e) + "\n");
-      process.exit(1);
-    });
-    return;
+function parseFlags(argv) {
+  const positionals = [];
+  const flags = {};
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (!a.startsWith("--")) {
+      positionals.push(a);
+      continue;
+    }
+    const eq = a.indexOf("=");
+    if (eq !== -1) {
+      const k2 = a.slice(2, eq);
+      const v = a.slice(eq + 1);
+      flags[k2] = v === "true" ? true : v === "false" ? false : v;
+      continue;
+    }
+    const k = a.slice(2);
+    const next = argv[i + 1];
+    if (!next || next.startsWith("--")) {
+      flags[k] = true;
+      continue;
+    }
+    flags[k] = next;
+    i++;
   }
-  if (cmd === "setup") {
-    cmdSetup(process.argv.slice(3));
+  return { positionals, flags };
+}
+function printPionexHelp() {
+  process.stdout.write(`
+Usage: pionex-trade-cli <group> <command> [args] [--flags]
+
+Groups:
+  market   Market data (public)
+  account  Account data (requires auth)
+  orders   Spot orders (requires auth)
+
+Examples:
+  pionex-trade-cli market depth BTC_USDT --limit 5
+  pionex-trade-cli market tickers --symbol BTC_USDT
+  pionex-trade-cli market symbols --symbols BTC_USDT
+  pionex-trade-cli account balance
+  pionex-trade-cli orders new --symbol BTC_USDT --side BUY --type MARKET --amount 10
+  pionex-trade-cli orders cancel --symbol BTC_USDT --order-id 123
+
+Global flags:
+  --profile <name>     Profile in ~/.pionex/config.toml
+  --modules <list>     Comma-separated modules (market,account,orders or all)
+  --base-url <url>     Override API base URL
+  --read-only          Disable write operations (orders new/cancel)
+  --dry-run            Print the tool call payload without executing (write ops only)
+`);
+}
+async function runPionexCommand(argv) {
+  const { positionals, flags } = parseFlags(argv);
+  const group = positionals[0];
+  const command = positionals[1];
+  if (!group || group === "help" || group === "--help" || group === "-h") {
+    printPionexHelp();
     return;
   }
-  if (cmd === "help" || cmd === "--help" || cmd === "-h" || !cmd) {
-    printHelp();
+  const config = loadConfig({
+    profile: typeof flags.profile === "string" ? flags.profile : void 0,
+    modules: typeof flags.modules === "string" ? flags.modules : void 0,
+    baseUrl: typeof flags["base-url"] === "string" ? flags["base-url"] : typeof flags.baseUrl === "string" ? flags.baseUrl : void 0,
+    readOnly: Boolean(flags["read-only"] || flags.readOnly)
+  });
+  const client = new PionexRestClient(config);
+  const runTool = createToolRunner(client, config);
+  const dryRun = Boolean(flags["dry-run"] || flags.dryRun);
+  if (group === "market") {
+    if (command === "depth") {
+      const symbol = positionals[2];
+      if (!symbol) throw new Error("Missing symbol. Example: pionex-trade-cli market depth BTC_USDT");
+      const limit = flags.limit != null ? Number(flags.limit) : void 0;
+      const out = await runTool("pionex_market_get_depth", { symbol, limit });
+      process.stdout.write(JSON.stringify(out.data, null, 2) + "\n");
+      return;
+    }
+    if (command === "trades") {
+      const symbol = positionals[2];
+      if (!symbol) throw new Error("Missing symbol. Example: pionex-trade-cli market trades BTC_USDT");
+      const limit = flags.limit != null ? Number(flags.limit) : void 0;
+      const out = await runTool("pionex_market_get_trades", { symbol, limit });
+      process.stdout.write(JSON.stringify(out.data, null, 2) + "\n");
+      return;
+    }
+    if (command === "symbols") {
+      const symbols = typeof flags.symbols === "string" ? flags.symbols : void 0;
+      const type = typeof flags.type === "string" ? flags.type : void 0;
+      const out = await runTool("pionex_market_get_symbol_info", { symbols, type });
+      process.stdout.write(JSON.stringify(out.data, null, 2) + "\n");
+      return;
+    }
+    if (command === "tickers") {
+      const symbol = typeof flags.symbol === "string" ? flags.symbol : void 0;
+      const type = typeof flags.type === "string" ? flags.type : void 0;
+      const out = await runTool("pionex_market_get_tickers", { symbol, type });
+      process.stdout.write(JSON.stringify(out.data, null, 2) + "\n");
+      return;
+    }
+    if (command === "klines") {
+      const symbol = typeof flags.symbol === "string" ? flags.symbol : positionals[2];
+      const interval = typeof flags.interval === "string" ? flags.interval : positionals[3];
+      if (!symbol || !interval)
+        throw new Error("Missing symbol/interval. Example: pionex-trade-cli market klines BTC_USDT 60M");
+      const endTime = flags.endTime != null ? Number(flags.endTime) : void 0;
+      const limit = flags.limit != null ? Number(flags.limit) : void 0;
+      const out = await runTool("pionex_market_get_klines", { symbol, interval, endTime, limit });
+      process.stdout.write(JSON.stringify(out.data, null, 2) + "\n");
+      return;
+    }
+    throw new Error(`Unknown market command: ${command}`);
+  }
+  if (group === "account") {
+    if (command === "balance") {
+      const out = await runTool("pionex_account_get_balance", {});
+      process.stdout.write(JSON.stringify(out.data, null, 2) + "\n");
+      return;
+    }
+    throw new Error(`Unknown account command: ${command}`);
+  }
+  if (group === "orders") {
+    if (command === "new") {
+      const symbol = typeof flags.symbol === "string" ? flags.symbol : void 0;
+      const side = typeof flags.side === "string" ? flags.side : void 0;
+      const type = typeof flags.type === "string" ? flags.type : void 0;
+      const clientOrderId = typeof flags["client-order-id"] === "string" ? flags["client-order-id"] : typeof flags.clientOrderId === "string" ? flags.clientOrderId : void 0;
+      const size = typeof flags.size === "string" ? flags.size : void 0;
+      const price = typeof flags.price === "string" ? flags.price : void 0;
+      const amount = typeof flags.amount === "string" ? flags.amount : void 0;
+      const IOC = typeof flags.IOC === "boolean" ? flags.IOC : void 0;
+      if (!symbol || !side || !type) throw new Error("Missing required flags: --symbol --side --type");
+      const payload = { symbol, side, type, clientOrderId, size, price, amount, IOC };
+      if (dryRun) {
+        process.stdout.write(JSON.stringify({ tool: "pionex_orders_new_order", args: payload }, null, 2) + "\n");
+        return;
+      }
+      const out = await runTool("pionex_orders_new_order", payload);
+      process.stdout.write(JSON.stringify(out.data, null, 2) + "\n");
+      return;
+    }
+    if (command === "get") {
+      const symbol = typeof flags.symbol === "string" ? flags.symbol : void 0;
+      const orderId = flags["order-id"] != null ? Number(flags["order-id"]) : void 0;
+      if (!symbol || orderId == null) throw new Error("Missing required flags: --symbol --order-id");
+      const out = await runTool("pionex_orders_get_order", { symbol, orderId });
+      process.stdout.write(JSON.stringify(out.data, null, 2) + "\n");
+      return;
+    }
+    if (command === "open") {
+      const symbol = typeof flags.symbol === "string" ? flags.symbol : void 0;
+      if (!symbol) throw new Error("Missing required flag: --symbol");
+      const out = await runTool("pionex_orders_get_open_orders", { symbol });
+      process.stdout.write(JSON.stringify(out.data, null, 2) + "\n");
+      return;
+    }
+    if (command === "all") {
+      const symbol = typeof flags.symbol === "string" ? flags.symbol : void 0;
+      const limit = flags.limit != null ? Number(flags.limit) : void 0;
+      if (!symbol) throw new Error("Missing required flag: --symbol");
+      const out = await runTool("pionex_orders_get_all_orders", { symbol, limit });
+      process.stdout.write(JSON.stringify(out.data, null, 2) + "\n");
+      return;
+    }
+    if (command === "fills") {
+      const symbol = typeof flags.symbol === "string" ? flags.symbol : void 0;
+      const startTime = flags.startTime != null ? Number(flags.startTime) : void 0;
+      const endTime = flags.endTime != null ? Number(flags.endTime) : void 0;
+      if (!symbol) throw new Error("Missing required flag: --symbol");
+      const out = await runTool("pionex_orders_get_fills", { symbol, startTime, endTime });
+      process.stdout.write(JSON.stringify(out.data, null, 2) + "\n");
+      return;
+    }
+    if (command === "cancel") {
+      const symbol = typeof flags.symbol === "string" ? flags.symbol : void 0;
+      const orderId = flags["order-id"] != null ? Number(flags["order-id"]) : void 0;
+      if (!symbol || orderId == null) throw new Error("Missing required flags: --symbol --order-id");
+      const payload = { symbol, orderId };
+      if (dryRun) {
+        process.stdout.write(JSON.stringify({ tool: "pionex_orders_cancel_order", args: payload }, null, 2) + "\n");
+        return;
+      }
+      const out = await runTool("pionex_orders_cancel_order", payload);
+      process.stdout.write(JSON.stringify(out.data, null, 2) + "\n");
+      return;
+    }
+    if (command === "cancel-all") {
+      const symbol = typeof flags.symbol === "string" ? flags.symbol : void 0;
+      if (!symbol) throw new Error("Missing required flag: --symbol");
+      const payload = { symbol };
+      if (dryRun) {
+        process.stdout.write(JSON.stringify({ tool: "pionex_orders_cancel_all_orders", args: payload }, null, 2) + "\n");
+        return;
+      }
+      const out = await runTool("pionex_orders_cancel_all_orders", payload);
+      process.stdout.write(JSON.stringify(out.data, null, 2) + "\n");
+      return;
+    }
+    throw new Error(`Unknown orders command: ${command}`);
+  }
+  throw new Error(`Unknown group: ${group}`);
+}
+function main() {
+  const invokedAs = basename(process.argv[1] || "");
+  const cmd = process.argv[2];
+  if (invokedAs.includes("pionex-ai-kit")) {
+    if (cmd === "onboard") {
+      cmdOnboard().catch((e) => {
+        process.stderr.write(String(e) + "\n");
+        process.exit(1);
+      });
+      return;
+    }
+    if (cmd === "setup") {
+      cmdSetup(process.argv.slice(3));
+      return;
+    }
+    if (cmd === "help" || cmd === "--help" || cmd === "-h" || !cmd) {
+      printHelp();
+      return;
+    }
+    process.stderr.write("Unknown command: " + cmd + ". Run 'pionex-ai-kit help'.\n");
+    process.exit(1);
     return;
   }
-  process.stderr.write("Unknown command: " + cmd + ". Run 'pionex-ai-kit help'.\n");
-  process.exit(1);
+  runPionexCommand(process.argv.slice(2)).catch((e) => {
+    const payload = toToolErrorPayload(e);
+    process.stderr.write(JSON.stringify(payload, null, 2) + "\n");
+    process.exit(1);
+  });
 }
 main();
 /*! Bundled license information: