Wind Mcp Skill

{
  "schema_version": 4,
  "description": "wind-mcp-skill CLI 错误码字典。每条 code 对应一段 agent_action（诊断 + 行动一体）。CLI 运行时读取本文件;本文件也是开发者参考与监控/集成的唯一码表。",
  "envelope_contract": {
    "success": "成功路径不返回 envelope,直接 stdout 输出纯数据。call 命令透传 result.content[0].text(JSON 字符串则 parse 后输出)；其它命令直接输出结构化对象;help 输出 USAGE 纯文本。exit code 0。",
    "failure": "失败路径返回 envelope: { ok: false, error: { code, agent_action } }。exit code 1。agent 用 exit code 判断成功/失败；失败时直接执行 agent_action 即可。"
  },
  "codes": {
    "TEMPORARILY_UNAVAILABLE": "后端偶发不可用。原样重试一次即可，可能是临时波动。重试仍失败则告知用户稍后再试，不得修改参数、工具或路由。",
    "INVALID_PARAM_NAME": "后端参数名错误：请求中包含不存在的字段或缺少必填字段。1) 读取 references/tool-contracts.md 当前工具段落，逐项核对字段名是否与文档完全一致；2) 检查是否遗漏必填字段；3) 只修 detail 指出的字段名问题，保持同一 server_type+tool_name 和其他参数不变。禁止改 shell 引号、发明字段名或切换工具。",
    "INVALID_PARAM_VALUE": "后端参数值错误：字段名正确但值不合法。1) 读取 references/tool-contracts.md 当前工具段落，核对 detail 指出字段的值域要求（日期格式 yyyyMMdd、枚举值、windcode 格式等）；2) 含 indexes 时读取 references/indicators.md 相关类别，逐字核对；3) 只修 detail 指出的值问题，保持同一 server_type+tool_name 和其他参数不变。禁止改字段名、shell 引号或切换工具。",
    "USAGE_ERROR": "命令用法错误。确认命令格式为 cli.mjs call <server_type> <tool_name> '<params_json>'，修正后重试。只修 CLI 形态，保持 server/tool/params 语义不变。",
    "INVALID_PARAMS_JSON": "命令传递错误：第三参数 JSON 解析失败。1) 按 SKILL.md「params JSON 写法」表核对当前 shell / 执行器的引号写法；2) 用同一执行路径运行 argv 探针：node -e \"JSON.parse(process.argv[1]); console.log(process.argv[1])\" '<params_json>'；3) 探针通过后，最终 CLI 调用的第三参数必须逐字符复用探针通过的 params_json。只修 JSON 字符串/引号/执行器转义；禁止改字段、日期、indexes、question 或工具。",
    "ROUTE_ERROR": "路由错误：server_type 或 tool_name 不合法。detail 中列出了可用选项。1) 根据 detail 中的可用列表，结合 SKILL.md 范围表重选合法的 server_type；2) 读取 references/tool-contracts.md 对应 server_type 的工具列表，重选合法的 tool_name；3) 保持用户原始数据意图，不要直接 fallback 到 analytics_data。",
    "PARAM_VALIDATION_ERROR": "业务参数错误：本地基础校验或后端参数校验未通过。1) 读取 references/tool-contracts.md 当前工具的段落，逐项核对字段名、必填项、日期格式（yyyyMMdd）、单标的和枚举值；2) 含 indexes 时读取 references/indicators.md 相关类别，每个 index 必须逐字存在；3) 只修 detail 指出的错误项，保持同一 server_type+tool_name 和业务参数语义。禁止改 shell 引号、添加用户未请求的指标、发明字段名或直接上 analytics。",
    "AUTH_ERROR": "认证错误。不得手动检查部分来源后判定缺 Key；CLI 已按“用户全局配置 > Skill 本地配置 > WIND_API_KEY 环境变量”完整检查。detail 中有具体原因，分两种情况处理：1) Key 未配置（detail 含'未配置'）：先问用户选择——由 agent 执行 node scripts/cli.mjs open-portal 打开开发者中心，还是用户自行获取 Key；拿到 Key 后问用户选 global 还是 skill scope，执行 node scripts/cli.mjs setup-key <KEY> --scope <global|skill>，再原样重试失败的调用；2) Key 无效或过期（detail 含 HTTP 401）：让用户到开发者中心重新生成 Key，用 setup-key 配置后原样重试。不得换工具/路由绕过。",
    "QUOTA_ERROR": "额度/限流错误。detail 中有具体原因，分三种情况处理：1) 日额度用完（detail 含'超限'或'daily'）：告知用户等次日 0 点额度刷新后重试，或换有额度的备用 Key；2) QPS 限流（detail 含'频繁'或'qps'或 HTTP 429）：等 3-5 秒后原样重试同一请求；3) 余额不足（detail 含'余额'或'充值'）：告知用户到开发者中心充值，或换有余额的 Key。不得换工具/路由绕过。保持同一 server_type+tool_name 和参数。",
    "NETWORK_ERROR": "网络/后端错误。detail 中有具体原因和 HTTP 状态码，分两种情况处理：1) 网络连接失败（detail 含 DNS/超时/代理/ECONNREFUSED）：检查本机网络和联网权限，修复后原样重试同一请求；2) 后端 HTTP 5xx（detail 含 HTTP 500/502/503/504）：先按 references/tool-contracts.md 当前工具段落核对 params key/value（必填、日期、枚举、单标的、indexes），入参有错只修该错重试一次；入参无误则稍后原样重试。不得改业务参数或路由。保持同一 server_type+tool_name。",
    "TOOL_RUNTIME_ERROR": "后端工具运行错误。detail 中有后端返回的原文。按以下顺序处理：1) 看 detail 是否明确指出问题——请求过大、字段不支持、数据未覆盖等；2) 若能明确定位原因，只修对应项重试一次（如缩小时间范围、减少 indexes、换字段）；3) 若 detail 是泛化提示（如'服务暂不可用'或'工具执行失败'），按 references/tool-contracts.md 当前工具段落核对 params key/value 后重试一次；4) 无法定位则告知用户后端原文并停止。不得切换工具、改 shell 引号或扩展指标。",
    "NO_RESULTS": "数据结果为空：后端执行成功但未匹配到数据。保持同一 server_type、tool_name 和用户意图，只可调整关键词、时间范围或粒度中与原问题直接相关的一项，最多重试一次。仍无结果时按路由顺序尝试 analytics_data 兜底或 wind-alice 最终兜底（先问用户）。禁止编造值或用常识补全。",
    "SETUP_ERROR": "本地配置/环境错误，发生在 setup-key 或 open-portal 过程中。detail 中有具体原因和路径，分三种情况处理：1) scope 不合法（detail 含'scope'）：问用户选择 global（全局共享）或 skill（仅当前 skill），带 --scope <global|skill> 重试 setup-key；2) 配置写入失败（detail 含'写入失败'或路径）：detail 中有目标路径，检查路径权限，或建议用户换另一个 scope 重试；3) 浏览器无法打开（detail 含'浏览器'或'URL'）：把 detail 中的 URL 告知用户，让用户手动在浏览器中打开。不要改数据查询。",
    "UNKNOWN": "未知错误。detail 中有后端原文或异常信息。尝试从 detail 识别属于哪个已知错误域：命令传递→检查 JSON 格式；业务参数→检查字段名和值；认证→检查 Key；网络→检查连接。能定位则只在该域修复并重试一次；无法定位则告知用户 detail 原文并停止。"
  }
}

{
  "schema_version": 1,
  "description": "Runtime normalization rules used by scripts/cli.mjs before calling Wind MCP tools.",
  "kline_periods": ["1", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13", "14", "15"],
  "period_aliases": {
    "1m": "1",
    "1min": "1",
    "1分钟": "1",
    "5m": "3",
    "5min": "3",
    "5分钟": "3",
    "10m": "4",
    "10min": "4",
    "10分钟": "4",
    "15m": "5",
    "15min": "5",
    "15分钟": "5",
    "30m": "6",
    "30min": "6",
    "30分钟": "6",
    "60m": "7",
    "60min": "7",
    "1h": "7",
    "60分钟": "7",
    "120m": "8",
    "120min": "8",
    "2h": "8",
    "120分钟": "8",
    "240m": "9",
    "240min": "9",
    "4h": "9",
    "240分钟": "9",
    "d": "10",
    "day": "10",
    "daily": "10",
    "日": "10",
    "日k": "10",
    "日线": "10",
    "w": "11",
    "week": "11",
    "weekly": "11",
    "周": "11",
    "周k": "11",
    "周线": "11",
    "m": "12",
    "month": "12",
    "monthly": "12",
    "月": "12",
    "月k": "12",
    "月线": "12",
    "y": "13",
    "year": "13",
    "yearly": "13",
    "年": "13",
    "年k": "13",
    "年线": "13",
    "q": "14",
    "quarter": "14",
    "quarterly": "14",
    "季": "14",
    "季k": "14",
    "halfyear": "15",
    "half-year": "15",
    "半年": "15",
    "半年k": "15"
  },
  "indicator_aliases": {
    "最新价": "最新成交价",
    "最新价格": "最新成交价",
    "最新收盘价": "最新成交价",
    "收盘价": "最新成交价",
    "close": "最新成交价",
    "last": "最新成交价",
    "price": "最新成交价",
    "昨收": "前收盘价",
    "昨收价": "前收盘价",
    "昨收盘": "前收盘价",
    "昨日收盘价": "前收盘价",
    "preclose": "前收盘价",
    "pre_close": "前收盘价",
    "开盘价": "今日开盘价",
    "今开": "今日开盘价",
    "open": "今日开盘价",
    "最高价": "今日最高价",
    "high": "今日最高价",
    "最低价": "今日最低价",
    "low": "今日最低价",
    "volume": "成交量",
    "vol": "成交量",
    "amount": "成交额",
    "turnover": "成交额",
    "涨幅": "涨跌幅",
    "pct_chg": "涨跌幅",
    "pctchg": "涨跌幅",
    "change_pct": "涨跌幅",
    "涨跌额": "涨跌",
    "change": "涨跌",
    "市盈率": "市盈率(TTM)",
    "市盈率ttm": "市盈率(TTM)",
    "pe": "市盈率(TTM)",
    "pe_ttm": "市盈率(TTM)",
    "市净率lf": "市净率(LF)",
    "pb": "市净率",
    "pb_lf": "市净率(LF)",
    "总市值": "总市值2",
    "总市值含限售": "总市值2",
    "总市值不含限售": "总市值1",
    "股息率ttm": "股息率",
    "dividend_yield": "股息率",
    "近一年收益率": "近一年净值增长率",
    "近1年收益率": "近一年净值增长率",
    "一年收益率": "近一年净值增长率",
    "近一年净值收益率": "近一年净值增长率"
  },
  "index_code_aliases": {
    "HSI": "HSI.HI",
    "HSI.HK": "HSI.HI",
    "HKHSI": "HSI.HI",
    "恒生指数": "HSI.HI",
    "HSTECH": "HSTECH.HI",
    "HSTECH.HK": "HSTECH.HI",
    "恒生科技": "HSTECH.HI",
    "DJI": "DJI.GI",
    "DJIA": "DJI.GI",
    ".DJI": "DJI.GI",
    "SPX": "SPX.GI",
    ".SPX": "SPX.GI",
    "IXIC": "IXIC.GI",
    ".IXIC": "IXIC.GI",
    "NDX": "NDX.GI",
    ".NDX": "NDX.GI",
    "SOX": "SOX.GI"
  },
  "legacy_tool_aliases": {
    "get_global_stock_price_indicators": ["stock_data", "get_stock_price_indicators"],
    "get_global_stock_kline": ["stock_data", "get_stock_kline"],
    "get_global_stock_quote": ["stock_data", "get_stock_quote"]
  },
  "tool_by_domain": {
    "price": {
      "stock_data": "get_stock_price_indicators",
      "fund_data": "get_fund_price_indicators",
      "index_data": "get_index_price_indicators"
    },
    "kline": {
      "stock_data": "get_stock_kline",
      "fund_data": "get_fund_kline",
      "index_data": "get_index_kline"
    },
    "quote": {
      "stock_data": "get_stock_quote",
      "fund_data": "get_fund_quote",
      "index_data": "get_index_quote"
    }
  }
}

{
  "stock_data": [
    "search_stocks",
    "get_stock_price_indicators",
    "get_stock_kline",
    "get_stock_quote",
    "get_stock_basicinfo",
    "get_stock_fundamentals",
    "get_stock_equity_holders",
    "get_stock_events",
    "get_stock_technicals",
    "get_risk_metrics"
  ],
  "fund_data": [
    "search_funds",
    "get_fund_price_indicators",
    "get_fund_kline",
    "get_fund_quote",
    "get_fund_info",
    "get_fund_financials",
    "get_fund_holdings",
    "get_fund_performance",
    "get_fund_holders",
    "get_fund_company_info"
  ],
  "index_data": [
    "get_index_price_indicators",
    "get_index_kline",
    "get_index_quote",
    "get_index_basicinfo",
    "get_index_fundamentals",
    "get_index_technicals"
  ],
  "bond_data": [
    "get_bond_basicinfo",
    "get_bond_issuer_info",
    "get_bond_market_data",
    "get_bond_financial_data"
  ],
  "financial_docs": [
    "get_company_announcements",
    "get_financial_news"
  ],
  "economic_data": [
    "get_economic_data"
  ],
  "analytics_data": [
    "get_financial_data"
  ]
}

#!/usr/bin/env node
// wind-mcp-skill CLI: thin JSON-envelope wrapper around Wind MCP servers
import { readFileSync, writeFileSync, existsSync, mkdirSync, copyFileSync } from 'node:fs';
import { homedir } from 'node:os';
import { join, dirname, basename, resolve } from 'node:path';
import { fileURLToPath, pathToFileURL } from 'node:url';
import { spawn } from 'node:child_process';

const SKILL_VERSION = '1.9.2';

// 本地 registry: 工具选择可在任何网络调用前失败
const SERVERS = {
  stock_data: {
    endpoint: 'https://mcp.wind.com.cn/vserver_stock_data/mcp/',
    label: 'Wind A股/港股/美股 股票（选股筛选 + 档案/财务/股本/事件/技术/风险 + 行情/K线/分钟）',
  },
  fund_data: {
    endpoint: 'https://mcp.wind.com.cn/vserver_fund_data/mcp/',
    label: 'Wind 基金（基金筛选 + 档案/财务/持仓/业绩/持有人/公司 + 行情/K线/分钟）',
  },
  index_data: {
    endpoint: 'https://mcp.wind.com.cn/vserver_index_data/mcp/',
    label: 'Wind 指数/板块（档案/基本面/技术 + 行情/K线/分钟）',
  },
  bond_data: {
    endpoint: 'https://mcp.wind.com.cn/vserver_bond_data/mcp/',
    label: 'Wind 债券（基本档案/发债主体/行情估值/主体财务）',
  },
  financial_docs: {
    endpoint: 'https://mcp.wind.com.cn/vserver_financial_docs/mcp/',
    label: 'Wind 金融文档 RAG（公告 / 新闻）',
  },
  economic_data: {
    endpoint: 'https://mcp.wind.com.cn/vserver_economic_data/mcp/',
    label: 'Wind EDB 宏观/行业经济指标',
  },
  analytics_data: {
    endpoint: 'https://mcp.wind.com.cn/vserver_analytics_data/mcp/',
    label: 'Wind 通用分析数据（NL → Wind 数据）',
  },
};

const PORTAL_URL = 'https://aifinmarket.wind.com.cn/#/user/overview';

const SKILL_DIR = dirname(dirname(fileURLToPath(
  import.meta.url)));

const UPDATE_CHECK_PATH = join(SKILL_DIR, 'scripts', 'update-check.mjs');
const TOOL_MANIFEST_PATH = join(SKILL_DIR, 'references', 'tool-manifest.json');
const ERROR_CODES_PATH = join(SKILL_DIR, 'references', 'error-codes.json');
const NORMALIZATION_RULES_PATH = join(SKILL_DIR, 'references', 'normalization-rules.json');
const SKILL_NAME = basename(SKILL_DIR);

const CALL_EXAMPLES = [
  `cli.mjs call stock_data search_stocks '{"question":"筛选沪深市场市值超500亿且连续5日上涨的股票"}'`,
  `cli.mjs call stock_data search_stocks '{"question":"筛选港股中市值超1000亿港元的科技股"}'`,
  `cli.mjs call fund_data search_funds '{"question":"筛选股票型基金中近一年收益率超20%的产品"}'`,
  `cli.mjs call stock_data get_stock_basicinfo '{"question":"600519.SH公司基本档案"}'`,
  `cli.mjs call stock_data get_stock_price_indicators '{"windcode":"600519.SH","indexes":"中文简称,最新成交价,涨跌幅"}'`,
  `cli.mjs call fund_data get_fund_kline '{"windcode":"588200.SH","begin_date":"20260401","end_date":"20260430"}'`,
  `cli.mjs call stock_data get_stock_quote '{"windcode":"AAPL.O"}'`,
  `cli.mjs call index_data get_index_kline '{"windcode":"000300.SH","begin_date":"20260401","end_date":"20260430"}'`,
  `cli.mjs call financial_docs get_financial_news '{"query":"美联储利率政策","top_k":3}'`,
  `cli.mjs call economic_data get_economic_data '{"metricIdsStr":"中国GDP","endDate":"20261231"}'`,
  `cli.mjs call analytics_data get_financial_data '{"question":"查询中国A股市场过去一年的平均成交量"}'`,
];

// ───── 自动更新 ─────
// 每天首次使用 skill 时异步执行一次 npx skills update，不阻塞主流程。

function todayKey() {
  return new Date().toISOString().slice(0, 10);
}

function normalizePath(value) {
  const normalized = resolve(value).replace(/\\/g, '/');
  return process.platform === 'win32' ? normalized.toLowerCase() : normalized;
}

function updateScope() {
  const globalRoot = normalizePath(join(homedir(), '.agents', 'skills'));
  const skillDir = normalizePath(SKILL_DIR);
  return skillDir.startsWith(globalRoot + '/') ? 'global' : 'project';
}

function updateStateFile() {
  return join(SKILL_DIR, 'scripts', 'update-state.json');
}

function readUpdateState() {
  try {
    const stateFile = updateStateFile();
    if (!existsSync(stateFile)) return null;
    return JSON.parse(readFileSync(stateFile, 'utf8'));
  } catch {
    return null;
  }
}

function writeUpdateStatePatch(patch) {
  const stateFile = updateStateFile();
  mkdirSync(dirname(stateFile), { recursive: true });
  const state = { ...(readUpdateState() || {}), ...patch };
  writeFileSync(stateFile, JSON.stringify(state, null, 2) + '\n');
}

function alreadyUpdatedToday() {
  try {
    const state = readUpdateState();
    return state && state.date === todayKey() && state.status === 'success';
  } catch {
    return false;
  }
}

function markSkillUsed() {
  writeUpdateStatePatch({
    lastUsedAt: new Date().toISOString(),
    lastUsedPid: process.pid,
  });
}

function triggerUpdateCheck() {
  try {
    if (!existsSync(UPDATE_CHECK_PATH)) return;
    if (alreadyUpdatedToday()) return;
    markSkillUsed();
    const tmpDir = join(homedir(), '.cache', 'wind-aifinmarket');
    mkdirSync(tmpDir, { recursive: true });
    const runnerPath = join(tmpDir, `update-check-${SKILL_NAME}-${process.pid}.mjs`);
    copyFileSync(UPDATE_CHECK_PATH, runnerPath);
    const child = spawn('node', [runnerPath, SKILL_DIR], { detached: true, stdio: 'ignore', windowsHide: true });
    child.on('error', () => {});
    child.unref();
  } catch {}
}

export { triggerUpdateCheck };

// section: 工具函数

// call 成功: 完整透传 MCP result, 不抽取; agent 自行 parse content[0].text
function writeRawCallSuccess(result) {
  process.stdout.write(JSON.stringify(result, null, 2) + '\n');
}

function writePlainSuccess(data) {
  process.stdout.write(JSON.stringify(data, null, 2) + '\n');
}

// 失败 envelope { ok:false, error:{code, agent_action} }; update 信号走 stderr 不进 stdout
function writeErrorEnvelope(code, detail) {
  const envelope = {
    ok: false,
    error: {
      code,
      agent_action: buildAgentAction(code, detail),
    },
  };
  process.stdout.write(JSON.stringify(envelope, null, 2) + '\n');
}

function die(code, detail = null, exitCode = 1) {
  writeErrorEnvelope(code, detail);
  process.exit(exitCode);
}

function exitWithUsage(usage, exitCode = 0) {
  die('USAGE_ERROR', `USAGE:\n${usage}`, exitCode);
}

function maskKey(key) {
  if (!key || key.length < 8) return '***';
  return key.slice(0, 4) + '***' + key.slice(-4);
}

// dotenv 解析: 兼容注释 / 引号 / export 前缀
function parseDotenv(content) {
  const env = {};
  for (const rawLine of content.split('\n')) {
    let line = rawLine.replace(/^/, '').trim();
    if (!line || line.startsWith('#')) continue;
    if (line.startsWith('export ')) line = line.slice(7).trim();
    const eq = line.indexOf('=');
    if (eq <= 0) continue;
    const key = line.slice(0, eq).trim();
    let val = line.slice(eq + 1).trim();
    if ((val.startsWith('"') && val.endsWith('"')) || (val.startsWith("'") && val.endsWith("'"))) {
      val = val.slice(1, -1);
    } else {
      const hashIdx = val.indexOf(' #');
      if (hashIdx >= 0) val = val.slice(0, hashIdx).trim();
    }
    env[key] = val;
  }
  return env;
}

function getServer(server_type) {
  const server = SERVERS[server_type];
  if (!server) {
    die('ROUTE_ERROR', `未知 server_type: ${server_type}. 可用: ${Object.keys(SERVERS).join(' / ')}`);
  }
  return server;
}

function loadToolManifest() {
  try {
    // tool-manifest.json is the authority for legal server_type + tool_name combinations.
    const manifest = JSON.parse(readFileSync(TOOL_MANIFEST_PATH, 'utf8'));
    if (!manifest || typeof manifest !== 'object' || Array.isArray(manifest)) {
      throw new Error('manifest 顶层必须是对象');
    }
    for (const [serverType, tools] of Object.entries(manifest)) {
      if (!SERVERS[serverType]) {
        throw new Error(`manifest 包含未知 server_type: ${serverType}`);
      }
      if (!Array.isArray(tools) || tools.some(tool => typeof tool !== 'string' || !tool)) {
        throw new Error(`manifest 中 ${serverType} 的工具清单必须是非空字符串数组`);
      }
    }
    for (const serverType of Object.keys(SERVERS)) {
      if (!Array.isArray(manifest[serverType])) {
        throw new Error(`manifest 缺少 server_type: ${serverType}`);
      }
    }
    return manifest;
  } catch (err) {
    die('UNKNOWN', `工具清单读取失败: ${err.message}`);
  }
}

function validateToolSelection(server_type, toolName) {
  getServer(server_type);
  const manifest = loadToolManifest();
  const tools = manifest[server_type];
  if (!tools.includes(toolName)) {
    die('ROUTE_ERROR', `工具名 "${toolName}" 不属于 server_type "${server_type}"。`);
  }
}

const BASIC_TEXT_KEYS = ['question', 'query', 'metricIdsStr', 'windcode', 'indexes', 'freq', 'magnitude', 'currency'];
const BASIC_NO_WHITESPACE_KEYS = ['query', 'metricIdsStr'];
const BASIC_DATE_KEYS = ['begin_date', 'end_date', 'beginDate', 'endDate', 'date', 'tradeDate'];
const PRICE_INDICATOR_TOOLS = new Set(['get_stock_price_indicators', 'get_fund_price_indicators', 'get_index_price_indicators']);
const KLINE_TOOLS = new Set(['get_stock_kline', 'get_fund_kline', 'get_index_kline']);
const QUOTE_TOOLS = new Set(['get_stock_quote', 'get_fund_quote', 'get_index_quote']);
const EDB_TOOLS = new Set(['get_economic_data']);
const EDB_FREQ_VALUES = new Set(['日', '工作日', '周', '月', '季', '半年', '年', '年度']);
const EDB_MAGNITUDE_VALUES = new Set(['个', '千', '万', '百万', '千万', '亿', '十亿', '百亿', '千亿', '万亿']);
const EDB_CURRENCY_VALUES = new Set(['USD', 'CNY', 'EUR', 'JPY', 'AUD', 'GBP', 'CHF', 'CAD', 'SGD', 'BYR', 'HKD', 'MYR']);

function readNormalizationRules() {
  const rules = JSON.parse(readFileSync(NORMALIZATION_RULES_PATH, 'utf8'));
  return {
    klinePeriods: new Set(rules.kline_periods || []),
    periodAliases: new Map(Object.entries(rules.period_aliases || {})),
    indicatorAliases: new Map(Object.entries(rules.indicator_aliases || {})),
    indexCodeAliases: new Map(Object.entries(rules.index_code_aliases || {})),
    legacyToolAliases: new Map(Object.entries(rules.legacy_tool_aliases || {})),
    toolByDomain: rules.tool_by_domain || {},
  };
}

const NORMALIZATION_RULES = readNormalizationRules();
const KLINE_PERIODS = NORMALIZATION_RULES.klinePeriods;
const PERIOD_ALIASES = NORMALIZATION_RULES.periodAliases;
const INDICATOR_ALIASES = NORMALIZATION_RULES.indicatorAliases;
const INDEX_CODE_ALIASES = NORMALIZATION_RULES.indexCodeAliases;
const LEGACY_TOOL_ALIASES = NORMALIZATION_RULES.legacyToolAliases;
const TOOL_BY_DOMAIN = NORMALIZATION_RULES.toolByDomain;

function isValidBasicDate(value) {
  if (!/^\d{8}$/.test(value)) return false;
  const y = Number(value.slice(0, 4));
  const m = Number(value.slice(4, 6));
  const d = Number(value.slice(6, 8));
  const dt = new Date(Date.UTC(y, m - 1, d));
  return dt.getUTCFullYear() === y && dt.getUTCMonth() === m - 1 && dt.getUTCDate() === d;
}

function normalizeIndicatorKey(value) {
  return String(value || '').trim().replace(/\s+/g, '').replace(/[（]/g, '(').replace(/[）]/g, ')').toLowerCase();
}

function normalizeIndexes(indexes) {
  if (typeof indexes !== 'string') return indexes;
  return indexes.split(',').map((item) => INDICATOR_ALIASES.get(normalizeIndicatorKey(item)) || item.trim()).filter(Boolean).join(',');
}

function looksLikeFundCode(code) {
  return /^5\d{5}\.SH$/.test(code) || /^1[56]\d{4}\.SZ$/.test(code) || /^\d{6}\.OF$/.test(code);
}

function looksLikeIndexCode(code) {
  return /^(\d{6})\.(CSI|WI|MI|HI|GI)$/.test(code) ||
    /^(000300|000905|000852|000016|000001)\.SH$/.test(code) ||
    /^(399001|399006|399300)\.SZ$/.test(code) ||
    /^[A-Z]{2,10}\.(HI|GI)$/.test(code);
}

function normalizeWindcode(windcode) {
  if (typeof windcode !== 'string') return windcode;
  const raw = windcode.trim();
  const alias = INDEX_CODE_ALIASES.get(raw.toUpperCase());
  if (alias) return alias;
  const upper = raw.toUpperCase();
  if (/^\d{4}\.HK$/.test(upper)) return `0${upper}`;
  if (looksLikeIndexCode(upper)) return upper;
  if (/^\d{6}$/.test(upper)) {
    if (/^9\d{5}$/.test(upper)) return `${upper}.BJ`;
    if (/^5\d{5}$/.test(upper)) return `${upper}.SH`;
    if (/^1[56]\d{4}$/.test(upper)) return `${upper}.SZ`;
    if (/^(000300|000905|000852|000016|000001)$/.test(upper)) return `${upper}.SH`;
    if (/^399\d{3}$/.test(upper)) return `${upper}.SZ`;
    if (/^[036]\d{5}$/.test(upper)) return `${upper}.${upper.startsWith('6') ? 'SH' : 'SZ'}`;
  }
  if (/^5\d{5}\.SZ$/.test(upper)) return upper.replace(/\.SZ$/, '.SH');
  if (/^1[56]\d{4}\.SH$/.test(upper)) return upper.replace(/\.SH$/, '.SZ');
  if (/^[03]\d{5}\.SH$/.test(upper)) return upper.replace(/\.SH$/, '.SZ');
  if (/^6\d{5}\.SZ$/.test(upper)) return upper.replace(/\.SZ$/, '.SH');
  if (/^9\d{5}\.(SH|SZ)$/.test(upper)) return upper.replace(/\.(SH|SZ)$/, '.BJ');
  if (/^[A-Z]{1,5}$/.test(upper)) return `${upper}.O`;
  return upper;
}

function toolFamily(toolName) {
  if (PRICE_INDICATOR_TOOLS.has(toolName)) return 'price';
  if (KLINE_TOOLS.has(toolName)) return 'kline';
  if (QUOTE_TOOLS.has(toolName)) return 'quote';
  return null;
}

function inferServerTypeFromWindcode(currentServerType, windcode) {
  if (typeof windcode !== 'string') return currentServerType;
  if (looksLikeFundCode(windcode)) return 'fund_data';
  if (looksLikeIndexCode(windcode)) return 'index_data';
  if (/^\d{4,5}\.HK$/.test(windcode) || /^[A-Z]{1,5}\.(O|N|A|HK|SH|SZ|BJ)$/.test(windcode) || /^\d{6}\.(SH|SZ|BJ)$/.test(windcode)) {
    return 'stock_data';
  }
  return currentServerType;
}

function normalizeCall(server_type, toolName, args) {
  const legacyTool = LEGACY_TOOL_ALIASES.get(toolName);
  if (legacyTool) [server_type, toolName] = legacyTool;
  const normalizedArgs = { ...args };
  if (typeof normalizedArgs.indexes === 'string') normalizedArgs.indexes = normalizeIndexes(normalizedArgs.indexes);
  if (typeof normalizedArgs.windcode === 'string') normalizedArgs.windcode = normalizeWindcode(normalizedArgs.windcode);
  if (typeof normalizedArgs.period === 'string') {
    const key = normalizedArgs.period.trim().toLowerCase();
    normalizedArgs.period = PERIOD_ALIASES.get(key) || normalizedArgs.period.trim();
  }
  const family = toolFamily(toolName);
  if (family && typeof normalizedArgs.windcode === 'string') {
    server_type = inferServerTypeFromWindcode(server_type, normalizedArgs.windcode);
    toolName = TOOL_BY_DOMAIN[family]?.[server_type] || toolName;
  }
  return { server_type, toolName, args: normalizedArgs };
}

function validateBasicParams(params) {
  const errors = [];
  if (!params || typeof params !== 'object' || Array.isArray(params)) {
    return ['params 必须是 JSON object'];
  }

  for (const key of BASIC_TEXT_KEYS) {
    if (!(key in params)) continue;
    if (typeof params[key] !== 'string') {
      errors.push(`字段 '${key}' 必须是字符串`);
    } else if (params[key].trim().length === 0) {
      errors.push(`字段 '${key}' 不能为空或全空白`);
    }
  }

  for (const key of BASIC_NO_WHITESPACE_KEYS) {
    if (typeof params[key] === 'string' && /\s/.test(params[key])) {
      errors.push(`字段 '${key}' 不得含空格或其它空白字符`);
    }
  }

  if (typeof params.windcode === 'string' && params.windcode.includes(',')) {
    errors.push("字段 'windcode' 只允许单个标的，禁止逗号拼接多代码");
  }

  for (const key of BASIC_DATE_KEYS) {
    if (!(key in params)) continue;
    if (typeof params[key] === 'string' && !isValidBasicDate(params[key])) {
      errors.push(`字段 '${key}' 日期格式错误，要求 yyyyMMdd`);
    }
  }

  return errors;
}

function validateToolParams(toolName, params) {
  const errors = [];
  if (KLINE_TOOLS.has(toolName)) {
    for (const key of ['windcode', 'begin_date', 'end_date']) {
      if (!(key in params)) errors.push(`K 线工具缺少必填字段 '${key}'`);
    }
    if ('period' in params && !KLINE_PERIODS.has(String(params.period))) {
      errors.push(`字段 'period' 只能是 ${Array.from(KLINE_PERIODS).join('/')}，日 K 请传 '10'`);
    }
    for (const key of ['aftime', 'issusp']) {
      if (key in params && !new Set(['0', '1']).has(String(params[key]))) {
        errors.push(`字段 '${key}' 只能是 '0' 或 '1'`);
      }
    }
  }
  if (EDB_TOOLS.has(toolName)) {
    const allowedKeys = new Set(['metricIdsStr', 'beginDate', 'endDate', 'freq', 'magnitude', 'currency']);
    for (const key of Object.keys(params)) {
      if (!allowedKeys.has(key)) errors.push(`宏观 EDB 工具不支持字段 '${key}'`);
    }
    if (!params.metricIdsStr) errors.push("宏观 EDB 工具缺少必填字段 'metricIdsStr'");
    if (params.freq && !EDB_FREQ_VALUES.has(params.freq)) {
      errors.push("字段 'freq' 只能是 日/工作日/周/月/季/半年/年/年度");
    }
    if (params.magnitude && !EDB_MAGNITUDE_VALUES.has(params.magnitude)) {
      errors.push("字段 'magnitude' 取值不在宏观 EDB 工具枚举内");
    }
    if (params.currency && !EDB_CURRENCY_VALUES.has(params.currency)) {
      errors.push("字段 'currency' 取值不在宏观 EDB 工具枚举内");
    }
    if (params.beginDate && params.endDate && params.beginDate > params.endDate) {
      errors.push("字段 'beginDate' 不能晚于 'endDate'");
    }
  }
  return errors;
}

// ───── 认证 ─────

function getApiKey() {
  const globalConfig = join(homedir(), '.wind-aifinmarket', 'config');
  if (existsSync(globalConfig)) {
    try {
      const env = parseDotenv(readFileSync(globalConfig, 'utf8'));
      const key = env.WIND_API_KEY?.trim();
      if (key) return key;
    } catch {}
  }

  const localConfig = join(SKILL_DIR, 'config.json');
  if (existsSync(localConfig)) {
    try {
      const cfg = JSON.parse(readFileSync(localConfig, 'utf8'));
      const key = typeof cfg.wind_api_key === 'string' ? cfg.wind_api_key.trim() : '';
      if (key) return key;
    } catch {}
  }

  const envKey = process.env.WIND_API_KEY?.trim();
  if (envKey) return envKey;

  die('AUTH_ERROR', 'WIND_API_KEY 未配置（CLI 已完整检查：用户全局配置 > Skill 本地配置 > 环境变量）');
}

// section: 错误码 — message 来自 HTTP / JSON-RPC / 工具内嵌 JSON, 统一映射成稳定 code

const ERROR_PATTERNS = [
  ['TEMPORARILY_UNAVAILABLE', /temporarily_unavailable/i, '后端偶发不可用。'],
  ['INVALID_PARAM_VALUE', /invalid_param_value/i, '后端参数值错误。'],
  ['INVALID_PARAM_NAME', /invalid_param_name/i, '后端参数名错误。'],
  ['QUOTA_ERROR', /单日请求次数超限|daily.*limit|余额不足|请先充值|insufficient.*balance|请求过于频繁|qps.*limit|too.*frequent/i, '额度/限流错误。等待额度刷新、换备用 Key 或充值后原样重试。'],
  ['AUTH_ERROR', /密钥无效|key.*invalid|unauthorized|认证失败|auth.*fail/i, '认证/权限错误。按 Key 机制修复后原样重试。'],
  ['NO_RESULTS', /未获取到数据|"NO_RESULTS"|no\s*results?|not\s*found|empty\s*result/i, '未获取到匹配数据。先在不改变用户意图的前提下调整关键词或参数。'],
  ['PARAM_VALIDATION_ERROR', /参数验证失败|参数.*(错误|非法|无效)|字段.*(不存在|不识别|不支持|非法)|invalid\s*(param|argument|field)|missing\s*(param|argument|field|required)/i, '后端参数验证失败。先按 SKILL.md 工具表核对字段名、必填项、日期格式和枚举值后重试。'],
  ['NETWORK_ERROR', /服务.*暂不可用|服务.*不可用|service\s+unavailable|temporarily\s+unavailable/i, '网络/后端错误。先核对参数再稍后重试。'],
  ['TOOL_RUNTIME_ERROR', /TOOL_ERROR|tool.*error|工具.*(执行|运行).*错误|runtime.*error/i, '后端工具运行错误。保留后端原文，先检查请求是否过大或口径是否受支持；不要直接切换工具绕过。'],
];

function inferErrorCode(msg) {
  if (!msg) return 'UNKNOWN';
  for (const [code, pat] of ERROR_PATTERNS) {
    if (pat.test(msg)) return code;
  }
  return 'UNKNOWN';
}

// agent_action = 诊断 + 行动 一体的 NL 处方; 唯一总表在 references/error-codes.json
function loadAgentActions() {
  const fallback = {
    UNKNOWN: '未知错误。不要盲目重试；先查看当前错误详情，能定位本地问题（参数 / 配置 / 网络）则修正后重试一次，无法定位则保留原文告知用户并停止。',
  };
  try {
    const doc = JSON.parse(readFileSync(ERROR_CODES_PATH, 'utf8'));
    const codes = doc && typeof doc.codes === 'object' ? doc.codes : null;
    if (!codes) return fallback;
    return {
      ...fallback,
      ...Object.fromEntries(
        Object.entries(codes).filter(([, action]) => typeof action === 'string' && action.trim()),
      ),
    };
  } catch {
    return fallback;
  }
}

const AGENT_ACTIONS = loadAgentActions();

// detail 只保留短诊断，避免后端长文本淹没 agent_action。
function buildAgentAction(code, detail) {
  const template = AGENT_ACTIONS[code] || AGENT_ACTIONS.UNKNOWN;
  if (code === 'USAGE_ERROR') return template;
  if (detail && typeof detail === 'string' && detail.trim()) {
    const d = detail.trim().slice(0, 500);
    return `[${d}] ${template}`;
  }
  return template;
}

// section: MCP 调用 — 裸 HTTP + JSON-RPC, 响应兼容 SSE / 纯 JSON

function parseSSE(text) {
  const trimmed = text.trim();
  // 后端正常 SSE, 部分错误场景纯 JSON
  if (trimmed.startsWith('{')) {
    try {
      return JSON.parse(trimmed);
    } catch {}
  }
  const lines = text.split(/\r?\n/);
  let last = null;
  for (const line of lines) {
    if (line.startsWith('data: ')) last = line.slice(6);
  }
  if (last) {
    try {
      return JSON.parse(last);
    } catch (e) {
      throw new Error(`SSE data 行 JSON 解析失败：${e.message}。原文前 200 字符：${text.slice(0, 200)}`);
    }
  }
  throw new Error(`响应格式无法识别（既非 SSE 也非纯 JSON）。原文前 200 字符：${text.slice(0, 200)}`);
}

const HTTP_ERROR_MAP = {
  401: ['AUTH_ERROR', 'API Key 无效或过期'],
  429: ['QUOTA_ERROR', '请求过于频繁'],
  500: ['NETWORK_ERROR', '服务端异常'],
  502: ['NETWORK_ERROR', '网关异常'],
  503: ['NETWORK_ERROR', '服务暂不可用'],
  504: ['NETWORK_ERROR', '网关超时'],
};

async function mcpRequest(server_type, method, params, {
  timeoutMs = 60_000
} = {}) {
  const server = getServer(server_type);
  const apiKey = getApiKey();
  const headers = {
    Authorization: `Bearer ${apiKey}`,
    Accept: 'application/json, text/event-stream',
    'Content-Type': 'application/json',
  };

  const body = JSON.stringify({
    jsonrpc: '2.0',
    id: Date.now(),
    method,
    params
  });
  let resp;
  try {
    resp = await fetch(server.endpoint, {
      method: 'POST',
      headers,
      body,
      signal: AbortSignal.timeout(timeoutMs),
    });
  } catch (err) {
    die('NETWORK_ERROR', `${err.message} (server=${server_type})`);
  }

  if (!resp.ok) {
    const bodyText = await resp.text().catch(() => '');
    const code = HTTP_ERROR_MAP[resp.status]?.[0] || 'UNKNOWN';
    const detail = `HTTP ${resp.status} ${resp.statusText} (server=${server_type})` + (bodyText ? ` | body: ${bodyText.slice(0, 200)}` : '');
    die(code, detail);
  }

  const text = await resp.text();
  let payload;
  try {
    payload = parseSSE(text);
  } catch (err) {
    die('TOOL_RUNTIME_ERROR', `${err.message} (server=${server_type})`);
  }

  if (payload.error) {
    const msg = payload.error.message || JSON.stringify(payload.error);
    die(inferErrorCode(msg), `${msg} (server=${server_type})`);
  }

  if (payload.result?.isError) {
    const msg = payload.result.content?.[0]?.text || JSON.stringify(payload.result);
    die(inferErrorCode(msg), `${msg} (server=${server_type})`);
  }

  // 部分工具把业务错误包在 content[0].text 的 JSON 字符串里, 必须二次解析
  const innerText = payload.result?.content?.[0]?.text;
  if (typeof innerText === 'string') {
    let inner;
    try {
      inner = JSON.parse(innerText);
    } catch {
      inner = null;
    }
    if (inner) {
      if (typeof inner.mcp_tool_error_code === 'number' && inner.mcp_tool_error_code !== 0) {
        const msg = inner.mcp_tool_error_msg || JSON.stringify(inner);
        die(inferErrorCode(msg), `${msg} (server=${server_type})`);
      }
      if (inner.error && (inner.error.code || inner.error.message)) {
        const errCode = inner.error.code || '';
        const errMsg = inner.error.message || '';
        const combined = errCode ? `${errCode}: ${errMsg}` : errMsg;
        die(inferErrorCode(combined), `${combined} (server=${server_type})`);
      }
    }
  }

  return payload.result;
}

async function mcpInitializeAndCall(server_type, method, params) {
  await mcpRequest(server_type, 'initialize', {
    protocolVersion: '2025-03-26',
    capabilities: {},
    clientInfo: {
      name: SKILL_NAME,
      version: SKILL_VERSION
    },
  }, {
    timeoutMs: 30_000
  });

  return mcpRequest(server_type, method, params, {
    timeoutMs: 600_000
  });
}

// section: 命令

async function cmdCall(server_type, toolName, paramsJson) {
  if (!server_type || !toolName || !paramsJson) {
    exitWithUsage(
      `用法：call <server_type> <tool_name> '<params_json>'\n` +
      `可用 server_type: ${Object.keys(SERVERS).join(' / ')}\n` +
      `典型：\n  ${CALL_EXAMPLES.join('\n  ')}`,
      1,
    );
  }

  let args;
  try {
    args = JSON.parse(paramsJson);
  } catch (e) {
    die('INVALID_PARAMS_JSON', `params JSON 解析失败：${e.message} | 原文：${paramsJson.slice(0, 200)}`);
  }

  ({ server_type, toolName, args } = normalizeCall(server_type, toolName, args));
  validateToolSelection(server_type, toolName);

  const validationErrors = validateBasicParams(args);
  validationErrors.push(...validateToolParams(toolName, args));
  if (validationErrors.length > 0) {
    die('PARAM_VALIDATION_ERROR', validationErrors.join('；'));
  }

  const result = await mcpInitializeAndCall(server_type, 'tools/call', {
    name: toolName,
    arguments: args,
    _meta: { clientVersion: SKILL_VERSION },
  });
  return {
    server_type,
    tool: toolName,
    result,
  };
}

async function cmdSetupKey(...rawArgs) {
  const key = rawArgs[0];

  if (!key || key.startsWith('--')) {
    exitWithUsage(
      `用法：cli.mjs setup-key <KEY> --scope <global|skill>\n\n` +
      `scope: global=全局共享；skill=仅当前 skill。调用前先让用户选择。`,
      1,
    );
  }

  let scope = null;
  for (let i = 1; i < rawArgs.length; i++) {
    const a = rawArgs[i];
    if (a === '--scope' && rawArgs[i + 1]) {
      scope = rawArgs[i + 1];
      break;
    }
    if (a.startsWith('--scope=')) {
      scope = a.slice(8);
      break;
    }
  }

  if (!scope) {
    exitWithUsage(
      `setup-key 缺 --scope 参数。\n\n` +
      `先让用户选择 global 或 skill，再重试：cli.mjs setup-key ${maskKey(key)} --scope <global|skill>`,
      1,
    );
  }

  if (!['global', 'skill'].includes(scope)) {
    die('SETUP_ERROR', `setup-key 未知 scope: ${scope} (可选: global / skill)`);
  }

  let file;
  try {
    if (scope === 'global') {
      const dir = join(homedir(), '.wind-aifinmarket');
      if (!existsSync(dir)) mkdirSync(dir, {
        recursive: true
      });
      file = join(dir, 'config');
      let lines = [];
      if (existsSync(file)) {
        lines = readFileSync(file, 'utf8').split('\n')
          .filter(l => l.length > 0 && !/^\s*(export\s+)?WIND_API_KEY\s*=/.test(l));
      }
      lines.push(`WIND_API_KEY=${key}`);
      writeFileSync(file, lines.join('\n') + '\n', {
        mode: 0o600
      });
    } else {
      file = join(SKILL_DIR, 'config.json');
      writeFileSync(file, JSON.stringify({ wind_api_key: key }, null, 2) + '\n', { mode: 0o600 });
    }
  } catch (err) {
    die('SETUP_ERROR', `配置写入失败 (scope=${scope}, path=${file || 'n/a'}): ${err.message}`);
  }

  return {
    scope,
    path: file,
    key_masked: maskKey(key),
    next: '现在可以重试原 Wind 调用',
  };
}

async function cmdOpenPortal() {
  const platform = process.platform;
  let bin, args;
  if (platform === 'darwin') {
    bin = 'open';
    args = [PORTAL_URL];
  } else if (platform === 'win32') {
    bin = 'cmd';
    args = ['/c', 'start', '', PORTAL_URL];
  } else {
    bin = 'xdg-open';
    args = [PORTAL_URL];
  }

  let spawnError = null;
  try {
    const child = spawn(bin, args, {
      stdio: 'ignore',
      detached: true,
      windowsHide: true
    });
    child.unref();
    spawnError = await new Promise((resolve) => {
      child.once('error', resolve);
      setTimeout(() => resolve(null), 300);
    });
  } catch (err) {
    spawnError = err;
  }

  const data = {
    url: PORTAL_URL,
    platform,
    spawn_command: `${bin} ${args.join(' ')}`,
    flow_note: '未登录时会自动跳转到登录页（/#/login）；登录完成后回到 overview 页面即可获取 API Key。',
    fallback_message: `如果浏览器没有自动弹出，请手动访问：${PORTAL_URL}`,
  };
  if (spawnError) {
    die('SETUP_ERROR', `本地无法启动浏览器: ${spawnError.message} | 用户应手动打开 ${data.url}`);
  }
  return data;
}

// 诊断: 输出自动更新状态
async function cmdDiagnose() {
  let updateState = null;
  try {
    const stateFile = updateStateFile();
    if (existsSync(stateFile)) {
      updateState = JSON.parse(readFileSync(stateFile, 'utf8'));
    }
  } catch {
    updateState = { status: 'unreadable' };
  }
  return {
    platform: process.platform,
    node_pid: process.pid,
    update_scope: updateScope(),
    update_state_file: updateStateFile(),
    update_state: updateState,
    next_update_needed: !alreadyUpdatedToday(),
  };
}

// section: 主入口 — IS_MAIN guard 让单元测试 import 不副作用
const IS_MAIN = process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href;

if (IS_MAIN) runMain();

function runMain() {
const [cmd, ...args] = process.argv.slice(2);

const USAGE =
  `wind-mcp-skill\n` +
  `访问万得 Wind 金融数据（按数据域分类调用）\n\n` +
  `用法:\n` +
  `  cli.mjs call <server_type> <tool_name> '<params_json>'\n` +
  `  cli.mjs open-portal                                # 打开万得开发者中心拿 API Key\n` +
  `  cli.mjs setup-key <KEY> --scope <global|skill>     # 配置 API Key（先问用户存放位置）\n\n` +
  `可用 server_type:\n` +
  Object.entries(SERVERS).map(([k, v]) => `  ${k.padEnd(20)}${v.label}`).join('\n') + '\n\n' +
  `典型:\n` +
  `  ${CALL_EXAMPLES.join('\n  ')}`;

const commands = {
  call: () => cmdCall(args[0], args[1], args[2]),
  'open-portal': () => cmdOpenPortal(),
  'setup-key': () => cmdSetupKey(...args),
  diagnose: () => cmdDiagnose(),
};

if (!cmd) {
  // help: 直接输出 USAGE 纯文本
  process.stdout.write(USAGE + '\n');
  process.exit(0);
}

if (!commands[cmd]) {
  die('USAGE_ERROR', `未知命令: ${cmd}\nUSAGE:\n${USAGE}`);
}

commands[cmd]()
  .then((data) => {
    if (cmd === 'call') {
      // call: 透传 result 内容 (parse JSON if applicable, else raw text)
      writeRawCallSuccess(data?.result);
      setTimeout(triggerUpdateCheck, 0);
    } else {
      // open-portal / setup-key: 直接输出结构化数据 (无 envelope 包裹)
      writePlainSuccess(data);
    }
  })
  .catch((err) => {
    die('UNKNOWN', `执行失败: ${err.message || err}${err.stack ? ' | stack: ' + err.stack.slice(0, 300) : ''}`);
  });
}