okx-trade-cli 1.0.3 → 1.0.5

package/dist/index.js

@@ -3,6 +3,7 @@
 // src/index.ts
 import { parseArgs } from "util";
 import { createRequire } from "module";
+import { pathToFileURL } from "url";
 
 // ../core/dist/index.js
 import { createHmac } from "crypto";
@@ -15,6 +16,10 @@ import { parse } from "smol-toml";
 import { readFileSync as readFileSync2, writeFileSync, mkdirSync, existsSync as existsSync2 } from "fs";
 import { join as join2 } from "path";
 import { homedir as homedir2 } from "os";
+import * as fs3 from "fs";
+import * as path3 from "path";
+import * as os3 from "os";
+import { execFileSync } from "child_process";
 function getNow() {
   return (/* @__PURE__ */ new Date()).toISOString();
 }
@@ -156,6 +161,34 @@ var RateLimiter = class {
     bucket.lastRefillMs = now;
   }
 };
+var OKX_CODE_BEHAVIORS = {
+  // Rate limit → throw RateLimitError
+  "50011": { retry: true, suggestion: "Rate limited. Back off and retry after a delay." },
+  "50061": { retry: true, suggestion: "Too many connections. Reduce request frequency and retry." },
+  // Server temporarily unavailable → retryable
+  "50001": { retry: true, suggestion: "OKX system upgrade in progress. Retry in a few minutes." },
+  "50004": { retry: true, suggestion: "Endpoint temporarily unavailable. Retry later." },
+  "50013": { retry: true, suggestion: "System busy. Retry after 1-2 seconds." },
+  "50026": { retry: true, suggestion: "Order book system upgrading. Retry in a few minutes." },
+  // Region / compliance restriction → do not retry
+  "51155": { retry: false, suggestion: "Feature unavailable in your region. Do not retry." },
+  "51734": { retry: false, suggestion: "Feature not supported for your KYC country. Do not retry." },
+  // Account issues → do not retry
+  "50007": { retry: false, suggestion: "Account suspended. Contact OKX support. Do not retry." },
+  "50009": { retry: false, suggestion: "Account blocked by risk control. Contact OKX support. Do not retry." },
+  "51009": { retry: false, suggestion: "Account mode not supported for this operation. Check account settings." },
+  // API key permission / expiry → do not retry
+  "50100": { retry: false, suggestion: "API key lacks required permissions. Update API key permissions." },
+  "50110": { retry: false, suggestion: "API key expired. Generate a new API key." },
+  // Insufficient funds / margin → do not retry
+  "51008": { retry: false, suggestion: "Insufficient balance. Top up account before retrying." },
+  "51119": { retry: false, suggestion: "Insufficient margin. Add margin before retrying." },
+  "51127": { retry: false, suggestion: "Insufficient available margin. Reduce position or add margin." },
+  // Instrument unavailable → do not retry
+  "51021": { retry: false, suggestion: "Instrument does not exist. Check instId." },
+  "51022": { retry: false, suggestion: "Instrument not available for trading." },
+  "51027": { retry: false, suggestion: "Contract has expired." }
+};
 function isDefined(value) {
   return value !== void 0 && value !== null;
 }
@@ -188,28 +221,28 @@ var OkxRestClient = class {
   constructor(config) {
     this.config = config;
   }
-  async publicGet(path3, query, rateLimit) {
+  async publicGet(path4, query, rateLimit) {
     return this.request({
       method: "GET",
-      path: path3,
+      path: path4,
       auth: "public",
       query,
       rateLimit
     });
   }
-  async privateGet(path3, query, rateLimit) {
+  async privateGet(path4, query, rateLimit) {
     return this.request({
       method: "GET",
-      path: path3,
+      path: path4,
       auth: "private",
       query,
       rateLimit
     });
   }
-  async privatePost(path3, body, rateLimit) {
+  async privatePost(path4, body, rateLimit) {
     return this.request({
       method: "POST",
-      path: path3,
+      path: path4,
       auth: "private",
       body,
       rateLimit
@@ -307,17 +340,23 @@ var OkxRestClient = class {
     const responseCode = parsed.code;
     if (responseCode && responseCode !== "0") {
       const message = parsed.msg ?? "OKX API request failed.";
+      const endpoint = `${config.method} ${config.path}`;
       if (responseCode === "50111" || responseCode === "50112" || responseCode === "50113") {
         throw new AuthenticationError(
           message,
           "Check API key, secret, passphrase and permissions.",
-          `${config.method} ${config.path}`,
+          endpoint,
           traceId
         );
       }
+      const behavior = OKX_CODE_BEHAVIORS[responseCode];
+      if (responseCode === "50011" || responseCode === "50061") {
+        throw new RateLimitError(message, behavior?.suggestion, endpoint, traceId);
+      }
       throw new OkxApiError(message, {
         code: responseCode,
-        endpoint: `${config.method} ${config.path}`,
+        endpoint,
+        suggestion: behavior?.suggestion,
         traceId
       });
     }
@@ -344,9 +383,9 @@ function configFilePath() {
   return join(homedir(), ".okx", "config.toml");
 }
 function readTomlProfile(profileName) {
-  const path3 = configFilePath();
-  if (!existsSync(path3)) return {};
-  const raw = readFileSync(path3, "utf-8");
+  const path4 = configFilePath();
+  if (!existsSync(path4)) return {};
+  const raw = readFileSync(path4, "utf-8");
   const config = parse(raw);
   const name = profileName ?? config.default_profile ?? "default";
   return config.profiles?.[name] ?? {};
@@ -484,6 +523,120 @@ Run: npm install -g ${packageName}
     refreshCacheInBackground(packageName);
   }
 }
+var CLIENT_NAMES = {
+  "claude-desktop": "Claude Desktop",
+  cursor: "Cursor",
+  windsurf: "Windsurf",
+  vscode: "VS Code",
+  "claude-code": "Claude Code CLI"
+};
+var SUPPORTED_CLIENTS = Object.keys(CLIENT_NAMES);
+function appData() {
+  return process.env.APPDATA ?? path3.join(os3.homedir(), "AppData", "Roaming");
+}
+function getConfigPath(client) {
+  const home = os3.homedir();
+  const win = process.platform === "win32";
+  switch (client) {
+    case "claude-desktop":
+      return win ? path3.join(appData(), "Claude", "claude_desktop_config.json") : path3.join(home, "Library", "Application Support", "Claude", "claude_desktop_config.json");
+    case "cursor":
+      return path3.join(home, ".cursor", "mcp.json");
+    case "windsurf":
+      return path3.join(home, ".codeium", "windsurf", "mcp_config.json");
+    case "vscode":
+      return path3.join(process.cwd(), ".mcp.json");
+    case "claude-code":
+      return null;
+  }
+}
+function buildEntry(client, args) {
+  if (client === "vscode") {
+    return { type: "stdio", command: "okx-trade-mcp", args };
+  }
+  return { command: "okx-trade-mcp", args };
+}
+function buildArgs(options) {
+  const args = [];
+  if (options.profile) args.push("--profile", options.profile);
+  args.push("--modules", options.modules ?? "all");
+  return args;
+}
+function mergeJsonConfig(configPath, serverName, entry) {
+  const dir = path3.dirname(configPath);
+  if (!fs3.existsSync(dir)) fs3.mkdirSync(dir, { recursive: true });
+  let data = {};
+  if (fs3.existsSync(configPath)) {
+    const raw = fs3.readFileSync(configPath, "utf-8");
+    try {
+      data = JSON.parse(raw);
+    } catch {
+      throw new Error(`Failed to parse existing config at ${configPath}`);
+    }
+    const backupPath = configPath + ".bak";
+    fs3.copyFileSync(configPath, backupPath);
+    process.stdout.write(`  Backup \u2192 ${backupPath}
+`);
+  }
+  if (typeof data.mcpServers !== "object" || data.mcpServers === null) {
+    data.mcpServers = {};
+  }
+  data.mcpServers[serverName] = entry;
+  fs3.writeFileSync(configPath, JSON.stringify(data, null, 2) + "\n", "utf-8");
+}
+function printSetupUsage() {
+  process.stdout.write(
+    `Usage: okx-trade-mcp setup --client <client> [--profile <name>] [--modules <list>]
+
+Clients:
+` + SUPPORTED_CLIENTS.map((id) => `  ${id.padEnd(16)} ${CLIENT_NAMES[id]}`).join("\n") + `
+
+Options:
+  --profile <name>   Profile from ~/.okx/config.toml (default: uses default_profile)
+  --modules <list>   Comma-separated modules or "all" (default: all)
+`
+  );
+}
+function runSetup(options) {
+  const { client } = options;
+  const name = CLIENT_NAMES[client];
+  const args = buildArgs(options);
+  const serverName = options.profile ? `okx-trade-mcp-${options.profile}` : "okx-trade-mcp";
+  if (client === "claude-code") {
+    const claudeArgs = [
+      "mcp",
+      "add",
+      "--transport",
+      "stdio",
+      serverName,
+      "--",
+      "okx-trade-mcp",
+      ...args
+    ];
+    process.stdout.write(`Running: claude ${claudeArgs.join(" ")}
+`);
+    execFileSync("claude", claudeArgs, { stdio: "inherit" });
+    process.stdout.write(`\u2713 Configured ${name}
+`);
+    return;
+  }
+  const configPath = getConfigPath(client);
+  if (!configPath) {
+    throw new Error(`${name} is not supported on this platform`);
+  }
+  const entry = buildEntry(client, args);
+  mergeJsonConfig(configPath, serverName, entry);
+  process.stdout.write(
+    `\u2713 Configured ${name}
+  ${configPath}
+  Server args: ${args.join(" ")}
+`
+  );
+  if (client !== "vscode") {
+    process.stdout.write(`  Restart ${name} to apply changes.
+`);
+  }
+}
 
 // src/config/loader.ts
 function loadProfileConfig(opts) {
@@ -533,6 +686,153 @@ function printKv(obj, indent = 0) {
 }
 
 // src/commands/market.ts
+async function cmdMarketInstruments(client, opts) {
+  const params = { instType: opts.instType };
+  if (opts.instId) params["instId"] = opts.instId;
+  const res = await client.publicGet("/api/v5/public/instruments", params);
+  const items = res.data;
+  if (opts.json) return printJson(items);
+  printTable(
+    (items ?? []).slice(0, 50).map((t) => ({
+      instId: t["instId"],
+      ctVal: t["ctVal"],
+      lotSz: t["lotSz"],
+      minSz: t["minSz"],
+      tickSz: t["tickSz"],
+      state: t["state"]
+    }))
+  );
+}
+async function cmdMarketFundingRate(client, instId, opts) {
+  if (opts.history) {
+    const params = { instId };
+    if (opts.limit) params["limit"] = String(opts.limit);
+    const res = await client.publicGet("/api/v5/public/funding-rate-history", params);
+    const items = res.data;
+    if (opts.json) return printJson(items);
+    printTable(
+      (items ?? []).map((r) => ({
+        instId: r["instId"],
+        fundingRate: r["fundingRate"],
+        realizedRate: r["realizedRate"],
+        fundingTime: new Date(Number(r["fundingTime"])).toLocaleString()
+      }))
+    );
+  } else {
+    const res = await client.publicGet("/api/v5/public/funding-rate", { instId });
+    const items = res.data;
+    if (opts.json) return printJson(items);
+    const r = items?.[0];
+    if (!r) {
+      process.stdout.write("No data\n");
+      return;
+    }
+    printKv({
+      instId: r["instId"],
+      fundingRate: r["fundingRate"],
+      nextFundingRate: r["nextFundingRate"],
+      fundingTime: new Date(Number(r["fundingTime"])).toLocaleString(),
+      nextFundingTime: new Date(Number(r["nextFundingTime"])).toLocaleString()
+    });
+  }
+}
+async function cmdMarketMarkPrice(client, opts) {
+  const params = { instType: opts.instType };
+  if (opts.instId) params["instId"] = opts.instId;
+  const res = await client.publicGet("/api/v5/public/mark-price", params);
+  const items = res.data;
+  if (opts.json) return printJson(items);
+  printTable(
+    (items ?? []).map((r) => ({
+      instId: r["instId"],
+      instType: r["instType"],
+      markPx: r["markPx"],
+      ts: new Date(Number(r["ts"])).toLocaleString()
+    }))
+  );
+}
+async function cmdMarketTrades(client, instId, opts) {
+  const params = { instId };
+  if (opts.limit) params["limit"] = String(opts.limit);
+  const res = await client.publicGet("/api/v5/market/trades", params);
+  const items = res.data;
+  if (opts.json) return printJson(items);
+  printTable(
+    (items ?? []).map((t) => ({
+      tradeId: t["tradeId"],
+      px: t["px"],
+      sz: t["sz"],
+      side: t["side"],
+      ts: new Date(Number(t["ts"])).toLocaleString()
+    }))
+  );
+}
+async function cmdMarketIndexTicker(client, opts) {
+  const params = {};
+  if (opts.instId) params["instId"] = opts.instId;
+  if (opts.quoteCcy) params["quoteCcy"] = opts.quoteCcy;
+  const res = await client.publicGet("/api/v5/market/index-tickers", params);
+  const items = res.data;
+  if (opts.json) return printJson(items);
+  printTable(
+    (items ?? []).map((t) => ({
+      instId: t["instId"],
+      idxPx: t["idxPx"],
+      high24h: t["high24h"],
+      low24h: t["low24h"],
+      ts: new Date(Number(t["ts"])).toLocaleString()
+    }))
+  );
+}
+async function cmdMarketIndexCandles(client, instId, opts) {
+  const path2 = opts.history ? "/api/v5/market/history-index-candles" : "/api/v5/market/index-candles";
+  const params = { instId };
+  if (opts.bar) params["bar"] = opts.bar;
+  if (opts.limit) params["limit"] = String(opts.limit);
+  const res = await client.publicGet(path2, params);
+  const candles = res.data;
+  if (opts.json) return printJson(candles);
+  printTable(
+    (candles ?? []).map(([ts, o, h, l, c]) => ({
+      time: new Date(Number(ts)).toLocaleString(),
+      open: o,
+      high: h,
+      low: l,
+      close: c
+    }))
+  );
+}
+async function cmdMarketPriceLimit(client, instId, json) {
+  const res = await client.publicGet("/api/v5/public/price-limit", { instId });
+  const items = res.data;
+  if (json) return printJson(items);
+  const r = items?.[0];
+  if (!r) {
+    process.stdout.write("No data\n");
+    return;
+  }
+  printKv({
+    instId: r["instId"],
+    buyLmt: r["buyLmt"],
+    sellLmt: r["sellLmt"],
+    ts: new Date(Number(r["ts"])).toLocaleString()
+  });
+}
+async function cmdMarketOpenInterest(client, opts) {
+  const params = { instType: opts.instType };
+  if (opts.instId) params["instId"] = opts.instId;
+  const res = await client.publicGet("/api/v5/public/open-interest", params);
+  const items = res.data;
+  if (opts.json) return printJson(items);
+  printTable(
+    (items ?? []).map((r) => ({
+      instId: r["instId"],
+      oi: r["oi"],
+      oiCcy: r["oiCcy"],
+      ts: new Date(Number(r["ts"])).toLocaleString()
+    }))
+  );
+}
 async function cmdMarketTicker(client, instId, json) {
   const res = await client.publicGet("/api/v5/market/ticker", { instId });
   const items = res.data;
@@ -621,6 +921,187 @@ async function cmdAccountBalance(client, ccy, json) {
     }))
   );
 }
+async function cmdAccountAssetBalance(client, ccy, json) {
+  const params = {};
+  if (ccy) params["ccy"] = ccy;
+  const res = await client.privateGet("/api/v5/asset/balances", params);
+  const data = res.data;
+  if (json) return printJson(data);
+  printTable(
+    (data ?? []).filter((r) => Number(r["bal"]) > 0).map((r) => ({
+      ccy: r["ccy"],
+      bal: r["bal"],
+      availBal: r["availBal"],
+      frozenBal: r["frozenBal"]
+    }))
+  );
+}
+async function cmdAccountPositions(client, opts) {
+  const params = {};
+  if (opts.instType) params["instType"] = opts.instType;
+  if (opts.instId) params["instId"] = opts.instId;
+  const res = await client.privateGet("/api/v5/account/positions", params);
+  const positions = res.data;
+  if (opts.json) return printJson(positions);
+  const open = (positions ?? []).filter((p) => Number(p["pos"]) !== 0);
+  if (!open.length) {
+    process.stdout.write("No open positions\n");
+    return;
+  }
+  printTable(
+    open.map((p) => ({
+      instId: p["instId"],
+      instType: p["instType"],
+      side: p["posSide"],
+      pos: p["pos"],
+      avgPx: p["avgPx"],
+      upl: p["upl"],
+      lever: p["lever"]
+    }))
+  );
+}
+async function cmdAccountBills(client, opts) {
+  const endpoint = opts.archive ? "/api/v5/account/bills-archive" : "/api/v5/account/bills";
+  const params = {};
+  if (opts.instType) params["instType"] = opts.instType;
+  if (opts.ccy) params["ccy"] = opts.ccy;
+  if (opts.limit) params["limit"] = String(opts.limit);
+  const res = await client.privateGet(endpoint, params);
+  const bills = res.data;
+  if (opts.json) return printJson(bills);
+  printTable(
+    (bills ?? []).map((b) => ({
+      billId: b["billId"],
+      instId: b["instId"],
+      type: b["type"],
+      ccy: b["ccy"],
+      balChg: b["balChg"],
+      bal: b["bal"],
+      ts: new Date(Number(b["ts"])).toLocaleString()
+    }))
+  );
+}
+async function cmdAccountFees(client, opts) {
+  const params = { instType: opts.instType };
+  if (opts.instId) params["instId"] = opts.instId;
+  const res = await client.privateGet("/api/v5/account/trade-fee", params);
+  const data = res.data;
+  if (opts.json) return printJson(data);
+  const fee = data?.[0];
+  if (!fee) {
+    process.stdout.write("No data\n");
+    return;
+  }
+  printKv({
+    level: fee["level"],
+    maker: fee["maker"],
+    taker: fee["taker"],
+    makerU: fee["makerU"],
+    takerU: fee["takerU"],
+    ts: new Date(Number(fee["ts"])).toLocaleString()
+  });
+}
+async function cmdAccountConfig(client, json) {
+  const res = await client.privateGet("/api/v5/account/config", {});
+  const data = res.data;
+  if (json) return printJson(data);
+  const cfg = data?.[0];
+  if (!cfg) {
+    process.stdout.write("No data\n");
+    return;
+  }
+  printKv({
+    uid: cfg["uid"],
+    acctLv: cfg["acctLv"],
+    posMode: cfg["posMode"],
+    autoLoan: cfg["autoLoan"],
+    greeksType: cfg["greeksType"],
+    level: cfg["level"],
+    levelTmp: cfg["levelTmp"]
+  });
+}
+async function cmdAccountSetPositionMode(client, posMode, json) {
+  const res = await client.privatePost("/api/v5/account/set-position-mode", { posMode });
+  if (json) return printJson(res.data);
+  const r = res.data[0];
+  process.stdout.write(`Position mode set: ${r?.["posMode"]}
+`);
+}
+async function cmdAccountMaxSize(client, opts) {
+  const params = { instId: opts.instId, tdMode: opts.tdMode };
+  if (opts.px) params["px"] = opts.px;
+  const res = await client.privateGet("/api/v5/account/max-size", params);
+  const data = res.data;
+  if (opts.json) return printJson(data);
+  const r = data?.[0];
+  if (!r) {
+    process.stdout.write("No data\n");
+    return;
+  }
+  printKv({ instId: r["instId"], maxBuy: r["maxBuy"], maxSell: r["maxSell"] });
+}
+async function cmdAccountMaxAvailSize(client, opts) {
+  const res = await client.privateGet("/api/v5/account/max-avail-size", {
+    instId: opts.instId,
+    tdMode: opts.tdMode
+  });
+  const data = res.data;
+  if (opts.json) return printJson(data);
+  const r = data?.[0];
+  if (!r) {
+    process.stdout.write("No data\n");
+    return;
+  }
+  printKv({ instId: r["instId"], availBuy: r["availBuy"], availSell: r["availSell"] });
+}
+async function cmdAccountMaxWithdrawal(client, ccy, json) {
+  const params = {};
+  if (ccy) params["ccy"] = ccy;
+  const res = await client.privateGet("/api/v5/account/max-withdrawal", params);
+  const data = res.data;
+  if (json) return printJson(data);
+  printTable(
+    (data ?? []).map((r) => ({
+      ccy: r["ccy"],
+      maxWd: r["maxWd"],
+      maxWdEx: r["maxWdEx"]
+    }))
+  );
+}
+async function cmdAccountPositionsHistory(client, opts) {
+  const params = {};
+  if (opts.instType) params["instType"] = opts.instType;
+  if (opts.instId) params["instId"] = opts.instId;
+  if (opts.limit) params["limit"] = String(opts.limit);
+  const res = await client.privateGet("/api/v5/account/positions-history", params);
+  const data = res.data;
+  if (opts.json) return printJson(data);
+  printTable(
+    (data ?? []).map((p) => ({
+      instId: p["instId"],
+      direction: p["direction"],
+      openAvgPx: p["openAvgPx"],
+      closeAvgPx: p["closeAvgPx"],
+      realizedPnl: p["realizedPnl"],
+      uTime: new Date(Number(p["uTime"])).toLocaleString()
+    }))
+  );
+}
+async function cmdAccountTransfer(client, opts) {
+  const body = {
+    ccy: opts.ccy,
+    amt: opts.amt,
+    from: opts.from,
+    to: opts.to
+  };
+  if (opts.transferType) body["type"] = opts.transferType;
+  if (opts.subAcct) body["subAcct"] = opts.subAcct;
+  const res = await client.privatePost("/api/v5/asset/transfer", body);
+  if (opts.json) return printJson(res.data);
+  const r = res.data[0];
+  process.stdout.write(`Transfer: ${r?.["transId"]} (${r?.["ccy"]} ${r?.["amt"]})
+`);
+}
 
 // src/commands/spot.ts
 async function cmdSpotOrders(client, opts) {
@@ -714,6 +1195,43 @@ async function cmdSpotAlgoCancel(client, instId, algoId, json) {
 `
   );
 }
+async function cmdSpotGet(client, opts) {
+  const params = { instId: opts.instId };
+  if (opts.ordId) params["ordId"] = opts.ordId;
+  if (opts.clOrdId) params["clOrdId"] = opts.clOrdId;
+  const res = await client.privateGet("/api/v5/trade/order", params);
+  const data = res.data;
+  if (opts.json) return printJson(data);
+  const o = data?.[0];
+  if (!o) {
+    process.stdout.write("No data\n");
+    return;
+  }
+  printKv({
+    ordId: o["ordId"],
+    instId: o["instId"],
+    side: o["side"],
+    ordType: o["ordType"],
+    px: o["px"],
+    sz: o["sz"],
+    fillSz: o["fillSz"],
+    avgPx: o["avgPx"],
+    state: o["state"],
+    cTime: new Date(Number(o["cTime"])).toLocaleString()
+  });
+}
+async function cmdSpotAmend(client, opts) {
+  const body = { instId: opts.instId };
+  if (opts.ordId) body["ordId"] = opts.ordId;
+  if (opts.clOrdId) body["clOrdId"] = opts.clOrdId;
+  if (opts.newSz) body["newSz"] = opts.newSz;
+  if (opts.newPx) body["newPx"] = opts.newPx;
+  const res = await client.privatePost("/api/v5/trade/amend-order", body);
+  if (opts.json) return printJson(res.data);
+  const r = res.data[0];
+  process.stdout.write(`Order amended: ${r?.["ordId"]} (${r?.["sCode"] === "0" ? "OK" : r?.["sMsg"]})
+`);
+}
 async function cmdSpotAlgoOrders(client, opts) {
   const endpoint = opts.status === "history" ? "/api/v5/trade/orders-algo-history" : "/api/v5/trade/orders-algo-pending";
   const baseParams = { instType: "SPOT" };
@@ -946,6 +1464,80 @@ async function cmdSwapAlgoOrders(client, opts) {
     }))
   );
 }
+async function cmdSwapFills(client, opts) {
+  const path2 = opts.archive ? "/api/v5/trade/fills-history" : "/api/v5/trade/fills";
+  const params = { instType: "SWAP" };
+  if (opts.instId) params["instId"] = opts.instId;
+  if (opts.ordId) params["ordId"] = opts.ordId;
+  const res = await client.privateGet(path2, params);
+  const fills = res.data;
+  if (opts.json) return printJson(fills);
+  printTable(
+    (fills ?? []).map((f) => ({
+      instId: f["instId"],
+      side: f["side"],
+      fillPx: f["fillPx"],
+      fillSz: f["fillSz"],
+      fee: f["fee"],
+      ts: new Date(Number(f["ts"])).toLocaleString()
+    }))
+  );
+}
+async function cmdSwapGet(client, opts) {
+  const params = { instId: opts.instId };
+  if (opts.ordId) params["ordId"] = opts.ordId;
+  if (opts.clOrdId) params["clOrdId"] = opts.clOrdId;
+  const res = await client.privateGet("/api/v5/trade/order", params);
+  const data = res.data;
+  if (opts.json) return printJson(data);
+  const o = data?.[0];
+  if (!o) {
+    process.stdout.write("No data\n");
+    return;
+  }
+  printKv({
+    ordId: o["ordId"],
+    instId: o["instId"],
+    side: o["side"],
+    posSide: o["posSide"],
+    ordType: o["ordType"],
+    px: o["px"],
+    sz: o["sz"],
+    fillSz: o["fillSz"],
+    avgPx: o["avgPx"],
+    state: o["state"],
+    cTime: new Date(Number(o["cTime"])).toLocaleString()
+  });
+}
+async function cmdSwapClose(client, opts) {
+  const body = {
+    instId: opts.instId,
+    mgnMode: opts.mgnMode
+  };
+  if (opts.posSide) body["posSide"] = opts.posSide;
+  if (opts.autoCxl !== void 0) body["autoCxl"] = String(opts.autoCxl);
+  const res = await client.privatePost("/api/v5/trade/close-position", body);
+  if (opts.json) return printJson(res.data);
+  const r = res.data[0];
+  process.stdout.write(`Position closed: ${r?.["instId"]} ${r?.["posSide"] ?? ""}
+`);
+}
+async function cmdSwapGetLeverage(client, opts) {
+  const res = await client.privateGet("/api/v5/account/leverage-info", {
+    instId: opts.instId,
+    mgnMode: opts.mgnMode
+  });
+  const data = res.data;
+  if (opts.json) return printJson(data);
+  printTable(
+    (data ?? []).map((r) => ({
+      instId: r["instId"],
+      mgnMode: r["mgnMode"],
+      posSide: r["posSide"],
+      lever: r["lever"]
+    }))
+  );
+}
 async function cmdSwapSetLeverage(client, opts) {
   const body = {
     instId: opts.instId,
@@ -960,29 +1552,141 @@ async function cmdSwapSetLeverage(client, opts) {
 `);
 }
 
+// src/commands/futures.ts
+async function cmdFuturesOrders(client, opts) {
+  const path2 = opts.status === "archive" ? "/api/v5/trade/orders-history-archive" : opts.status === "history" ? "/api/v5/trade/orders-history" : "/api/v5/trade/orders-pending";
+  const params = { instType: "FUTURES" };
+  if (opts.instId) params["instId"] = opts.instId;
+  const res = await client.privateGet(path2, params);
+  const orders = res.data;
+  if (opts.json) return printJson(orders);
+  printTable(
+    (orders ?? []).map((o) => ({
+      ordId: o["ordId"],
+      instId: o["instId"],
+      side: o["side"],
+      posSide: o["posSide"],
+      type: o["ordType"],
+      price: o["px"],
+      size: o["sz"],
+      state: o["state"]
+    }))
+  );
+}
+async function cmdFuturesPositions(client, instId, json) {
+  const params = { instType: "FUTURES" };
+  if (instId) params["instId"] = instId;
+  const res = await client.privateGet("/api/v5/account/positions", params);
+  const positions = res.data;
+  if (json) return printJson(positions);
+  const open = (positions ?? []).filter((p) => Number(p["pos"]) !== 0);
+  if (!open.length) {
+    process.stdout.write("No open positions\n");
+    return;
+  }
+  printTable(
+    open.map((p) => ({
+      instId: p["instId"],
+      side: p["posSide"],
+      pos: p["pos"],
+      avgPx: p["avgPx"],
+      upl: p["upl"],
+      lever: p["lever"]
+    }))
+  );
+}
+async function cmdFuturesFills(client, opts) {
+  const path2 = opts.archive ? "/api/v5/trade/fills-history" : "/api/v5/trade/fills";
+  const params = { instType: "FUTURES" };
+  if (opts.instId) params["instId"] = opts.instId;
+  if (opts.ordId) params["ordId"] = opts.ordId;
+  const res = await client.privateGet(path2, params);
+  const fills = res.data;
+  if (opts.json) return printJson(fills);
+  printTable(
+    (fills ?? []).map((f) => ({
+      instId: f["instId"],
+      side: f["side"],
+      fillPx: f["fillPx"],
+      fillSz: f["fillSz"],
+      fee: f["fee"],
+      ts: new Date(Number(f["ts"])).toLocaleString()
+    }))
+  );
+}
+async function cmdFuturesPlace(client, opts) {
+  const body = {
+    instId: opts.instId,
+    tdMode: opts.tdMode,
+    side: opts.side,
+    ordType: opts.ordType,
+    sz: opts.sz
+  };
+  if (opts.posSide) body["posSide"] = opts.posSide;
+  if (opts.px) body["px"] = opts.px;
+  if (opts.reduceOnly !== void 0) body["reduceOnly"] = String(opts.reduceOnly);
+  const res = await client.privatePost("/api/v5/trade/order", body);
+  if (opts.json) return printJson(res.data);
+  const order = res.data[0];
+  process.stdout.write(`Order placed: ${order?.["ordId"]} (${order?.["sCode"] === "0" ? "OK" : order?.["sMsg"]})
+`);
+}
+async function cmdFuturesCancel(client, instId, ordId, json) {
+  const res = await client.privatePost("/api/v5/trade/cancel-order", { instId, ordId });
+  if (json) return printJson(res.data);
+  const r = res.data[0];
+  process.stdout.write(`Cancelled: ${r?.["ordId"]} (${r?.["sCode"] === "0" ? "OK" : r?.["sMsg"]})
+`);
+}
+async function cmdFuturesGet(client, opts) {
+  const params = { instId: opts.instId };
+  if (opts.ordId) params["ordId"] = opts.ordId;
+  const res = await client.privateGet("/api/v5/trade/order", params);
+  const data = res.data;
+  if (opts.json) return printJson(data);
+  const o = data?.[0];
+  if (!o) {
+    process.stdout.write("No data\n");
+    return;
+  }
+  printKv({
+    ordId: o["ordId"],
+    instId: o["instId"],
+    side: o["side"],
+    posSide: o["posSide"],
+    ordType: o["ordType"],
+    px: o["px"],
+    sz: o["sz"],
+    fillSz: o["fillSz"],
+    avgPx: o["avgPx"],
+    state: o["state"],
+    cTime: new Date(Number(o["cTime"])).toLocaleString()
+  });
+}
+
 // src/config/toml.ts
-import { writeFileSync as writeFileSync2, mkdirSync as mkdirSync2, existsSync as existsSync3 } from "fs";
+import { writeFileSync as writeFileSync3, mkdirSync as mkdirSync3, existsSync as existsSync4 } from "fs";
 import { stringify } from "smol-toml";
 function configDir() {
   return configFilePath().replace(/\/config\.toml$/, "");
 }
 function writeCliConfig(config) {
   const dir = configDir();
-  if (!existsSync3(dir)) {
-    mkdirSync2(dir, { recursive: true });
+  if (!existsSync4(dir)) {
+    mkdirSync3(dir, { recursive: true });
   }
-  writeFileSync2(configFilePath(), stringify(config), "utf-8");
+  writeFileSync3(configFilePath(), stringify(config), "utf-8");
 }
 
 // src/commands/config.ts
-import { existsSync as existsSync4, readFileSync as readFileSync3 } from "fs";
+import { existsSync as existsSync5, readFileSync as readFileSync4 } from "fs";
 import { parse as parse2, stringify as stringify2 } from "smol-toml";
 import { createInterface } from "readline";
 import { spawnSync } from "child_process";
 function readFullConfig() {
-  const path3 = configFilePath();
-  if (!existsSync4(path3)) return { profiles: {} };
-  const raw = readFileSync3(path3, "utf-8");
+  const path2 = configFilePath();
+  if (!existsSync5(path2)) return { profiles: {} };
+  const raw = readFileSync4(path2, "utf-8");
   return parse2(raw);
 }
 function prompt(rl, question) {
@@ -1093,110 +1797,146 @@ async function cmdConfigInit() {
 
 // src/commands/client-setup.ts
 import * as fs from "fs";
-import * as path2 from "path";
-import * as os2 from "os";
-import * as readline from "readline";
-var CLIENTS = [
-  {
-    name: "Claude Desktop",
-    configPath: path2.join(os2.homedir(), "Library/Application Support/Claude/claude_desktop_config.json"),
-    mcpKey: "mcpServers"
-  },
-  {
-    name: "Cursor",
-    configPath: path2.join(os2.homedir(), ".cursor/mcp.json"),
-    mcpKey: "mcpServers"
-  },
-  {
-    name: "Windsurf",
-    configPath: path2.join(os2.homedir(), ".codeium/windsurf/mcp_config.json"),
-    mcpKey: "mcpServers"
+function cmdSetupClient(options) {
+  runSetup(options);
+}
+function cmdSetupClients() {
+  const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
+  const detectedPaths = {
+    "claude-desktop": `${home}/Library/Application Support/Claude/claude_desktop_config.json`,
+    cursor: `${home}/.cursor/mcp.json`,
+    windsurf: `${home}/.codeium/windsurf/mcp_config.json`
+  };
+  const detected = Object.entries(detectedPaths).filter(
+    ([, p]) => fs.existsSync(p)
+  );
+  if (detected.length > 0) {
+    process.stdout.write(`Detected clients:
+`);
+    for (const [id] of detected) {
+      process.stdout.write(`  ${id}
+`);
+    }
+    process.stdout.write(`
+`);
   }
-];
-var MCP_ENTRY = {
-  command: "okx-trade-mcp",
-  args: ["--modules", "all"]
-};
-var MCP_SERVER_NAME = "okx-trade-mcp";
-function prompt2(rl, question) {
-  return new Promise((resolve) => {
-    rl.question(question, (answer) => {
-      resolve(answer);
-    });
-  });
+  printSetupUsage();
 }
-async function cmdSetupClients() {
-  const detected = CLIENTS.filter((c) => fs.existsSync(c.configPath));
-  if (detected.length === 0) {
-    process.stdout.write(
-      "No supported IDE/client installations detected.\nChecked:\n" + CLIENTS.map((c) => `  - ${c.name}: ${c.configPath}`).join("\n") + "\n"
-    );
+
+// src/commands/bot.ts
+async function cmdGridOrders(client, opts) {
+  const path2 = opts.status === "history" ? "/api/v5/tradingBot/grid/orders-algo-history" : "/api/v5/tradingBot/grid/orders-algo-pending";
+  const params = { algoOrdType: opts.algoOrdType };
+  if (opts.instId) params["instId"] = opts.instId;
+  if (opts.algoId) params["algoId"] = opts.algoId;
+  const res = await client.privateGet(path2, params);
+  const orders = res.data ?? [];
+  if (opts.json) return printJson(orders);
+  if (!orders.length) {
+    process.stdout.write("No grid bots\n");
     return;
   }
-  process.stdout.write(`Detected ${detected.length} client(s):
-`);
-  for (const c of detected) {
-    process.stdout.write(`  - ${c.name}
-`);
+  printTable(
+    orders.map((o) => ({
+      algoId: o["algoId"],
+      instId: o["instId"],
+      type: o["algoOrdType"],
+      state: o["state"],
+      pnl: o["pnlRatio"],
+      gridNum: o["gridNum"],
+      maxPx: o["maxPx"],
+      minPx: o["minPx"],
+      createdAt: new Date(Number(o["cTime"])).toLocaleString()
+    }))
+  );
+}
+async function cmdGridDetails(client, opts) {
+  const res = await client.privateGet("/api/v5/tradingBot/grid/orders-algo-details", {
+    algoOrdType: opts.algoOrdType,
+    algoId: opts.algoId
+  });
+  const detail = (res.data ?? [])[0];
+  if (!detail) {
+    process.stdout.write("Bot not found\n");
+    return;
   }
-  process.stdout.write("\n");
-  const rl = readline.createInterface({
-    input: process.stdin,
-    output: process.stdout
+  if (opts.json) return printJson(detail);
+  printKv({
+    algoId: detail["algoId"],
+    instId: detail["instId"],
+    type: detail["algoOrdType"],
+    state: detail["state"],
+    maxPx: detail["maxPx"],
+    minPx: detail["minPx"],
+    gridNum: detail["gridNum"],
+    runType: detail["runType"] === "1" ? "arithmetic" : "geometric",
+    pnl: detail["pnl"],
+    pnlRatio: detail["pnlRatio"],
+    investAmt: detail["investAmt"],
+    totalAnnRate: detail["totalAnnRate"],
+    createdAt: new Date(Number(detail["cTime"])).toLocaleString()
   });
-  try {
-    for (const client of detected) {
-      const answer = await prompt2(rl, `Configure ${client.name}? (y/N) `);
-      if (answer.trim().toLowerCase() !== "y") {
-        process.stdout.write(`  Skipped ${client.name}.
-`);
-        continue;
-      }
-      let data = { [client.mcpKey]: {} };
-      if (fs.existsSync(client.configPath)) {
-        const raw = fs.readFileSync(client.configPath, "utf-8");
-        try {
-          data = JSON.parse(raw);
-        } catch {
-          process.stderr.write(
-            `  Error: Failed to parse JSON for ${client.name} at ${client.configPath}. Skipping.
-`
-          );
-          continue;
-        }
-      }
-      if (typeof data[client.mcpKey] !== "object" || data[client.mcpKey] === null) {
-        data[client.mcpKey] = {};
-      }
-      const servers = data[client.mcpKey];
-      if (Object.prototype.hasOwnProperty.call(servers, MCP_SERVER_NAME)) {
-        process.stdout.write(`  Already configured in ${client.name}. Skipping.
-`);
-        continue;
-      }
-      servers[MCP_SERVER_NAME] = MCP_ENTRY;
-      const jsonOutput = JSON.stringify(data, null, 2);
-      try {
-        fs.writeFileSync(client.configPath, jsonOutput, "utf-8");
-        process.stdout.write(`  Configured ${client.name} successfully.
-`);
-      } catch (err) {
-        const reason = err instanceof Error ? err.message : String(err);
-        process.stderr.write(
-          `  Error: Failed to write config for ${client.name}: ${reason}
-  Add the following to "${client.configPath}" manually:
-
-  "${MCP_SERVER_NAME}": ${JSON.stringify(MCP_ENTRY, null, 2).split("\n").join("\n  ")}
-
-`
-        );
-      }
-    }
-  } finally {
-    rl.close();
+}
+async function cmdGridSubOrders(client, opts) {
+  const res = await client.privateGet("/api/v5/tradingBot/grid/sub-orders", {
+    algoOrdType: opts.algoOrdType,
+    algoId: opts.algoId,
+    type: opts.type
+  });
+  const orders = res.data ?? [];
+  if (opts.json) return printJson(orders);
+  if (!orders.length) {
+    process.stdout.write("No sub-orders\n");
+    return;
   }
+  printTable(
+    orders.map((o) => ({
+      ordId: o["ordId"],
+      side: o["side"],
+      px: o["px"],
+      sz: o["sz"],
+      fillPx: o["fillPx"],
+      fillSz: o["fillSz"],
+      state: o["state"],
+      fee: o["fee"]
+    }))
+  );
+}
+async function cmdGridCreate(client, opts) {
+  const body = {
+    instId: opts.instId,
+    algoOrdType: opts.algoOrdType,
+    maxPx: opts.maxPx,
+    minPx: opts.minPx,
+    gridNum: opts.gridNum
+  };
+  if (opts.runType) body["runType"] = opts.runType;
+  if (opts.quoteSz) body["quoteSz"] = opts.quoteSz;
+  if (opts.baseSz) body["baseSz"] = opts.baseSz;
+  if (opts.direction) body["direction"] = opts.direction;
+  if (opts.lever) body["lever"] = opts.lever;
+  if (opts.sz) body["sz"] = opts.sz;
+  const res = await client.privatePost("/api/v5/tradingBot/grid/order-algo", body);
+  if (opts.json) return printJson(res.data);
+  const r = res.data[0];
   process.stdout.write(
-    "\nDone. Please restart any configured IDE/client for the changes to take effect.\n"
+    `Grid bot created: ${r?.["algoId"]} (${r?.["sCode"] === "0" ? "OK" : r?.["sMsg"]})
+`
+  );
+}
+async function cmdGridStop(client, opts) {
+  const entry = {
+    algoId: opts.algoId,
+    algoOrdType: opts.algoOrdType,
+    instId: opts.instId
+  };
+  if (opts.stopType) entry["stopType"] = opts.stopType;
+  const res = await client.privatePost("/api/v5/tradingBot/grid/stop-order-algo", [entry]);
+  if (opts.json) return printJson(res.data);
+  const r = res.data[0];
+  process.stdout.write(
+    `Grid bot stopped: ${r?.["algoId"]} (${r?.["sCode"] === "0" ? "OK" : r?.["sMsg"]})
+`
   );
 }
 
@@ -1209,6 +1949,7 @@ Usage: okx [--profile <name>] [--json] <command> [args]
 
 Global Options:
   --profile <name>   Use a named profile from ~/.okx/config.toml
+  --demo             Use simulated trading (demo) mode
   --json             Output raw JSON
   --help             Show this help
 
@@ -1217,12 +1958,33 @@ Commands:
   market tickers <instType>               (SPOT|SWAP|FUTURES|OPTION)
   market orderbook <instId> [--sz <n>]
   market candles <instId> [--bar <bar>] [--limit <n>]
+  market instruments --instType <type> [--instId <id>]
+  market funding-rate <instId> [--history] [--limit <n>]
+  market mark-price --instType <MARGIN|SWAP|FUTURES|OPTION> [--instId <id>]
+  market trades <instId> [--limit <n>]
+  market index-ticker [--instId <id>] [--quoteCcy <ccy>]
+  market index-candles <instId> [--bar <bar>] [--limit <n>] [--history]
+  market price-limit <instId>
+  market open-interest --instType <SWAP|FUTURES|OPTION> [--instId <id>]
 
   account balance [<ccy>]
+  account asset-balance [--ccy <ccy>]
+  account positions [--instType <type>] [--instId <id>]
+  account positions-history [--instType <type>] [--instId <id>] [--limit <n>]
+  account bills [--instType <type>] [--ccy <ccy>] [--limit <n>] [--archive]
+  account fees --instType <type> [--instId <id>]
+  account config
+  account set-position-mode --posMode <long_short_mode|net_mode>
+  account max-size --instId <id> --tdMode <cross|isolated> [--px <price>]
+  account max-avail-size --instId <id> --tdMode <cross|isolated|cash>
+  account max-withdrawal [--ccy <ccy>]
+  account transfer --ccy <ccy> --amt <n> --from <acct> --to <acct> [--transferType <0|1|2|3>]
 
   spot orders [--instId <id>] [--history]
+  spot get --instId <id> --ordId <id>
   spot fills [--instId <id>] [--ordId <id>]
   spot place --instId <id> --side <buy|sell> --ordType <type> --sz <n> [--px <price>]
+  spot amend --instId <id> --ordId <id> [--newSz <n>] [--newPx <price>]
   spot cancel <instId> --ordId <id>
   spot algo orders [--instId <id>] [--history] [--ordType <conditional|oco>]
   spot algo place --instId <id> --side <buy|sell> --sz <n> [--ordType <conditional|oco>]
@@ -1234,10 +1996,14 @@ Commands:
   spot algo cancel --instId <id> --algoId <id>
 
   swap positions [<instId>]
-  swap orders [--instId <id>] [--history]
+  swap orders [--instId <id>] [--history] [--archive]
+  swap get --instId <id> --ordId <id>
+  swap fills [--instId <id>] [--ordId <id>] [--archive]
   swap place --instId <id> --side <buy|sell> --ordType <type> --sz <n> [--posSide <side>] [--px <price>] [--tdMode <cross|isolated>]
   swap cancel <instId> --ordId <id>
+  swap close --instId <id> --mgnMode <cross|isolated> [--posSide <net|long|short>] [--autoCxl]
   swap leverage --instId <id> --lever <n> --mgnMode <cross|isolated> [--posSide <side>]
+  swap get-leverage --instId <id> --mgnMode <cross|isolated>
   swap algo orders [--instId <id>] [--history] [--ordType <conditional|oco>]
   swap algo trail --instId <id> --side <buy|sell> --sz <n> --callbackRatio <ratio>
                   [--activePx <price>] [--posSide <net|long|short>] [--tdMode <cross|isolated>] [--reduceOnly]
@@ -1250,20 +2016,399 @@ Commands:
                   [--newSlTriggerPx <price>] [--newSlOrdPx <price|-1>]
   swap algo cancel --instId <id> --algoId <id>
 
+  futures orders [--instId <id>] [--history] [--archive]
+  futures positions [--instId <id>]
+  futures fills [--instId <id>] [--ordId <id>] [--archive]
+  futures place --instId <id> --side <buy|sell> --ordType <type> --sz <n> [--tdMode <cross|isolated>]
+                [--posSide <net|long|short>] [--px <price>] [--reduceOnly]
+  futures cancel <instId> --ordId <id>
+  futures get --instId <id> --ordId <id>
+
+  bot grid orders --algoOrdType <grid|contract_grid|moon_grid> [--instId <id>] [--algoId <id>] [--history]
+  bot grid details --algoOrdType <type> --algoId <id>
+  bot grid sub-orders --algoOrdType <type> --algoId <id> [--live]
+  bot grid create --instId <id> --algoOrdType <grid|contract_grid> --maxPx <px> --minPx <px> --gridNum <n>
+                  [--runType <1|2>] [--quoteSz <n>] [--baseSz <n>]
+                  [--direction <long|short|neutral>] [--lever <n>] [--sz <n>]
+  bot grid stop --algoId <id> --algoOrdType <type> --instId <id> [--stopType <1|2|3|5|6>]
+
   config init
   config show
   config set <key> <value>
   config setup-clients
+
+  setup --client <client> [--profile <name>] [--modules <list>]
+
+  Clients: ${SUPPORTED_CLIENTS.join(", ")}
 `);
 }
+function handleConfigCommand(action, rest, json) {
+  if (action === "init") return cmdConfigInit();
+  if (action === "show") return cmdConfigShow(json);
+  if (action === "set") return cmdConfigSet(rest[0], rest[1]);
+  if (action === "setup-clients") return cmdSetupClients();
+  process.stderr.write(`Unknown config command: ${action}
+`);
+  process.exitCode = 1;
+}
+function handleSetupCommand(v) {
+  if (!v.client) {
+    printSetupUsage();
+    return;
+  }
+  if (!SUPPORTED_CLIENTS.includes(v.client)) {
+    process.stderr.write(
+      `Unknown client: "${v.client}"
+Supported: ${SUPPORTED_CLIENTS.join(", ")}
+`
+    );
+    process.exitCode = 1;
+    return;
+  }
+  cmdSetupClient({
+    client: v.client,
+    profile: v.profile,
+    modules: v.modules
+  });
+}
+function handleMarketPublicCommand(client, action, rest, v, json) {
+  if (action === "ticker") return cmdMarketTicker(client, rest[0], json);
+  if (action === "tickers") return cmdMarketTickers(client, rest[0], json);
+  if (action === "instruments")
+    return cmdMarketInstruments(client, { instType: v.instType, instId: v.instId, json });
+  if (action === "mark-price")
+    return cmdMarketMarkPrice(client, { instType: v.instType, instId: v.instId, json });
+  if (action === "index-ticker")
+    return cmdMarketIndexTicker(client, { instId: v.instId, quoteCcy: v.quoteCcy, json });
+  if (action === "price-limit") return cmdMarketPriceLimit(client, rest[0], json);
+  if (action === "open-interest")
+    return cmdMarketOpenInterest(client, { instType: v.instType, instId: v.instId, json });
+}
+function handleMarketDataCommand(client, action, rest, v, json) {
+  const limit = v.limit !== void 0 ? Number(v.limit) : void 0;
+  if (action === "orderbook")
+    return cmdMarketOrderbook(client, rest[0], v.sz !== void 0 ? Number(v.sz) : void 0, json);
+  if (action === "candles")
+    return cmdMarketCandles(client, rest[0], { bar: v.bar, limit, json });
+  if (action === "funding-rate")
+    return cmdMarketFundingRate(client, rest[0], { history: v.history ?? false, limit, json });
+  if (action === "trades")
+    return cmdMarketTrades(client, rest[0], { limit, json });
+  if (action === "index-candles")
+    return cmdMarketIndexCandles(client, rest[0], { bar: v.bar, limit, history: v.history ?? false, json });
+}
+function handleMarketCommand(client, action, rest, v, json) {
+  return handleMarketPublicCommand(client, action, rest, v, json) ?? handleMarketDataCommand(client, action, rest, v, json);
+}
+function handleAccountWriteCommand(client, action, v, json) {
+  if (action === "set-position-mode")
+    return cmdAccountSetPositionMode(client, v.posMode, json);
+  if (action === "max-size")
+    return cmdAccountMaxSize(client, { instId: v.instId, tdMode: v.tdMode, px: v.px, json });
+  if (action === "max-avail-size")
+    return cmdAccountMaxAvailSize(client, { instId: v.instId, tdMode: v.tdMode, json });
+  if (action === "max-withdrawal") return cmdAccountMaxWithdrawal(client, v.ccy, json);
+  if (action === "transfer")
+    return cmdAccountTransfer(client, {
+      ccy: v.ccy,
+      amt: v.amt,
+      from: v.from,
+      to: v.to,
+      transferType: v.transferType,
+      subAcct: v.subAcct,
+      json
+    });
+}
+function handleAccountCommand(client, action, rest, v, json) {
+  const limit = v.limit !== void 0 ? Number(v.limit) : void 0;
+  if (action === "balance") return cmdAccountBalance(client, rest[0], json);
+  if (action === "asset-balance") return cmdAccountAssetBalance(client, v.ccy, json);
+  if (action === "positions")
+    return cmdAccountPositions(client, { instType: v.instType, instId: v.instId, json });
+  if (action === "positions-history")
+    return cmdAccountPositionsHistory(client, {
+      instType: v.instType,
+      instId: v.instId,
+      limit,
+      json
+    });
+  if (action === "bills")
+    return cmdAccountBills(client, {
+      archive: v.archive ?? false,
+      instType: v.instType,
+      ccy: v.ccy,
+      limit,
+      json
+    });
+  if (action === "fees")
+    return cmdAccountFees(client, { instType: v.instType, instId: v.instId, json });
+  if (action === "config") return cmdAccountConfig(client, json);
+  return handleAccountWriteCommand(client, action, v, json);
+}
+function handleSpotAlgoCommand(client, subAction, v, json) {
+  if (subAction === "place")
+    return cmdSpotAlgoPlace(client, {
+      instId: v.instId,
+      side: v.side,
+      ordType: v.ordType ?? "conditional",
+      sz: v.sz,
+      tpTriggerPx: v.tpTriggerPx,
+      tpOrdPx: v.tpOrdPx,
+      slTriggerPx: v.slTriggerPx,
+      slOrdPx: v.slOrdPx,
+      json
+    });
+  if (subAction === "amend")
+    return cmdSpotAlgoAmend(client, {
+      instId: v.instId,
+      algoId: v.algoId,
+      newSz: v.newSz,
+      newTpTriggerPx: v.newTpTriggerPx,
+      newTpOrdPx: v.newTpOrdPx,
+      newSlTriggerPx: v.newSlTriggerPx,
+      newSlOrdPx: v.newSlOrdPx,
+      json
+    });
+  if (subAction === "cancel")
+    return cmdSpotAlgoCancel(client, v.instId, v.algoId, json);
+  if (subAction === "orders")
+    return cmdSpotAlgoOrders(client, {
+      instId: v.instId,
+      status: v.history ? "history" : "pending",
+      ordType: v.ordType,
+      json
+    });
+}
+function handleSpotCommand(client, action, rest, v, json) {
+  if (action === "orders")
+    return cmdSpotOrders(client, {
+      instId: v.instId,
+      status: v.history ? "history" : "open",
+      json
+    });
+  if (action === "get")
+    return cmdSpotGet(client, { instId: v.instId, ordId: v.ordId, clOrdId: v.clOrdId, json });
+  if (action === "fills")
+    return cmdSpotFills(client, { instId: v.instId, ordId: v.ordId, json });
+  if (action === "amend")
+    return cmdSpotAmend(client, {
+      instId: v.instId,
+      ordId: v.ordId,
+      clOrdId: v.clOrdId,
+      newSz: v.newSz,
+      newPx: v.newPx,
+      json
+    });
+  if (action === "place")
+    return cmdSpotPlace(client, {
+      instId: v.instId,
+      side: v.side,
+      ordType: v.ordType,
+      sz: v.sz,
+      px: v.px,
+      json
+    });
+  if (action === "cancel")
+    return cmdSpotCancel(client, rest[0], v.ordId, json);
+  if (action === "algo")
+    return handleSpotAlgoCommand(client, rest[0], v, json);
+}
+function handleSwapAlgoCommand(client, subAction, v, json) {
+  if (subAction === "trail")
+    return cmdSwapAlgoTrailPlace(client, {
+      instId: v.instId,
+      side: v.side,
+      sz: v.sz,
+      callbackRatio: v.callbackRatio,
+      callbackSpread: v.callbackSpread,
+      activePx: v.activePx,
+      posSide: v.posSide,
+      tdMode: v.tdMode ?? "cross",
+      reduceOnly: v.reduceOnly,
+      json
+    });
+  if (subAction === "place")
+    return cmdSwapAlgoPlace(client, {
+      instId: v.instId,
+      side: v.side,
+      ordType: v.ordType ?? "conditional",
+      sz: v.sz,
+      posSide: v.posSide,
+      tdMode: v.tdMode ?? "cross",
+      tpTriggerPx: v.tpTriggerPx,
+      tpOrdPx: v.tpOrdPx,
+      slTriggerPx: v.slTriggerPx,
+      slOrdPx: v.slOrdPx,
+      reduceOnly: v.reduceOnly,
+      json
+    });
+  if (subAction === "amend")
+    return cmdSwapAlgoAmend(client, {
+      instId: v.instId,
+      algoId: v.algoId,
+      newSz: v.newSz,
+      newTpTriggerPx: v.newTpTriggerPx,
+      newTpOrdPx: v.newTpOrdPx,
+      newSlTriggerPx: v.newSlTriggerPx,
+      newSlOrdPx: v.newSlOrdPx,
+      json
+    });
+  if (subAction === "cancel")
+    return cmdSwapAlgoCancel(client, v.instId, v.algoId, json);
+  if (subAction === "orders")
+    return cmdSwapAlgoOrders(client, {
+      instId: v.instId,
+      status: v.history ? "history" : "pending",
+      ordType: v.ordType,
+      json
+    });
+}
+function handleSwapCommand(client, action, rest, v, json) {
+  if (action === "positions")
+    return cmdSwapPositions(client, rest[0] ?? v.instId, json);
+  if (action === "orders")
+    return cmdSwapOrders(client, {
+      instId: v.instId,
+      status: v.history ? "history" : "open",
+      json
+    });
+  if (action === "get")
+    return cmdSwapGet(client, { instId: v.instId, ordId: v.ordId, clOrdId: v.clOrdId, json });
+  if (action === "fills")
+    return cmdSwapFills(client, {
+      instId: v.instId,
+      ordId: v.ordId,
+      archive: v.archive ?? false,
+      json
+    });
+  if (action === "close")
+    return cmdSwapClose(client, {
+      instId: v.instId,
+      mgnMode: v.mgnMode,
+      posSide: v.posSide,
+      autoCxl: v.autoCxl,
+      json
+    });
+  if (action === "get-leverage")
+    return cmdSwapGetLeverage(client, { instId: v.instId, mgnMode: v.mgnMode, json });
+  if (action === "place")
+    return cmdSwapPlace(client, {
+      instId: v.instId,
+      side: v.side,
+      ordType: v.ordType,
+      sz: v.sz,
+      posSide: v.posSide,
+      px: v.px,
+      tdMode: v.tdMode ?? "cross",
+      json
+    });
+  if (action === "cancel")
+    return cmdSwapCancel(client, rest[0], v.ordId, json);
+  if (action === "leverage")
+    return cmdSwapSetLeverage(client, {
+      instId: v.instId,
+      lever: v.lever,
+      mgnMode: v.mgnMode,
+      posSide: v.posSide,
+      json
+    });
+  if (action === "algo")
+    return handleSwapAlgoCommand(client, rest[0], v, json);
+}
+function handleFuturesCommand(client, action, rest, v, json) {
+  if (action === "orders") {
+    let status = "open";
+    if (v.archive) status = "archive";
+    else if (v.history) status = "history";
+    return cmdFuturesOrders(client, { instId: v.instId, status, json });
+  }
+  if (action === "positions") return cmdFuturesPositions(client, v.instId, json);
+  if (action === "fills")
+    return cmdFuturesFills(client, {
+      instId: v.instId,
+      ordId: v.ordId,
+      archive: v.archive ?? false,
+      json
+    });
+  if (action === "place")
+    return cmdFuturesPlace(client, {
+      instId: v.instId,
+      side: v.side,
+      ordType: v.ordType,
+      sz: v.sz,
+      tdMode: v.tdMode ?? "cross",
+      posSide: v.posSide,
+      px: v.px,
+      reduceOnly: v.reduceOnly,
+      json
+    });
+  if (action === "cancel")
+    return cmdFuturesCancel(client, rest[0] ?? v.instId, v.ordId, json);
+  if (action === "get")
+    return cmdFuturesGet(client, { instId: rest[0] ?? v.instId, ordId: v.ordId, json });
+}
+function handleBotGridCommand(client, v, rest, json) {
+  const subAction = rest[0];
+  if (subAction === "orders")
+    return cmdGridOrders(client, {
+      algoOrdType: v.algoOrdType,
+      instId: v.instId,
+      algoId: v.algoId,
+      status: v.history ? "history" : "active",
+      json
+    });
+  if (subAction === "details")
+    return cmdGridDetails(client, {
+      algoOrdType: v.algoOrdType,
+      algoId: v.algoId,
+      json
+    });
+  if (subAction === "sub-orders")
+    return cmdGridSubOrders(client, {
+      algoOrdType: v.algoOrdType,
+      algoId: v.algoId,
+      type: v.live ? "live" : "filled",
+      json
+    });
+  if (subAction === "create")
+    return cmdGridCreate(client, {
+      instId: v.instId,
+      algoOrdType: v.algoOrdType,
+      maxPx: v.maxPx,
+      minPx: v.minPx,
+      gridNum: v.gridNum,
+      runType: v.runType,
+      quoteSz: v.quoteSz,
+      baseSz: v.baseSz,
+      direction: v.direction,
+      lever: v.lever,
+      sz: v.sz,
+      json
+    });
+  if (subAction === "stop")
+    return cmdGridStop(client, {
+      algoId: v.algoId,
+      algoOrdType: v.algoOrdType,
+      instId: v.instId,
+      stopType: v.stopType,
+      json
+    });
+}
+function handleBotCommand(client, action, rest, v, json) {
+  if (action === "grid") return handleBotGridCommand(client, v, rest, json);
+}
 async function main() {
   checkForUpdates("okx-trade-cli", CLI_VERSION);
   const { values, positionals } = parseArgs({
     args: process.argv.slice(2),
     options: {
       profile: { type: "string" },
+      demo: { type: "boolean", default: false },
       json: { type: "boolean", default: false },
       help: { type: "boolean", default: false },
+      // setup command
+      client: { type: "string" },
+      modules: { type: "string" },
       // market candles
       bar: { type: "string" },
       limit: { type: "string" },
@@ -1297,7 +2442,34 @@ async function main() {
       // trailing stop
       callbackRatio: { type: "string" },
       callbackSpread: { type: "string" },
-      activePx: { type: "string" }
+      activePx: { type: "string" },
+      // grid bot
+      algoOrdType: { type: "string" },
+      gridNum: { type: "string" },
+      maxPx: { type: "string" },
+      minPx: { type: "string" },
+      runType: { type: "string" },
+      quoteSz: { type: "string" },
+      baseSz: { type: "string" },
+      direction: { type: "string" },
+      stopType: { type: "string" },
+      live: { type: "boolean", default: false },
+      // market extras
+      instType: { type: "string" },
+      quoteCcy: { type: "string" },
+      // account extras
+      archive: { type: "boolean", default: false },
+      posMode: { type: "string" },
+      ccy: { type: "string" },
+      from: { type: "string" },
+      to: { type: "string" },
+      transferType: { type: "string" },
+      subAcct: { type: "string" },
+      amt: { type: "string" },
+      // swap/order extras
+      autoCxl: { type: "boolean", default: false },
+      clOrdId: { type: "string" },
+      newPx: { type: "string" }
     },
     allowPositionals: true
   });
@@ -1306,186 +2478,45 @@ async function main() {
     return;
   }
   const [module, action, ...rest] = positionals;
-  const json = values.json ?? false;
-  if (module === "config") {
-    if (action === "init") return cmdConfigInit();
-    if (action === "show") return cmdConfigShow(json);
-    if (action === "set") return cmdConfigSet(rest[0], rest[1]);
-    if (action === "setup-clients") return cmdSetupClients();
-    process.stderr.write(`Unknown config command: ${action}
-`);
-    process.exitCode = 1;
-    return;
-  }
-  const config = loadProfileConfig({ profile: values.profile, userAgent: `okx-trade-cli/${CLI_VERSION}` });
+  const v = values;
+  const json = v.json ?? false;
+  if (module === "config") return handleConfigCommand(action, rest, json);
+  if (module === "setup") return handleSetupCommand(v);
+  const config = loadProfileConfig({ profile: v.profile, demo: v.demo, userAgent: `okx-trade-cli/${CLI_VERSION}` });
   const client = new OkxRestClient(config);
-  if (module === "market") {
-    if (action === "ticker") return cmdMarketTicker(client, rest[0], json);
-    if (action === "tickers") return cmdMarketTickers(client, rest[0], json);
-    if (action === "orderbook")
-      return cmdMarketOrderbook(client, rest[0], values.sz ? Number(values.sz) : void 0, json);
-    if (action === "candles")
-      return cmdMarketCandles(client, rest[0], {
-        bar: values.bar,
-        limit: values.limit ? Number(values.limit) : void 0,
-        json
-      });
-  }
-  if (module === "account") {
-    if (action === "balance") return cmdAccountBalance(client, rest[0], json);
-  }
-  if (module === "spot") {
-    if (action === "orders")
-      return cmdSpotOrders(client, {
-        instId: values.instId,
-        status: values.history ? "history" : "open",
-        json
-      });
-    if (action === "fills")
-      return cmdSpotFills(client, { instId: values.instId, ordId: values.ordId, json });
-    if (action === "place")
-      return cmdSpotPlace(client, {
-        instId: values.instId,
-        side: values.side,
-        ordType: values.ordType,
-        sz: values.sz,
-        px: values.px,
-        json
-      });
-    if (action === "cancel")
-      return cmdSpotCancel(client, rest[0], values.ordId, json);
-    if (action === "algo") {
-      const subAction = rest[0];
-      if (subAction === "place")
-        return cmdSpotAlgoPlace(client, {
-          instId: values.instId,
-          side: values.side,
-          ordType: values.ordType ?? "conditional",
-          sz: values.sz,
-          tpTriggerPx: values.tpTriggerPx,
-          tpOrdPx: values.tpOrdPx,
-          slTriggerPx: values.slTriggerPx,
-          slOrdPx: values.slOrdPx,
-          json
-        });
-      if (subAction === "amend")
-        return cmdSpotAlgoAmend(client, {
-          instId: values.instId,
-          algoId: values.algoId,
-          newSz: values.newSz,
-          newTpTriggerPx: values.newTpTriggerPx,
-          newTpOrdPx: values.newTpOrdPx,
-          newSlTriggerPx: values.newSlTriggerPx,
-          newSlOrdPx: values.newSlOrdPx,
-          json
-        });
-      if (subAction === "cancel")
-        return cmdSpotAlgoCancel(client, values.instId, values.algoId, json);
-      if (subAction === "orders")
-        return cmdSpotAlgoOrders(client, {
-          instId: values.instId,
-          status: values.history ? "history" : "pending",
-          ordType: values.ordType,
-          json
-        });
-    }
-  }
-  if (module === "swap") {
-    if (action === "positions")
-      return cmdSwapPositions(client, rest[0] ?? values.instId, json);
-    if (action === "orders")
-      return cmdSwapOrders(client, {
-        instId: values.instId,
-        status: values.history ? "history" : "open",
-        json
-      });
-    if (action === "place")
-      return cmdSwapPlace(client, {
-        instId: values.instId,
-        side: values.side,
-        ordType: values.ordType,
-        sz: values.sz,
-        posSide: values.posSide,
-        px: values.px,
-        tdMode: values.tdMode ?? "cross",
-        json
-      });
-    if (action === "cancel")
-      return cmdSwapCancel(client, rest[0], values.ordId, json);
-    if (action === "leverage")
-      return cmdSwapSetLeverage(client, {
-        instId: values.instId,
-        lever: values.lever,
-        mgnMode: values.mgnMode,
-        posSide: values.posSide,
-        json
-      });
-    if (action === "algo") {
-      const subAction = rest[0];
-      if (subAction === "trail")
-        return cmdSwapAlgoTrailPlace(client, {
-          instId: values.instId,
-          side: values.side,
-          sz: values.sz,
-          callbackRatio: values.callbackRatio,
-          callbackSpread: values.callbackSpread,
-          activePx: values.activePx,
-          posSide: values.posSide,
-          tdMode: values.tdMode ?? "cross",
-          reduceOnly: values.reduceOnly,
-          json
-        });
-      if (subAction === "place")
-        return cmdSwapAlgoPlace(client, {
-          instId: values.instId,
-          side: values.side,
-          ordType: values.ordType ?? "conditional",
-          sz: values.sz,
-          posSide: values.posSide,
-          tdMode: values.tdMode ?? "cross",
-          tpTriggerPx: values.tpTriggerPx,
-          tpOrdPx: values.tpOrdPx,
-          slTriggerPx: values.slTriggerPx,
-          slOrdPx: values.slOrdPx,
-          reduceOnly: values.reduceOnly,
-          json
-        });
-      if (subAction === "amend")
-        return cmdSwapAlgoAmend(client, {
-          instId: values.instId,
-          algoId: values.algoId,
-          newSz: values.newSz,
-          newTpTriggerPx: values.newTpTriggerPx,
-          newTpOrdPx: values.newTpOrdPx,
-          newSlTriggerPx: values.newSlTriggerPx,
-          newSlOrdPx: values.newSlOrdPx,
-          json
-        });
-      if (subAction === "cancel")
-        return cmdSwapAlgoCancel(client, values.instId, values.algoId, json);
-      if (subAction === "orders")
-        return cmdSwapAlgoOrders(client, {
-          instId: values.instId,
-          status: values.history ? "history" : "pending",
-          ordType: values.ordType,
-          json
-        });
-    }
-  }
+  if (module === "market") return handleMarketCommand(client, action, rest, v, json);
+  if (module === "account") return handleAccountCommand(client, action, rest, v, json);
+  if (module === "spot") return handleSpotCommand(client, action, rest, v, json);
+  if (module === "swap") return handleSwapCommand(client, action, rest, v, json);
+  if (module === "futures") return handleFuturesCommand(client, action, rest, v, json);
+  if (module === "bot") return handleBotCommand(client, action, rest, v, json);
   process.stderr.write(`Unknown command: ${module} ${action ?? ""}
 `);
   process.exitCode = 1;
 }
-main().catch((error) => {
-  const payload = toToolErrorPayload(error);
-  process.stderr.write(`Error: ${payload.message}
+if (import.meta.url === pathToFileURL(process.argv[1]).href) {
+  main().catch((error) => {
+    const payload = toToolErrorPayload(error);
+    process.stderr.write(`Error: ${payload.message}
 `);
-  if (payload.traceId) process.stderr.write(`TraceId: ${payload.traceId}
+    if (payload.traceId) process.stderr.write(`TraceId: ${payload.traceId}
 `);
-  if (payload.suggestion) process.stderr.write(`Hint: ${payload.suggestion}
+    if (payload.suggestion) process.stderr.write(`Hint: ${payload.suggestion}
 `);
-  process.stderr.write(`Version: okx-trade-cli@${CLI_VERSION}
+    process.stderr.write(`Version: okx-trade-cli@${CLI_VERSION}
 `);
-  process.exitCode = 1;
-});
+    process.exitCode = 1;
+  });
+}
+export {
+  handleAccountWriteCommand,
+  handleBotCommand,
+  handleBotGridCommand,
+  handleConfigCommand,
+  handleMarketCommand,
+  handleMarketDataCommand,
+  handleMarketPublicCommand,
+  handleSetupCommand,
+  printHelp
+};
 //# sourceMappingURL=index.js.map