@okx_ai/okx-trade-cli 1.2.8-beta.4 → 1.2.8-beta.5

package/dist/index.js

@@ -9,9 +9,20 @@ import { createHmac } from "crypto";
 import fs from "fs";
 import path from "path";
 import os from "os";
-import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
-import { join, dirname } from "path";
+import { writeFileSync, renameSync, unlinkSync, mkdirSync } from "fs";
+import { join, 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";
 
 // ../../node_modules/.pnpm/smol-toml@1.6.0/node_modules/smol-toml/dist/error.js
 function getLineColFromPtr(string, ptr) {
@@ -88,7 +99,7 @@ function skipVoid(str, ptr, banNewLines, banComments) {
     ptr++;
   return banComments || c !== "#" ? ptr : skipVoid(str, skipComment(str, ptr), banNewLines);
 }
-function skipUntil(str, ptr, sep, end, banNewLines = false) {
+function skipUntil(str, ptr, sep2, end, banNewLines = false) {
   if (!end) {
     ptr = indexOfNewline(str, ptr);
     return ptr < 0 ? str.length : ptr;
@@ -97,7 +108,7 @@ function skipUntil(str, ptr, sep, end, banNewLines = false) {
     let c = str[i];
     if (c === "#") {
       i = indexOfNewline(str, i);
-    } else if (c === sep) {
+    } else if (c === sep2) {
       return i + 1;
     } else if (c === end || banNewLines && (c === "\n" || c === "\r" && str[i + 1] === "\n")) {
       return i;
@@ -840,9 +851,9 @@ function stringify(obj, { maxDepth = 1e3, numbersAsFloat = false } = {}) {
 }
 
 // ../core/dist/index.js
-import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2, existsSync as existsSync2 } from "fs";
-import { join as join2 } from "path";
-import { homedir as homedir2 } from "os";
+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 * as fs3 from "fs";
 import * as path3 from "path";
 import * as os3 from "os";
@@ -927,8 +938,8 @@ function toToolErrorPayload(error, fallbackEndpoint) {
   };
 }
 function sleep(ms) {
-  return new Promise((resolve) => {
-    setTimeout(resolve, ms);
+  return new Promise((resolve3) => {
+    setTimeout(resolve3, ms);
   });
 }
 var RateLimiter = class {
@@ -1061,7 +1072,7 @@ function vlog(message) {
   process.stderr.write(`[verbose] ${message}
 `);
 }
-var OkxRestClient = class {
+var OkxRestClient = class _OkxRestClient {
   config;
   rateLimiter;
   dispatcher;
@@ -1214,6 +1225,88 @@ var OkxRestClient = class {
       raw: parsed
     };
   }
+  // ---------------------------------------------------------------------------
+  // Binary (non-JSON) download — reuses auth, proxy, rate-limit, verbose
+  // ---------------------------------------------------------------------------
+  static DEFAULT_MAX_BYTES = 50 * 1024 * 1024;
+  // 50 MB
+  /**
+   * Try to parse a text body as OKX JSON error and throw the appropriate error.
+   * Re-throws OkxApiError / AuthenticationError / RateLimitError if matched.
+   * Returns the parsed message string (or fallback) if no specific error was thrown.
+   */
+  tryThrowJsonError(text, path42, traceId) {
+    try {
+      const parsed = JSON.parse(text);
+      if (parsed.code && parsed.code !== "0") {
+        this.throwOkxError(parsed.code, parsed.msg, { method: "POST", path: path42, auth: "private" }, traceId);
+      }
+      return parsed.msg ?? "";
+    } catch (e) {
+      if (e instanceof OkxApiError || e instanceof AuthenticationError || e instanceof RateLimitError) throw e;
+      return "";
+    }
+  }
+  /**
+   * Send a signed POST request and return the raw binary response.
+   * Inherits all client capabilities: auth, proxy, rate-limit, verbose, user-agent.
+   * Security: validates Content-Type and enforces maxBytes limit.
+   */
+  async privatePostBinary(path42, body, opts) {
+    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");
+    const reqConfig = { method: "POST", path: path42, auth: "private" };
+    const headers = this.buildHeaders(reqConfig, path42, bodyJson, getNow());
+    const t0 = Date.now();
+    const response = await this.fetchBinary(path42, endpoint, headers, bodyJson, t0);
+    const elapsed = Date.now() - t0;
+    const traceId = extractTraceId(response.headers);
+    if (!response.ok) {
+      const text = await response.text();
+      this.logResponse(response.status, text.length, elapsed, traceId, String(response.status));
+      const msg = this.tryThrowJsonError(text, path42, traceId) || `HTTP ${response.status}`;
+      throw new OkxApiError(msg, { code: String(response.status), endpoint, traceId });
+    }
+    const ct = response.headers.get("content-type") ?? "";
+    if (!ct.includes(expectedCT)) {
+      const text = await response.text();
+      this.logResponse(response.status, text.length, elapsed, traceId, "unexpected-ct");
+      this.tryThrowJsonError(text, path42, traceId);
+      throw new OkxApiError(`Expected binary response (${expectedCT}) but got: ${ct}`, { code: "UNEXPECTED_CONTENT_TYPE", endpoint, traceId });
+    }
+    const buffer = Buffer.from(await response.arrayBuffer());
+    if (buffer.length > maxBytes) {
+      throw new OkxApiError(`Response size ${buffer.length} bytes exceeds limit of ${maxBytes} bytes.`, { code: "RESPONSE_TOO_LARGE", endpoint, traceId });
+    }
+    if (this.config.verbose) {
+      vlog(`\u2190 ${response.status} | binary ${buffer.length}B | ${elapsed}ms | trace=${traceId ?? "-"}`);
+    }
+    return { endpoint, requestTime: (/* @__PURE__ */ new Date()).toISOString(), data: buffer, contentType: ct, contentLength: buffer.length, traceId };
+  }
+  /** Execute fetch for binary endpoint, wrapping network errors. */
+  async fetchBinary(path42, endpoint, headers, bodyJson, t0) {
+    try {
+      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}${path42}`, fetchOptions);
+    } catch (error) {
+      if (this.config.verbose) {
+        vlog(`\u2717 NetworkError after ${Date.now() - t0}ms: ${error instanceof Error ? error.message : String(error)}`);
+      }
+      throw new NetworkError(`Failed to call OKX endpoint ${endpoint}.`, endpoint, error);
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Header building
+  // ---------------------------------------------------------------------------
   buildHeaders(reqConfig, requestPath, bodyJson, timestamp) {
     const headers = new Headers({
       "Content-Type": "application/json",
@@ -1235,6 +1328,9 @@ var OkxRestClient = class {
     }
     return headers;
   }
+  // ---------------------------------------------------------------------------
+  // JSON request
+  // ---------------------------------------------------------------------------
   async request(reqConfig) {
     const queryString = buildQueryString(reqConfig.query);
     const requestPath = queryString.length > 0 ? `${reqConfig.path}?${queryString}` : reqConfig.path;
@@ -1546,9 +1642,10 @@ var MODULES = [
   "account",
   "news",
   ...EARN_SUB_MODULE_IDS,
-  ...BOT_SUB_MODULE_IDS
+  ...BOT_SUB_MODULE_IDS,
+  "skills"
 ];
-var DEFAULT_MODULES = ["spot", "swap", "option", "account", ...BOT_DEFAULT_SUB_MODULES];
+var DEFAULT_MODULES = ["spot", "swap", "option", "account", ...BOT_DEFAULT_SUB_MODULES, "skills"];
 function registerAccountTools() {
   return [
     {
@@ -1901,7 +1998,16 @@ function registerAccountTools() {
           {},
           privateRateLimit("account_get_config", 5)
         );
-        return normalizeResponse(response);
+        const result = normalizeResponse(response);
+        if (Array.isArray(result.data)) {
+          return {
+            ...result,
+            data: result.data.map(
+              ({ settleCcy, settleCcyList, ...rest }) => rest
+            )
+          };
+        }
+        return result;
       }
     },
     {
@@ -2879,6 +2985,299 @@ function registerAuditTools() {
     }
   ];
 }
+function safeWriteFile(targetDir, fileName, data) {
+  const safeName = basename(fileName);
+  if (!safeName || safeName === "." || safeName === "..") {
+    throw new Error(`Invalid file name: "${fileName}"`);
+  }
+  const resolvedDir = resolve(targetDir);
+  const filePath = join(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 });
+  const tmpPath = `${resolvedPath}.${randomUUID()}.tmp`;
+  try {
+    writeFileSync(tmpPath, data);
+    renameSync(tmpPath, resolvedPath);
+  } catch (err) {
+    try {
+      unlinkSync(tmpPath);
+    } catch {
+    }
+    throw err;
+  }
+  return resolvedPath;
+}
+function validateZipEntryPath(targetDir, entryName) {
+  const resolvedDir = resolve(targetDir);
+  const resolvedEntry = resolve(resolvedDir, entryName);
+  if (!resolvedEntry.startsWith(resolvedDir + sep) && resolvedEntry !== resolvedDir) {
+    throw new Error(`Zip path traversal detected: "${entryName}" resolves outside extraction directory`);
+  }
+  return resolvedEntry;
+}
+var MAX_DOWNLOAD_BYTES = 50 * 1024 * 1024;
+async function downloadSkillZip(client, name, targetDir) {
+  const result = await client.privatePostBinary(
+    "/api/v5/skill/download",
+    { name },
+    { maxBytes: MAX_DOWNLOAD_BYTES }
+  );
+  const fileName = `${name}.zip`;
+  const filePath = safeWriteFile(targetDir, fileName, result.data);
+  return filePath;
+}
+var DEFAULT_MAX_TOTAL_BYTES = 100 * 1024 * 1024;
+var DEFAULT_MAX_FILES = 1e3;
+var DEFAULT_MAX_COMPRESSION_RATIO = 100;
+function validateEntry(entry, targetDir, state, limits) {
+  state.fileCount++;
+  if (state.fileCount > limits.maxFiles) {
+    throw new Error(
+      `Zip contains more than ${limits.maxFiles} entries, exceeding limit of ${limits.maxFiles}. Possible zip bomb.`
+    );
+  }
+  const resolvedPath = validateZipEntryPath(targetDir, entry.fileName);
+  const externalAttrs = entry.externalFileAttributes;
+  if (externalAttrs) {
+    const unixMode = externalAttrs >>> 16 & 65535;
+    if ((unixMode & 40960) === 40960) {
+      throw new Error(`Zip entry "${entry.fileName}" is a symlink. Symlinks are not allowed for security.`);
+    }
+  }
+  if (entry.compressedSize > 0) {
+    const ratio = entry.uncompressedSize / entry.compressedSize;
+    if (ratio > limits.maxCompressionRatio) {
+      throw new Error(
+        `Zip entry "${entry.fileName}" has compression ratio ${ratio.toFixed(1)}, exceeding limit of ${limits.maxCompressionRatio}. Possible zip bomb.`
+      );
+    }
+  }
+  state.totalBytes += entry.uncompressedSize;
+  if (state.totalBytes > limits.maxTotalBytes) {
+    throw new Error(
+      `Extracted size ${state.totalBytes} bytes exceeds limit of ${limits.maxTotalBytes} bytes. Possible zip bomb.`
+    );
+  }
+  return resolvedPath;
+}
+async function extractSkillZip(zipPath, targetDir, limits) {
+  const maxTotalBytes = limits?.maxTotalBytes ?? DEFAULT_MAX_TOTAL_BYTES;
+  const maxFiles = limits?.maxFiles ?? DEFAULT_MAX_FILES;
+  const maxCompressionRatio = limits?.maxCompressionRatio ?? DEFAULT_MAX_COMPRESSION_RATIO;
+  const resolvedTarget = resolve2(targetDir);
+  mkdirSync2(resolvedTarget, { recursive: true });
+  return new Promise((resolvePromise, reject) => {
+    yauzl.open(zipPath, { lazyEntries: true }, (err, zipfile) => {
+      if (err) return reject(err);
+      const state = { fileCount: 0, totalBytes: 0 };
+      zipfile.readEntry();
+      zipfile.on("entry", (entry) => {
+        if (entry.fileName.endsWith("/")) {
+          zipfile.readEntry();
+          return;
+        }
+        let resolvedPath;
+        try {
+          resolvedPath = validateEntry(entry, resolvedTarget, state, { maxFiles, maxTotalBytes, maxCompressionRatio });
+        } catch (e) {
+          zipfile.close();
+          return reject(e);
+        }
+        zipfile.openReadStream(entry, (streamErr, readStream) => {
+          if (streamErr) {
+            zipfile.close();
+            return reject(streamErr);
+          }
+          mkdirSync2(dirname(resolvedPath), { recursive: true });
+          const writeStream = createWriteStream(resolvedPath);
+          readStream.pipe(writeStream);
+          writeStream.on("close", () => zipfile.readEntry());
+          writeStream.on("error", (writeErr) => {
+            zipfile.close();
+            reject(writeErr);
+          });
+        });
+      });
+      zipfile.on("end", () => resolvePromise(resolvedTarget));
+      zipfile.on("error", reject);
+    });
+  });
+}
+function readMetaJson(contentDir) {
+  const metaPath = join2(contentDir, "_meta.json");
+  if (!existsSync(metaPath)) {
+    throw new Error(`_meta.json not found in ${contentDir}. Invalid skill package.`);
+  }
+  const raw = readFileSync(metaPath, "utf-8");
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    throw new Error(`Failed to parse _meta.json: invalid JSON`);
+  }
+  const meta = parsed;
+  if (typeof meta.name !== "string" || !meta.name) {
+    throw new Error(`_meta.json: "name" field is required`);
+  }
+  if (typeof meta.version !== "string" || !meta.version) {
+    throw new Error(`_meta.json: "version" field is required`);
+  }
+  return {
+    name: String(meta.name),
+    version: String(meta.version),
+    title: typeof meta.title === "string" ? meta.title : "",
+    description: typeof meta.description === "string" ? meta.description : ""
+  };
+}
+function validateSkillMdExists(contentDir) {
+  const skillMdPath = join2(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");
+function readRegistry(registryPath = DEFAULT_REGISTRY_PATH) {
+  if (!existsSync2(registryPath)) {
+    return { version: 1, skills: {} };
+  }
+  try {
+    const raw = readFileSync2(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");
+}
+function upsertSkillRecord(meta, registryPath = DEFAULT_REGISTRY_PATH) {
+  const registry = readRegistry(registryPath);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const existing = registry.skills[meta.name];
+  registry.skills[meta.name] = {
+    name: meta.name,
+    version: meta.version,
+    description: meta.description,
+    installedAt: existing?.installedAt ?? now,
+    updatedAt: now,
+    source: "marketplace"
+  };
+  writeRegistry(registry, registryPath);
+}
+function removeSkillRecord(name, registryPath = DEFAULT_REGISTRY_PATH) {
+  const registry = readRegistry(registryPath);
+  if (!(name in registry.skills)) return false;
+  delete registry.skills[name];
+  writeRegistry(registry, registryPath);
+  return true;
+}
+function getSkillRecord(name, registryPath = DEFAULT_REGISTRY_PATH) {
+  const registry = readRegistry(registryPath);
+  return registry.skills[name];
+}
+function registerSkillsTools() {
+  return [
+    {
+      name: "skills_get_categories",
+      module: "skills",
+      description: "List all available skill categories in OKX Skills Marketplace. Use the returned categoryId as input to skills_search for category filtering. Do NOT use for searching or downloading skills \u2014 use skills_search or skills_download.",
+      inputSchema: {
+        type: "object",
+        properties: {},
+        additionalProperties: false
+      },
+      isWrite: false,
+      handler: handleGetCategories
+    },
+    {
+      name: "skills_search",
+      module: "skills",
+      description: "Search for skills in OKX Skills Marketplace by keyword or category. To get valid category IDs, call skills_get_categories first. Returns skill names for use with skills_download. Do NOT use for downloading \u2014 use skills_download.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          keyword: {
+            type: "string",
+            description: "Search keyword (matches name, description, tags)"
+          },
+          categories: {
+            type: "string",
+            description: "Filter by category ID"
+          },
+          page: {
+            type: "string",
+            description: "Page number, starting from 1. Default: 1"
+          },
+          limit: {
+            type: "string",
+            description: "Results per page. Default: 20, max: 100"
+          }
+        },
+        additionalProperties: false
+      },
+      isWrite: false,
+      handler: handleSearch
+    },
+    {
+      name: "skills_download",
+      module: "skills",
+      description: "Download a skill zip file from OKX Skills Marketplace to a local directory. Always call skills_search first to confirm the skill name exists. Downloads the latest approved version. NOTE: This only downloads the zip \u2014 it does NOT install to agents. For full installation use CLI: okx skill add <name>. Use when the user wants to inspect or manually install a skill package.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          name: {
+            type: "string",
+            description: "Skill name (unique identifier)"
+          },
+          targetDir: {
+            type: "string",
+            description: "Directory path where the zip file will be saved"
+          }
+        },
+        required: ["name", "targetDir"],
+        additionalProperties: false
+      },
+      isWrite: true,
+      handler: handleDownload
+    }
+  ];
+}
+async function handleGetCategories(_args, ctx) {
+  const result = await ctx.client.privateGet(
+    "/api/v5/skill/categories"
+  );
+  return result;
+}
+async function handleSearch(args, ctx) {
+  const query = {};
+  if (args.keyword) query.keyword = String(args.keyword);
+  if (args.categories) query.categories = String(args.categories);
+  if (args.page) query.page = String(args.page);
+  if (args.limit) query.limit = String(args.limit);
+  const result = await ctx.client.privateGet(
+    "/api/v5/skill/search",
+    query
+  );
+  const totalPage = result.raw?.totalPage;
+  return { ...result, totalPage };
+}
+async function handleDownload(args, ctx) {
+  const name = String(args.name);
+  const targetDir = String(args.targetDir);
+  const filePath = await downloadSkillZip(ctx.client, name, targetDir);
+  return {
+    endpoint: "POST /api/v5/skill/download",
+    requestTime: (/* @__PURE__ */ new Date()).toISOString(),
+    data: {
+      name,
+      filePath
+    }
+  };
+}
 function normalizeWrite(response) {
   const data = response.data;
   if (Array.isArray(data) && data.length > 0) {
@@ -3477,7 +3876,6 @@ function registerEarnTools() {
         required: ["ccy", "amt"]
       },
       handler: async (rawArgs, context) => {
-        assertNotDemo(context.config, "earn_savings_purchase");
         const args = asRecord(rawArgs);
         const response = await context.client.privatePost(
           "/api/v5/finance/savings/purchase-redempt",
@@ -3512,7 +3910,6 @@ function registerEarnTools() {
         required: ["ccy", "amt"]
       },
       handler: async (rawArgs, context) => {
-        assertNotDemo(context.config, "earn_savings_redeem");
         const args = asRecord(rawArgs);
         const response = await context.client.privatePost(
           "/api/v5/finance/savings/purchase-redempt",
@@ -3546,7 +3943,6 @@ function registerEarnTools() {
         required: ["ccy", "rate"]
       },
       handler: async (rawArgs, context) => {
-        assertNotDemo(context.config, "earn_set_lending_rate");
         const args = asRecord(rawArgs);
         const response = await context.client.privatePost(
           "/api/v5/finance/savings/set-lending-rate",
@@ -3690,7 +4086,7 @@ function registerOnchainEarnTools() {
     {
       name: "onchain_earn_purchase",
       module: "earn.onchain",
-      description: "Invest in a staking/DeFi product. [CAUTION] Moves real funds. Not available in demo mode.",
+      description: "Invest in a staking/DeFi product. [CAUTION] Moves real funds.",
       isWrite: true,
       inputSchema: {
         type: "object",
@@ -3723,7 +4119,6 @@ function registerOnchainEarnTools() {
         required: ["productId", "investData"]
       },
       handler: async (rawArgs, context) => {
-        assertNotDemo(context.config, "onchain_earn_purchase");
         const args = asRecord(rawArgs);
         const response = await context.client.privatePost(
           "/api/v5/finance/staking-defi/purchase",
@@ -3744,7 +4139,7 @@ function registerOnchainEarnTools() {
     {
       name: "onchain_earn_redeem",
       module: "earn.onchain",
-      description: "Redeem a staking/DeFi investment. [CAUTION] Some products have lock periods, early redemption may incur penalties. Not available in demo mode.",
+      description: "Redeem a staking/DeFi investment. [CAUTION] Some products have lock periods, early redemption may incur penalties.",
       isWrite: true,
       inputSchema: {
         type: "object",
@@ -3765,7 +4160,6 @@ function registerOnchainEarnTools() {
         required: ["ordId", "protocolType"]
       },
       handler: async (rawArgs, context) => {
-        assertNotDemo(context.config, "onchain_earn_redeem");
         const args = asRecord(rawArgs);
         const response = await context.client.privatePost(
           "/api/v5/finance/staking-defi/redeem",
@@ -3785,7 +4179,7 @@ function registerOnchainEarnTools() {
     {
       name: "onchain_earn_cancel",
       module: "earn.onchain",
-      description: "Cancel a pending staking/DeFi purchase order. [CAUTION] Not available in demo mode.",
+      description: "Cancel a pending staking/DeFi purchase order. [CAUTION]",
       isWrite: true,
       inputSchema: {
         type: "object",
@@ -3802,7 +4196,6 @@ function registerOnchainEarnTools() {
         required: ["ordId", "protocolType"]
       },
       handler: async (rawArgs, context) => {
-        assertNotDemo(context.config, "onchain_earn_cancel");
         const args = asRecord(rawArgs);
         const response = await context.client.privatePost(
           "/api/v5/finance/staking-defi/cancel",
@@ -4095,7 +4488,6 @@ function registerDcdTools() {
         required: ["productId", "notionalSz", "notionalCcy"]
       },
       handler: async (rawArgs, context) => {
-        assertNotDemo(context.config, "dcd_subscribe");
         const args = asRecord(rawArgs);
         const productId = requireString(args, "productId");
         const notionalSz = requireString(args, "notionalSz");
@@ -4267,13 +4659,30 @@ function registerAutoEarnTools() {
     }
   ];
 }
+var EARN_DEMO_MESSAGE = "Earn features (savings, DCD, on-chain staking, auto-earn) are not available in simulated trading mode.";
+var EARN_DEMO_SUGGESTION = "Switch to a live account to use Earn features.";
+var DEMO_GUARD_SKIP = /* @__PURE__ */ new Set(["dcd_redeem"]);
+function withDemoGuard(tool) {
+  if (!tool.isWrite || DEMO_GUARD_SKIP.has(tool.name)) return tool;
+  const originalHandler = tool.handler;
+  return {
+    ...tool,
+    handler: async (args, context) => {
+      if (context.config.demo) {
+        throw new ConfigError(EARN_DEMO_MESSAGE, EARN_DEMO_SUGGESTION);
+      }
+      return originalHandler(args, context);
+    }
+  };
+}
 function registerAllEarnTools() {
-  return [
+  const tools = [
     ...registerEarnTools(),
     ...registerOnchainEarnTools(),
     ...registerDcdTools(),
     ...registerAutoEarnTools()
   ];
+  return tools.map(withDemoGuard);
 }
 function buildContractTradeTools(cfg) {
   const { prefix, module, label, instTypes, instIdExample } = cfg;
@@ -5297,7 +5706,7 @@ function registerMarketTools() {
     {
       name: "market_get_stock_tokens",
       module: "market",
-      description: "Get all stock token instruments (instCategory=3). Stock tokens track real-world stock prices on OKX (e.g. AAPL-USDT-SWAP). Filters client-side by instCategory=3.",
+      description: '[Deprecated: use market_get_instruments_by_category with instCategory="3" instead] Get all stock token instruments (instCategory=3). Stock tokens track real-world stock prices on OKX (e.g. AAPL-USDT-SWAP).',
       isWrite: false,
       inputSchema: {
         type: "object",
@@ -5327,6 +5736,46 @@ function registerMarketTools() {
         const filtered = Array.isArray(data) ? data.filter((item) => item.instCategory === "3") : data;
         return normalizeResponse({ ...response, data: filtered });
       }
+    },
+    {
+      name: "market_get_instruments_by_category",
+      module: "market",
+      description: "Discover tradeable instruments by asset category. Stock tokens (instCategory=3, e.g. AAPL-USDT-SWAP, TSLA-USDT-SWAP), Metals (4, e.g. XAUUSDT-USDT-SWAP for gold), Commodities (5, e.g. OIL-USDT-SWAP for crude oil), Forex (6, e.g. EURUSDT-USDT-SWAP for EUR/USD), Bonds (7, e.g. US30Y-USDT-SWAP). Use this to find instIds before querying prices or placing orders. Filters client-side by instCategory.",
+      isWrite: false,
+      inputSchema: {
+        type: "object",
+        properties: {
+          instCategory: {
+            type: "string",
+            enum: ["3", "4", "5", "6", "7"],
+            description: "Asset category: 3=Stock tokens, 4=Metals, 5=Commodities, 6=Forex, 7=Bonds"
+          },
+          instType: {
+            type: "string",
+            enum: ["SPOT", "SWAP"],
+            description: "Instrument type. Default: SWAP"
+          },
+          instId: {
+            type: "string",
+            description: "Optional: filter by specific instrument ID"
+          }
+        },
+        required: ["instCategory"]
+      },
+      handler: async (rawArgs, context) => {
+        const args = asRecord(rawArgs);
+        const instCategory = requireString(args, "instCategory");
+        const instType = readString(args, "instType") ?? "SWAP";
+        const instId = readString(args, "instId");
+        const response = await context.client.publicGet(
+          "/api/v5/public/instruments",
+          compactObject({ instType, instId }),
+          publicRateLimit("market_get_instruments_by_category", 20)
+        );
+        const data = response.data;
+        const filtered = Array.isArray(data) ? data.filter((item) => item.instCategory === instCategory) : data;
+        return normalizeResponse({ ...response, data: filtered });
+      }
     }
   ];
 }
@@ -7104,7 +7553,8 @@ function allToolSpecs() {
     ...registerNewsTools(),
     ...registerBotTools(),
     ...registerAllEarnTools(),
-    ...registerAuditTools()
+    ...registerAuditTools(),
+    ...registerSkillsTools()
   ];
 }
 function createToolRunner(client, config) {
@@ -7119,12 +7569,12 @@ function createToolRunner(client, config) {
   };
 }
 function configFilePath() {
-  return join(homedir(), ".okx", "config.toml");
+  return join4(homedir2(), ".okx", "config.toml");
 }
 function readFullConfig() {
   const path42 = configFilePath();
-  if (!existsSync(path42)) return { profiles: {} };
-  const raw = readFileSync(path42, "utf-8");
+  if (!existsSync3(path42)) return { profiles: {} };
+  const raw = readFileSync3(path42, "utf-8");
   try {
     return parse(raw);
   } catch (err) {
@@ -7152,11 +7602,11 @@ var CONFIG_HEADER = `# OKX Trade Kit Configuration
 `;
 function writeFullConfig(config) {
   const path42 = configFilePath();
-  const dir = dirname(path42);
-  if (!existsSync(dir)) {
-    mkdirSync(dir, { recursive: true });
+  const dir = dirname3(path42);
+  if (!existsSync3(dir)) {
+    mkdirSync4(dir, { recursive: true });
   }
-  writeFileSync(path42, CONFIG_HEADER + stringify(config), "utf-8");
+  writeFileSync3(path42, CONFIG_HEADER + stringify(config), "utf-8");
 }
 function expandShorthand(moduleId) {
   if (moduleId === "all") return [...MODULES];
@@ -7270,12 +7720,12 @@ function loadConfig(cli) {
     verbose: cli.verbose ?? false
   };
 }
-var CACHE_FILE = join2(homedir2(), ".okx", "update-check.json");
+var CACHE_FILE = join5(homedir3(), ".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"));
+    if (existsSync4(CACHE_FILE)) {
+      return JSON.parse(readFileSync4(CACHE_FILE, "utf-8"));
     }
   } catch {
   }
@@ -7283,8 +7733,8 @@ function readCache() {
 }
 function writeCache(cache) {
   try {
-    mkdirSync2(join2(homedir2(), ".okx"), { recursive: true });
-    writeFileSync2(CACHE_FILE, JSON.stringify(cache, null, 2), "utf-8");
+    mkdirSync5(join5(homedir3(), ".okx"), { recursive: true });
+    writeFileSync4(CACHE_FILE, JSON.stringify(cache, null, 2), "utf-8");
   } catch {
   }
 }
@@ -7591,26 +8041,26 @@ var Report = class {
     this.lines.push({ key, value });
   }
   print() {
-    const sep = "\u2500".repeat(52);
+    const sep2 = "\u2500".repeat(52);
     outputLine("");
-    outputLine(`  \u2500\u2500 Diagnostic Report (copy & share) ${sep.slice(35)}`);
+    outputLine(`  \u2500\u2500 Diagnostic Report (copy & share) ${sep2.slice(35)}`);
     for (const { key, value } of this.lines) {
       outputLine(`  ${key.padEnd(14)} ${value}`);
     }
-    outputLine(`  ${sep}`);
+    outputLine(`  ${sep2}`);
     outputLine("");
   }
   /** Write report to a file path, returns true on success. */
   writeToFile(filePath) {
     try {
-      const sep = "-".repeat(52);
+      const sep2 = "-".repeat(52);
       const lines = [
-        `-- Diagnostic Report (copy & share) ${sep.slice(35)}`
+        `-- Diagnostic Report (copy & share) ${sep2.slice(35)}`
       ];
       for (const { key, value } of this.lines) {
         lines.push(`${key.padEnd(14)} ${value}`);
       }
-      lines.push(sep, "");
+      lines.push(sep2, "");
       fs2.writeFileSync(filePath, lines.join("\n"), "utf8");
       return true;
     } catch (_e) {
@@ -7986,13 +8436,13 @@ async function checkStdioHandshake(entryPath, report) {
       clientInfo: { name: "okx-diagnose", version: "1.0" }
     }
   });
-  return new Promise((resolve) => {
+  return new Promise((resolve3) => {
     let settled = false;
     const settle = (passed) => {
       if (settled) return;
       settled = true;
       clearTimeout(timer);
-      resolve(passed);
+      resolve3(passed);
     };
     const child = spawn(process.execPath, [entryPath], {
       stdio: ["pipe", "pipe", "pipe"],
@@ -8113,7 +8563,7 @@ async function cmdDiagnoseMcp(options = {}) {
 
 // src/commands/diagnose.ts
 var CLI_VERSION = readCliVersion();
-var GIT_HASH = true ? "7b97fe6" : "dev";
+var GIT_HASH = true ? "f0a9e50" : "dev";
 function maskKey2(key) {
   if (!key) return "(not set)";
   if (key.length <= 8) return "****";
@@ -8130,7 +8580,7 @@ async function checkDns(hostname) {
 }
 async function checkSocket(createFn, successEvent, timeoutMs) {
   const t0 = Date.now();
-  return new Promise((resolve) => {
+  return new Promise((resolve3) => {
     const socket = createFn();
     const cleanup = () => {
       socket.removeAllListeners();
@@ -8138,15 +8588,15 @@ async function checkSocket(createFn, successEvent, timeoutMs) {
     };
     socket.once(successEvent, () => {
       cleanup();
-      resolve({ ok: true, ms: Date.now() - t0 });
+      resolve3({ ok: true, ms: Date.now() - t0 });
     });
     socket.once("timeout", () => {
       cleanup();
-      resolve({ ok: false, ms: Date.now() - t0, error: `timed out after ${timeoutMs}ms` });
+      resolve3({ ok: false, ms: Date.now() - t0, error: `timed out after ${timeoutMs}ms` });
     });
     socket.once("error", (err) => {
       cleanup();
-      resolve({ ok: false, ms: Date.now() - t0, error: err.message });
+      resolve3({ ok: false, ms: Date.now() - t0, error: err.message });
     });
   });
 }
@@ -8410,24 +8860,24 @@ async function runCliChecks(config, profile, outputPath) {
 
 // src/commands/upgrade.ts
 import { spawnSync as spawnSync2 } from "child_process";
-import { readFileSync as readFileSync4, writeFileSync as writeFileSync4, mkdirSync as mkdirSync4 } from "fs";
-import { dirname as dirname3, join as join4 } from "path";
-import { homedir as homedir4 } from "os";
+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";
 var PACKAGES = ["@okx_ai/okx-trade-mcp", "@okx_ai/okx-trade-cli"];
-var CACHE_FILE2 = join4(homedir4(), ".okx", "last_check");
+var CACHE_FILE2 = join7(homedir5(), ".okx", "last_check");
 var THROTTLE_MS = 12 * 60 * 60 * 1e3;
-var NPM_BIN = join4(dirname3(process.execPath), process.platform === "win32" ? "npm.cmd" : "npm");
+var NPM_BIN = join7(dirname5(process.execPath), process.platform === "win32" ? "npm.cmd" : "npm");
 function readLastCheck() {
   try {
-    return parseInt(readFileSync4(CACHE_FILE2, "utf-8").trim(), 10) || 0;
+    return parseInt(readFileSync6(CACHE_FILE2, "utf-8").trim(), 10) || 0;
   } catch {
     return 0;
   }
 }
 function writeLastCheck() {
   try {
-    mkdirSync4(join4(homedir4(), ".okx"), { recursive: true });
-    writeFileSync4(CACHE_FILE2, String(Math.floor(Date.now() / 1e3)), "utf-8");
+    mkdirSync7(join7(homedir5(), ".okx"), { recursive: true });
+    writeFileSync6(CACHE_FILE2, String(Math.floor(Date.now() / 1e3)), "utf-8");
   } catch {
   }
 }
@@ -8632,7 +9082,12 @@ async function cmdNewsDetail(run, id, opts) {
     return;
   }
   const rawContent = article["content"] ? String(article["content"]) : void 0;
-  const content = rawContent ? rawContent.length > 500 ? rawContent.slice(0, 500) + "... (use --json for full text)" : rawContent : void 0;
+  let content;
+  if (rawContent && rawContent.length > 500) {
+    content = rawContent.slice(0, 500) + "... (use --json for full text)";
+  } else {
+    content = rawContent;
+  }
   printKv({
     id: article["id"],
     title: article["title"],
@@ -8820,7 +9275,11 @@ var HELP_TREE = {
       },
       "stock-tokens": {
         usage: "okx market stock-tokens [--instType <SPOT|SWAP>] [--instId <id>]",
-        description: "List all stock token instruments (instCategory=3, e.g. AAPL-USDT-SWAP)"
+        description: "[Deprecated: use instruments-by-category --instCategory 3] List all stock token instruments (instCategory=3, e.g. AAPL-USDT-SWAP)"
+      },
+      "instruments-by-category": {
+        usage: "okx market instruments-by-category --instCategory <4|5|6|7> [--instType <SPOT|SWAP>] [--instId <id>]",
+        description: "List instruments by asset category: 4=Metals (gold/silver), 5=Commodities (oil/gas), 6=Forex (EUR/USD), 7=Bonds"
       }
     }
   },
@@ -9577,6 +10036,7 @@ var CLI_OPTIONS = {
   live: { type: "boolean", default: false },
   // market extras
   instType: { type: "string" },
+  instCategory: { type: "string" },
   quoteCcy: { type: "string" },
   // account extras
   archive: { type: "boolean", default: false },
@@ -9666,6 +10126,10 @@ var CLI_OPTIONS = {
   period: { type: "string" },
   points: { type: "string" },
   "sort-by": { type: "string" },
+  // skill marketplace
+  categories: { type: "string" },
+  dir: { type: "string" },
+  page: { type: "string" },
   // diagnostics — cli/mcp/all/output are diagnose-specific; verbose is shared
   verbose: { type: "boolean", default: false },
   mcp: { type: "boolean", default: false },
@@ -9949,6 +10413,37 @@ async function cmdMarketIndicator(run, indicator, instId, opts) {
     }
   }
 }
+async function cmdMarketInstrumentsByCategory(run, opts) {
+  const result = await run("market_get_instruments_by_category", {
+    instCategory: opts.instCategory,
+    instType: opts.instType,
+    instId: opts.instId
+  });
+  const items = getData2(result);
+  if (opts.json) return printJson(items);
+  const CATEGORY_LABELS = {
+    "3": "Stock tokens",
+    "4": "Metals",
+    "5": "Commodities",
+    "6": "Forex",
+    "7": "Bonds"
+  };
+  const label = CATEGORY_LABELS[opts.instCategory] ?? opts.instCategory;
+  process.stdout.write(`instCategory=${opts.instCategory} (${label}) \u2014 ${items?.length ?? 0} instruments
+
+`);
+  printTable(
+    (items ?? []).slice(0, 50).map((t) => ({
+      instId: t["instId"],
+      instCategory: t["instCategory"],
+      ctVal: t["ctVal"],
+      lotSz: t["lotSz"],
+      minSz: t["minSz"],
+      tickSz: t["tickSz"],
+      state: t["state"]
+    }))
+  );
+}
 async function cmdMarketStockTokens(run, opts) {
   const result = await run("market_get_stock_tokens", { instType: opts.instType, instId: opts.instId });
   const items = getData2(result);
@@ -11384,7 +11879,7 @@ Config saved to ${p}
   }
 };
 function prompt(rl, question) {
-  return new Promise((resolve) => rl.question(question, resolve));
+  return new Promise((resolve3) => rl.question(question, resolve3));
 }
 function cmdConfigShow(json) {
   const config = readFullConfig();
@@ -12349,10 +12844,194 @@ 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 { execFileSync as execFileSync2 } from "child_process";
+import { randomUUID as randomUUID2 } from "crypto";
+function resolveNpx() {
+  const sibling = join9(dirname6(process.execPath), "npx");
+  if (existsSync7(sibling)) return sibling;
+  return "npx";
+}
+async function cmdSkillSearch(run, opts) {
+  const args = {};
+  if (opts.keyword) args.keyword = opts.keyword;
+  if (opts.categories) args.categories = opts.categories;
+  if (opts.page) args.page = opts.page;
+  if (opts.limit) args.limit = opts.limit;
+  const result = await run("skills_search", args);
+  const data = result.data;
+  const totalPage = result.totalPage;
+  if (opts.json) {
+    outputLine(JSON.stringify(result, null, 2));
+    return;
+  }
+  if (!Array.isArray(data) || data.length === 0) {
+    outputLine("No skills found.");
+    return;
+  }
+  outputLine("");
+  outputLine("  NAME                VERSION   DESCRIPTION");
+  for (const item of data) {
+    const name = (item.name ?? "").padEnd(20);
+    const ver = (item.latestVersion ?? "").padEnd(10);
+    const desc = (item.description ?? "").slice(0, 50);
+    outputLine(`  ${name}${ver}${desc}`);
+  }
+  outputLine("");
+  const page = opts.page ?? "1";
+  const pageInfo = totalPage ? ` (page ${page}/${totalPage})` : "";
+  outputLine(`${data.length} skills found${pageInfo}. Use \`okx skill add <name>\` to install.`);
+}
+async function cmdSkillCategories(run, json) {
+  const result = await run("skills_get_categories", {});
+  const data = result.data;
+  if (json) {
+    outputLine(JSON.stringify(result, null, 2));
+    return;
+  }
+  if (!Array.isArray(data) || data.length === 0) {
+    outputLine("No categories found.");
+    return;
+  }
+  outputLine("");
+  outputLine("  ID                  NAME");
+  for (const cat of data) {
+    outputLine(`  ${(cat.categoryId ?? "").padEnd(20)}${cat.name ?? ""}`);
+  }
+  outputLine("");
+}
+async function cmdSkillAdd(name, config, json) {
+  const tmpBase = join9(tmpdir(), `okx-skill-${randomUUID2()}`);
+  mkdirSync8(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 meta = readMetaJson(contentDir);
+    validateSkillMdExists(contentDir);
+    outputLine("Installing to detected agents...");
+    try {
+      execFileSync2(resolveNpx(), ["skills", "add", contentDir, "-y", "-g"], {
+        stdio: "inherit",
+        timeout: 6e4
+      });
+    } catch (e) {
+      const savedZip = join9(process.cwd(), `${name}.zip`);
+      try {
+        copyFileSync2(zipPath, savedZip);
+      } catch {
+      }
+      errorLine(`npx skills add failed. The zip has been downloaded but not installed.`);
+      errorLine(`You can manually install from: ${savedZip}`);
+      throw e;
+    }
+    upsertSkillRecord(meta);
+    if (json) {
+      outputLine(JSON.stringify({ name: meta.name, version: meta.version, status: "installed" }, null, 2));
+    } else {
+      outputLine(`\u2713 Skill "${meta.name}" v${meta.version} installed`);
+    }
+  } finally {
+    rmSync(tmpBase, { recursive: true, force: true });
+  }
+}
+async function cmdSkillDownload(name, targetDir, config, json) {
+  outputLine(`Downloading ${name}...`);
+  const client = new OkxRestClient(config);
+  const filePath = await downloadSkillZip(client, name, targetDir);
+  if (json) {
+    outputLine(JSON.stringify({ name, filePath }, null, 2));
+  } else {
+    outputLine(`\u2713 Downloaded ${name}.zip`);
+    outputLine(`  Path: ${filePath}`);
+  }
+}
+function cmdSkillRemove(name, json) {
+  const removed = removeSkillRecord(name);
+  if (!removed) {
+    errorLine(`Skill "${name}" is not installed.`);
+    process.exitCode = 1;
+    return;
+  }
+  try {
+    execFileSync2(resolveNpx(), ["skills", "remove", name, "-y", "-g"], {
+      stdio: "inherit",
+      timeout: 6e4
+    });
+  } catch {
+    const agentsPath = join9(homedir7(), ".agents", "skills", name);
+    try {
+      rmSync(agentsPath, { recursive: true, force: true });
+    } catch {
+    }
+  }
+  if (json) {
+    outputLine(JSON.stringify({ name, status: "removed" }, null, 2));
+  } else {
+    outputLine(`\u2713 Skill "${name}" removed`);
+  }
+}
+async function cmdSkillCheck(run, name, json) {
+  const local = getSkillRecord(name);
+  if (!local) {
+    errorLine(`Skill "${name}" is not installed.`);
+    process.exitCode = 1;
+    return;
+  }
+  const result = await run("skills_search", { keyword: name });
+  const data = result.data;
+  const remote = data?.find((s) => s.name === name);
+  if (!remote) {
+    errorLine(`Skill "${name}" not found in marketplace.`);
+    process.exitCode = 1;
+    return;
+  }
+  const upToDate = local.version === remote.latestVersion;
+  if (json) {
+    outputLine(JSON.stringify({
+      name,
+      installedVersion: local.version,
+      latestVersion: remote.latestVersion,
+      upToDate
+    }, null, 2));
+  } else if (upToDate) {
+    outputLine(`${name}: installed v${local.version} \u2192 latest v${remote.latestVersion} (up to date)`);
+  } else {
+    outputLine(`${name}: installed v${local.version} \u2192 latest v${remote.latestVersion} (update available)`);
+    outputLine(`  Use \`okx skill add ${name}\` to update.`);
+  }
+}
+function cmdSkillList(json) {
+  const registry = readRegistry();
+  const skills = Object.values(registry.skills);
+  if (json) {
+    outputLine(JSON.stringify(registry, null, 2));
+    return;
+  }
+  if (skills.length === 0) {
+    outputLine("No skills installed.");
+    return;
+  }
+  outputLine("");
+  outputLine("  NAME                VERSION   INSTALLED AT");
+  for (const s of skills) {
+    const name = s.name.padEnd(20);
+    const ver = s.version.padEnd(10);
+    const date = s.installedAt.slice(0, 19).replace("T", " ");
+    outputLine(`  ${name}${ver}${date}`);
+  }
+  outputLine("");
+  outputLine(`${skills.length} skills installed.`);
+}
+
 // src/index.ts
 var _require3 = createRequire3(import.meta.url);
 var CLI_VERSION2 = _require3("../package.json").version;
-var GIT_HASH2 = true ? "7b97fe6" : "dev";
+var GIT_HASH2 = true ? "f0a9e50" : "dev";
 function handleConfigCommand(action, rest, json, lang, force) {
   if (action === "init") return cmdConfigInit(lang === "zh" ? "zh" : "en");
   if (action === "show") return cmdConfigShow(json);
@@ -12395,6 +13074,13 @@ function handleMarketPublicCommand(run, action, rest, v, json) {
     return cmdMarketOpenInterest(run, { instType: v.instType, instId: v.instId, json });
   if (action === "stock-tokens")
     return cmdMarketStockTokens(run, { instType: v.instType, instId: v.instId, json });
+  if (action === "instruments-by-category")
+    return cmdMarketInstrumentsByCategory(run, {
+      instCategory: v.instCategory,
+      instType: v.instType,
+      instId: v.instId,
+      json
+    });
   if (action === "indicator") {
     const limit = v.limit !== void 0 ? Number(v.limit) : void 0;
     const backtestTime = v["backtest-time"] !== void 0 ? Number(v["backtest-time"]) : void 0;
@@ -13141,6 +13827,42 @@ function handleNewsCommand(run, action, rest, v, json) {
 `);
   process.exitCode = 1;
 }
+function requireSkillName(rest, usage) {
+  const name = rest[0];
+  if (!name) {
+    errorLine(usage);
+    process.exitCode = 1;
+  }
+  return name;
+}
+function handleSkillAdd(rest, config, json) {
+  const n = requireSkillName(rest, "Usage: okx skill add <name>");
+  if (n) return cmdSkillAdd(n, config, json);
+}
+function handleSkillDownload(rest, v, config, json) {
+  const n = requireSkillName(rest, "Usage: okx skill download <name> [--dir <path>]");
+  if (n) return cmdSkillDownload(n, v.dir ?? process.cwd(), config, json);
+}
+function handleSkillRemove(rest, json) {
+  const n = requireSkillName(rest, "Usage: okx skill remove <name>");
+  if (n) cmdSkillRemove(n, json);
+}
+function handleSkillCheck(run, rest, json) {
+  const n = requireSkillName(rest, "Usage: okx skill check <name>");
+  if (n) return cmdSkillCheck(run, n, json);
+}
+function handleSkillCommand(run, action, rest, v, json, config) {
+  if (action === "search") return cmdSkillSearch(run, { keyword: rest[0] ?? v.keyword, categories: v.categories, page: v.page, limit: v.limit, json });
+  if (action === "categories") return cmdSkillCategories(run, json);
+  if (action === "list") return cmdSkillList(json);
+  if (action === "add") return handleSkillAdd(rest, config, json);
+  if (action === "download") return handleSkillDownload(rest, v, config, json);
+  if (action === "remove") return handleSkillRemove(rest, json);
+  if (action === "check") return handleSkillCheck(run, rest, json);
+  errorLine(`Unknown skill command: ${action}`);
+  errorLine("Valid: search, categories, add, download, remove, check, list");
+  process.exitCode = 1;
+}
 function outputResult(result, json) {
   if (json) {
     outputLine(JSON.stringify(result, null, 2));
@@ -13203,7 +13925,8 @@ async function main() {
     option: () => handleOptionCommand(run, action, rest, v, json),
     news: () => handleNewsCommand(run, action, rest, v, json),
     bot: () => handleBotCommand(run, action, rest, v, json),
-    earn: () => handleEarnCommand(run, action, rest, v, json)
+    earn: () => handleEarnCommand(run, action, rest, v, json),
+    skill: () => handleSkillCommand(run, action, rest, v, json, config)
   };
   const handler = moduleHandlers[module];
   if (handler) return handler();
@@ -13234,6 +13957,7 @@ export {
   handleOptionAlgoCommand,
   handleOptionCommand,
   handleSetupCommand,
+  handleSkillCommand,
   handleSpotAlgoCommand,
   handleSpotCommand,
   handleSwapAlgoCommand,