ym-mcp-wangyi 0.1.0

package/dist/lib/cdp.js

@@ -0,0 +1,244 @@
+import { spawn, spawnSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { installCandidates } from "./paths.js";
+import { isInstalled, isRunning } from "./process.js";
+import { ToolError } from "./errors.js";
+export const DEFAULT_CDP_PORT = Number(process.env.WANGYI_CDP_PORT || 9223);
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+export async function cdpListTargets(port = DEFAULT_CDP_PORT) {
+    const urls = [`http://127.0.0.1:${port}/json/list`, `http://127.0.0.1:${port}/json`];
+    for (const url of urls) {
+        try {
+            const res = await fetch(url, { signal: AbortSignal.timeout(1500) });
+            if (!res.ok)
+                continue;
+            const data = (await res.json());
+            if (Array.isArray(data))
+                return data;
+        }
+        catch {
+            // try next
+        }
+    }
+    return [];
+}
+export async function findOrpheusPage(port = DEFAULT_CDP_PORT) {
+    const targets = await cdpListTargets(port);
+    const pages = targets.filter((t) => t.type === "page" && t.webSocketDebuggerUrl);
+    return (pages.find((t) => String(t.url || "").startsWith("orpheus://orpheus/app.html")) ||
+        pages.find((t) => String(t.url || "").startsWith("orpheus://")) ||
+        pages[0] ||
+        null);
+}
+export async function isCdpReady(port = DEFAULT_CDP_PORT) {
+    return Boolean(await findOrpheusPage(port));
+}
+export async function cdpEvaluate(expression, awaitPromise = false, port = DEFAULT_CDP_PORT) {
+    const target = await findOrpheusPage(port);
+    if (!target?.webSocketDebuggerUrl) {
+        throw new ToolError("CDP_UNAVAILABLE", "网易云未开启本地控制通道（CDP）", `请先执行: node dist/index.js launch\n会以 --remote-debugging-port=${port} 重启客户端，之后 play/next/prev 才能真正控制播放`);
+    }
+    const ws = new WebSocket(target.webSocketDebuggerUrl);
+    try {
+        await new Promise((resolve, reject) => {
+            const timer = setTimeout(() => reject(new Error("CDP websocket timeout")), 8000);
+            ws.addEventListener("open", () => {
+                clearTimeout(timer);
+                resolve();
+            });
+            ws.addEventListener("error", () => {
+                clearTimeout(timer);
+                reject(new Error("CDP websocket error"));
+            });
+        });
+        const id = 1;
+        const payload = JSON.stringify({
+            id,
+            method: "Runtime.evaluate",
+            params: { expression, returnByValue: true, awaitPromise },
+        });
+        const response = await new Promise((resolve, reject) => {
+            const timer = setTimeout(() => reject(new Error("CDP evaluate timeout")), 15000);
+            ws.addEventListener("message", (event) => {
+                try {
+                    const msg = JSON.parse(String(event.data));
+                    if (msg.id !== id)
+                        return;
+                    clearTimeout(timer);
+                    resolve(msg);
+                }
+                catch (err) {
+                    clearTimeout(timer);
+                    reject(err);
+                }
+            });
+            ws.send(payload);
+        });
+        const result = response.result || {};
+        if (result.exceptionDetails) {
+            const detail = result.exceptionDetails.exception?.description ||
+                result.exceptionDetails.text ||
+                "Unknown JavaScript error";
+            throw new ToolError("CDP_ERROR", `客户端控制失败: ${detail}`);
+        }
+        return result.result?.value;
+    }
+    finally {
+        try {
+            ws.close();
+        }
+        catch {
+            // ignore
+        }
+    }
+}
+const BOOTSTRAP = `
+(() => {
+  if (!window.__wymReq) {
+    const id = Date.now();
+    if (typeof webpackJsonp === "undefined") return false;
+    webpackJsonp.push([[id], { [id]: function(m, e, r) { window.__wymReq = r; } }, [[id]]]);
+  }
+  return Boolean(window.__wymReq);
+})()
+`;
+const FIND_STORE = `
+(() => {
+  if (!window.__wymReq) return null;
+  if (window.__wymStoreId != null) return window.__wymStoreId;
+  const req = window.__wymReq;
+  for (let i = 0; i < 400; i++) {
+    try {
+      const mod = req(i);
+      if (mod && mod.a && typeof mod.a.getStore === "function" && typeof mod.a.getDispatch === "function") {
+        window.__wymStoreId = i;
+        return i;
+      }
+    } catch (e) {}
+  }
+  return null;
+})()
+`;
+export async function bootstrapClientRuntime() {
+    const ok = await cdpEvaluate(BOOTSTRAP);
+    if (!ok) {
+        throw new ToolError("CDP_ERROR", "无法注入网易云客户端运行时（webpackJsonp 不可用）");
+    }
+    const storeId = await cdpEvaluate(FIND_STORE);
+    if (typeof storeId !== "number") {
+        throw new ToolError("CDP_ERROR", "找不到客户端 Store 模块，可能版本不兼容");
+    }
+    return { storeId };
+}
+export async function cdpPlayerState() {
+    await bootstrapClientRuntime();
+    const value = await cdpEvaluate(`
+(() => {
+  const s = window.__wymReq(window.__wymStoreId).a.getStore();
+  const playing = s.playing || {};
+  const list = (s.playingList && s.playingList.curPlayingList) || [];
+  const cur = playing.curPlaying || {};
+  return {
+    songId: String(cur.resourceId || ""),
+    title: String((cur.track || {}).name || ""),
+    playing: playing.playingState === 2,
+    queue: list.map((x) => ({
+      id: String(x.resourceId || ""),
+      title: String((x.track || {}).name || ""),
+    })),
+  };
+})()
+`);
+    return value;
+}
+export async function cdpSkip(delta) {
+    await bootstrapClientRuntime();
+    const ok = await cdpEvaluate(`
+(() => {
+  const dispatch = window.__wymReq(window.__wymStoreId).a.getDispatch();
+  dispatch({
+    type: "playingList/jump2Track",
+    payload: { flag: ${delta}, type: "call", triggerScene: "minibarController" }
+  });
+  return true;
+})()
+`);
+    if (ok !== true)
+        throw new ToolError("CDP_ERROR", "切歌指令失败");
+}
+function resolveExecutable() {
+    const found = installCandidates().find((p) => existsSync(p)) || null;
+    if (!found)
+        return null;
+    if (process.platform === "darwin" && found.endsWith(".app")) {
+        const binary = join(found, "Contents", "MacOS", "NeteaseMusic");
+        return existsSync(binary) ? binary : found;
+    }
+    return found;
+}
+function quitClient() {
+    if (process.platform === "darwin") {
+        spawnSync("osascript", ["-e", 'tell application "NeteaseMusic" to quit'], {
+            timeout: 10000,
+            stdio: "ignore",
+        });
+    }
+    else if (process.platform === "win32") {
+        spawnSync("taskkill", ["/IM", "cloudmusic.exe", "/F"], {
+            timeout: 10000,
+            stdio: "ignore",
+            windowsHide: true,
+        });
+    }
+    const start = Date.now();
+    while (Date.now() - start < 10000) {
+        if (!isRunning())
+            return;
+        spawnSync(process.platform === "win32" ? "timeout" : "sleep", process.platform === "win32" ? ["/t", "1"] : ["0.2"], {
+            stdio: "ignore",
+            windowsHide: true,
+        });
+    }
+}
+export async function launchWithCdp(port = DEFAULT_CDP_PORT) {
+    if (!isInstalled()) {
+        throw new ToolError("NOT_INSTALLED", "未找到网易云音乐客户端");
+    }
+    if (await isCdpReady(port)) {
+        return {
+            ok: true,
+            port,
+            relaunched: false,
+            message: `控制通道已就绪（127.0.0.1:${port}）`,
+        };
+    }
+    const exe = resolveExecutable();
+    if (!exe) {
+        throw new ToolError("NOT_INSTALLED", "找不到可执行文件，无法带 CDP 启动");
+    }
+    const wasRunning = isRunning();
+    if (wasRunning)
+        quitClient();
+    // `open -a App --args` often drops CEF flags on macOS; spawn the binary directly.
+    spawn(exe, [`--remote-debugging-address=127.0.0.1`, `--remote-debugging-port=${port}`, "--remote-allow-origins=*"], {
+        detached: true,
+        stdio: "ignore",
+    }).unref();
+    for (let i = 0; i < 60; i++) {
+        if (await isCdpReady(port)) {
+            return {
+                ok: true,
+                port,
+                relaunched: true,
+                message: wasRunning
+                    ? `已重启网易云并开启控制通道（127.0.0.1:${port}）`
+                    : `已启动网易云控制通道（127.0.0.1:${port}）`,
+            };
+        }
+        await sleep(250);
+    }
+    throw new ToolError("CDP_UNAVAILABLE", "启动后仍未检测到 CDP 控制通道", `请手动退出网易云后执行: node dist/index.js launch`);
+}

package/dist/lib/cookies.js

@@ -0,0 +1,313 @@
+import { copyFileSync, existsSync, mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { createDecipheriv, pbkdf2Sync } from "node:crypto";
+import { execFileSync } from "node:child_process";
+import { tmpdir } from "node:os";
+import { createRequire } from "node:module";
+import { dirname, join } from "node:path";
+import { cookieDbPath, localStatePath, mmkvPath, storageDir } from "./paths.js";
+import { readMmkvEntries, stripToBplist } from "./mmkv.js";
+import { nsDictionary, parseKeyedArchive, resolveUid } from "./bplist.js";
+import { ToolError } from "./errors.js";
+const require = createRequire(import.meta.url);
+const COOKIE_NAMES = ["MUSIC_U", "MUSIC_A_T", "MUSIC_R_T", "MUSIC_R_U", "NMTID", "__csrf"];
+const AUTH_NAMES = new Set(["MUSIC_U", "MUSIC_A_T", "MUSIC_R_T", "MUSIC_R_U"]);
+function isNeteaseHost(value) {
+    if (typeof value !== "string")
+        return false;
+    const host = value.trim().toLowerCase().replace(/^\./, "");
+    return host === "music.163.com" || host.endsWith(".music.163.com") || host === "163.com" || host.endsWith(".163.com");
+}
+function readMmkvCookies(filePath) {
+    const entries = readMmkvEntries(filePath);
+    const cookies = {};
+    let userId = "";
+    const userRaw = entries.get("userInfo");
+    if (userRaw) {
+        try {
+            const { objects, root } = parseKeyedArchive(stripToBplist(userRaw));
+            const uid = root.userId;
+            if (typeof uid === "string" || typeof uid === "number")
+                userId = String(uid);
+            const musicU = root.musicU;
+            if (typeof musicU === "string" && musicU)
+                cookies.MUSIC_U = musicU;
+        }
+        catch {
+            // ignore malformed userInfo
+        }
+    }
+    const cookieRaw = entries.get("cookie");
+    if (cookieRaw) {
+        const { objects, root } = parseKeyedArchive(stripToBplist(cookieRaw));
+        const selected = {};
+        for (const [domain, cookieMapRef] of Object.entries(root)) {
+            if (!isNeteaseHost(domain))
+                continue;
+            const cookieMap = nsDictionary(objects, cookieMapRef);
+            for (const cookieRef of Object.values(cookieMap)) {
+                const cookieObj = resolveUid(objects, cookieRef);
+                if (!cookieObj || typeof cookieObj !== "object" || Array.isArray(cookieObj))
+                    continue;
+                const propsRef = cookieObj.properties;
+                if (propsRef == null)
+                    continue;
+                const props = nsDictionary(objects, propsRef);
+                const name = props.Name;
+                const value = props.Value;
+                const cookieDomain = props.Domain ?? domain;
+                if (typeof name !== "string" || !COOKIE_NAMES.includes(name))
+                    continue;
+                if (typeof value !== "string" || !value || !isNeteaseHost(cookieDomain))
+                    continue;
+                const normalized = String(cookieDomain).trim().toLowerCase().replace(/^\./, "");
+                const rank = normalized === "music.163.com" ? 0 : 1;
+                const prev = selected[name];
+                if (!prev || rank < prev.rank)
+                    selected[name] = { rank, value };
+            }
+        }
+        for (const [name, { value }] of Object.entries(selected))
+            cookies[name] = value;
+    }
+    return { cookies, userId };
+}
+function queryCookies(dbPath) {
+    const { DatabaseSync } = require("node:sqlite");
+    const db = new DatabaseSync(dbPath, { readOnly: true });
+    try {
+        return db
+            .prepare(`select name, value, encrypted_value, host_key from cookies
+         where host_key like '%163.com%' or host_key like '%netease%'`)
+            .all();
+    }
+    finally {
+        db.close();
+    }
+}
+function copyCookieDb() {
+    const dbPath = cookieDbPath();
+    if (!existsSync(dbPath))
+        return null;
+    const dir = mkdtempSync(join(tmpdir(), "ym-mcp-wangyi-cookies-"));
+    const db = join(dir, "Cookies");
+    copyFileSync(dbPath, db);
+    for (const extra of ["Cookies-wal", "Cookies-shm", "Cookies-journal"]) {
+        const src = join(dirname(dbPath), extra);
+        if (existsSync(src))
+            copyFileSync(src, join(dir, extra));
+    }
+    return { dir, db };
+}
+function blobOf(value) {
+    if (!value)
+        return null;
+    if (typeof value === "string")
+        return value ? Buffer.from(value) : null;
+    if (value.length === 0)
+        return null;
+    return Buffer.from(value);
+}
+function dpapiUnprotect(buf) {
+    const b64 = buf.toString("base64");
+    const script = `
+Add-Type -AssemblyName System.Security
+$enc = [Convert]::FromBase64String('${b64}')
+$dec = [System.Security.Cryptography.ProtectedData]::Unprotect($enc, $null, [System.Security.Cryptography.DataProtectionScope]::CurrentUser)
+[Convert]::ToBase64String($dec)
+`.trim();
+    try {
+        const encoded = Buffer.from(script, "utf16le").toString("base64");
+        const out = execFileSync("powershell.exe", ["-NoProfile", "-NonInteractive", "-EncodedCommand", encoded], { encoding: "utf8", timeout: 15000, windowsHide: true });
+        return Buffer.from(out.trim(), "base64");
+    }
+    catch {
+        return null;
+    }
+}
+function windowsOsCryptKey() {
+    const file = localStatePath();
+    if (!existsSync(file)) {
+        // also try parent CEFCache Local State / storage Local State
+        const alt = join(storageDir(), "Local State");
+        if (!existsSync(alt))
+            return null;
+    }
+    const path = existsSync(localStatePath()) ? localStatePath() : join(storageDir(), "Local State");
+    try {
+        const json = JSON.parse(readFileSync(path, "utf8"));
+        const raw = json.os_crypt?.encrypted_key;
+        if (!raw)
+            return null;
+        const buf = Buffer.from(raw, "base64");
+        if (buf.subarray(0, 5).toString("ascii") !== "DPAPI")
+            return null;
+        const key = dpapiUnprotect(buf.subarray(5));
+        return key && key.length === 32 ? key : null;
+    }
+    catch {
+        return null;
+    }
+}
+function decryptChromiumGcm(enc, key) {
+    const prefix = enc.subarray(0, 3).toString("ascii");
+    if (prefix !== "v10" && prefix !== "v11")
+        return "";
+    if (enc.length < 3 + 12 + 16)
+        return "";
+    const nonce = enc.subarray(3, 15);
+    const tag = enc.subarray(enc.length - 16);
+    const data = enc.subarray(15, enc.length - 16);
+    try {
+        const decipher = createDecipheriv("aes-256-gcm", key, nonce);
+        decipher.setAuthTag(tag);
+        return Buffer.concat([decipher.update(data), decipher.final()]).toString("utf8");
+    }
+    catch {
+        return "";
+    }
+}
+function macKeychainKey() {
+    for (const [account, service] of [
+        ["Chromium", "Chromium Safe Storage"],
+        ["Chrome", "Chrome Safe Storage"],
+        ["Chromium", "Chrome Safe Storage"],
+    ]) {
+        try {
+            const secret = execFileSync("/usr/bin/security", ["find-generic-password", "-a", account, "-s", service, "-w"], { encoding: "utf8", timeout: 10000 }).trim();
+            if (secret)
+                return pbkdf2Sync(secret, "saltysalt", 1003, 16, "sha1");
+        }
+        catch {
+            // try next
+        }
+    }
+    return null;
+}
+function decryptMacCbc(enc, key) {
+    if (!enc.subarray(0, 3).equals(Buffer.from("v10")) || enc.length <= 3)
+        return "";
+    try {
+        const decipher = createDecipheriv("aes-128-cbc", key, Buffer.alloc(16, 0x20));
+        const plain = Buffer.concat([decipher.update(enc.subarray(3)), decipher.final()]);
+        const pad = plain[plain.length - 1];
+        if (pad > 0 && pad <= 16)
+            return plain.subarray(0, plain.length - pad).toString("utf8");
+        return plain.toString("utf8");
+    }
+    catch {
+        return "";
+    }
+}
+function readCefCookies() {
+    const copied = copyCookieDb();
+    if (!copied)
+        return { cookies: {}, encrypted: false };
+    let rows = [];
+    try {
+        try {
+            rows = queryCookies(copied.db);
+        }
+        catch {
+            try {
+                rows = queryCookies(cookieDbPath());
+            }
+            catch {
+                rows = [];
+            }
+        }
+    }
+    finally {
+        rmSync(copied.dir, { recursive: true, force: true });
+    }
+    const osCryptKey = process.platform === "win32" ? windowsOsCryptKey() : null;
+    const macKey = process.platform === "darwin" ? macKeychainKey() : null;
+    const cookies = {};
+    let encrypted = false;
+    for (const row of rows) {
+        if (!COOKIE_NAMES.includes(row.name))
+            continue;
+        if (cookies[row.name])
+            continue;
+        if (row.value) {
+            cookies[row.name] = row.value;
+            continue;
+        }
+        const enc = blobOf(row.encrypted_value);
+        if (!enc)
+            continue;
+        let plain = "";
+        if (osCryptKey)
+            plain = decryptChromiumGcm(enc, osCryptKey);
+        else if (macKey)
+            plain = decryptMacCbc(enc, macKey);
+        if (plain)
+            cookies[row.name] = plain;
+        else
+            encrypted = true;
+    }
+    return { cookies, encrypted };
+}
+function buildHeader(cookies) {
+    return COOKIE_NAMES.filter((n) => cookies[n])
+        .map((n) => `${n}=${cookies[n]}`)
+        .join("; ");
+}
+function isLoggedIn(cookies, userId) {
+    if ([...AUTH_NAMES].some((n) => Boolean(cookies[n])))
+        return true;
+    return Boolean(userId && userId !== "0" && userId !== "-1");
+}
+export function loadCookies() {
+    const empty = {
+        header: "",
+        loggedIn: false,
+        cookieEncrypted: false,
+        source: "",
+        userId: "",
+    };
+    if (existsSync(mmkvPath())) {
+        try {
+            const { cookies, userId } = readMmkvCookies(mmkvPath());
+            const header = buildHeader(cookies);
+            if (header || userId) {
+                return {
+                    header,
+                    loggedIn: isLoggedIn(cookies, userId),
+                    cookieEncrypted: false,
+                    source: "mmkv",
+                    userId,
+                };
+            }
+        }
+        catch {
+            // fall through to CEF
+        }
+    }
+    try {
+        const { cookies, encrypted } = readCefCookies();
+        const header = buildHeader(cookies);
+        return {
+            header,
+            loggedIn: isLoggedIn(cookies, ""),
+            cookieEncrypted: encrypted && !isLoggedIn(cookies, ""),
+            source: header ? "cef" : "",
+            userId: "",
+        };
+    }
+    catch {
+        return empty;
+    }
+}
+export function requireCookieHeader() {
+    const cookies = loadCookies();
+    if (cookies.loggedIn && cookies.header.includes("MUSIC_U="))
+        return cookies.header;
+    if (cookies.loggedIn && cookies.header)
+        return cookies.header;
+    if (cookies.cookieEncrypted) {
+        throw new ToolError("COOKIE_ENCRYPTED", "Cookie 只有密文，无法得到 MUSIC_U", process.platform === "win32"
+            ? "Windows 上已尝试用 Local State + DPAPI 解密。请确认已用当前 Windows 用户登录网易云音乐。"
+            : "请先在网易云音乐客户端登录。可先关闭客户端再重试读取 MMKV。");
+    }
+    throw new ToolError("NOT_LOGGED_IN", "未读到网易云登录态（MUSIC_U）", `先打开客户端登录。存储目录：${storageDir()}`);
+}

package/dist/lib/errors.js

@@ -0,0 +1,19 @@
+export class ToolError extends Error {
+    code;
+    hint;
+    constructor(code, message, hint = "") {
+        super(message);
+        this.name = "ToolError";
+        this.code = code;
+        this.hint = hint;
+    }
+    toJSON() {
+        return { ok: false, code: this.code, error: this.message, hint: this.hint };
+    }
+}
+export function asToolError(err, fallback = "INTERNAL") {
+    if (err instanceof ToolError)
+        return err;
+    const message = err instanceof Error ? err.message : String(err);
+    return new ToolError(fallback, message);
+}

package/dist/lib/last-play.js

@@ -0,0 +1,33 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+function stateDir() {
+    if (process.platform === "win32") {
+        const base = process.env.LOCALAPPDATA || join(homedir(), "AppData", "Local");
+        return join(base, "ym-mcp-wangyi");
+    }
+    return join(homedir(), ".cache", "ym-mcp-wangyi");
+}
+function statePath() {
+    return join(stateDir(), "last-play.json");
+}
+export function readLastPlay() {
+    const file = statePath();
+    if (!existsSync(file))
+        return null;
+    try {
+        const data = JSON.parse(readFileSync(file, "utf8"));
+        if (!data?.id)
+            return null;
+        return data;
+    }
+    catch {
+        return null;
+    }
+}
+export function writeLastPlay(id) {
+    const dir = stateDir();
+    mkdirSync(dir, { recursive: true });
+    const payload = { id: String(id), at: Date.now() };
+    writeFileSync(statePath(), JSON.stringify(payload), "utf8");
+}

package/dist/lib/mmkv.js

@@ -0,0 +1,63 @@
+import { readFileSync } from "node:fs";
+function readVarint(payload, position) {
+    let value = 0;
+    for (let shift = 0; shift < 35; shift += 7) {
+        if (position >= payload.length)
+            throw new Error("mmkv truncated");
+        const byte = payload[position++];
+        value |= (byte & 0x7f) << shift;
+        if (!(byte & 0x80))
+            return { value, position };
+    }
+    throw new Error("mmkv varint overflow");
+}
+/** Read key/value entries from an MMKV data file (plain, not encrypted). */
+export function readMmkvEntries(filePath) {
+    const payload = readFileSync(filePath);
+    const entries = new Map();
+    // NetEase stores a 4-byte actual-size then 4-byte unused; entries start at offset 8.
+    let position = 8;
+    while (position < payload.length && payload[position] !== 0) {
+        let keyLength;
+        try {
+            ({ value: keyLength, position } = readVarint(payload, position));
+        }
+        catch {
+            break;
+        }
+        if (keyLength <= 0 || keyLength > 512 || position + keyLength > payload.length)
+            break;
+        const keyBytes = payload.subarray(position, position + keyLength);
+        position += keyLength;
+        let key;
+        try {
+            key = keyBytes.toString("utf8");
+        }
+        catch {
+            break;
+        }
+        if (!key || /[\x00-\x08]/.test(key))
+            break;
+        let valueLength;
+        try {
+            ({ value: valueLength, position } = readVarint(payload, position));
+        }
+        catch {
+            break;
+        }
+        if (valueLength < 0 || valueLength > 5_000_000 || position + valueLength > payload.length)
+            break;
+        entries.set(key, Buffer.from(payload.subarray(position, position + valueLength)));
+        position += valueLength;
+    }
+    return entries;
+}
+/** Strip MMKV value prefix so the remaining buffer starts at bplist00. */
+export function stripToBplist(raw) {
+    if (raw.subarray(0, 8).toString("ascii") === "bplist00")
+        return raw;
+    const idx = raw.indexOf("bplist00", 0, "ascii");
+    if (idx < 0)
+        throw new Error("no bplist in mmkv value");
+    return raw.subarray(idx);
+}