@okx_ai/okx-trade-cli 1.3.0-beta.2 → 1.3.0-beta.4

package/dist/index.js

@@ -4,25 +4,37 @@
 import { createRequire as createRequire3 } from "module";
 
 // ../core/dist/index.js
-import { ProxyAgent } from "undici";
+import { Agent, ProxyAgent } from "undici";
+import { execFile } from "child_process";
+import { homedir } from "os";
+import { join } from "path";
+import {
+  readFileSync,
+  writeFileSync,
+  mkdirSync,
+  unlinkSync,
+  renameSync
+} from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join2, dirname } 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 { writeFileSync as writeFileSync2, renameSync as renameSync2, unlinkSync as unlinkSync2, mkdirSync as mkdirSync2 } from "fs";
+import { join as join3, resolve, basename, sep } from "path";
 import { randomUUID } from "crypto";
 import yauzl from "yauzl";
-import { createWriteStream, mkdirSync as mkdirSync2 } from "fs";
-import { resolve as resolve2, dirname } from "path";
-import { readFileSync, existsSync } from "fs";
-import { join as join2 } from "path";
-import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, mkdirSync as mkdirSync3, existsSync as existsSync2 } from "fs";
-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 { homedir as homedir2 } from "os";
+import { createWriteStream, mkdirSync as mkdirSync3 } from "fs";
+import { resolve as resolve2, dirname as dirname2 } from "path";
+import { readFileSync as readFileSync2, existsSync } from "fs";
+import { join as join4 } from "path";
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync3, mkdirSync as mkdirSync4, existsSync as existsSync2 } from "fs";
+import { join as join5, dirname as dirname3 } from "path";
+import { homedir as homedir3 } from "os";
+import { readFileSync as readFileSync4, writeFileSync as writeFileSync4, mkdirSync as mkdirSync5, existsSync as existsSync3 } from "fs";
+import { join as join6, dirname as dirname4 } from "path";
+import { homedir as homedir4 } from "os";
 
 // ../../node_modules/.pnpm/smol-toml@1.6.0/node_modules/smol-toml/dist/error.js
 function getLineColFromPtr(string, ptr) {
@@ -851,9 +863,9 @@ function stringify(obj, { maxDepth = 1e3, numbersAsFloat = false } = {}) {
 }
 
 // ../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 { readFileSync as readFileSync5, writeFileSync as writeFileSync5, mkdirSync as mkdirSync6, existsSync as existsSync4 } from "fs";
+import { join as join7 } from "path";
+import { homedir as homedir5 } from "os";
 import fs2 from "fs";
 import path2 from "path";
 import os2 from "os";
@@ -861,6 +873,123 @@ import * as fs3 from "fs";
 import * as path3 from "path";
 import * as os3 from "os";
 import { execFileSync } from "child_process";
+var EXEC_TIMEOUT_MS = 3e4;
+var DOH_BIN_DIR = join(homedir(), ".okx", "bin");
+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 execDohBinary(domain, exclude = [], userAgent) {
+  const binPath = getDohBinaryPath();
+  const args = ["--domain", domain];
+  if (exclude.length > 0) {
+    args.push("--exclude", exclude.join(","));
+  }
+  if (userAgent) {
+    args.push("--user-agent", userAgent);
+  }
+  return new Promise((resolve3) => {
+    execFile(
+      binPath,
+      args,
+      { 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);
+        }
+      }
+    );
+  });
+}
+var DOH_CACHE_PATH = join2(homedir2(), ".okx", "doh-node-cache.json");
+function readCache(hostname, cachePath = DOH_CACHE_PATH) {
+  try {
+    const raw = readFileSync(cachePath, "utf-8");
+    const file = JSON.parse(raw);
+    return file[hostname] ?? null;
+  } catch {
+    return null;
+  }
+}
+function writeCache(hostname, entry, cachePath = DOH_CACHE_PATH) {
+  try {
+    const dir = dirname(cachePath);
+    mkdirSync(dir, { recursive: true });
+    let file = {};
+    try {
+      file = JSON.parse(readFileSync(cachePath, "utf-8"));
+    } catch {
+    }
+    file[hostname] = entry;
+    const tmpPath = `${cachePath}.tmp`;
+    writeFileSync(tmpPath, JSON.stringify(file));
+    renameSync(tmpPath, cachePath);
+  } catch {
+  }
+}
+var FAILED_NODE_TTL_MS = 60 * 60 * 1e3;
+function classifyAndCache(node, hostname, failedNodes, cachePath) {
+  if (!node) {
+    return { mode: null, node: null };
+  }
+  if (node.ip === hostname || node.host === hostname) {
+    writeCache(hostname, {
+      mode: "direct",
+      node: null,
+      failedNodes,
+      updatedAt: Date.now()
+    }, cachePath);
+    return { mode: "direct", node: null };
+  }
+  writeCache(hostname, {
+    mode: "proxy",
+    node,
+    failedNodes,
+    updatedAt: Date.now()
+  }, cachePath);
+  return { mode: "proxy", node };
+}
+function getActiveFailedNodes(nodes) {
+  if (!nodes || nodes.length === 0) return [];
+  const now = Date.now();
+  return nodes.filter((n) => now - n.failedAt < FAILED_NODE_TTL_MS);
+}
+function resolveDoh(hostname, cachePath) {
+  const entry = readCache(hostname, cachePath);
+  if (entry) {
+    if (entry.mode === "direct") {
+      return { mode: "direct", node: null };
+    }
+    if (entry.mode === "proxy" && entry.node) {
+      return { mode: "proxy", node: entry.node };
+    }
+  }
+  return { mode: null, node: null };
+}
+async function reResolveDoh(hostname, failedIp, userAgent, cachePath) {
+  const entry = readCache(hostname, cachePath);
+  const active = getActiveFailedNodes(entry?.failedNodes);
+  const now = Date.now();
+  const alreadyFailed = failedIp && active.some((n) => n.ip === failedIp);
+  const failedNodes = failedIp && !alreadyFailed ? [...active, { ip: failedIp, failedAt: now }] : active;
+  const excludeIps = failedNodes.map((n) => n.ip);
+  const node = await execDohBinary(hostname, excludeIps, userAgent);
+  return classifyAndCache(node, hostname, failedNodes, cachePath);
+}
 function getNow() {
   return (/* @__PURE__ */ new Date()).toISOString();
 }
@@ -1079,6 +1208,14 @@ var OkxRestClient = class _OkxRestClient {
   config;
   rateLimiter;
   dispatcher;
+  // DoH proxy state (lazy-resolved on first request)
+  dohResolved = false;
+  dohRetried = false;
+  directUnverified = false;
+  // The first direct connection has not yet been verified
+  dohNode = null;
+  dohAgent = null;
+  dohBaseUrl = null;
   constructor(config) {
     this.config = config;
     this.rateLimiter = new RateLimiter(3e4, config.verbose);
@@ -1086,6 +1223,98 @@ var OkxRestClient = class _OkxRestClient {
       this.dispatcher = new ProxyAgent(config.proxyUrl);
     }
   }
+  /**
+   * Lazily resolve the DoH proxy node on the first request.
+   * Uses cache-first strategy via the resolver.
+   */
+  ensureDoh() {
+    if (this.dohResolved || this.dispatcher) return;
+    this.dohResolved = true;
+    try {
+      const { hostname, protocol } = new URL(this.config.baseUrl);
+      const result = resolveDoh(hostname);
+      if (!result.mode) {
+        this.directUnverified = true;
+        if (this.config.verbose) {
+          vlog("DoH: no cache, trying direct connection first");
+        }
+        return;
+      }
+      if (result.mode === "direct") {
+        if (this.config.verbose) {
+          vlog("DoH: mode=direct (overseas or cached), using direct connection");
+        }
+        return;
+      }
+      if (result.node) {
+        this.applyDohNode(result.node, protocol);
+      }
+    } catch (err) {
+      if (this.config.verbose) {
+        const cause = err instanceof Error ? err.message : String(err);
+        vlog(`DoH resolution failed, falling back to direct: ${cause}`);
+      }
+    }
+  }
+  /** Apply a DoH node: set up the custom Agent + base URL. */
+  applyDohNode(node, protocol) {
+    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: \u2192 ${node.host} (${node.ip}), ttl=${node.ttl}s`);
+    }
+  }
+  /**
+   * Handle network failure: re-resolve with --exclude and retry once.
+   * Returns true if retry should proceed, false if already retried.
+   */
+  async handleDohNetworkFailure() {
+    if (this.dohRetried) return false;
+    this.dohRetried = true;
+    const failedIp = this.dohNode?.ip ?? "";
+    const { hostname, protocol } = new URL(this.config.baseUrl);
+    this.dohNode = null;
+    this.dohAgent = null;
+    this.dohBaseUrl = null;
+    if (!failedIp) this.directUnverified = false;
+    if (this.config.verbose) {
+      vlog(failedIp ? `DoH: proxy node ${failedIp} failed, re-resolving with --exclude` : "DoH: direct connection failed, calling binary for DoH resolution");
+    }
+    try {
+      const result = await reResolveDoh(hostname, failedIp, this.dohUserAgent);
+      if (result.mode === "proxy" && result.node) {
+        this.applyDohNode(result.node, protocol);
+        this.dohRetried = false;
+        return true;
+      }
+    } catch {
+    }
+    if (this.config.verbose) {
+      vlog("DoH: re-resolution failed or switched to direct, retrying with direct connection");
+    }
+    return true;
+  }
+  get activeBaseUrl() {
+    return this.dohNode ? this.dohBaseUrl : this.config.baseUrl;
+  }
+  get activeDispatcher() {
+    return this.dispatcher ?? this.dohAgent ?? void 0;
+  }
+  /** User-Agent for DoH proxy requests: OKX/@okx_ai/{packageName}/{version} */
+  get dohUserAgent() {
+    return `OKX/@okx_ai/${this.config.userAgent ?? "unknown"}`;
+  }
   logRequest(method, url, auth) {
     if (!this.config.verbose) return;
     vlog(`\u2192 ${method} ${url}`);
@@ -1255,13 +1484,17 @@ var OkxRestClient = class _OkxRestClient {
    * Security: validates Content-Type and enforces maxBytes limit.
    */
   async privatePostBinary(path42, body, opts) {
+    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 ${path42}`;
-    this.logRequest("POST", `${this.config.baseUrl}${path42}`, "private");
+    this.logRequest("POST", `${this.activeBaseUrl}${path42}`, "private");
     const reqConfig = { method: "POST", path: path42, auth: "private" };
     const headers = this.buildHeaders(reqConfig, path42, bodyJson, getNow());
+    if (this.dohNode) {
+      headers.set("User-Agent", this.dohUserAgent);
+    }
     const t0 = Date.now();
     const response = await this.fetchBinary(path42, endpoint, headers, bodyJson, t0);
     const elapsed = Date.now() - t0;
@@ -1295,10 +1528,10 @@ var OkxRestClient = class _OkxRestClient {
         method: "POST",
         headers,
         body: bodyJson || void 0,
-        signal: AbortSignal.timeout(this.config.timeoutMs)
+        signal: AbortSignal.timeout(this.config.timeoutMs),
+        dispatcher: this.activeDispatcher
       };
-      if (this.dispatcher) fetchOptions.dispatcher = this.dispatcher;
-      return await fetch(`${this.config.baseUrl}${path42}`, fetchOptions);
+      return await fetch(`${this.activeBaseUrl}${path42}`, fetchOptions);
     } catch (error) {
       if (this.config.verbose) {
         vlog(`\u2717 NetworkError after ${Date.now() - t0}ms: ${error instanceof Error ? error.message : String(error)}`);
@@ -1328,10 +1561,55 @@ var OkxRestClient = class _OkxRestClient {
   // ---------------------------------------------------------------------------
   // JSON request
   // ---------------------------------------------------------------------------
+  /**
+   * Handle network error during a JSON request: refresh DoH and maybe retry.
+   * Always either returns a retry result or throws NetworkError.
+   */
+  async handleRequestNetworkError(error, reqConfig, requestPath, t0) {
+    if (!this.dohRetried) {
+      if (this.config.verbose) {
+        const cause = error instanceof Error ? error.message : String(error);
+        vlog(`Network failure, refreshing DoH: ${cause}`);
+      }
+      const shouldRetry = await this.handleDohNetworkFailure();
+      if (shouldRetry && reqConfig.method === "GET") {
+        return this.request(reqConfig);
+      }
+    }
+    if (this.config.verbose) {
+      const elapsed = Date.now() - t0;
+      const cause = error instanceof Error ? error.message : String(error);
+      vlog(`\u2717 NetworkError after ${elapsed}ms: ${cause}`);
+    }
+    throw new NetworkError(
+      `Failed to call OKX endpoint ${reqConfig.method} ${requestPath}.`,
+      `${reqConfig.method} ${requestPath}`,
+      error
+    );
+  }
+  /**
+   * After a successful HTTP response on direct connection, cache mode=direct.
+   * (Even if the business response is an error, the network path is valid.)
+   */
+  cacheDirectConnectionIfNeeded() {
+    if (!this.directUnverified || this.dohNode) return;
+    this.directUnverified = false;
+    const { hostname } = new URL(this.config.baseUrl);
+    writeCache(hostname, {
+      mode: "direct",
+      node: null,
+      failedNodes: [],
+      updatedAt: Date.now()
+    });
+    if (this.config.verbose) {
+      vlog("DoH: direct connection succeeded, cached mode=direct");
+    }
+  }
   async request(reqConfig) {
+    this.ensureDoh();
     const queryString = buildQueryString(reqConfig.query);
     const requestPath = queryString.length > 0 ? `${reqConfig.path}?${queryString}` : reqConfig.path;
-    const url = `${this.config.baseUrl}${requestPath}`;
+    const url = `${this.activeBaseUrl}${requestPath}`;
     const bodyJson = reqConfig.body ? JSON.stringify(reqConfig.body) : "";
     const timestamp = getNow();
     this.logRequest(reqConfig.method, url, reqConfig.auth);
@@ -1339,6 +1617,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", this.dohUserAgent);
+    }
     const t0 = Date.now();
     let response;
     try {
@@ -1346,27 +1627,17 @@ var OkxRestClient = class _OkxRestClient {
         method: reqConfig.method,
         headers,
         body: reqConfig.method === "POST" ? bodyJson : void 0,
-        signal: AbortSignal.timeout(this.config.timeoutMs)
+        signal: AbortSignal.timeout(this.config.timeoutMs),
+        dispatcher: this.activeDispatcher
       };
-      if (this.dispatcher) {
-        fetchOptions.dispatcher = this.dispatcher;
-      }
       response = await fetch(url, fetchOptions);
     } catch (error) {
-      if (this.config.verbose) {
-        const elapsed2 = Date.now() - t0;
-        const cause = error instanceof Error ? error.message : String(error);
-        vlog(`\u2717 NetworkError after ${elapsed2}ms: ${cause}`);
-      }
-      throw new NetworkError(
-        `Failed to call OKX endpoint ${reqConfig.method} ${requestPath}.`,
-        `${reqConfig.method} ${requestPath}`,
-        error
-      );
+      return await this.handleRequestNetworkError(error, reqConfig, requestPath, t0);
     }
     const rawText = await response.text();
     const elapsed = Date.now() - t0;
     const traceId = extractTraceId(response.headers);
+    this.cacheDirectConnectionIfNeeded();
     return this.processResponse(rawText, response, elapsed, traceId, reqConfig, requestPath);
   }
 };
@@ -2398,9 +2669,15 @@ function computeContracts(p) {
   return { contractsStr, conversionNote };
 }
 async function resolveQuoteCcySz(instId, sz, tgtCcy, instType, client, tdMode) {
-  if (tgtCcy !== "quote_ccy" && tgtCcy !== "margin") {
+  if (tgtCcy === void 0 || tgtCcy === "base_ccy") {
     return { sz, tgtCcy, conversionNote: void 0 };
   }
+  if (tgtCcy !== "quote_ccy" && tgtCcy !== "margin") {
+    throw new ValidationError(
+      `Unknown tgtCcy value "${tgtCcy}". Valid values: base_ccy, quote_ccy, margin.`,
+      `Check the --tgtCcy flag. Use base_ccy (default, sz in contracts), quote_ccy (sz in USDT notional), or margin (sz in USDT margin cost).`
+    );
+  }
   const isMarginMode = tgtCcy === "margin";
   if (isMarginMode && !tdMode) {
     throw new Error(
@@ -3239,19 +3516,19 @@ function safeWriteFile(targetDir, fileName, data) {
     throw new Error(`Invalid file name: "${fileName}"`);
   }
   const resolvedDir = resolve(targetDir);
-  const filePath = join(resolvedDir, safeName);
+  const filePath = join3(resolvedDir, safeName);
   const resolvedPath = resolve(filePath);
   if (!resolvedPath.startsWith(resolvedDir + sep)) {
     throw new Error(`Path traversal detected: "${fileName}" resolves outside target directory`);
   }
-  mkdirSync(resolvedDir, { recursive: true });
+  mkdirSync2(resolvedDir, { recursive: true });
   const tmpPath = `${resolvedPath}.${randomUUID()}.tmp`;
   try {
-    writeFileSync(tmpPath, data);
-    renameSync(tmpPath, resolvedPath);
+    writeFileSync2(tmpPath, data);
+    renameSync2(tmpPath, resolvedPath);
   } catch (err) {
     try {
-      unlinkSync(tmpPath);
+      unlinkSync2(tmpPath);
     } catch {
     }
     throw err;
@@ -3316,7 +3593,7 @@ async function extractSkillZip(zipPath, targetDir, limits) {
   const maxFiles = limits?.maxFiles ?? DEFAULT_MAX_FILES;
   const maxCompressionRatio = limits?.maxCompressionRatio ?? DEFAULT_MAX_COMPRESSION_RATIO;
   const resolvedTarget = resolve2(targetDir);
-  mkdirSync2(resolvedTarget, { recursive: true });
+  mkdirSync3(resolvedTarget, { recursive: true });
   return new Promise((resolvePromise, reject) => {
     yauzl.open(zipPath, { lazyEntries: true }, (err, zipfile) => {
       if (err) return reject(err);
@@ -3339,7 +3616,7 @@ async function extractSkillZip(zipPath, targetDir, limits) {
             zipfile.close();
             return reject(streamErr);
           }
-          mkdirSync2(dirname(resolvedPath), { recursive: true });
+          mkdirSync3(dirname2(resolvedPath), { recursive: true });
           const writeStream = createWriteStream(resolvedPath);
           readStream.pipe(writeStream);
           writeStream.on("close", () => zipfile.readEntry());
@@ -3355,11 +3632,11 @@ async function extractSkillZip(zipPath, targetDir, limits) {
   });
 }
 function readMetaJson(contentDir) {
-  const metaPath = join2(contentDir, "_meta.json");
+  const metaPath = join4(contentDir, "_meta.json");
   if (!existsSync(metaPath)) {
     throw new Error(`_meta.json not found in ${contentDir}. Invalid skill package.`);
   }
-  const raw = readFileSync(metaPath, "utf-8");
+  const raw = readFileSync2(metaPath, "utf-8");
   let parsed;
   try {
     parsed = JSON.parse(raw);
@@ -3381,26 +3658,26 @@ function readMetaJson(contentDir) {
   };
 }
 function validateSkillMdExists(contentDir) {
-  const skillMdPath = join2(contentDir, "SKILL.md");
+  const skillMdPath = join4(contentDir, "SKILL.md");
   if (!existsSync(skillMdPath)) {
     throw new Error(`SKILL.md not found in ${contentDir}. Invalid skill package.`);
   }
 }
-var DEFAULT_REGISTRY_PATH = join3(homedir(), ".okx", "skills", "registry.json");
+var DEFAULT_REGISTRY_PATH = join5(homedir3(), ".okx", "skills", "registry.json");
 function readRegistry(registryPath = DEFAULT_REGISTRY_PATH) {
   if (!existsSync2(registryPath)) {
     return { version: 1, skills: {} };
   }
   try {
-    const raw = readFileSync2(registryPath, "utf-8");
+    const raw = readFileSync3(registryPath, "utf-8");
     return JSON.parse(raw);
   } catch {
     return { version: 1, skills: {} };
   }
 }
 function writeRegistry(registry, registryPath = DEFAULT_REGISTRY_PATH) {
-  mkdirSync3(dirname2(registryPath), { recursive: true });
-  writeFileSync2(registryPath, JSON.stringify(registry, null, 2) + "\n", "utf-8");
+  mkdirSync4(dirname3(registryPath), { recursive: true });
+  writeFileSync3(registryPath, JSON.stringify(registry, null, 2) + "\n", "utf-8");
 }
 function upsertSkillRecord(meta, registryPath = DEFAULT_REGISTRY_PATH) {
   const registry = readRegistry(registryPath);
@@ -7723,12 +8000,12 @@ function createToolRunner(client, config) {
   };
 }
 function configFilePath() {
-  return join4(homedir2(), ".okx", "config.toml");
+  return join6(homedir4(), ".okx", "config.toml");
 }
 function readFullConfig() {
   const path42 = configFilePath();
   if (!existsSync3(path42)) return { profiles: {} };
-  const raw = readFileSync3(path42, "utf-8");
+  const raw = readFileSync4(path42, "utf-8");
   try {
     return parse(raw);
   } catch (err) {
@@ -7756,11 +8033,11 @@ var CONFIG_HEADER = `# OKX Trade Kit Configuration
 `;
 function writeFullConfig(config) {
   const path42 = configFilePath();
-  const dir = dirname3(path42);
+  const dir = dirname4(path42);
   if (!existsSync3(dir)) {
-    mkdirSync4(dir, { recursive: true });
+    mkdirSync5(dir, { recursive: true });
   }
-  writeFileSync3(path42, CONFIG_HEADER + stringify(config), "utf-8");
+  writeFileSync4(path42, CONFIG_HEADER + stringify(config), "utf-8");
 }
 function expandShorthand(moduleId) {
   if (moduleId === "all") return [...MODULES];
@@ -7874,21 +8151,21 @@ function loadConfig(cli) {
     verbose: cli.verbose ?? false
   };
 }
-var CACHE_FILE = join5(homedir3(), ".okx", "update-check.json");
+var CACHE_FILE = join7(homedir5(), ".okx", "update-check.json");
 var CHECK_INTERVAL_MS = 24 * 60 * 60 * 1e3;
-function readCache() {
+function readCache2() {
   try {
     if (existsSync4(CACHE_FILE)) {
-      return JSON.parse(readFileSync4(CACHE_FILE, "utf-8"));
+      return JSON.parse(readFileSync5(CACHE_FILE, "utf-8"));
     }
   } catch {
   }
   return {};
 }
-function writeCache(cache) {
+function writeCache2(cache) {
   try {
-    mkdirSync5(join5(homedir3(), ".okx"), { recursive: true });
-    writeFileSync4(CACHE_FILE, JSON.stringify(cache, null, 2), "utf-8");
+    mkdirSync6(join7(homedir5(), ".okx"), { recursive: true });
+    writeFileSync5(CACHE_FILE, JSON.stringify(cache, null, 2), "utf-8");
   } catch {
   }
 }
@@ -7935,14 +8212,14 @@ async function fetchLatestVersion(packageName) {
 function refreshCacheInBackground(packageName) {
   fetchLatestVersion(packageName).then((latest) => {
     if (!latest) return;
-    const cache = readCache();
+    const cache = readCache2();
     cache[packageName] = { latestVersion: latest, checkedAt: Date.now() };
-    writeCache(cache);
+    writeCache2(cache);
   }).catch(() => {
   });
 }
 function checkForUpdates(packageName, currentVersion) {
-  const cache = readCache();
+  const cache = readCache2();
   const entry = cache[packageName];
   if (entry && isNewerVersion(currentVersion, entry.latestVersion)) {
     process.stderr.write(
@@ -8797,7 +9074,7 @@ async function cmdDiagnoseMcp(options = {}) {
 
 // src/commands/diagnose.ts
 var CLI_VERSION = readCliVersion();
-var GIT_HASH = true ? "0a5911f" : "dev";
+var GIT_HASH = true ? "caa6dae" : "dev";
 function maskKey2(key) {
   if (!key) return "(not set)";
   if (key.length <= 8) return "****";
@@ -9094,24 +9371,24 @@ async function runCliChecks(config, profile, outputPath) {
 
 // src/commands/upgrade.ts
 import { spawnSync as spawnSync2 } from "child_process";
-import { readFileSync as readFileSync6, writeFileSync as writeFileSync6, mkdirSync as mkdirSync7 } from "fs";
-import { dirname as dirname5, join as join7 } from "path";
-import { homedir as homedir5 } from "os";
+import { readFileSync as readFileSync7, writeFileSync as writeFileSync7, mkdirSync as mkdirSync8 } from "fs";
+import { dirname as dirname6, join as join9 } from "path";
+import { homedir as homedir7 } from "os";
 var PACKAGES = ["@okx_ai/okx-trade-mcp", "@okx_ai/okx-trade-cli"];
-var CACHE_FILE2 = join7(homedir5(), ".okx", "last_check");
+var CACHE_FILE2 = join9(homedir7(), ".okx", "last_check");
 var THROTTLE_MS = 12 * 60 * 60 * 1e3;
-var NPM_BIN = join7(dirname5(process.execPath), process.platform === "win32" ? "npm.cmd" : "npm");
+var NPM_BIN = join9(dirname6(process.execPath), process.platform === "win32" ? "npm.cmd" : "npm");
 function readLastCheck() {
   try {
-    return parseInt(readFileSync6(CACHE_FILE2, "utf-8").trim(), 10) || 0;
+    return parseInt(readFileSync7(CACHE_FILE2, "utf-8").trim(), 10) || 0;
   } catch {
     return 0;
   }
 }
 function writeLastCheck() {
   try {
-    mkdirSync7(join7(homedir5(), ".okx"), { recursive: true });
-    writeFileSync6(CACHE_FILE2, String(Math.floor(Date.now() / 1e3)), "utf-8");
+    mkdirSync8(join9(homedir7(), ".okx"), { recursive: true });
+    writeFileSync7(CACHE_FILE2, String(Math.floor(Date.now() / 1e3)), "utf-8");
   } catch {
   }
 }
@@ -12939,13 +13216,13 @@ async function cmdDcdQuoteAndBuy(run, opts) {
 }
 
 // src/commands/skill.ts
-import { tmpdir, homedir as homedir7 } from "os";
-import { join as join9, dirname as dirname6 } from "path";
-import { mkdirSync as mkdirSync8, rmSync, existsSync as existsSync7, copyFileSync as copyFileSync2 } from "fs";
+import { tmpdir, homedir as homedir9 } from "os";
+import { join as join11, dirname as dirname7 } from "path";
+import { mkdirSync as mkdirSync9, rmSync, existsSync as existsSync7, copyFileSync as copyFileSync2 } from "fs";
 import { execFileSync as execFileSync2 } from "child_process";
 import { randomUUID as randomUUID2 } from "crypto";
 function resolveNpx() {
-  const sibling = join9(dirname6(process.execPath), "npx");
+  const sibling = join11(dirname7(process.execPath), "npx");
   if (existsSync7(sibling)) return sibling;
   return "npx";
 }
@@ -12999,13 +13276,13 @@ async function cmdSkillCategories(run, json) {
   outputLine("");
 }
 async function cmdSkillAdd(name, config, json) {
-  const tmpBase = join9(tmpdir(), `okx-skill-${randomUUID2()}`);
-  mkdirSync8(tmpBase, { recursive: true });
+  const tmpBase = join11(tmpdir(), `okx-skill-${randomUUID2()}`);
+  mkdirSync9(tmpBase, { recursive: true });
   try {
     outputLine(`Downloading ${name}...`);
     const client = new OkxRestClient(config);
     const zipPath = await downloadSkillZip(client, name, tmpBase);
-    const contentDir = await extractSkillZip(zipPath, join9(tmpBase, "content"));
+    const contentDir = await extractSkillZip(zipPath, join11(tmpBase, "content"));
     const meta = readMetaJson(contentDir);
     validateSkillMdExists(contentDir);
     outputLine("Installing to detected agents...");
@@ -13015,7 +13292,7 @@ async function cmdSkillAdd(name, config, json) {
         timeout: 6e4
       });
     } catch (e) {
-      const savedZip = join9(process.cwd(), `${name}.zip`);
+      const savedZip = join11(process.cwd(), `${name}.zip`);
       try {
         copyFileSync2(zipPath, savedZip);
       } catch {
@@ -13054,7 +13331,7 @@ function cmdSkillRemove(name, json) {
       timeout: 6e4
     });
   } catch {
-    const agentsPath = join9(homedir7(), ".agents", "skills", name);
+    const agentsPath = join11(homedir9(), ".agents", "skills", name);
     try {
       rmSync(agentsPath, { recursive: true, force: true });
     } catch {
@@ -13130,7 +13407,7 @@ function printSkillInstallResult(meta, json) {
 // src/index.ts
 var _require3 = createRequire3(import.meta.url);
 var CLI_VERSION2 = _require3("../package.json").version;
-var GIT_HASH2 = true ? "0a5911f" : "dev";
+var GIT_HASH2 = true ? "caa6dae" : "dev";
 function handleConfigCommand(action, rest, json, lang, force) {
   if (action === "init") return cmdConfigInit(lang === "zh" ? "zh" : "en");
   if (action === "show") return cmdConfigShow(json);