@okx_ai/okx-trade-mcp 1.2.8 → 1.2.9-beta.1

package/dist/index.js

@@ -5,20 +5,25 @@ import { parseArgs } from "util";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 
 // ../core/dist/index.js
-import { ProxyAgent } from "undici";
+import { Agent, ProxyAgent } from "undici";
+import { unlink } from "fs/promises";
+import { execFile } from "child_process";
+import { access, constants } from "fs/promises";
+import { homedir } from "os";
+import { join } from "path";
 import { createHmac } from "crypto";
 import fs from "fs";
 import path from "path";
 import os from "os";
 import { writeFileSync, renameSync, unlinkSync, mkdirSync } from "fs";
-import { join, resolve, basename, sep } from "path";
+import { join as join2, resolve, basename, sep } from "path";
 import { randomUUID } from "crypto";
 import yauzl from "yauzl";
-import { join as join3, dirname as dirname2 } from "path";
-import { homedir } from "os";
-import { readFileSync as readFileSync3, writeFileSync as writeFileSync3, mkdirSync as mkdirSync4, existsSync as existsSync3 } from "fs";
-import { join as join4, dirname as dirname3 } from "path";
+import { join as join4, dirname as dirname2 } from "path";
 import { homedir as homedir2 } from "os";
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync3, mkdirSync as mkdirSync4, existsSync as existsSync3 } from "fs";
+import { join as join5, dirname as dirname3 } from "path";
+import { homedir as homedir3 } from "os";
 
 // ../../node_modules/.pnpm/smol-toml@1.6.0/node_modules/smol-toml/dist/error.js
 function getLineColFromPtr(string, ptr) {
@@ -707,8 +712,8 @@ function parse(toml, { maxDepth = 1e3, integersAsBigInt } = {}) {
 
 // ../core/dist/index.js
 import { readFileSync as readFileSync4, writeFileSync as writeFileSync4, mkdirSync as mkdirSync5, existsSync as existsSync4 } from "fs";
-import { join as join5 } from "path";
-import { homedir as homedir3 } from "os";
+import { join as join6 } from "path";
+import { homedir as homedir4 } from "os";
 import fs2 from "fs";
 import path2 from "path";
 import os2 from "os";
@@ -716,6 +721,60 @@ import * as fs3 from "fs";
 import * as path3 from "path";
 import * as os3 from "os";
 import { execFileSync } from "child_process";
+var EXEC_TIMEOUT_MS = 15e3;
+var DOH_BIN_DIR = join(homedir(), ".okx", "bin");
+var DOH_CACHE_FILE = join(homedir(), ".okx", ".doh-cache.json");
+function getDohBinaryPath() {
+  if (process.env.OKX_DOH_BINARY_PATH) {
+    return process.env.OKX_DOH_BINARY_PATH;
+  }
+  const ext = process.platform === "win32" ? ".exe" : "";
+  return join(DOH_BIN_DIR, `okx-doh-resolver${ext}`);
+}
+function getDohCachePath() {
+  return DOH_CACHE_FILE;
+}
+async function dohBinaryExists() {
+  try {
+    const flag = process.platform === "win32" ? constants.F_OK : constants.X_OK;
+    await access(getDohBinaryPath(), flag);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function execDohBinary(domain) {
+  const binPath = getDohBinaryPath();
+  return new Promise((resolve3) => {
+    execFile(
+      binPath,
+      ["--domain", domain],
+      { timeout: EXEC_TIMEOUT_MS, encoding: "utf-8" },
+      (error, stdout) => {
+        if (error) {
+          resolve3(null);
+          return;
+        }
+        try {
+          const result = JSON.parse(stdout);
+          if (result.code === 0 && result.data) {
+            resolve3(result.data);
+          } else {
+            resolve3(null);
+          }
+        } catch {
+          resolve3(null);
+        }
+      }
+    );
+  });
+}
+async function resolveDoh(domain) {
+  if (!await dohBinaryExists()) {
+    return null;
+  }
+  return execDohBinary(domain);
+}
 function getNow() {
   return (/* @__PURE__ */ new Date()).toISOString();
 }
@@ -934,12 +993,80 @@ var OkxRestClient = class _OkxRestClient {
   config;
   rateLimiter;
   dispatcher;
-  constructor(config) {
+  // DoH proxy state (lazy-resolved on first request)
+  dohResolverFn;
+  dohResolved = false;
+  dohNode = null;
+  dohAgent = null;
+  dohBaseUrl = null;
+  /**
+   * @param config - OKX API client configuration
+   * @param options - Optional overrides (e.g. custom DoH resolver for testing).
+   *                  Pass `{ resolveDoh: null }` to disable DoH entirely.
+   */
+  constructor(config, options) {
     this.config = config;
     this.rateLimiter = new RateLimiter(3e4, config.verbose);
     if (config.proxyUrl) {
       this.dispatcher = new ProxyAgent(config.proxyUrl);
     }
+    this.dohResolverFn = options?.resolveDoh !== void 0 ? options.resolveDoh : resolveDoh;
+  }
+  /**
+   * Lazily resolve the DoH proxy node on the first request.
+   * Skipped entirely when the user has configured proxy_url or DoH is disabled.
+   * On failure, silently falls back to direct connection.
+   */
+  async ensureDoh() {
+    if (this.dohResolved || this.dispatcher || !this.dohResolverFn) return;
+    this.dohResolved = true;
+    try {
+      const { hostname, protocol } = new URL(this.config.baseUrl);
+      const node = await this.dohResolverFn(hostname);
+      if (!node) return;
+      if (node.ip === hostname) {
+        if (this.config.verbose) {
+          vlog(`DoH: resolved ip matches hostname (${hostname}), using direct connection`);
+        }
+        return;
+      }
+      this.dohNode = node;
+      this.dohBaseUrl = `${protocol}//${node.host}`;
+      this.dohAgent = new Agent({
+        connect: {
+          lookup: (_hostname, options, callback) => {
+            if (options?.all) {
+              callback(null, [{ address: node.ip, family: 4 }]);
+            } else {
+              callback(null, node.ip, 4);
+            }
+          }
+        }
+      });
+      if (this.config.verbose) {
+        vlog(`DoH proxy active: ${hostname} \u2192 ${node.host} (${node.ip}), ttl=${node.ttl}s`);
+      }
+    } catch (err) {
+      if (this.config.verbose) {
+        const cause = err instanceof Error ? err.message : String(err);
+        vlog(`DoH resolution failed, falling back to direct: ${cause}`);
+      }
+    }
+  }
+  /**
+   * Invalidate DoH state and delete the binary's cache file so the next
+   * resolution performs a fresh lookup.  Called on network-level failures
+   * when a DoH proxy node was in use.
+   */
+  async invalidateDoh() {
+    this.dohNode = null;
+    this.dohAgent = null;
+    this.dohBaseUrl = null;
+    this.dohResolved = false;
+    try {
+      await unlink(getDohCachePath());
+    } catch {
+    }
   }
   logRequest(method, url, auth) {
     if (!this.config.verbose) return;
@@ -1110,13 +1237,18 @@ var OkxRestClient = class _OkxRestClient {
    * Security: validates Content-Type and enforces maxBytes limit.
    */
   async privatePostBinary(path4, body, opts) {
+    await this.ensureDoh();
     const maxBytes = opts?.maxBytes ?? _OkxRestClient.DEFAULT_MAX_BYTES;
     const expectedCT = opts?.expectedContentType ?? "application/octet-stream";
     const bodyJson = body ? JSON.stringify(body) : "";
     const endpoint = `POST ${path4}`;
-    this.logRequest("POST", `${this.config.baseUrl}${path4}`, "private");
+    const baseUrl = this.dohNode ? this.dohBaseUrl : this.config.baseUrl;
+    this.logRequest("POST", `${baseUrl}${path4}`, "private");
     const reqConfig = { method: "POST", path: path4, auth: "private" };
     const headers = this.buildHeaders(reqConfig, path4, bodyJson, getNow());
+    if (this.dohNode) {
+      headers.set("User-Agent", "OKX/2.7.2");
+    }
     const t0 = Date.now();
     const response = await this.fetchBinary(path4, endpoint, headers, bodyJson, t0);
     const elapsed = Date.now() - t0;
@@ -1146,14 +1278,19 @@ var OkxRestClient = class _OkxRestClient {
   /** Execute fetch for binary endpoint, wrapping network errors. */
   async fetchBinary(path4, endpoint, headers, bodyJson, t0) {
     try {
+      const baseUrl = this.dohNode ? this.dohBaseUrl : this.config.baseUrl;
       const fetchOptions = {
         method: "POST",
         headers,
         body: bodyJson || void 0,
         signal: AbortSignal.timeout(this.config.timeoutMs)
       };
-      if (this.dispatcher) fetchOptions.dispatcher = this.dispatcher;
-      return await fetch(`${this.config.baseUrl}${path4}`, fetchOptions);
+      if (this.dispatcher) {
+        fetchOptions.dispatcher = this.dispatcher;
+      } else if (this.dohAgent) {
+        fetchOptions.dispatcher = this.dohAgent;
+      }
+      return await fetch(`${baseUrl}${path4}`, fetchOptions);
     } catch (error) {
       if (this.config.verbose) {
         vlog(`\u2717 NetworkError after ${Date.now() - t0}ms: ${error instanceof Error ? error.message : String(error)}`);
@@ -1184,9 +1321,11 @@ var OkxRestClient = class _OkxRestClient {
   // JSON request
   // ---------------------------------------------------------------------------
   async request(reqConfig) {
+    await this.ensureDoh();
     const queryString = buildQueryString(reqConfig.query);
     const requestPath = queryString.length > 0 ? `${reqConfig.path}?${queryString}` : reqConfig.path;
-    const url = `${this.config.baseUrl}${requestPath}`;
+    const baseUrl = this.dohNode ? this.dohBaseUrl : this.config.baseUrl;
+    const url = `${baseUrl}${requestPath}`;
     const bodyJson = reqConfig.body ? JSON.stringify(reqConfig.body) : "";
     const timestamp = getNow();
     this.logRequest(reqConfig.method, url, reqConfig.auth);
@@ -1194,6 +1333,9 @@ var OkxRestClient = class _OkxRestClient {
       await this.rateLimiter.consume(reqConfig.rateLimit);
     }
     const headers = this.buildHeaders(reqConfig, requestPath, bodyJson, timestamp);
+    if (this.dohNode) {
+      headers.set("User-Agent", "OKX/2.7.2");
+    }
     const t0 = Date.now();
     let response;
     try {
@@ -1205,9 +1347,18 @@ var OkxRestClient = class _OkxRestClient {
       };
       if (this.dispatcher) {
         fetchOptions.dispatcher = this.dispatcher;
+      } else if (this.dohAgent) {
+        fetchOptions.dispatcher = this.dohAgent;
       }
       response = await fetch(url, fetchOptions);
     } catch (error) {
+      if (this.dohNode) {
+        if (this.config.verbose) {
+          vlog(`DoH request failed, invalidating cache and retrying: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        await this.invalidateDoh();
+        return this.request(reqConfig);
+      }
       if (this.config.verbose) {
         const elapsed2 = Date.now() - t0;
         const cause = error instanceof Error ? error.message : String(error);
@@ -2833,7 +2984,7 @@ function safeWriteFile(targetDir, fileName, data) {
     throw new Error(`Invalid file name: "${fileName}"`);
   }
   const resolvedDir = resolve(targetDir);
-  const filePath = join(resolvedDir, safeName);
+  const filePath = join2(resolvedDir, safeName);
   const resolvedPath = resolve(filePath);
   if (!resolvedPath.startsWith(resolvedDir + sep)) {
     throw new Error(`Path traversal detected: "${fileName}" resolves outside target directory`);
@@ -2864,7 +3015,7 @@ async function downloadSkillZip(client, name, targetDir) {
   return filePath;
 }
 var DEFAULT_MAX_TOTAL_BYTES = 100 * 1024 * 1024;
-var DEFAULT_REGISTRY_PATH = join3(homedir(), ".okx", "skills", "registry.json");
+var DEFAULT_REGISTRY_PATH = join4(homedir2(), ".okx", "skills", "registry.json");
 function registerSkillsTools() {
   return [
     {
@@ -6966,7 +7117,7 @@ function toMcpTool(tool) {
   };
 }
 function configFilePath() {
-  return join4(homedir2(), ".okx", "config.toml");
+  return join5(homedir3(), ".okx", "config.toml");
 }
 function readFullConfig() {
   const path4 = configFilePath();
@@ -7102,7 +7253,7 @@ function loadConfig(cli) {
     verbose: cli.verbose ?? false
   };
 }
-var CACHE_FILE = join5(homedir3(), ".okx", "update-check.json");
+var CACHE_FILE = join6(homedir4(), ".okx", "update-check.json");
 var CHECK_INTERVAL_MS = 24 * 60 * 60 * 1e3;
 function readCache() {
   try {
@@ -7115,7 +7266,7 @@ function readCache() {
 }
 function writeCache(cache) {
   try {
-    mkdirSync5(join5(homedir3(), ".okx"), { recursive: true });
+    mkdirSync5(join6(homedir4(), ".okx"), { recursive: true });
     writeFileSync4(CACHE_FILE, JSON.stringify(cache, null, 2), "utf-8");
   } catch {
   }
@@ -7384,7 +7535,7 @@ var _require = createRequire(import.meta.url);
 var pkg = _require("../package.json");
 var SERVER_NAME = "okx-trade-mcp";
 var SERVER_VERSION = pkg.version;
-var GIT_HASH = true ? "0b9b3b7" : "dev";
+var GIT_HASH = true ? "53b8eb6" : "dev";
 
 // src/server.ts
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";