@okx_ai/okx-trade-cli 1.0.8

package/dist/index.js

@@ -0,0 +1,2580 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { parseArgs } from "util";
+import { createRequire } from "module";
+
+// ../core/dist/index.js
+import { createHmac } from "crypto";
+import path from "path";
+import os from "os";
+import { readFileSync, existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+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();
+}
+function signOkxPayload(payload, secretKey) {
+  return createHmac("sha256", secretKey).update(payload).digest("base64");
+}
+var OkxMcpError = class extends Error {
+  type;
+  code;
+  suggestion;
+  endpoint;
+  traceId;
+  constructor(type, message, options) {
+    super(message, options?.cause ? { cause: options.cause } : void 0);
+    this.name = type;
+    this.type = type;
+    this.code = options?.code;
+    this.suggestion = options?.suggestion;
+    this.endpoint = options?.endpoint;
+    this.traceId = options?.traceId;
+  }
+};
+var ConfigError = class extends OkxMcpError {
+  constructor(message, suggestion) {
+    super("ConfigError", message, { suggestion });
+  }
+};
+var RateLimitError = class extends OkxMcpError {
+  constructor(message, suggestion, endpoint, traceId) {
+    super("RateLimitError", message, { suggestion, endpoint, traceId });
+  }
+};
+var AuthenticationError = class extends OkxMcpError {
+  constructor(message, suggestion, endpoint, traceId) {
+    super("AuthenticationError", message, { suggestion, endpoint, traceId });
+  }
+};
+var OkxApiError = class extends OkxMcpError {
+  constructor(message, options) {
+    super("OkxApiError", message, options);
+  }
+};
+var NetworkError = class extends OkxMcpError {
+  constructor(message, endpoint, cause) {
+    super("NetworkError", message, {
+      endpoint,
+      cause,
+      suggestion: "Please check network connectivity and retry the request in a few seconds."
+    });
+  }
+};
+function toToolErrorPayload(error, fallbackEndpoint) {
+  if (error instanceof OkxMcpError) {
+    return {
+      error: true,
+      type: error.type,
+      code: error.code,
+      message: error.message,
+      suggestion: error.suggestion,
+      endpoint: error.endpoint ?? fallbackEndpoint,
+      traceId: error.traceId,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  const message = error instanceof Error ? error.message : String(error);
+  return {
+    error: true,
+    type: "InternalError",
+    message,
+    suggestion: "Unexpected server error. Check tool arguments and retry. If it persists, inspect server logs.",
+    endpoint: fallbackEndpoint,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function sleep(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+var RateLimiter = class {
+  buckets = /* @__PURE__ */ new Map();
+  maxWaitMs;
+  constructor(maxWaitMs = 3e4) {
+    this.maxWaitMs = maxWaitMs;
+  }
+  async consume(config, amount = 1) {
+    const bucket = this.getBucket(config);
+    this.refill(bucket);
+    if (bucket.tokens >= amount) {
+      bucket.tokens -= amount;
+      return;
+    }
+    const missing = amount - bucket.tokens;
+    const secondsToWait = missing / bucket.refillPerSecond;
+    const waitMs = Math.ceil(secondsToWait * 1e3);
+    if (waitMs > this.maxWaitMs) {
+      throw new RateLimitError(
+        `Client-side rate limit reached for ${config.key}. Required wait ${waitMs}ms exceeds allowed max ${this.maxWaitMs}ms.`,
+        "Reduce tool call frequency or retry later."
+      );
+    }
+    await sleep(waitMs);
+    this.refill(bucket);
+    if (bucket.tokens < amount) {
+      throw new RateLimitError(
+        `Rate limiter failed to acquire enough tokens for ${config.key}.`
+      );
+    }
+    bucket.tokens -= amount;
+  }
+  getBucket(config) {
+    const existing = this.buckets.get(config.key);
+    if (existing) {
+      if (existing.capacity !== config.capacity || existing.refillPerSecond !== config.refillPerSecond) {
+        existing.capacity = config.capacity;
+        existing.refillPerSecond = config.refillPerSecond;
+        existing.tokens = Math.min(existing.tokens, config.capacity);
+      }
+      return existing;
+    }
+    const now = Date.now();
+    const created = {
+      tokens: config.capacity,
+      lastRefillMs: now,
+      capacity: config.capacity,
+      refillPerSecond: config.refillPerSecond
+    };
+    this.buckets.set(config.key, created);
+    return created;
+  }
+  refill(bucket) {
+    const now = Date.now();
+    const elapsedMs = now - bucket.lastRefillMs;
+    if (elapsedMs <= 0) {
+      return;
+    }
+    const refillTokens = elapsedMs / 1e3 * bucket.refillPerSecond;
+    bucket.tokens = Math.min(bucket.capacity, bucket.tokens + refillTokens);
+    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 (site: {site}). Verify your site setting matches your account registration region. Available sites: global, eea, us. Do not retry." },
+  "51734": { retry: false, suggestion: "Feature not supported for your KYC country (site: {site}). Verify your site setting matches your account registration region. Available sites: global, eea, us. 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;
+}
+function extractTraceId(headers) {
+  return headers.get("x-trace-id") ?? headers.get("x-request-id") ?? headers.get("traceid") ?? void 0;
+}
+function stringifyQueryValue(value) {
+  if (Array.isArray(value)) {
+    return value.map((item) => String(item)).join(",");
+  }
+  return String(value);
+}
+function buildQueryString(query) {
+  if (!query) {
+    return "";
+  }
+  const entries = Object.entries(query).filter(([, value]) => isDefined(value));
+  if (entries.length === 0) {
+    return "";
+  }
+  const params = new URLSearchParams();
+  for (const [key, value] of entries) {
+    params.set(key, stringifyQueryValue(value));
+  }
+  return params.toString();
+}
+var OkxRestClient = class {
+  config;
+  rateLimiter = new RateLimiter();
+  constructor(config) {
+    this.config = config;
+  }
+  async publicGet(path4, query, rateLimit) {
+    return this.request({
+      method: "GET",
+      path: path4,
+      auth: "public",
+      query,
+      rateLimit
+    });
+  }
+  async privateGet(path4, query, rateLimit) {
+    return this.request({
+      method: "GET",
+      path: path4,
+      auth: "private",
+      query,
+      rateLimit
+    });
+  }
+  async privatePost(path4, body, rateLimit) {
+    return this.request({
+      method: "POST",
+      path: path4,
+      auth: "private",
+      body,
+      rateLimit
+    });
+  }
+  async request(config) {
+    const queryString = buildQueryString(config.query);
+    const requestPath = queryString.length > 0 ? `${config.path}?${queryString}` : config.path;
+    const url = `${this.config.baseUrl}${requestPath}`;
+    const bodyJson = config.body ? JSON.stringify(config.body) : "";
+    const timestamp = getNow();
+    if (config.rateLimit) {
+      await this.rateLimiter.consume(config.rateLimit);
+    }
+    const headers = new Headers({
+      "Content-Type": "application/json",
+      Accept: "application/json"
+    });
+    if (this.config.userAgent) {
+      headers.set("User-Agent", this.config.userAgent);
+    }
+    if (config.auth === "private") {
+      if (!this.config.hasAuth) {
+        throw new ConfigError(
+          "Private endpoint requires API credentials.",
+          "Configure OKX_API_KEY, OKX_SECRET_KEY and OKX_PASSPHRASE."
+        );
+      }
+      if (!this.config.apiKey || !this.config.secretKey || !this.config.passphrase) {
+        throw new ConfigError(
+          "Invalid private API credentials state.",
+          "Ensure all OKX credentials are set."
+        );
+      }
+      const payload = `${timestamp}${config.method.toUpperCase()}${requestPath}${bodyJson}`;
+      const signature = signOkxPayload(payload, this.config.secretKey);
+      headers.set("OK-ACCESS-KEY", this.config.apiKey);
+      headers.set("OK-ACCESS-SIGN", signature);
+      headers.set("OK-ACCESS-PASSPHRASE", this.config.passphrase);
+      headers.set("OK-ACCESS-TIMESTAMP", timestamp);
+    }
+    if (this.config.demo) {
+      headers.set("x-simulated-trading", "1");
+    }
+    let response;
+    try {
+      response = await fetch(url, {
+        method: config.method,
+        headers,
+        body: config.method === "POST" ? bodyJson : void 0,
+        signal: AbortSignal.timeout(this.config.timeoutMs)
+      });
+    } catch (error) {
+      throw new NetworkError(
+        `Failed to call OKX endpoint ${config.method} ${requestPath}.`,
+        `${config.method} ${requestPath}`,
+        error
+      );
+    }
+    const rawText = await response.text();
+    const traceId = extractTraceId(response.headers);
+    let parsed;
+    try {
+      parsed = rawText ? JSON.parse(rawText) : {};
+    } catch (error) {
+      if (!response.ok) {
+        const messagePreview = rawText.slice(0, 160).replace(/\s+/g, " ").trim();
+        throw new OkxApiError(
+          `HTTP ${response.status} from OKX: ${messagePreview || "Non-JSON response body"}`,
+          {
+            code: String(response.status),
+            endpoint: `${config.method} ${config.path}`,
+            suggestion: "Verify endpoint path and request parameters.",
+            traceId
+          }
+        );
+      }
+      throw new NetworkError(
+        `OKX returned non-JSON response for ${config.method} ${requestPath}.`,
+        `${config.method} ${requestPath}`,
+        error
+      );
+    }
+    if (!response.ok) {
+      throw new OkxApiError(
+        `HTTP ${response.status} from OKX: ${parsed.msg ?? "Unknown error"}`,
+        {
+          code: String(response.status),
+          endpoint: `${config.method} ${config.path}`,
+          suggestion: "Retry later or verify endpoint parameters.",
+          traceId
+        }
+      );
+    }
+    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.",
+          endpoint,
+          traceId
+        );
+      }
+      const behavior = OKX_CODE_BEHAVIORS[responseCode];
+      const suggestion = behavior?.suggestion?.replace("{site}", this.config.site);
+      if (responseCode === "50011" || responseCode === "50061") {
+        throw new RateLimitError(message, suggestion, endpoint, traceId);
+      }
+      throw new OkxApiError(message, {
+        code: responseCode,
+        endpoint,
+        suggestion,
+        traceId
+      });
+    }
+    return {
+      endpoint: `${config.method} ${config.path}`,
+      requestTime: (/* @__PURE__ */ new Date()).toISOString(),
+      data: parsed.data ?? null,
+      raw: parsed
+    };
+  }
+};
+var DEFAULT_LOG_DIR = path.join(os.homedir(), ".okx", "logs");
+var OKX_SITES = {
+  global: {
+    label: "Global",
+    apiBaseUrl: "https://www.okx.com",
+    webUrl: "https://www.okx.com"
+  },
+  eea: {
+    label: "EEA",
+    apiBaseUrl: "https://eea.okx.com",
+    webUrl: "https://my.okx.com"
+  },
+  us: {
+    label: "US",
+    apiBaseUrl: "https://app.okx.com",
+    webUrl: "https://app.okx.com"
+  }
+};
+var SITE_IDS = Object.keys(OKX_SITES);
+var MODULES = [
+  "market",
+  "spot",
+  "swap",
+  "futures",
+  "option",
+  "account",
+  "bot"
+];
+var DEFAULT_MODULES = ["spot", "swap", "account"];
+function configFilePath() {
+  return join(homedir(), ".okx", "config.toml");
+}
+function readTomlProfile(profileName) {
+  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] ?? {};
+}
+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((item) => item.trim()).filter((item) => item.length > 0);
+  if (requested.length === 0) {
+    return [...DEFAULT_MODULES];
+  }
+  const deduped = /* @__PURE__ */ new Set();
+  for (const moduleId of requested) {
+    if (!MODULES.includes(moduleId)) {
+      throw new ConfigError(
+        `Unknown module "${moduleId}".`,
+        `Use one of: ${MODULES.join(", ")} or "all".`
+      );
+    }
+    deduped.add(moduleId);
+  }
+  return Array.from(deduped);
+}
+function loadConfig(cli) {
+  const toml = readTomlProfile(cli.profile);
+  const apiKey = process.env.OKX_API_KEY?.trim() ?? toml.api_key;
+  const secretKey = process.env.OKX_SECRET_KEY?.trim() ?? toml.secret_key;
+  const passphrase = process.env.OKX_PASSPHRASE?.trim() ?? toml.passphrase;
+  const hasAuth = Boolean(apiKey && secretKey && passphrase);
+  const partialAuth = Boolean(apiKey) || Boolean(secretKey) || Boolean(passphrase);
+  if (partialAuth && !hasAuth) {
+    throw new ConfigError(
+      "Partial API credentials detected.",
+      "Set OKX_API_KEY, OKX_SECRET_KEY and OKX_PASSPHRASE together (env vars or config.toml profile)."
+    );
+  }
+  const demo = cli.demo || process.env.OKX_DEMO === "1" || process.env.OKX_DEMO === "true" || (toml.demo ?? false);
+  const rawSite = cli.site?.trim() ?? process.env.OKX_SITE?.trim() ?? toml.site ?? "global";
+  if (!SITE_IDS.includes(rawSite)) {
+    throw new ConfigError(
+      `Unknown site "${rawSite}".`,
+      `Use one of: ${SITE_IDS.join(", ")}.`
+    );
+  }
+  const site = rawSite;
+  const rawBaseUrl = process.env.OKX_API_BASE_URL?.trim() ?? toml.base_url ?? OKX_SITES[site].apiBaseUrl;
+  if (!rawBaseUrl.startsWith("http://") && !rawBaseUrl.startsWith("https://")) {
+    throw new ConfigError(
+      `Invalid base URL "${rawBaseUrl}".`,
+      "OKX_API_BASE_URL must start with http:// or https://"
+    );
+  }
+  const baseUrl = rawBaseUrl.replace(/\/+$/, "");
+  const rawTimeout = process.env.OKX_TIMEOUT_MS ? Number(process.env.OKX_TIMEOUT_MS) : toml.timeout_ms ?? 15e3;
+  if (!Number.isFinite(rawTimeout) || rawTimeout <= 0) {
+    throw new ConfigError(
+      `Invalid timeout value "${rawTimeout}".`,
+      "Set OKX_TIMEOUT_MS as a positive integer in milliseconds."
+    );
+  }
+  return {
+    apiKey,
+    secretKey,
+    passphrase,
+    hasAuth,
+    baseUrl,
+    timeoutMs: Math.floor(rawTimeout),
+    modules: parseModuleList(cli.modules),
+    readOnly: cli.readOnly,
+    demo,
+    site,
+    userAgent: cli.userAgent
+  };
+}
+var CACHE_FILE = join2(homedir2(), ".okx", "update-check.json");
+var CHECK_INTERVAL_MS = 24 * 60 * 60 * 1e3;
+function readCache() {
+  try {
+    if (existsSync2(CACHE_FILE)) {
+      return JSON.parse(readFileSync2(CACHE_FILE, "utf-8"));
+    }
+  } catch {
+  }
+  return {};
+}
+function writeCache(cache) {
+  try {
+    mkdirSync(join2(homedir2(), ".okx"), { recursive: true });
+    writeFileSync(CACHE_FILE, JSON.stringify(cache, null, 2), "utf-8");
+  } catch {
+  }
+}
+function isNewerVersion(current, latest) {
+  const parse22 = (v) => v.replace(/^v/, "").split(".").map((n) => parseInt(n, 10));
+  const [cMaj, cMin, cPat] = parse22(current);
+  const [lMaj, lMin, lPat] = parse22(latest);
+  if (lMaj !== cMaj) return lMaj > cMaj;
+  if (lMin !== cMin) return lMin > cMin;
+  return lPat > cPat;
+}
+async function fetchLatestVersion(packageName) {
+  try {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 3e3);
+    const res = await fetch(`https://registry.npmjs.org/${encodeURIComponent(packageName)}/latest`, {
+      signal: controller.signal,
+      headers: { accept: "application/json" }
+    });
+    clearTimeout(timeout);
+    if (!res.ok) return null;
+    const data = await res.json();
+    return data.version ?? null;
+  } catch {
+    return null;
+  }
+}
+function refreshCacheInBackground(packageName) {
+  fetchLatestVersion(packageName).then((latest) => {
+    if (!latest) return;
+    const cache = readCache();
+    cache[packageName] = { latestVersion: latest, checkedAt: Date.now() };
+    writeCache(cache);
+  }).catch(() => {
+  });
+}
+function checkForUpdates(packageName, currentVersion) {
+  const cache = readCache();
+  const entry = cache[packageName];
+  if (entry && isNewerVersion(currentVersion, entry.latestVersion)) {
+    process.stderr.write(
+      `
+Update available for ${packageName}: ${currentVersion} \u2192 ${entry.latestVersion}
+Run: npm install -g ${packageName}
+
+`
+    );
+  }
+  if (!entry || Date.now() - entry.checkedAt > CHECK_INTERVAL_MS) {
+    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) {
+  return loadConfig({
+    profile: opts.profile,
+    modules: opts.modules,
+    readOnly: opts.readOnly ?? false,
+    demo: opts.demo ?? false,
+    site: opts.site,
+    userAgent: opts.userAgent
+  });
+}
+
+// src/formatter.ts
+function printJson(data) {
+  process.stdout.write(JSON.stringify(data, null, 2) + "\n");
+}
+function printTable(rows) {
+  if (rows.length === 0) {
+    process.stdout.write("(no data)\n");
+    return;
+  }
+  const keys = Object.keys(rows[0]);
+  const widths = keys.map(
+    (k) => Math.max(k.length, ...rows.map((r) => String(r[k] ?? "").length))
+  );
+  const header = keys.map((k, i) => k.padEnd(widths[i])).join("  ");
+  const divider = widths.map((w) => "-".repeat(w)).join("  ");
+  process.stdout.write(header + "\n" + divider + "\n");
+  for (const row of rows) {
+    process.stdout.write(
+      keys.map((k, i) => String(row[k] ?? "").padEnd(widths[i])).join("  ") + "\n"
+    );
+  }
+}
+function printKv(obj, indent = 0) {
+  const pad = " ".repeat(indent);
+  for (const [k, v] of Object.entries(obj)) {
+    if (v !== null && typeof v === "object" && !Array.isArray(v)) {
+      process.stdout.write(`${pad}${k}:
+`);
+      printKv(v, indent + 2);
+    } else {
+      process.stdout.write(`${pad}${k.padEnd(20 - indent)}  ${v}
+`);
+    }
+  }
+}
+
+// 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;
+  if (json) return printJson(items);
+  if (!items?.length) {
+    process.stdout.write("No data\n");
+    return;
+  }
+  const t = items[0];
+  printKv({
+    instId: t["instId"],
+    last: t["last"],
+    "24h change %": t["sodUtc8"],
+    "24h high": t["high24h"],
+    "24h low": t["low24h"],
+    "24h vol": t["vol24h"],
+    time: new Date(Number(t["ts"])).toLocaleString()
+  });
+}
+async function cmdMarketTickers(client, instType, json) {
+  const res = await client.publicGet("/api/v5/market/tickers", { instType });
+  const items = res.data;
+  if (json) return printJson(items);
+  printTable(
+    (items ?? []).map((t) => ({
+      instId: t["instId"],
+      last: t["last"],
+      "24h high": t["high24h"],
+      "24h low": t["low24h"],
+      "24h vol": t["vol24h"]
+    }))
+  );
+}
+async function cmdMarketOrderbook(client, instId, sz, json) {
+  const params = { instId };
+  if (sz !== void 0) params["sz"] = String(sz);
+  const res = await client.publicGet("/api/v5/market/books", params);
+  if (json) return printJson(res.data);
+  const book = res.data[0];
+  if (!book) {
+    process.stdout.write("No data\n");
+    return;
+  }
+  const asks = book["asks"].slice(0, 5);
+  const bids = book["bids"].slice(0, 5);
+  process.stdout.write("Asks (price / size):\n");
+  for (const [p, s] of asks.reverse()) process.stdout.write(`  ${p.padStart(16)}  ${s}
+`);
+  process.stdout.write("Bids (price / size):\n");
+  for (const [p, s] of bids) process.stdout.write(`  ${p.padStart(16)}  ${s}
+`);
+}
+async function cmdMarketCandles(client, instId, opts) {
+  const params = { instId };
+  if (opts.bar) params["bar"] = opts.bar;
+  if (opts.limit) params["limit"] = String(opts.limit);
+  const res = await client.publicGet("/api/v5/market/candles", params);
+  const candles = res.data;
+  if (opts.json) return printJson(candles);
+  printTable(
+    (candles ?? []).map(([ts, o, h, l, c, vol]) => ({
+      time: new Date(Number(ts)).toLocaleString(),
+      open: o,
+      high: h,
+      low: l,
+      close: c,
+      vol
+    }))
+  );
+}
+
+// src/commands/account.ts
+async function cmdAccountBalance(client, ccy, json) {
+  const params = {};
+  if (ccy) params["ccy"] = ccy;
+  const res = await client.privateGet("/api/v5/account/balance", params);
+  const data = res.data;
+  if (json) return printJson(data);
+  const details = data?.[0]?.["details"] ?? [];
+  printTable(
+    details.filter((d) => Number(d["eq"]) > 0).map((d) => ({
+      currency: d["ccy"],
+      equity: d["eq"],
+      available: d["availEq"],
+      frozen: d["frozenBal"]
+    }))
+  );
+}
+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) {
+  const endpoint = opts.status === "history" ? "/api/v5/trade/orders-history" : "/api/v5/trade/orders-pending";
+  const params = { instType: "SPOT" };
+  if (opts.instId) params["instId"] = opts.instId;
+  const res = await client.privateGet(endpoint, params);
+  const orders = res.data;
+  if (opts.json) return printJson(orders);
+  printTable(
+    (orders ?? []).map((o) => ({
+      ordId: o["ordId"],
+      instId: o["instId"],
+      side: o["side"],
+      type: o["ordType"],
+      price: o["px"],
+      size: o["sz"],
+      filled: o["fillSz"],
+      state: o["state"]
+    }))
+  );
+}
+async function cmdSpotPlace(client, opts) {
+  const body = {
+    instId: opts.instId,
+    tdMode: "cash",
+    side: opts.side,
+    ordType: opts.ordType,
+    sz: opts.sz
+  };
+  if (opts.px) body["px"] = opts.px;
+  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 cmdSpotCancel(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 cmdSpotAlgoPlace(client, opts) {
+  const body = {
+    instId: opts.instId,
+    tdMode: "cash",
+    side: opts.side,
+    ordType: opts.ordType,
+    sz: opts.sz
+  };
+  if (opts.tpTriggerPx) body["tpTriggerPx"] = opts.tpTriggerPx;
+  if (opts.tpOrdPx) body["tpOrdPx"] = opts.tpOrdPx;
+  if (opts.slTriggerPx) body["slTriggerPx"] = opts.slTriggerPx;
+  if (opts.slOrdPx) body["slOrdPx"] = opts.slOrdPx;
+  const res = await client.privatePost("/api/v5/trade/order-algo", body);
+  if (opts.json) return printJson(res.data);
+  const order = res.data[0];
+  process.stdout.write(
+    `Algo order placed: ${order?.["algoId"]} (${order?.["sCode"] === "0" ? "OK" : order?.["sMsg"]})
+`
+  );
+}
+async function cmdSpotAlgoAmend(client, opts) {
+  const body = {
+    instId: opts.instId,
+    algoId: opts.algoId
+  };
+  if (opts.newSz) body["newSz"] = opts.newSz;
+  if (opts.newTpTriggerPx) body["newTpTriggerPx"] = opts.newTpTriggerPx;
+  if (opts.newTpOrdPx) body["newTpOrdPx"] = opts.newTpOrdPx;
+  if (opts.newSlTriggerPx) body["newSlTriggerPx"] = opts.newSlTriggerPx;
+  if (opts.newSlOrdPx) body["newSlOrdPx"] = opts.newSlOrdPx;
+  const res = await client.privatePost("/api/v5/trade/amend-algos", body);
+  if (opts.json) return printJson(res.data);
+  const r = res.data[0];
+  process.stdout.write(
+    `Algo order amended: ${r?.["algoId"]} (${r?.["sCode"] === "0" ? "OK" : r?.["sMsg"]})
+`
+  );
+}
+async function cmdSpotAlgoCancel(client, instId, algoId, json) {
+  const res = await client.privatePost("/api/v5/trade/cancel-algos", [
+    { algoId, instId }
+  ]);
+  if (json) return printJson(res.data);
+  const r = res.data[0];
+  process.stdout.write(
+    `Algo order cancelled: ${r?.["algoId"]} (${r?.["sCode"] === "0" ? "OK" : r?.["sMsg"]})
+`
+  );
+}
+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" };
+  if (opts.instId) baseParams["instId"] = opts.instId;
+  let orders;
+  if (opts.ordType) {
+    const res = await client.privateGet(endpoint, { ...baseParams, ordType: opts.ordType });
+    orders = res.data ?? [];
+  } else {
+    const [r1, r2] = await Promise.all([
+      client.privateGet(endpoint, { ...baseParams, ordType: "conditional" }),
+      client.privateGet(endpoint, { ...baseParams, ordType: "oco" })
+    ]);
+    orders = [
+      ...r1.data ?? [],
+      ...r2.data ?? []
+    ];
+  }
+  if (opts.json) return printJson(orders);
+  if (!(orders ?? []).length) {
+    process.stdout.write("No algo orders\n");
+    return;
+  }
+  printTable(
+    orders.map((o) => ({
+      algoId: o["algoId"],
+      instId: o["instId"],
+      type: o["ordType"],
+      side: o["side"],
+      sz: o["sz"],
+      tpTrigger: o["tpTriggerPx"],
+      slTrigger: o["slTriggerPx"],
+      state: o["state"]
+    }))
+  );
+}
+async function cmdSpotFills(client, opts) {
+  const params = { instType: "SPOT" };
+  if (opts.instId) params["instId"] = opts.instId;
+  if (opts.ordId) params["ordId"] = opts.ordId;
+  const res = await client.privateGet("/api/v5/trade/fills", 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()
+    }))
+  );
+}
+
+// src/commands/swap.ts
+async function cmdSwapPositions(client, instId, json) {
+  const params = { instType: "SWAP" };
+  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"],
+      size: p["pos"],
+      avgPx: p["avgPx"],
+      upl: p["upl"],
+      uplRatio: p["uplRatio"],
+      lever: p["lever"]
+    }))
+  );
+}
+async function cmdSwapOrders(client, opts) {
+  const endpoint = opts.status === "history" ? "/api/v5/trade/orders-history" : "/api/v5/trade/orders-pending";
+  const params = { instType: "SWAP" };
+  if (opts.instId) params["instId"] = opts.instId;
+  const res = await client.privateGet(endpoint, 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 cmdSwapPlace(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;
+  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 cmdSwapCancel(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 cmdSwapAlgoPlace(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.tpTriggerPx) body["tpTriggerPx"] = opts.tpTriggerPx;
+  if (opts.tpOrdPx) body["tpOrdPx"] = opts.tpOrdPx;
+  if (opts.slTriggerPx) body["slTriggerPx"] = opts.slTriggerPx;
+  if (opts.slOrdPx) body["slOrdPx"] = opts.slOrdPx;
+  if (opts.reduceOnly !== void 0) body["reduceOnly"] = String(opts.reduceOnly);
+  const res = await client.privatePost("/api/v5/trade/order-algo", body);
+  if (opts.json) return printJson(res.data);
+  const order = res.data[0];
+  process.stdout.write(
+    `Algo order placed: ${order?.["algoId"]} (${order?.["sCode"] === "0" ? "OK" : order?.["sMsg"]})
+`
+  );
+}
+async function cmdSwapAlgoAmend(client, opts) {
+  const body = {
+    instId: opts.instId,
+    algoId: opts.algoId
+  };
+  if (opts.newSz) body["newSz"] = opts.newSz;
+  if (opts.newTpTriggerPx) body["newTpTriggerPx"] = opts.newTpTriggerPx;
+  if (opts.newTpOrdPx) body["newTpOrdPx"] = opts.newTpOrdPx;
+  if (opts.newSlTriggerPx) body["newSlTriggerPx"] = opts.newSlTriggerPx;
+  if (opts.newSlOrdPx) body["newSlOrdPx"] = opts.newSlOrdPx;
+  const res = await client.privatePost("/api/v5/trade/amend-algos", body);
+  if (opts.json) return printJson(res.data);
+  const r = res.data[0];
+  process.stdout.write(
+    `Algo order amended: ${r?.["algoId"]} (${r?.["sCode"] === "0" ? "OK" : r?.["sMsg"]})
+`
+  );
+}
+async function cmdSwapAlgoTrailPlace(client, opts) {
+  const body = {
+    instId: opts.instId,
+    tdMode: opts.tdMode,
+    side: opts.side,
+    ordType: "move_order_stop",
+    sz: opts.sz
+  };
+  if (opts.posSide) body["posSide"] = opts.posSide;
+  if (opts.callbackRatio) body["callbackRatio"] = opts.callbackRatio;
+  if (opts.callbackSpread) body["callbackSpread"] = opts.callbackSpread;
+  if (opts.activePx) body["activePx"] = opts.activePx;
+  if (opts.reduceOnly !== void 0) body["reduceOnly"] = String(opts.reduceOnly);
+  const res = await client.privatePost("/api/v5/trade/order-algo", body);
+  if (opts.json) return printJson(res.data);
+  const order = res.data[0];
+  process.stdout.write(
+    `Trailing stop placed: ${order?.["algoId"]} (${order?.["sCode"] === "0" ? "OK" : order?.["sMsg"]})
+`
+  );
+}
+async function cmdSwapAlgoCancel(client, instId, algoId, json) {
+  const res = await client.privatePost("/api/v5/trade/cancel-algos", [
+    { algoId, instId }
+  ]);
+  if (json) return printJson(res.data);
+  const r = res.data[0];
+  process.stdout.write(
+    `Algo order cancelled: ${r?.["algoId"]} (${r?.["sCode"] === "0" ? "OK" : r?.["sMsg"]})
+`
+  );
+}
+async function cmdSwapAlgoOrders(client, opts) {
+  const endpoint = opts.status === "history" ? "/api/v5/trade/orders-algo-history" : "/api/v5/trade/orders-algo-pending";
+  const baseParams = { instType: "SWAP" };
+  if (opts.instId) baseParams["instId"] = opts.instId;
+  let orders;
+  if (opts.ordType) {
+    const res = await client.privateGet(endpoint, { ...baseParams, ordType: opts.ordType });
+    orders = res.data ?? [];
+  } else {
+    const [r1, r2, r3] = await Promise.all([
+      client.privateGet(endpoint, { ...baseParams, ordType: "conditional" }),
+      client.privateGet(endpoint, { ...baseParams, ordType: "oco" }),
+      client.privateGet(endpoint, { ...baseParams, ordType: "move_order_stop" })
+    ]);
+    orders = [
+      ...r1.data ?? [],
+      ...r2.data ?? [],
+      ...r3.data ?? []
+    ];
+  }
+  if (opts.json) return printJson(orders);
+  if (!(orders ?? []).length) {
+    process.stdout.write("No algo orders\n");
+    return;
+  }
+  printTable(
+    orders.map((o) => ({
+      algoId: o["algoId"],
+      instId: o["instId"],
+      type: o["ordType"],
+      side: o["side"],
+      sz: o["sz"],
+      tpTrigger: o["tpTriggerPx"],
+      slTrigger: o["slTriggerPx"],
+      state: o["state"]
+    }))
+  );
+}
+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,
+    lever: opts.lever,
+    mgnMode: opts.mgnMode
+  };
+  if (opts.posSide) body["posSide"] = opts.posSide;
+  const res = await client.privatePost("/api/v5/account/set-leverage", body);
+  if (opts.json) return printJson(res.data);
+  const r = res.data[0];
+  process.stdout.write(`Leverage set: ${r?.["lever"]}x ${r?.["instId"]}
+`);
+}
+
+// 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 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 (!existsSync4(dir)) {
+    mkdirSync3(dir, { recursive: true });
+  }
+  writeFileSync3(configFilePath(), stringify(config), "utf-8");
+}
+
+// src/commands/config.ts
+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 path2 = configFilePath();
+  if (!existsSync5(path2)) return { profiles: {} };
+  const raw = readFileSync4(path2, "utf-8");
+  return parse2(raw);
+}
+function prompt(rl, question) {
+  return new Promise((resolve) => rl.question(question, resolve));
+}
+function cmdConfigShow(json) {
+  const config = readFullConfig();
+  if (json) return printJson(config);
+  process.stdout.write(`Config: ${configFilePath()}
+
+`);
+  process.stdout.write(`default_profile: ${config.default_profile ?? "(not set)"}
+
+`);
+  for (const [name, profile] of Object.entries(config.profiles)) {
+    process.stdout.write(`[${name}]
+`);
+    printKv({
+      api_key: profile.api_key ? "***" + profile.api_key.slice(-4) : "(not set)",
+      demo: profile.demo ?? false,
+      base_url: profile.base_url ?? "(default)"
+    }, 2);
+    process.stdout.write("\n");
+  }
+}
+function cmdConfigSet(key, value) {
+  const config = readFullConfig();
+  if (key === "default_profile") {
+    config.default_profile = value;
+    writeCliConfig(config);
+    process.stdout.write(`default_profile set to "${value}"
+`);
+  } else {
+    process.stderr.write(`Unknown config key: ${key}
+`);
+    process.exitCode = 1;
+  }
+}
+var SITES = {
+  global: { label: "Global (www.okx.com)", webUrl: "https://www.okx.com" },
+  eea: { label: "EEA (my.okx.com)", webUrl: "https://my.okx.com" },
+  us: { label: "US (app.okx.com)", webUrl: "https://app.okx.com" }
+};
+function parseSiteKey(raw) {
+  if (raw === "2") return "eea";
+  if (raw === "3") return "us";
+  return "global";
+}
+function buildApiUrl(siteKey, demo) {
+  const query = demo ? "?go-demo-trading=1" : "?go-live-trading=1";
+  return `${SITES[siteKey].webUrl}/account/my-api${query}`;
+}
+function buildProfileEntry(siteKey, apiKey, secretKey, passphrase, demo) {
+  const entry = { api_key: apiKey, secret_key: secretKey, passphrase, demo };
+  if (siteKey !== "global") {
+    entry.base_url = SITES[siteKey].webUrl;
+  }
+  return entry;
+}
+async function cmdConfigInit() {
+  process.stdout.write("OKX Trade CLI \u2014 \u914D\u7F6E\u5411\u5BFC\n\n");
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    process.stdout.write("\u8BF7\u9009\u62E9\u7AD9\u70B9:\n");
+    process.stdout.write("  1) Global (www.okx.com)  [\u9ED8\u8BA4]\n");
+    process.stdout.write("  2) EEA   (my.okx.com)\n");
+    process.stdout.write("  3) US    (app.okx.com)\n");
+    const siteRaw = (await prompt(rl, "\u7AD9\u70B9 (1/2/3, \u9ED8\u8BA4: 1): ")).trim();
+    const siteKey = parseSiteKey(siteRaw);
+    const demoRaw = (await prompt(rl, "\u4F7F\u7528\u6A21\u62DF\u76D8\uFF1F(Y/n) ")).trim().toLowerCase();
+    const demo = demoRaw !== "n";
+    const apiUrl = buildApiUrl(siteKey, demo);
+    const hint = demo ? "\u9875\u9762\u4F1A\u81EA\u52A8\u8DF3\u8F6C\u5230\u6A21\u62DF\u76D8 API \u7BA1\u7406" : "\u9875\u9762\u4F1A\u81EA\u52A8\u8DF3\u8F6C\u5230\u5B9E\u76D8 API \u7BA1\u7406";
+    process.stdout.write(`
+\u8BF7\u524D\u5F80 ${apiUrl} \u521B\u5EFA API Key\uFF08\u9700\u8981 trade \u6743\u9650\uFF09
+`);
+    process.stdout.write(`\u63D0\u793A\uFF1A${hint}
+
+`);
+    try {
+      const opener = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+      spawnSync(opener, [apiUrl], { stdio: "ignore", shell: process.platform === "win32" });
+    } catch {
+    }
+    const profileNameRaw = await prompt(rl, "Profile \u540D\u79F0 (\u9ED8\u8BA4: default): ");
+    const profileName = profileNameRaw.trim() || "default";
+    const apiKey = (await prompt(rl, "API Key: ")).trim();
+    if (!apiKey) {
+      process.stderr.write("\u9519\u8BEF: API Key \u4E0D\u80FD\u4E3A\u7A7A\n");
+      process.exitCode = 1;
+      return;
+    }
+    const secretKey = (await prompt(rl, "Secret Key: ")).trim();
+    if (!secretKey) {
+      process.stderr.write("\u9519\u8BEF: Secret Key \u4E0D\u80FD\u4E3A\u7A7A\n");
+      process.exitCode = 1;
+      return;
+    }
+    const passphrase = (await prompt(rl, "Passphrase: ")).trim();
+    if (!passphrase) {
+      process.stderr.write("\u9519\u8BEF: Passphrase \u4E0D\u80FD\u4E3A\u7A7A\n");
+      process.exitCode = 1;
+      return;
+    }
+    if (demo) {
+      process.stdout.write("\u5DF2\u9009\u62E9\u6A21\u62DF\u76D8\u6A21\u5F0F\uFF0C\u53EF\u968F\u65F6\u901A\u8FC7 okx config set \u5207\u6362\u4E3A\u5B9E\u76D8\u3002\n");
+    }
+    const config = readFullConfig();
+    const profileEntry = buildProfileEntry(siteKey, apiKey, secretKey, passphrase, demo);
+    config.profiles[profileName] = profileEntry;
+    const configPath = configFilePath();
+    try {
+      writeCliConfig(config);
+      process.stdout.write(`
+\u914D\u7F6E\u5DF2\u4FDD\u5B58\u5230 ${configPath}
+`);
+      process.stdout.write(`\u4F7F\u7528\u65B9\u5F0F: okx --profile ${profileName} account balance
+`);
+      if (!config.default_profile) {
+        process.stdout.write(`\u63D0\u793A: \u8FD0\u884C okx config set default_profile ${profileName} \u53EF\u5C06\u5176\u8BBE\u4E3A\u9ED8\u8BA4
+`);
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      const isPermission = err instanceof Error && "code" in err && (err.code === "EACCES" || err.code === "EPERM");
+      process.stderr.write(`\u5199\u5165\u914D\u7F6E\u6587\u4EF6\u5931\u8D25: ${message}
+`);
+      if (isPermission) {
+        process.stderr.write(`\u6743\u9650\u4E0D\u8DB3\uFF0C\u8BF7\u68C0\u67E5 ${configPath} \u53CA\u5176\u7236\u76EE\u5F55\u7684\u8BFB\u5199\u6743\u9650\u3002
+`);
+      }
+      process.stderr.write("\u8BF7\u624B\u52A8\u5C06\u4EE5\u4E0B\u5185\u5BB9\u5199\u5165 " + configPath + ":\n\n");
+      process.stdout.write(stringify2(config) + "\n");
+      process.exitCode = 1;
+    }
+  } finally {
+    rl.close();
+  }
+}
+
+// src/commands/client-setup.ts
+import * as fs from "fs";
+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(`
+`);
+  }
+  printSetupUsage();
+}
+
+// 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;
+  }
+  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;
+  }
+  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()
+  });
+}
+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(
+    `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"]})
+`
+  );
+}
+
+// src/index.ts
+var _require = createRequire(import.meta.url);
+var CLI_VERSION = _require("../package.json").version;
+function printHelp() {
+  process.stdout.write(`
+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
+
+Commands:
+  market ticker <instId>
+  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>]
+                  [--tpTriggerPx <price>] [--tpOrdPx <price|-1>]
+                  [--slTriggerPx <price>] [--slOrdPx <price|-1>]
+  spot algo amend --instId <id> --algoId <id> [--newSz <n>]
+                  [--newTpTriggerPx <price>] [--newTpOrdPx <price|-1>]
+                  [--newSlTriggerPx <price>] [--newSlOrdPx <price|-1>]
+  spot algo cancel --instId <id> --algoId <id>
+
+  swap positions [<instId>]
+  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]
+  swap algo place --instId <id> --side <buy|sell> --sz <n> [--ordType <conditional|oco>]
+                  [--tpTriggerPx <price>] [--tpOrdPx <price|-1>]
+                  [--slTriggerPx <price>] [--slOrdPx <price|-1>]
+                  [--posSide <net|long|short>] [--tdMode <cross|isolated>] [--reduceOnly]
+  swap algo amend --instId <id> --algoId <id> [--newSz <n>]
+                  [--newTpTriggerPx <price>] [--newTpOrdPx <price|-1>]
+                  [--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_ai/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" },
+      sz: { type: "string" },
+      // orders
+      instId: { type: "string" },
+      history: { type: "boolean", default: false },
+      ordId: { type: "string" },
+      // trade
+      side: { type: "string" },
+      ordType: { type: "string" },
+      px: { type: "string" },
+      posSide: { type: "string" },
+      tdMode: { type: "string" },
+      // leverage
+      lever: { type: "string" },
+      mgnMode: { type: "string" },
+      // algo orders
+      tpTriggerPx: { type: "string" },
+      tpOrdPx: { type: "string" },
+      slTriggerPx: { type: "string" },
+      slOrdPx: { type: "string" },
+      algoId: { type: "string" },
+      reduceOnly: { type: "boolean", default: false },
+      // algo amend
+      newSz: { type: "string" },
+      newTpTriggerPx: { type: "string" },
+      newTpOrdPx: { type: "string" },
+      newSlTriggerPx: { type: "string" },
+      newSlOrdPx: { type: "string" },
+      // trailing stop
+      callbackRatio: { type: "string" },
+      callbackSpread: { 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
+  });
+  if (values.help || positionals.length === 0) {
+    printHelp();
+    return;
+  }
+  const [module, action, ...rest] = positionals;
+  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") 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 (payload.traceId) process.stderr.write(`TraceId: ${payload.traceId}
+`);
+  if (payload.suggestion) process.stderr.write(`Hint: ${payload.suggestion}
+`);
+  process.stderr.write(`Version: @okx_ai/okx-trade-cli@${CLI_VERSION}
+`);
+  process.exitCode = 1;
+});
+export {
+  handleAccountWriteCommand,
+  handleBotCommand,
+  handleBotGridCommand,
+  handleConfigCommand,
+  handleMarketCommand,
+  handleMarketDataCommand,
+  handleMarketPublicCommand,
+  handleSetupCommand,
+  printHelp
+};
+//# sourceMappingURL=index.js.map