methodalgo-cli 1.0.1

package/src/commands/news.js

@@ -0,0 +1,76 @@
+import { Command } from "commander";
+import chalk from "chalk";
+import { signedRequest } from "../utils/api.js";
+import logger from "../utils/logger.js";
+import { t } from "../utils/i18n.js";
+
+const newsCmd = new Command("news")
+    .description(t("NEWS_DESC"))
+    .option("-t, --type <type>", "News type. Use 'methodalgo news --help' to see all types.")
+    .option("-l, --limit <number>", t("OPT_LIMIT_DESC"), "10")
+    .option("-g, --language <lang>", "Language (zh, en)", "zh")
+    .option("-s, --search <keyword>", t("OPT_SEARCH_DESC"))
+    .option("-S, --start-date <date>", t("OPT_START_DATE_DESC"))
+    .option("-E, --end-date <date>", t("OPT_END_DATE_DESC"))
+    .option("--json", "Output raw JSON data")
+    .addHelpText("after", `\n${t("NEWS_LIMIT_NOTE")}\n\n${t("LABEL_EXAMPLE")}\n  $ ${t("NEWS_EXAMPLE")}\n\n${t("NEWS_TYPES")}`)
+    .action(async (options) => {
+        if (!options.type) {
+            newsCmd.help();
+            return;
+        }
+
+        try {
+            const params = {
+                type: options.type,
+                limit: options.limit,
+                lang: options.language,
+                search: options.search,
+                startDate: options.startDate,
+                endDate: options.endDate
+            };
+
+            const res = await signedRequest("/mcp/news", params);
+            const { status, data, message } = res.data;
+
+            if (!status) {
+                logger.error(`${t("ERR_NETWORK")}: ${message}`);
+                return;
+            }
+
+            if (options.json) {
+                logger.json(data);
+            } else {
+                const lang = t("FETCH_SUCCESS").includes("获取") ? "zh" : "en";
+                logger.success(t("FETCH_SUCCESS", { count: data.length }));
+                data.forEach((item, index) => {
+                    const title = (item.title[lang] || item.title["en"]).replace(/\n/g, ", ");
+                    let source = "MethodAlgo";
+                    try { if (item.url) source = new URL(item.url).hostname.replace("www.", ""); } catch (_) {}
+                    const date = new Date(item.publish_date).toLocaleString(lang === "zh" ? "zh-CN" : "en-US", {
+                        hour12: false, month: "2-digit", day: "2-digit", hour: "2-digit", minute: "2-digit"
+                    }).replace(/\//g, "-");
+                    const excerpt = item.excerpt ? (item.excerpt[lang] || item.excerpt["en"]) : "";
+                    
+                    console.log(`\n${chalk.bold(`[${index + 1}] ${title}`)} ${chalk.dim(`(${source} · ${date})`)}`);
+                    if (excerpt) {
+                        console.log(`    ${chalk.gray(excerpt.replace(/\n/g, " ").substring(0, 150) + "...")}`);
+                    }
+                    if (item.url) {
+                        console.log(`    ${chalk.blue.underline(item.url)}`);
+                    }
+                    if (item.image_url) {
+                        console.log(`    ${chalk.yellow("🖼  Image: ")}${chalk.dim.underline(item.image_url)}`);
+                    }
+                    if (item.video_url) {
+                        console.log(`    ${chalk.yellow("📹 Video: ")}${chalk.dim.underline(item.video_url)}`);
+                    }
+                });
+                console.log(""); // 底部留白
+            }
+        } catch (error) {
+            logger.error(`News Error: ${error.message}`);
+        }
+    });
+
+export default newsCmd;

package/src/commands/signals.js

@@ -0,0 +1,234 @@
+import { Command } from "commander";
+import chalk from "chalk";
+import { signedRequest } from "../utils/api.js";
+import logger from "../utils/logger.js";
+import { t, getLang } from "../utils/i18n.js";
+
+const signalsCmd = new Command("signals")
+    .description(t("SIGNALS_DESC"))
+    .argument("[channel]", t("ARG_CHANNEL_DESC") || "Channel name")
+    .addHelpText("after", `\n${t("LABEL_EXAMPLE")}\n  $ ${t("SIGNALS_EXAMPLE")}\n\n${t("SIGNALS_CHANNELS")}`)
+    .option("-l, --limit <number>", t("OPT_LIMIT_DESC"), "10")
+    .option("-a, --after <id>", t("OPT_AFTER_DESC"))
+    .option("--json", "Output raw JSON data")
+    .addHelpText("after", `\n${t("SIGNALS_LIMIT_NOTE")}`)
+    .action(async (channel, options) => {
+        if (!channel) {
+            signalsCmd.help();
+            return;
+        }
+        try {
+            const res = await signedRequest("/mcp/signals", { 
+                channelName: channel, 
+                limit: options.limit,
+                after: options.after
+            });
+            const { status, data, message } = res.data;
+
+            if (!status) {
+                logger.error(`${t("ERR_NETWORK")}: ${message}`);
+                return;
+            }
+
+            if (options.json) {
+                if (channel === "token-unlock") {
+                    const cleanData = data.map(item => {
+                        const sig = item.signals && item.signals[0];
+                        if (!sig) return item;
+                        
+                        const baseTime = new Date(item.timestamp).getTime();
+                        const tokens = [];
+                        for (const [key, value] of Object.entries(sig.details || {})) {
+                            const keyMatch = key.match(/(.+)\s*-\s*(.+)\s*\n\s*In\s+(.+)/i);
+                            if (!keyMatch) continue;
+
+                            const symbol = keyMatch[1].trim();
+                            const percent = keyMatch[2].trim();
+                            const offsetStr = keyMatch[3].trim();
+
+                            let offsetMs = 0;
+                            const timeParts = offsetStr.match(/(\d+)\s*(Day|Hour|Min)/gi);
+                            if (timeParts) {
+                                timeParts.forEach(part => {
+                                    const m = part.match(/(\d+)\s*(d|h|m)/i);
+                                    if (m) {
+                                        const v = parseInt(m[1]);
+                                        const u = m[2].toLowerCase();
+                                        if (u.startsWith("d")) offsetMs += v * 24 * 60 * 60 * 1000;
+                                        else if (u.startsWith("h")) offsetMs += v * 60 * 60 * 1000;
+                                        else if (u.startsWith("m")) offsetMs += v * 60 * 1000;
+                                    }
+                                });
+                            }
+                            const unlockTime = new Date(baseTime + offsetMs);
+                            const diff = unlockTime.getTime() - Date.now();
+                            let remaining = "Unlocked";
+                            if (diff > 0) {
+                                const rd = Math.floor(diff / (1000 * 60 * 60 * 24));
+                                const rh = Math.floor((diff / (1000 * 60 * 60)) % 24);
+                                const rm = Math.floor((diff / (1000 * 60)) % 60);
+                                remaining = `In ${rd > 0 ? `${rd}d ` : ""}${rh > 0 ? `${rh}h ` : ""}${rm}m`;
+                            }
+
+                            let mcapPercent = "";
+                            const vLines = value.replace(/```/g, "").trim().split("\n");
+                            const circulationSupply = (vLines.find(l => l.includes("🔋")) || "").replace("🔋", "").trim();
+                            const unlockingProgress = (vLines.find(l => l.includes("⌛")) || "").replace("⌛", "").trim();
+                            const unlockingAmount = (vLines.find(l => l.includes("🔑")) || "").replace("🔑", "").trim();
+                            const unlockingValueLine = vLines.find(l => l.includes("💰")) || "";
+                            const vMatch = unlockingValueLine.match(/\((.+)\)/);
+                            if (vMatch) mcapPercent = vMatch[1].replace("of M.Cap", "").trim();
+                            const unlockingValue = unlockingValueLine.replace("💰", "").replace(/\s*\(.+\)/, "").trim();
+
+                            tokens.push({
+                                symbol, percent, unlockAt: unlockTime.toISOString(), remaining,
+                                circulationSupply, unlockingProgress, unlockingAmount, unlockingValue, mcapPercent
+                            });
+                        }
+                        return { ...item, tokens, signals: undefined }; // Simplify JSON
+                    });
+                    logger.json(cleanData);
+                } else {
+                    logger.json(data);
+                }
+            } else {
+                logger.success(t("FETCH_SUCCESS", { count: data.length }));
+                data.forEach((item, index) => {
+                    const signals = (item.signals && item.signals.length > 0) ? item.signals : [{ title: item.title || item.content?.substring(0, 50) + "...", description: "", details: {} }];
+                    const lang = getLang();
+                    const date = new Date(item.timestamp).toLocaleString(lang === "zh" ? "zh-CN" : "en-US", {
+                        hour12: false, month: "2-digit", day: "2-digit", hour: "2-digit", minute: "2-digit"
+                    }).replace(/\//g, "-");
+
+                    // 打印项目头部（如果只有一个信号且标题相同，可简化，但此处为了通用性保留索引）
+                    if (channel !== "token-unlock") {
+                        console.log(`\n${chalk.bold(`[${index + 1}]`)} ${chalk.dim(`(${date})`)}`);
+                    }
+
+                    signals.forEach((sig, sigIndex) => {
+                        const title = sig.title;
+                        const desc = sig.description || "";
+                        const indent = channel === "token-unlock" ? "" : "    ";
+
+                        if (channel !== "token-unlock") {
+                            console.log(`${indent}${chalk.bold(title)}`);
+                        }
+
+                        if (channel.startsWith("breakout")) {
+                            const breakPrice = sig?.details?.BreakPrice || sig?.breakPrice || sig?.break_price;
+                            if (breakPrice) console.log(`${indent}    ${chalk.yellow(`BreakPrice: ${breakPrice}`)}`);
+                        } else if (channel.startsWith("exhaustion")) {
+                            const symbol = title.includes(" for ") ? title.split(" for ").pop()?.trim() : "";
+                            if (symbol) console.log(`${indent}    ${chalk.green(`Symbol: ${symbol}`)}`);
+                            const timeframe = sig?.details?.Timeframe || sig?.details?.timeframe;
+                            const exhaustionSide = sig?.details?.["Exhaustion Side"] || sig?.details?.exhaustion_side;
+                            if (timeframe) console.log(`${indent}    ${chalk.cyan(`Timeframe: ${timeframe}`)}`);
+                            if (exhaustionSide) console.log(`${indent}    ${chalk.magenta(`Exhaustion Side: ${exhaustionSide}`)}`);
+                        }
+                        
+                        if (channel === "token-unlock") {
+                            // Token Unlock 特有逻辑（保持原样，但适配遍历环境）
+                            if (sigIndex === 0) console.log(`\n${chalk.bold(`[${index + 1}] ${title}`)} ${chalk.dim(`(${date})`)}`);
+                            const baseTime = new Date(item.timestamp).getTime();
+                            let subIndex = 1;
+                            for (const [key, value] of Object.entries(sig.details || {})) {
+                                const keyMatch = key.match(/(.+)\s*-\s*(.+)\s*\n\s*In\s+(.+)/i);
+                                if (!keyMatch) continue;
+                                const token = keyMatch[1].trim();
+                                const percent = keyMatch[2].trim();
+                                const offsetStr = keyMatch[3].trim();
+                                let offsetMs = 0;
+                                const timeParts = offsetStr.match(/(\d+)\s*(Day|Hour|Min)/gi);
+                                if (timeParts) {
+                                    timeParts.forEach(part => {
+                                        const m = part.match(/(\d+)\s*(d|h|m)/i);
+                                        if (m) {
+                                            const v = parseInt(m[1]);
+                                            const u = m[2].toLowerCase();
+                                            if (u.startsWith("d")) offsetMs += v * 24 * 60 * 60 * 1000;
+                                            else if (u.startsWith("h")) offsetMs += v * 60 * 60 * 1000;
+                                            else if (u.startsWith("m")) offsetMs += v * 60 * 1000;
+                                        }
+                                    });
+                                }
+                                const unlockTime = new Date(baseTime + offsetMs);
+                                const diff = unlockTime.getTime() - Date.now();
+                                let remainingStr = "";
+                                if (diff <= 0) remainingStr = chalk.red("Unlocked / Ongoing");
+                                else {
+                                    const rd = Math.floor(diff / (1000 * 60 * 60 * 24));
+                                    const rh = Math.floor((diff / (1000 * 60 * 60)) % 24);
+                                    const rm = Math.floor((diff / (1000 * 60)) % 60);
+                                    remainingStr = "In " + (rd > 0 ? `${rd}d ` : "") + (rh > 0 ? `${rh}h ` : "") + `${rm}m`;
+                                }
+                                let percentOfMCap = "";
+                                const formattedValue = value.replace(/```/g, "").trim().split("\n")
+                                    .map(line => {
+                                        let l = line.trim();
+                                        if (l.includes("💰") && l.includes("(") && l.includes(")")) {
+                                            const pMatch = l.match(/\((.+)\)/);
+                                            if (pMatch) {
+                                                percentOfMCap = pMatch[1].replace("of M.Cap", "").trim();
+                                                l = l.replace(/\s*\(.+\)/, "");
+                                            }
+                                        }
+                                        l = l.replace(/🔋/g, "Circulation supply:  ")
+                                             .replace(/⌛/g, "Unlocking progress:   ")
+                                             .replace(/🔑/g, "Unlocking amount:     ")
+                                             .replace(/💰/g, "Unlocking value:      ");
+                                        return `    ${l}`;
+                                    }).join("\n");
+                                console.log(`\n    ${chalk.yellow.bold(`[${subIndex++}] Token: ${token}`)}`);
+                                console.log(`    ${chalk.dim("Unlock At:")}            ${chalk.white(unlockTime.toLocaleString(lang === "zh" ? "zh-CN" : "en-US", { hour12: false, month: "2-digit", day: "2-digit", hour: "2-digit", minute: "2-digit" }).replace(/\//g, "-"))} (${chalk.cyan(remainingStr)})`);
+                                console.log(chalk.white(formattedValue));
+                                if (percentOfMCap) console.log(`    ${chalk.white(`Percent:               ${percentOfMCap} of its Market Cap`)}`);
+                            }
+                        } else if (channel === "market-today") {
+                            // Market Today 精细清洗逻辑
+                            if (title === "Fear And Greed Index") {
+                                if (sig?.details) {
+                                    for (const [k, v] of Object.entries(sig.details)) {
+                                        console.log(`${indent}    ${chalk.cyan(`${k}:`)} ${chalk.white(v)}`);
+                                    }
+                                }
+                            } else if (sig?.details) {
+                                // 其他子信号（如果有）显示 details
+                                for (const [k, v] of Object.entries(sig.details)) {
+                                    console.log(`${indent}    ${chalk.cyan(`${k}:`)} ${chalk.white(v)}`);
+                                }
+                            }
+                        } else if (channel === "etf-tracker") {
+                            if (sig?.details) {
+                                for (const [k, v] of Object.entries(sig.details)) {
+                                    console.log(`${indent}    ${chalk.cyan(`${k}:`)} ${chalk.white(v)}`);
+                                }
+                            }
+                        }
+
+                        // 描述处理：token-unlock 已处理
+                        if (desc && channel !== "token-unlock") {
+                            const cleanDesc = desc.replace(/```/g, "").trim().split("\n").map(l => `${indent}    ${l}`).join("\n");
+                            if (cleanDesc) console.log(chalk.gray(cleanDesc));
+                        }
+
+                        // 图片/附件处理
+                        const attachments = [...(sig.image ? [sig.image] : [])];
+                        if (sigIndex === signals.length - 1 && item.attachments) {
+                            attachments.push(...item.attachments);
+                        }
+                        if (attachments.length > 0) {
+                            attachments.forEach(att => {
+                                const url = typeof att === "string" ? att : (att.url || att.proxy_url);
+                                if (url) console.log(`${indent}    ${chalk.blue.underline(url)}`);
+                            });
+                        }
+                    });
+                });
+                console.log("");
+            }
+        } catch (error) {
+            logger.error(`Signals Error: ${error.message}`);
+        }
+    });
+
+export default signalsCmd;

package/src/commands/snapshot.js

@@ -0,0 +1,82 @@
+import { Command } from "commander";
+import chalk from "chalk";
+import axios from "axios";
+import { signedRequest } from "../utils/api.js";
+import logger from "../utils/logger.js";
+import { t } from "../utils/i18n.js";
+
+const snapshotCmd = new Command("snapshot")
+    .description(t("SNAPSHOT_DESC"))
+    .argument("<symbol>", t("ARG_SYMBOL_DESC"))
+    .argument("[tf]", t("ARG_TF_DESC"), "60")
+    .option("--json", "Output raw JSON data")
+    .option("-u, --url", t("OPT_URL_DESC"))
+    .option("-b, --buffer", t("OPT_BUFFER_DESC"))
+    .addHelpText("after", `\n${t("LABEL_EXAMPLE")}\n  $ ${t("SNAPSHOT_EXAMPLE")}\n`)
+    .action(async (symbol, tf, options) => {
+        try {
+            let ticker = symbol.toUpperCase();
+            if (!ticker.startsWith("BINANCE:")) ticker = `BINANCE:${ticker}`;
+
+            // 智能选择存储模式优先级：--buffer > --url/--json > iTerm2 自动检测
+            const useLocal = (options.buffer || logger.isIterm2) && !options.json && !options.url;
+            // 如果显式指定了 --buffer，即使不是 iterm2 也尝试 local
+            const storage = (options.buffer || useLocal) ? "local" : "localurl";
+            const isBinaryMode = storage === "local";
+
+            const res = await signedRequest(
+                "/mcp/snapshot", 
+                { ticker, tf, storage }, 
+                isBinaryMode ? { responseType: "arraybuffer" } : {}
+            );
+
+            if (isBinaryMode) {
+                // 处理二进制返回
+                const contentType = res.headers["content-type"] || "";
+                if (contentType.includes("image")) {
+                    const buffer = Buffer.from(res.data);
+                    if (options.json) {
+                        logger.json({ ticker, tf, size: buffer.length, format: contentType });
+                    } else {
+                        logger.image(buffer, options.buffer); // 如果指定了 --buffer，强制渲染
+                        logger.success(t("SNAPSHOT_SUCCESS", { ticker, tf }));
+                        const tip = t("VAL_ALLOWED_KEYS").includes("键") ? "提示: 二进制模式下不显示 URL" : "Note: URL not available in binary mode";
+                        logger.info(tip);
+                    }
+                    return;
+                } else {
+                    // 可能是错误响应被转成了 buffer
+                    const result = JSON.parse(Buffer.from(res.data).toString());
+                    const errMsg = result.message || result.error || JSON.stringify(result);
+                    logger.error(`${t("ERR_NETWORK")}: ${errMsg}`);
+                    return;
+                }
+            }
+
+            // 处理常规 JSON 返回 (localurl)
+            const result = res.data;
+            const snapshotUrl = result.url || (result.data && result.data.url);
+            
+            if (snapshotUrl) {
+                if (options.json) {
+                    logger.json(result);
+                } else {
+                    logger.success(t("SNAPSHOT_SUCCESS", { ticker, tf }));
+                    console.log(chalk.cyan("URL: ") + snapshotUrl);
+                }
+                return;
+            }
+
+            if (result.status === false) {
+                const errMsg = result.message || result.error || JSON.stringify(result);
+                logger.error(`${t("ERR_NETWORK")}: ${errMsg}`);
+                return;
+            }
+
+            logger.error(`${t("ERR_NETWORK")}: ${JSON.stringify(result)}`);
+        } catch (error) {
+            logger.error(`Snapshot Error: ${error.message}`, t("SUGGESTION_KEY"));
+        }
+    });
+
+export default snapshotCmd;

package/src/index.js

@@ -0,0 +1,70 @@
+import { program } from "commander";
+import chalk from "chalk";
+import { readFileSync } from "fs";
+import { resolve } from "path";
+import configCmd from "./commands/config.js";
+import snapshotCmd from "./commands/snapshot.js";
+import newsCmd from "./commands/news.js";
+import signalsCmd from "./commands/signals.js";
+import dashboardCmd from "./commands/dashboard.js";
+import logoutCmd from "./commands/logout.js";
+import config from "./utils/config-manager.js";
+import { startOnboarding } from "./utils/onboard.js";
+import { t } from "./utils/i18n.js";
+
+const pkgPath = resolve(process.cwd(), "package.json");
+const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+
+// 极简版: 仅保留用户指定的蓝色块状 ASCII 字
+const title = chalk.blueBright.bold;
+const finalBanner = `
+${chalk.red.bold("▄▄▄      ▄▄▄             ▄▄             ▄▄   ▄▄▄▄   ▄▄             ")}
+${chalk.red.bold("████▄  ▄████        ██   ██             ██ ▄██▀▀██▄ ██             ")}
+${chalk.red.bold("███▀████▀███ ▄█▀█▄ ▀██▀▀ ████▄ ▄███▄ ▄████ ███  ███ ██ ▄████ ▄███▄ ")}
+${chalk.red.bold("███  ▀▀  ███ ██▄█▀  ██   ██ ██ ██ ██ ██ ██ ███▀▀███ ██ ██ ██ ██ ██ ")}
+${chalk.white.bold("███      ███ ▀█▄▄▄  ██   ██ ██ ▀███▀ ▀████ ███  ███ ██ ▀████ ▀███▀ ")}
+${chalk.white.bold("                                                          ██       ")}
+${chalk.white.bold("                                                        ▀▀▀        ")}
+  ${chalk.dim("Cli | v" + pkg.version)}
+`;
+
+program
+    .name("methodalgo")
+    .description(t("HELP_DESC"))
+    .version(pkg.version)
+    .showHelpAfterError();
+
+program.addCommand(configCmd.description(t("CONFIG_DESC")));
+program.addCommand(snapshotCmd.description(t("SNAPSHOT_DESC")));
+program.addCommand(newsCmd.description(t("NEWS_DESC")));
+program.addCommand(signalsCmd.description(t("SIGNALS_DESC")));
+program.addCommand(dashboardCmd.description(t("DASHBOARD_DESC")));
+program.addCommand(logoutCmd);
+
+// 确保所有层级的指令（包括嵌套子指令）在参数缺失/报错时也显示帮助信息
+function applyShowHelp(cmd) {
+    cmd.showHelpAfterError();
+    cmd.commands.forEach(applyShowHelp);
+}
+applyShowHelp(program);
+
+program.on("command:*", () => {
+    console.error(`无效的命令: ${program.args.join(" ")}\n使用 "methodalgo --help" 查看可用命令。`);
+    process.exit(1);
+});
+
+async function main() {
+    // 检查是否需要引导 (无 API Key 则引导)
+    if (!config.get("apiKey") && !process.argv.includes("config") && !process.argv.includes("--help") && !process.argv.includes("-h")) {
+        await startOnboarding(finalBanner);
+    }
+    
+    if (process.argv.length <= 2) {
+        process.stdout.write(finalBanner + "\n");
+        program.help();
+    }
+
+    await program.parseAsync(process.argv);
+}
+
+main();

package/src/utils/api.js

@@ -0,0 +1,108 @@
+import crypto from "crypto";
+import config from "./config-manager.js";
+import { t } from "./i18n.js";
+
+const SALT = "methodalgoMcpSALT";
+
+/**
+ * 带有 HMAC 签名的安全请求函数 (迁移自原 core.js)
+ * 使用原生 fetch 以获得更好的跨平台兼容性 (Node 18+, Bun)
+ */
+export async function signedRequest(endpoint, params = {}, extraOptions = {}) {
+    const apiKey = process.env.METHODALGO_API_KEY || config.get("apiKey");
+    const apiBase = config.get("apiBase");
+
+    if (!apiKey) {
+        throw new Error(t("ERR_MISSING_KEY"));
+    }
+
+    const timestamp = Date.now().toString();
+
+    // 过滤并排序参数
+    const cleanParams = Object.fromEntries(
+        Object.entries(params).filter(([_, v]) => v !== undefined && v !== null)
+    );
+    const urlObj = new URL(`${apiBase}${endpoint}`);
+    Object.entries(cleanParams).forEach(([k, v]) => urlObj.searchParams.append(k, v));
+
+    const sortedKeys = Object.keys(cleanParams).sort();
+    const sortedParams = sortedKeys.map(key => `${key}=${encodeURIComponent(cleanParams[key])}`).join("&");
+
+    const signature = crypto.createHmac("sha256", apiKey + SALT)
+        .update(sortedParams)
+        .digest("hex");
+
+    const response = await fetch(urlObj.toString(), {
+        method: "GET",
+        headers: {
+            "x-mcp-signature": signature,
+            "x-mcp-timestamp": timestamp,
+            "Authorization": `Bearer ${apiKey}`,
+            "Accept": "application/json",
+            ...extraOptions.headers
+        },
+        signal: extraOptions.signal,
+    });
+
+    if (!response.ok) {
+        let serverMsg = "";
+        try {
+            const errorData = await response.json();
+            serverMsg = errorData.msg || errorData.message || "";
+        } catch (_) {}
+        const error = new Error(serverMsg || `Request failed with status ${response.status}`);
+        error.status = response.status;
+        throw error;
+    }
+
+    if (extraOptions.responseType === "arraybuffer") {
+        const data = await response.arrayBuffer();
+        return { data, headers: Object.fromEntries(response.headers.entries()) };
+    }
+
+    const data = await response.json();
+    return { data, headers: Object.fromEntries(response.headers.entries()) };
+}
+
+/**
+ * 验证 API Key 是否有效 (拉取 1 条新闻测试)
+ */
+export async function validateApiKey(apiKey) {
+    if (!apiKey) return false;
+    const apiBase = config.get("apiBase");
+    const endpoint = "/mcp/news";
+    const timestamp = Date.now().toString();
+
+    // 构造签名
+    const sortedParams = "limit=1&type=news";
+    const signature = crypto.createHmac("sha256", apiKey + SALT)
+        .update(sortedParams)
+        .digest("hex");
+
+    const urlObj = new URL(`${apiBase}${endpoint}`);
+    urlObj.searchParams.append("type", "news");
+    urlObj.searchParams.append("limit", "1");
+
+    try {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), 5000);
+
+        const response = await fetch(urlObj.toString(), {
+            method: "GET",
+            headers: {
+                "x-mcp-signature": signature,
+                "x-mcp-timestamp": timestamp,
+                "Authorization": `Bearer ${apiKey}`,
+                "Accept": "application/json"
+            },
+            signal: controller.signal
+        });
+        clearTimeout(timeoutId);
+
+        if (!response.ok) return false;
+        const data = await response.json();
+        return data.status === true;
+    } catch (err) {
+        return false;
+    }
+}

package/src/utils/config-manager.js

@@ -0,0 +1,23 @@
+import Conf from "conf";
+
+const schema = {
+    apiKey: {
+        type: "string",
+        default: ""
+    },
+    apiBase: {
+        type: "string",
+        default: "https://mm.methodalgo.com"
+    },
+    lang: {
+        type: "string",
+        default: "en"
+    }
+};
+
+const config = new Conf({
+    projectName: "methodalgo",
+    schema
+});
+
+export default config;