dsh-sidebar-media-player 0.2.0 → 0.2.5
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/CHANGELOG.md +30 -0
- package/README.md +5 -0
- package/icon.svg +5 -0
- package/lib/client.js +7375 -176
- package/lib/index.js +1503 -11
- package/lib/qq.js +1013 -0
- package/lib/qrc.js +409 -0
- package/locale/en.json +7 -0
- package/locale/zh.json +7 -0
- package/package.json +14 -6
package/lib/index.js
CHANGED
|
@@ -23,15 +23,43 @@
|
|
|
23
23
|
* 注意:本文件是宿主半边,改动后必须**彻底退出 DSH 客户端再启动**才生效
|
|
24
24
|
* (宿主是 Node 进程,没有热重载)。
|
|
25
25
|
*/
|
|
26
|
-
import { createReadStream } from 'node:fs'
|
|
27
|
-
import { readFile, stat } from 'node:fs/promises'
|
|
28
|
-
import {
|
|
26
|
+
import { createReadStream, existsSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSync } from 'node:fs'
|
|
27
|
+
import { lstat, readFile, readdir, stat } from 'node:fs/promises'
|
|
28
|
+
import { homedir } from 'node:os'
|
|
29
|
+
import { Readable } from 'node:stream'
|
|
30
|
+
import { basename, dirname, extname, join, parse as parsePath, resolve } from 'node:path'
|
|
31
|
+
// 在线 QQ 音乐底层(扫码登录 / 取链 / 歌词)。原样拷入本目录,MIT,来自 dsh-music-player v1.0.4。
|
|
32
|
+
import * as QQ from './qq.js'
|
|
33
|
+
import { decryptHex as qrcDecryptHex, parseQrc as qrcParse } from './qrc.js'
|
|
34
|
+
import { spawn } from 'node:child_process'
|
|
35
|
+
|
|
36
|
+
/**
|
|
37
|
+
* 找本机 Chromium 系浏览器(Edge 优先,其次 Chrome)。
|
|
38
|
+
* 「免费时长」自动化外壳要靠它开 --app 窗口;找不到返回空串,路由会明确报错。
|
|
39
|
+
*/
|
|
40
|
+
function findBrowserExecutable() {
|
|
41
|
+
const pf = process.env.ProgramFiles || 'C:\\Program Files'
|
|
42
|
+
const pf86 = process.env['ProgramFiles(x86)'] || 'C:\\Program Files (x86)'
|
|
43
|
+
const cands = [
|
|
44
|
+
join(pf86, 'Microsoft', 'Edge', 'Application', 'msedge.exe'),
|
|
45
|
+
join(pf, 'Microsoft', 'Edge', 'Application', 'msedge.exe'),
|
|
46
|
+
join(pf, 'Google', 'Chrome', 'Application', 'chrome.exe'),
|
|
47
|
+
join(pf86, 'Google', 'Chrome', 'Application', 'chrome.exe')
|
|
48
|
+
]
|
|
49
|
+
for (const p of cands) {
|
|
50
|
+
try { if (existsSync(p)) return p } catch { /* 忽略单条探测失败 */ }
|
|
51
|
+
}
|
|
52
|
+
return ''
|
|
53
|
+
}
|
|
29
54
|
|
|
30
55
|
/** Plugin identity — 必须与 package.json 的 name 一致,client bundle 靠它对上号。 */
|
|
31
56
|
export const name = 'dsh-sidebar-media-player'
|
|
32
57
|
|
|
33
|
-
/** 挂载前需要就绪的服务:web 服务器 + 会话存储(取权威 cwd
|
|
34
|
-
|
|
58
|
+
/** 挂载前需要就绪的服务:web 服务器 + 会话存储(取权威 cwd)。
|
|
59
|
+
* webRuntime 不再是硬依赖:trustedHosts 仅用于放行「非 loopback 的 Host」;
|
|
60
|
+
* 桌面端全部走 127.0.0.1(loopback),无 webRuntime 时 trustedHosts 兜底为空数组,
|
|
61
|
+
* isTrustedApiRequest 仍会放行 loopback,故从 inject 移除该服务,卸载 dsh-web-runtime-shim 后本插件照常挂载。 */
|
|
62
|
+
export const inject = ['webServer', 'sessions']
|
|
35
63
|
|
|
36
64
|
/** 本插件独占的路由前缀(避免与别的插件撞车)。 */
|
|
37
65
|
const ROUTE_PREFIX = '/dsh-sidebar-media-player'
|
|
@@ -44,6 +72,14 @@ const LYRIC_PATH = `${ROUTE_PREFIX}/lyric`
|
|
|
44
72
|
|
|
45
73
|
/** 字幕端点(同目录同名 .vtt/.srt/.ass,统一转 VTT 回纯文本)。 */
|
|
46
74
|
const SUBTITLE_PATH = `${ROUTE_PREFIX}/subtitle`
|
|
75
|
+
/** 曲库扫描(本地音乐页):GET /library?dir=<绝对路径>&depth=<n>,只读。 */
|
|
76
|
+
const LIBRARY_PATH = `${ROUTE_PREFIX}/library`
|
|
77
|
+
const DIR_PATH = `${ROUTE_PREFIX}/dir`
|
|
78
|
+
|
|
79
|
+
/** 时长解析端点(本地 mp3/flac 头解析):GET /duration?path=<绝对路径>[&cwd=][&sessionId=]。
|
|
80
|
+
* 为什么放在宿主:桌面端媒体走自定义协议 / 代理流时,<audio>.duration 常是 Infinity 或 0,
|
|
81
|
+
* 本地文件又没有元数据,客户端只能显示 0:00。在宿主读容器头算一次,客户端缓存进 durMeta。 */
|
|
82
|
+
const DURATION_PATH = `${ROUTE_PREFIX}/duration`
|
|
47
83
|
|
|
48
84
|
/**
|
|
49
85
|
* 允许服务的扩展名 → Content-Type。
|
|
@@ -193,6 +229,128 @@ function sessionCwdOf(ctx, sessionId, clientCwd) {
|
|
|
193
229
|
return process.cwd()
|
|
194
230
|
}
|
|
195
231
|
|
|
232
|
+
/** 取本次请求的会话基准目录(/library 与 /dir 共用)。 */
|
|
233
|
+
function sessionBaseOf(url, ctx) {
|
|
234
|
+
const cwdParam = url.searchParams.get('cwd') ?? undefined
|
|
235
|
+
const sessionId = url.searchParams.get('sessionId')
|
|
236
|
+
if (
|
|
237
|
+
sessionId !== null && sessionId !== ''
|
|
238
|
+
&& ctx.sessions !== undefined && typeof ctx.sessions.get === 'function'
|
|
239
|
+
&& ctx.sessions.get(sessionId) !== undefined
|
|
240
|
+
) {
|
|
241
|
+
return sessionCwdOf(ctx, sessionId, cwdParam)
|
|
242
|
+
}
|
|
243
|
+
if (cwdParam !== undefined && cwdParam !== '') {
|
|
244
|
+
try { return resolve(cwdParam) } catch { throw new MediaError('bad-request', `invalid working directory "${cwdParam}"`) }
|
|
245
|
+
}
|
|
246
|
+
return process.cwd()
|
|
247
|
+
}
|
|
248
|
+
|
|
249
|
+
// ── 允许访问的根目录(多根围栏)─────────────────────────────────────────────
|
|
250
|
+
// 播放器要能直接播音乐库里的歌,但音乐库不在会话 cwd 之下。
|
|
251
|
+
// 这里把「允许的根」从单一会话 cwd 扩展成一份可信根名单:
|
|
252
|
+
// 1) 会话 cwd(session.header.cwd / 客户端 cwd 参数 / process.cwd())
|
|
253
|
+
// 2) 音乐播放器的音乐库 root(~/.dsh/music-player-state.json 的 root 字段,
|
|
254
|
+
// 运行时可能被改写,所以每次请求都重新读,只做 1 秒 TTL 缓存)
|
|
255
|
+
// 3) 播放器自己的默认音乐目录 ~/Music(未设置 root 时的回退目录)
|
|
256
|
+
// 4) 环境变量 DSH_SIDEBAR_MEDIA_ROOTS(分号或逗号分隔的绝对路径列表)
|
|
257
|
+
// 除这几个根之外仍然一律拒绝;不允许 target 是这些根的父目录,也不允许 `..` 逃逸。
|
|
258
|
+
|
|
259
|
+
const MUSIC_STATE_FILE = 'music-player-state.json'
|
|
260
|
+
const MUSIC_STATE_TTL_MS = 1000
|
|
261
|
+
const musicStateCache = { at: 0, root: null }
|
|
262
|
+
|
|
263
|
+
/** DSH 家目录:优先 DSH_HOME,回落 ~/.dsh。 */
|
|
264
|
+
function dshHomeDir() {
|
|
265
|
+
const env = process.env && process.env.DSH_HOME
|
|
266
|
+
if (typeof env === 'string' && env !== '') return env
|
|
267
|
+
try {
|
|
268
|
+
return join(homedir(), '.dsh')
|
|
269
|
+
} catch {
|
|
270
|
+
return null
|
|
271
|
+
}
|
|
272
|
+
}
|
|
273
|
+
|
|
274
|
+
/** 音乐库 root(来自 music-player-state.json);读不到返回 null。 */
|
|
275
|
+
function musicLibraryRoot() {
|
|
276
|
+
const now = Date.now()
|
|
277
|
+
if (now - musicStateCache.at < MUSIC_STATE_TTL_MS) return musicStateCache.root
|
|
278
|
+
let root = null
|
|
279
|
+
const home = dshHomeDir()
|
|
280
|
+
if (home !== null) {
|
|
281
|
+
try {
|
|
282
|
+
const raw = readFileSync(join(home, MUSIC_STATE_FILE), 'utf8')
|
|
283
|
+
const data = JSON.parse(raw)
|
|
284
|
+
if (data && typeof data.root === 'string' && data.root !== '') root = data.root
|
|
285
|
+
} catch {
|
|
286
|
+
root = null
|
|
287
|
+
}
|
|
288
|
+
}
|
|
289
|
+
musicStateCache.at = now
|
|
290
|
+
musicStateCache.root = root
|
|
291
|
+
return root
|
|
292
|
+
}
|
|
293
|
+
|
|
294
|
+
/** 播放器默认音乐目录 ~/Music(未设置 root 时 dsh-music-player 的回退目录)。 */
|
|
295
|
+
function defaultMusicRoot() {
|
|
296
|
+
try {
|
|
297
|
+
return join(homedir(), 'Music')
|
|
298
|
+
} catch {
|
|
299
|
+
return null
|
|
300
|
+
}
|
|
301
|
+
}
|
|
302
|
+
|
|
303
|
+
/** 环境变量追加的额外根目录。 */
|
|
304
|
+
function envMediaRoots() {
|
|
305
|
+
const env = process.env && process.env.DSH_SIDEBAR_MEDIA_ROOTS
|
|
306
|
+
if (typeof env !== 'string' || env.trim() === '') return []
|
|
307
|
+
return env.split(/[;,]/).map((part) => part.trim()).filter((part) => part !== '')
|
|
308
|
+
}
|
|
309
|
+
|
|
310
|
+
/**
|
|
311
|
+
* 当前请求允许的根目录名单(绝对路径,已 resolve)。
|
|
312
|
+
* @param {string} sessionBase - 会话 cwd
|
|
313
|
+
* @returns {string[]}
|
|
314
|
+
*/
|
|
315
|
+
function allowedBases(sessionBase) {
|
|
316
|
+
const bases = []
|
|
317
|
+
const push = (value) => {
|
|
318
|
+
if (typeof value !== 'string') return
|
|
319
|
+
const trimmed = value.trim()
|
|
320
|
+
if (trimmed === '') return
|
|
321
|
+
try {
|
|
322
|
+
bases.push(resolve(trimmed))
|
|
323
|
+
} catch {
|
|
324
|
+
/* 非法路径忽略 */
|
|
325
|
+
}
|
|
326
|
+
}
|
|
327
|
+
push(sessionBase)
|
|
328
|
+
push(musicLibraryRoot())
|
|
329
|
+
push(defaultMusicRoot())
|
|
330
|
+
for (const extra of envMediaRoots()) push(extra)
|
|
331
|
+
return bases
|
|
332
|
+
}
|
|
333
|
+
|
|
334
|
+
/** target 是否落在任一允许根之下(target 先 resolve,`..` 逃逸会被归一后判越界)。 */
|
|
335
|
+
function isAllowedTarget(target, sessionBase) {
|
|
336
|
+
let resolvedTarget
|
|
337
|
+
try {
|
|
338
|
+
resolvedTarget = resolve(target)
|
|
339
|
+
} catch {
|
|
340
|
+
return false
|
|
341
|
+
}
|
|
342
|
+
return allowedBases(sessionBase).some((base) => isWithin(base, resolvedTarget))
|
|
343
|
+
}
|
|
344
|
+
|
|
345
|
+
/** 越界错误:保留原措辞,附带允许根列表便于排错。 */
|
|
346
|
+
function outsideFenceError(raw, bases) {
|
|
347
|
+
return new MediaError(
|
|
348
|
+
'forbidden',
|
|
349
|
+
`"${raw}" is outside the session working directory (allowed roots: ${bases.join(' | ')})`,
|
|
350
|
+
403,
|
|
351
|
+
)
|
|
352
|
+
}
|
|
353
|
+
|
|
196
354
|
// ── Range 解析 ──────────────────────────────────────────────────────────────
|
|
197
355
|
|
|
198
356
|
/**
|
|
@@ -289,6 +447,268 @@ function serveFile(req, res, path, size, type) {
|
|
|
289
447
|
stream.pipe(res)
|
|
290
448
|
}
|
|
291
449
|
|
|
450
|
+
// ── 曲库扫描(GET /library)────────────────────────────────────────────────
|
|
451
|
+
// 只读:递归列目录、按扩展名白名单挑出音频/视频,绝不创建/删除/移动任何文件。
|
|
452
|
+
// 扩展名与前端 client.js:361-371 的 VIDEO_EXTS / AUDIO_EXTS 严格对齐(别另立一套)。
|
|
453
|
+
const LIBRARY_VIDEO_EXTS = new Set(['mp4', 'm4v', 'webm', 'mov', 'qt', 'mkv', 'avi', 'wmv', 'flv', 'ogv', 'ogg', 'mpeg', 'mpg', '3gp', '3g2', 'm2ts'])
|
|
454
|
+
const LIBRARY_AUDIO_EXTS = new Set(['mp3', 'wav', 'wave', 'flac', 'oga', 'opus', 'm4a', 'aac', 'wma', 'aif', 'aiff', 'amr', 'ape', 'caf', 'mka'])
|
|
455
|
+
const LIBRARY_SKIP_DIRS = new Set(['node_modules', '.git', 'dist', 'build', '.next', '.venv', 'venv', '__pycache__', '$recycle.bin', 'system volume information'])
|
|
456
|
+
const LIBRARY_MAX_FILES = 20000
|
|
457
|
+
const LIBRARY_MAX_DEPTH = 8
|
|
458
|
+
/** /dir 单次返回条目上限(dirs+files 合计),超出截断并打 truncated 标。 */
|
|
459
|
+
const DIR_MAX_ENTRIES = 2000
|
|
460
|
+
const DIR_DRIVES = '__drives__'
|
|
461
|
+
|
|
462
|
+
/**
|
|
463
|
+
* 递归扫描一个根目录,返回 { tracks, truncated }。
|
|
464
|
+
* - lstat 判定:符号链接一律跳过(既不跟目录链也不收文件链);
|
|
465
|
+
* - 跳过 LIBRARY_SKIP_DIRS(大小写不敏感);
|
|
466
|
+
* - 深度上限 maxDepth;文件数上限 LIBRARY_MAX_FILES,超出即截断并置 truncated=true。
|
|
467
|
+
*/
|
|
468
|
+
async function scanLibrary(root, maxDepth) {
|
|
469
|
+
const tracks = []
|
|
470
|
+
let truncated = false
|
|
471
|
+
const stack = [{ dir: root, depth: 0 }]
|
|
472
|
+
while (stack.length > 0) {
|
|
473
|
+
const current = stack.pop()
|
|
474
|
+
let entries
|
|
475
|
+
try {
|
|
476
|
+
entries = await readdir(current.dir, { withFileTypes: true })
|
|
477
|
+
} catch {
|
|
478
|
+
continue // 无权限 / 扫描期间被删的目录:跳过,不中断整次扫描
|
|
479
|
+
}
|
|
480
|
+
entries.sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0))
|
|
481
|
+
for (const entry of entries) {
|
|
482
|
+
const full = join(current.dir, entry.name)
|
|
483
|
+
let info
|
|
484
|
+
try {
|
|
485
|
+
info = await lstat(full)
|
|
486
|
+
} catch {
|
|
487
|
+
continue
|
|
488
|
+
}
|
|
489
|
+
if (info.isSymbolicLink()) continue
|
|
490
|
+
if (info.isDirectory()) {
|
|
491
|
+
if (current.depth + 1 > maxDepth) continue
|
|
492
|
+
if (LIBRARY_SKIP_DIRS.has(entry.name.toLowerCase())) continue
|
|
493
|
+
stack.push({ dir: full, depth: current.depth + 1 })
|
|
494
|
+
continue
|
|
495
|
+
}
|
|
496
|
+
if (!info.isFile()) continue
|
|
497
|
+
const ext = extname(entry.name).slice(1).toLowerCase()
|
|
498
|
+
const isVideo = LIBRARY_VIDEO_EXTS.has(ext)
|
|
499
|
+
if (!isVideo && !LIBRARY_AUDIO_EXTS.has(ext)) continue
|
|
500
|
+
if (tracks.length >= LIBRARY_MAX_FILES) {
|
|
501
|
+
truncated = true
|
|
502
|
+
return { tracks, truncated }
|
|
503
|
+
}
|
|
504
|
+
tracks.push({ name: entry.name, path: full, ext, size: info.size, mtimeMs: info.mtimeMs, isVideo })
|
|
505
|
+
}
|
|
506
|
+
}
|
|
507
|
+
return { tracks, truncated }
|
|
508
|
+
}
|
|
509
|
+
|
|
510
|
+
/** 解析 /library 的目标目录:dir 缺省时回落到 state 里的音乐库 root(只读),并做与 /media 同一套围栏。 */
|
|
511
|
+
function libraryTargetOf(url, ctx) {
|
|
512
|
+
const dirParam = url.searchParams.get('dir')
|
|
513
|
+
const base = sessionBaseOf(url, ctx)
|
|
514
|
+
let raw = dirParam
|
|
515
|
+
if (raw === null || raw === '') {
|
|
516
|
+
raw = musicLibraryRoot() ?? defaultMusicRoot()
|
|
517
|
+
if (raw === null || raw === '') {
|
|
518
|
+
throw new MediaError('bad-request', 'no music library root configured; pass dir=<absolute path>', 400)
|
|
519
|
+
}
|
|
520
|
+
}
|
|
521
|
+
const target = requireAbsolute(raw)
|
|
522
|
+
const bases = allowedBases(base)
|
|
523
|
+
if (!bases.some((b) => isWithin(b, target))) {
|
|
524
|
+
throw outsideFenceError(raw, bases)
|
|
525
|
+
}
|
|
526
|
+
return target
|
|
527
|
+
}
|
|
528
|
+
|
|
529
|
+
async function handleLibrary(url, ctx, request, response) {
|
|
530
|
+
if (request.method !== 'GET' && request.method !== 'HEAD') {
|
|
531
|
+
throw new MediaError('method-not-allowed', 'only GET and HEAD are allowed', 405)
|
|
532
|
+
}
|
|
533
|
+
const root = libraryTargetOf(url, ctx)
|
|
534
|
+
let info
|
|
535
|
+
try {
|
|
536
|
+
info = await stat(root)
|
|
537
|
+
} catch {
|
|
538
|
+
throw new MediaError('fs-error', `cannot read "${root}"`, 404)
|
|
539
|
+
}
|
|
540
|
+
if (!info.isDirectory()) throw new MediaError('fs-error', `"${root}" is not a directory`, 400)
|
|
541
|
+
const depthParam = url.searchParams.get('depth')
|
|
542
|
+
const depthNum = Number(depthParam)
|
|
543
|
+
const maxDepth = Number.isFinite(depthNum) && depthNum > 0
|
|
544
|
+
? Math.min(Math.floor(depthNum), LIBRARY_MAX_DEPTH)
|
|
545
|
+
: LIBRARY_MAX_DEPTH
|
|
546
|
+
const { tracks, truncated } = await scanLibrary(root, maxDepth)
|
|
547
|
+
if (request.method === 'HEAD') {
|
|
548
|
+
response.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8' })
|
|
549
|
+
response.end()
|
|
550
|
+
return
|
|
551
|
+
}
|
|
552
|
+
writeJson(response, 200, { ok: true, root, count: tracks.length, truncated, tracks })
|
|
553
|
+
}
|
|
554
|
+
|
|
555
|
+
// ── 目录浏览(/dir):给前端自绘目录选择器用,只读 ──────────────────────────
|
|
556
|
+
// 为什么要有:DSH 这个 webview 里 <input webkitdirectory> 点了不弹框,
|
|
557
|
+
// 所以走「后端 readdir + 前端自绘浏览器」这条路(与参照插件同路子,但保留我们的围栏)。
|
|
558
|
+
// 与 /library 的区别:/library 递归找媒体文件;/dir 只列一层(子目录 + 媒体文件)。
|
|
559
|
+
|
|
560
|
+
/** 允许浏览的判定:目标在某个允许根之下(向下自由),或目标本身就是某个允许根的祖先(只为让用户能沿路径走下来)。
|
|
561
|
+
* ⚠️ 绝不能把「盘根」当成允许根塞进名单——isWithin('C:\\', 'C:\\Windows\\System32') 会成立,
|
|
562
|
+
* 等于整盘放行。这里用「祖先方向只放行到允许根所在的路径链」的双向判定。 */
|
|
563
|
+
function isBrowsable(target, bases) {
|
|
564
|
+
return bases.some((base) => isWithin(base, target) || isWithin(target, base))
|
|
565
|
+
}
|
|
566
|
+
|
|
567
|
+
/** 面包屑:从盘根逐级到当前目录。盘根那级 name 与 path 都是 `C:\` 形式。 */
|
|
568
|
+
function dirCrumbs(target) {
|
|
569
|
+
const abs = String(target || '')
|
|
570
|
+
if (abs === '' || abs === DIR_DRIVES) return []
|
|
571
|
+
const parsed = parsePath(abs)
|
|
572
|
+
const root = parsed.root || ''
|
|
573
|
+
const crumbs = []
|
|
574
|
+
if (root !== '') crumbs.push({ name: root, path: root })
|
|
575
|
+
const parts = []
|
|
576
|
+
let d = parsed.dir
|
|
577
|
+
if (d !== '' && d !== root) {
|
|
578
|
+
while (d !== '' && d !== root) {
|
|
579
|
+
parts.unshift(basename(d))
|
|
580
|
+
d = dirname(d)
|
|
581
|
+
}
|
|
582
|
+
}
|
|
583
|
+
let cur = root
|
|
584
|
+
for (const part of parts) {
|
|
585
|
+
cur = cur === '' ? part : join(cur, part)
|
|
586
|
+
crumbs.push({ name: part, path: cur })
|
|
587
|
+
}
|
|
588
|
+
if (parsed.base !== '' && parsed.base !== root) {
|
|
589
|
+
cur = cur === '' ? parsed.base : join(cur, parsed.base)
|
|
590
|
+
crumbs.push({ name: parsed.base, path: cur })
|
|
591
|
+
}
|
|
592
|
+
return crumbs
|
|
593
|
+
}
|
|
594
|
+
|
|
595
|
+
/** 枚举存在的盘符(A:\ ~ Z:\);name 与 path 都带反斜杠,与参照插件一致。 */
|
|
596
|
+
function listDrives() {
|
|
597
|
+
const drives = []
|
|
598
|
+
for (const letter of 'ABCDEFGHIJKLMNOPQRSTUVWXYZ') {
|
|
599
|
+
const root = `${letter}:\\`
|
|
600
|
+
try {
|
|
601
|
+
if (existsSync(root)) drives.push({ name: root, path: root })
|
|
602
|
+
} catch { /* 不可访问的盘符直接跳过 */ }
|
|
603
|
+
}
|
|
604
|
+
return drives
|
|
605
|
+
}
|
|
606
|
+
|
|
607
|
+
async function handleDir(url, ctx, request, response) {
|
|
608
|
+
if (request.method !== 'GET' && request.method !== 'HEAD') {
|
|
609
|
+
throw new MediaError('method-not-allowed', 'only GET and HEAD are allowed', 405)
|
|
610
|
+
}
|
|
611
|
+
const raw = url.searchParams.get('path')
|
|
612
|
+
const isDrives = raw === null || raw === '' || raw === DIR_DRIVES
|
|
613
|
+
if (isDrives) {
|
|
614
|
+
const payload = {
|
|
615
|
+
ok: true,
|
|
616
|
+
path: DIR_DRIVES,
|
|
617
|
+
name: '本机磁盘',
|
|
618
|
+
up: null,
|
|
619
|
+
dirs: listDrives(),
|
|
620
|
+
files: [],
|
|
621
|
+
crumbs: [],
|
|
622
|
+
truncated: false,
|
|
623
|
+
}
|
|
624
|
+
if (request.method === 'HEAD') {
|
|
625
|
+
response.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8' })
|
|
626
|
+
response.end()
|
|
627
|
+
return
|
|
628
|
+
}
|
|
629
|
+
writeJson(response, 200, payload)
|
|
630
|
+
return
|
|
631
|
+
}
|
|
632
|
+
|
|
633
|
+
const target = requireAbsolute(raw) // 非绝对路径 → 400
|
|
634
|
+
const bases = allowedBases(sessionBaseOf(url, ctx))
|
|
635
|
+
if (!isBrowsable(target, bases)) throw outsideFenceError(raw, bases)
|
|
636
|
+
|
|
637
|
+
let info
|
|
638
|
+
try {
|
|
639
|
+
info = statSync(target)
|
|
640
|
+
} catch {
|
|
641
|
+
throw new MediaError('fs-error', `cannot read "${target}"`, 404)
|
|
642
|
+
}
|
|
643
|
+
if (!info.isDirectory()) throw new MediaError('fs-error', `"${target}" is not a directory`, 404)
|
|
644
|
+
|
|
645
|
+
const dirs = []
|
|
646
|
+
const files = []
|
|
647
|
+
let truncated = false
|
|
648
|
+
let entries = []
|
|
649
|
+
try {
|
|
650
|
+
entries = readdirSync(target, { withFileTypes: true, encoding: 'utf8' })
|
|
651
|
+
} catch {
|
|
652
|
+
entries = [] // 目录不可读(权限/占用)→ 空列表,不抛
|
|
653
|
+
}
|
|
654
|
+
for (const entry of entries) {
|
|
655
|
+
if (dirs.length + files.length >= DIR_MAX_ENTRIES) {
|
|
656
|
+
truncated = true
|
|
657
|
+
break
|
|
658
|
+
}
|
|
659
|
+
const name = entry.name
|
|
660
|
+
const full = join(target, name)
|
|
661
|
+
try {
|
|
662
|
+
let isDir = entry.isDirectory()
|
|
663
|
+
if (!isDir && entry.isSymbolicLink()) {
|
|
664
|
+
try { isDir = statSync(full).isDirectory() } catch { continue }
|
|
665
|
+
}
|
|
666
|
+
if (isDir) {
|
|
667
|
+
dirs.push({ name, path: full })
|
|
668
|
+
continue
|
|
669
|
+
}
|
|
670
|
+
if (!entry.isFile() && !entry.isSymbolicLink()) continue
|
|
671
|
+
const ext = extname(name).slice(1).toLowerCase()
|
|
672
|
+
if (ext === '') continue
|
|
673
|
+
const isVideo = LIBRARY_VIDEO_EXTS.has(ext)
|
|
674
|
+
if (!isVideo && !LIBRARY_AUDIO_EXTS.has(ext)) continue
|
|
675
|
+
let size = 0
|
|
676
|
+
try {
|
|
677
|
+
const fileInfo = statSync(full)
|
|
678
|
+
if (!fileInfo.isFile()) continue
|
|
679
|
+
size = fileInfo.size
|
|
680
|
+
} catch {
|
|
681
|
+
size = 0 // 单个坏条目(被占用/无权限)不给整次请求 500
|
|
682
|
+
}
|
|
683
|
+
files.push({ name, path: full, ext, size, isVideo })
|
|
684
|
+
} catch {
|
|
685
|
+
continue // 不可读条目跳过
|
|
686
|
+
}
|
|
687
|
+
}
|
|
688
|
+
const sortByName = (a, b) => a.name.localeCompare(b.name, 'zh-Hans-CN', { numeric: true, sensitivity: 'base' })
|
|
689
|
+
dirs.sort(sortByName)
|
|
690
|
+
files.sort(sortByName)
|
|
691
|
+
|
|
692
|
+
const parsed = parsePath(target)
|
|
693
|
+
const atRoot = parsed.dir === target
|
|
694
|
+
const payload = {
|
|
695
|
+
ok: true,
|
|
696
|
+
path: target,
|
|
697
|
+
name: parsed.base !== '' ? parsed.base : (parsed.root !== '' ? parsed.root : basename(target)),
|
|
698
|
+
up: atRoot ? (process.platform === 'win32' ? DIR_DRIVES : null) : dirname(target),
|
|
699
|
+
dirs,
|
|
700
|
+
files,
|
|
701
|
+
crumbs: dirCrumbs(target),
|
|
702
|
+
truncated,
|
|
703
|
+
}
|
|
704
|
+
if (request.method === 'HEAD') {
|
|
705
|
+
response.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8' })
|
|
706
|
+
response.end()
|
|
707
|
+
return
|
|
708
|
+
}
|
|
709
|
+
writeJson(response, 200, payload)
|
|
710
|
+
}
|
|
711
|
+
|
|
292
712
|
// ── 请求处理 ────────────────────────────────────────────────────────────────
|
|
293
713
|
|
|
294
714
|
function requireParam(url, key) {
|
|
@@ -307,9 +727,10 @@ async function statRequestedFile(url, ctx) {
|
|
|
307
727
|
const cwd = sessionCwdOf(ctx, sessionId, url.searchParams.get('cwd') ?? undefined)
|
|
308
728
|
|
|
309
729
|
const target = requireAbsolute(raw)
|
|
310
|
-
//
|
|
311
|
-
|
|
312
|
-
|
|
730
|
+
// 路径围栏:必须落在允许根之一之下(会话 cwd / 音乐库 root / ~/Music / 环境变量根)
|
|
731
|
+
const bases = allowedBases(cwd)
|
|
732
|
+
if (!bases.some((base) => isWithin(base, target))) {
|
|
733
|
+
throw outsideFenceError(raw, bases)
|
|
313
734
|
}
|
|
314
735
|
|
|
315
736
|
const ext = extname(target).toLowerCase()
|
|
@@ -341,6 +762,88 @@ async function handleMedia(url, ctx, request, response) {
|
|
|
341
762
|
serveFile(request, response, facts.path, facts.size, facts.type)
|
|
342
763
|
}
|
|
343
764
|
|
|
765
|
+
/**
|
|
766
|
+
* 从容器头解析音频时长(秒)。覆盖 mp3(Xing/Info 帧数优先,否则 CBR 按比特率估算)与 flac(STREAMINFO)。
|
|
767
|
+
* 返回 null 表示「这种容器/这个文件解析不出来」——调用方回 ok:false,客户端回退到 el.duration / 元数据。
|
|
768
|
+
*/
|
|
769
|
+
function probeDurationFromBuffer(buf, size, ext) {
|
|
770
|
+
if (ext === '.flac') {
|
|
771
|
+
if (buf.length < 42 || buf.toString('latin1', 0, 4) !== 'fLaC') return null
|
|
772
|
+
const sampleRate = (buf[18] << 12) | (buf[19] << 4) | (buf[20] >> 4)
|
|
773
|
+
// totalSamples 是 36 位:JS 位移只有 32 位,这里拆成「高 4 位 × 2^32 + 低 32 位」
|
|
774
|
+
const totalSamples = (buf[21] & 0x0f) * 4294967296
|
|
775
|
+
+ buf[22] * 16777216 + buf[23] * 65536 + buf[24] * 256 + buf[25]
|
|
776
|
+
if (!sampleRate || !totalSamples) return null
|
|
777
|
+
return totalSamples / sampleRate
|
|
778
|
+
}
|
|
779
|
+
if (ext !== '.mp3' && ext !== '.mpga') return null
|
|
780
|
+
let off = 0
|
|
781
|
+
if (buf.length >= 10 && buf.toString('latin1', 0, 3) === 'ID3') {
|
|
782
|
+
// ID3v2 头:size 是 4 字节 syncsafe 整数(每字节只用低 7 位)
|
|
783
|
+
off = 10 + (((buf[6] & 0x7f) << 21) | ((buf[7] & 0x7f) << 14) | ((buf[8] & 0x7f) << 7) | (buf[9] & 0x7f))
|
|
784
|
+
}
|
|
785
|
+
let i = off
|
|
786
|
+
for (; i + 4 < buf.length; i++) {
|
|
787
|
+
if (buf[i] === 0xff && (buf[i + 1] & 0xe0) === 0xe0) break
|
|
788
|
+
}
|
|
789
|
+
if (i + 4 >= buf.length) return null
|
|
790
|
+
const header = buf.readUInt32BE(i)
|
|
791
|
+
const verBits = (header >>> 19) & 3 // 3=MPEG1, 2=MPEG2, 0=MPEG2.5
|
|
792
|
+
const layer = (header >>> 17) & 3 // 1=Layer III
|
|
793
|
+
const brIdx = (header >>> 12) & 0xf
|
|
794
|
+
const srIdx = (header >>> 10) & 3
|
|
795
|
+
const chanMode = (header >>> 6) & 3
|
|
796
|
+
const srTable = { 3: [44100, 48000, 32000], 2: [22050, 24000, 16000], 0: [11025, 12000, 8000] }[verBits]
|
|
797
|
+
const sampleRate = srTable ? srTable[srIdx] : 0
|
|
798
|
+
if (!sampleRate || layer !== 1) return null
|
|
799
|
+
const isMpeg1 = verBits === 3
|
|
800
|
+
const samplesPerFrame = isMpeg1 ? 1152 : 576
|
|
801
|
+
// Xing/Info 标签在帧头 + side info 之后;side info 长度按 MPEG 版本与声道模式定
|
|
802
|
+
const sideInfo = isMpeg1 ? (chanMode === 3 ? 17 : 32) : (chanMode === 3 ? 9 : 17)
|
|
803
|
+
const xoff = i + 4 + sideInfo
|
|
804
|
+
if (xoff + 12 <= buf.length) {
|
|
805
|
+
const tag = buf.toString('latin1', xoff, xoff + 4)
|
|
806
|
+
if (tag === 'Xing' || tag === 'Info') {
|
|
807
|
+
const flags = buf.readUInt32BE(xoff + 4)
|
|
808
|
+
if (flags & 1) {
|
|
809
|
+
const frames = buf.readUInt32BE(xoff + 8)
|
|
810
|
+
if (frames > 0) return (frames * samplesPerFrame) / sampleRate
|
|
811
|
+
}
|
|
812
|
+
}
|
|
813
|
+
}
|
|
814
|
+
const brTable = [0, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 0]
|
|
815
|
+
const bitrate = brTable[brIdx] * 1000
|
|
816
|
+
if (!bitrate) return null
|
|
817
|
+
return ((size - off) * 8) / bitrate
|
|
818
|
+
}
|
|
819
|
+
|
|
820
|
+
async function handleDuration(url, ctx, request, response) {
|
|
821
|
+
if (request.method !== 'GET' && request.method !== 'HEAD') {
|
|
822
|
+
throw new MediaError('method-not-allowed', 'only GET and HEAD are supported', 405)
|
|
823
|
+
}
|
|
824
|
+
const target = resolveFencedTarget(url, ctx)
|
|
825
|
+
const ext = extname(target).toLowerCase()
|
|
826
|
+
let info
|
|
827
|
+
try {
|
|
828
|
+
info = await stat(target)
|
|
829
|
+
} catch {
|
|
830
|
+
throw new MediaError('fs-error', `cannot read "${target}"`, 404)
|
|
831
|
+
}
|
|
832
|
+
if (!info.isFile()) throw new MediaError('fs-error', `"${target}" is not a regular file`, 400)
|
|
833
|
+
// 只读前 1MB:ID3 + 第一帧(Xing)与 flac STREAMINFO 全在这一段里
|
|
834
|
+
let buf
|
|
835
|
+
try {
|
|
836
|
+
const fd = await readFile(target)
|
|
837
|
+
buf = fd.subarray(0, Math.min(fd.length, 1024 * 1024))
|
|
838
|
+
} catch {
|
|
839
|
+
throw new MediaError('fs-error', `cannot read "${target}"`, 404)
|
|
840
|
+
}
|
|
841
|
+
const duration = probeDurationFromBuffer(buf, info.size, ext)
|
|
842
|
+
writeJson(response, 200, duration === null
|
|
843
|
+
? { ok: false, duration: null, ext, reason: 'unparsable-container' }
|
|
844
|
+
: { ok: true, duration, ext })
|
|
845
|
+
}
|
|
846
|
+
|
|
344
847
|
// ── 文本轨:歌词(.lrc)/ 字幕(.vtt/.srt/.ass → VTT)────────────────────────
|
|
345
848
|
//
|
|
346
849
|
// 这两条路由不进 MEDIA_TYPES 白名单(它们不吐媒体字节,只回 JSON / VTT 文本)。
|
|
@@ -375,8 +878,9 @@ function resolveFencedTarget(url, ctx) {
|
|
|
375
878
|
base = process.cwd()
|
|
376
879
|
}
|
|
377
880
|
const target = requireAbsolute(raw)
|
|
378
|
-
|
|
379
|
-
|
|
881
|
+
const bases = allowedBases(base)
|
|
882
|
+
if (!bases.some((b) => isWithin(b, target))) {
|
|
883
|
+
throw outsideFenceError(raw, bases)
|
|
380
884
|
}
|
|
381
885
|
return target
|
|
382
886
|
}
|
|
@@ -523,13 +1027,978 @@ async function handleSubtitle(url, ctx, request, response) {
|
|
|
523
1027
|
response.end(body)
|
|
524
1028
|
}
|
|
525
1029
|
|
|
1030
|
+
// ── 在线 QQ 音乐:扫码登录 / 搜索 / 歌单 / 播放直链 / 歌词 ───────────────────────
|
|
1031
|
+
// 移植自 dsh-music-player v1.0.4(MIT,github.com/kendu76/dsh-music-player):
|
|
1032
|
+
// · 底层原样拷入本目录 lib/qq.js、lib/qrc.js(正文逐字节未改,见文件顶部来源声明);
|
|
1033
|
+
// · 路由形状**逐字段对齐**其 lib/index.js 的 QQ 分支(:4358-4634),只把前缀
|
|
1034
|
+
// /dsh-music 换成 /dsh-sidebar-media-player —— 前端按「一模一样、小改加功能」
|
|
1035
|
+
// 照抄母本,所以字段名一个不改、一个不删,只做加法。
|
|
1036
|
+
// 与母本的有意差异(移植时改的,不是抄错):
|
|
1037
|
+
// 1) 全部路由走本插件 handleRequest → 继承 trustedHosts 围栏(母本那些路由无鉴权);
|
|
1038
|
+
// 2) 凭据落 ~/.dsh/sidebar-media-player-qq-cookie.json,与母本 music-player-qq-cookie.json 物理隔离;
|
|
1039
|
+
// 3) 不做登录态主动探测(依据 lib/qq.js:411-425 实测:探测接口对有效会话也回 500003,只会误报);
|
|
1040
|
+
// 4) 不设本地过期门(实测二维码 120 s 由服务端判死,本地计时不参与任何请求,见 lib/qq.js:61-64);
|
|
1041
|
+
// 5) 额外保留四个别名路由:/qq/qr、/qq/qr/status、/qq/playlist?id=、/qq/lyric?mid=
|
|
1042
|
+
// (lead 早先契约用它们;别名纯加法,不改变母本形状)。
|
|
1043
|
+
// 错误体:QQ 路由内一律 `{ok:false, error:'字符串'}`(同母本),不走本插件外层的
|
|
1044
|
+
// `{ok:false,error:{code,message}}` —— 照抄母本的前端直接读 data.error 字符串。
|
|
1045
|
+
|
|
1046
|
+
/** 在线 QQ 音乐端点(挂在插件自己的前缀下,不另开裸 HTTP 路由)。 */
|
|
1047
|
+
const QQ_PATH = `${ROUTE_PREFIX}/qq`
|
|
1048
|
+
|
|
1049
|
+
/** QQ 凭据文件——**不是**母本的 music-player-qq-cookie.json,两套互不覆盖。 */
|
|
1050
|
+
const QQ_COOKIE_FILE = join(homedir(), '.dsh', 'sidebar-media-player-qq-cookie.json')
|
|
1051
|
+
|
|
1052
|
+
const QQ_USER_AGENT = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36'
|
|
1053
|
+
|
|
1054
|
+
/** 取链缓存 TTL(5 分钟,落在 vkey 直链有效期内)。 */
|
|
1055
|
+
const QQ_TAKE_TTL_MS = 5 * 60 * 1000
|
|
1056
|
+
|
|
1057
|
+
/** songmid → 数字 songID 缓存上限(QRC 歌词要先换 songid)。 */
|
|
1058
|
+
const QQ_MID_INFO_MAX = 300
|
|
1059
|
+
|
|
1060
|
+
/** 二维码复用窗口:同一把 key 的图在此窗口内重复请求直接复用(母本无此概念,仅别名 /qq/qr 用)。 */
|
|
1061
|
+
const QQ_QR_REUSE_MS = 15 * 1000
|
|
1062
|
+
|
|
1063
|
+
/** 登录态(进程内单例;凭据只从 QQ_COOKIE_FILE 读,绝不碰母本那个文件)。 */
|
|
1064
|
+
const qq = { cookie: '', cookies: null, nickname: '', loginFrom: '', isVip: null, loaded: false }
|
|
1065
|
+
|
|
1066
|
+
/** 服务端持有的扫码会话(别名 /qq/qr + /qq/qr/status 用;母本版把 key 下发给前端,见 /qq/login/start)。 */
|
|
1067
|
+
let qqLoginSession = null
|
|
1068
|
+
|
|
1069
|
+
const qqTakeCache = new Map()
|
|
1070
|
+
const qqMidInfoCache = new Map()
|
|
1071
|
+
|
|
1072
|
+
/** 逐字歌词缓存(加法路由 /qq/lyric-words 用;解密一次约 3 KB 文本,缓存即可)。 */
|
|
1073
|
+
const qqWordsCache = new Map()
|
|
1074
|
+
|
|
1075
|
+
/** 从 cookie 串里取 uin(母本同逻辑;取不到给空串)。 */
|
|
1076
|
+
function qqUin() {
|
|
1077
|
+
const m = /(?:^|;)\s*?uin=([^;]+)/.exec(qq.cookie)
|
|
1078
|
+
return m === null ? '' : m[1].trim()
|
|
1079
|
+
}
|
|
1080
|
+
|
|
1081
|
+
/**
|
|
1082
|
+
* 读凭据文件(幂等,只读一次)。
|
|
1083
|
+
* 文件里 `cookies` 是 map、`cookie` 是拼好的串,两种形态都在:map 给需要重算的接口,
|
|
1084
|
+
* 串给直接用 Cookie 头的接口;只有一方时从另一方推导。
|
|
1085
|
+
*/
|
|
1086
|
+
function loadQQCookie() {
|
|
1087
|
+
if (qq.loaded) return
|
|
1088
|
+
qq.loaded = true
|
|
1089
|
+
try {
|
|
1090
|
+
const data = JSON.parse(readFileSync(QQ_COOKIE_FILE, 'utf8'))
|
|
1091
|
+
if (data === null || typeof data !== 'object') throw new Error('bad cookie file')
|
|
1092
|
+
qq.cookies = data.cookies !== null && typeof data.cookies === 'object' ? data.cookies : null
|
|
1093
|
+
if (typeof data.cookie === 'string' && data.cookie !== '') qq.cookie = data.cookie
|
|
1094
|
+
else qq.cookie = qq.cookies === null ? '' : QQ.joinCookieMap(qq.cookies)
|
|
1095
|
+
qq.nickname = typeof data.nickname === 'string' ? data.nickname : ''
|
|
1096
|
+
qq.loginFrom = data.from === 'qq' || data.from === 'wx' ? data.from : ''
|
|
1097
|
+
} catch {
|
|
1098
|
+
// 文件不存在 / 坏 JSON:按未登录处理,不抛错(首次使用就是这种状态)。
|
|
1099
|
+
qq.cookie = ''
|
|
1100
|
+
qq.cookies = null
|
|
1101
|
+
qq.nickname = ''
|
|
1102
|
+
qq.loginFrom = ''
|
|
1103
|
+
}
|
|
1104
|
+
}
|
|
1105
|
+
|
|
1106
|
+
/**
|
|
1107
|
+
* 落盘(权限 0600)。母本存 {cookie,nickname,loginFrom},我们多存 cookies/source/savedAt——
|
|
1108
|
+
* 纯加法,母本那份文件的读取方不受影响,而我们自己下次启动能直接复用。
|
|
1109
|
+
*/
|
|
1110
|
+
function saveQQCookie() {
|
|
1111
|
+
const payload = {
|
|
1112
|
+
savedAt: new Date().toISOString(),
|
|
1113
|
+
source: 'dsh-sidebar-media-player',
|
|
1114
|
+
from: qq.loginFrom,
|
|
1115
|
+
nickname: qq.nickname,
|
|
1116
|
+
cookie: qq.cookie,
|
|
1117
|
+
cookies: qq.cookies,
|
|
1118
|
+
}
|
|
1119
|
+
try {
|
|
1120
|
+
mkdirSync(join(homedir(), '.dsh'), { recursive: true })
|
|
1121
|
+
writeFileSync(QQ_COOKIE_FILE, JSON.stringify(payload, null, 2), { encoding: 'utf8', mode: 0o600 })
|
|
1122
|
+
} catch (error) {
|
|
1123
|
+
throw new MediaError('qq-cookie', `QQ 凭据写入失败:${error?.message ?? error}`, 502)
|
|
1124
|
+
}
|
|
1125
|
+
}
|
|
1126
|
+
|
|
1127
|
+
function clearQQTakeCache() {
|
|
1128
|
+
qqTakeCache.clear()
|
|
1129
|
+
}
|
|
1130
|
+
|
|
1131
|
+
/** 退出登录:清内存态 + 清取链缓存 + 把空凭据落盘(母本 :4401-4405 同一动作)。 */
|
|
1132
|
+
function clearQQCookie() {
|
|
1133
|
+
qq.cookie = ''
|
|
1134
|
+
qq.cookies = null
|
|
1135
|
+
qq.nickname = ''
|
|
1136
|
+
qq.loginFrom = ''
|
|
1137
|
+
qq.isVip = null
|
|
1138
|
+
clearQQTakeCache()
|
|
1139
|
+
saveQQCookie()
|
|
1140
|
+
}
|
|
1141
|
+
|
|
1142
|
+
/** VIP 判定(母本 :2612-2616):未登录直接 false;只探测一次并缓存,失败按 false。 */
|
|
1143
|
+
async function refreshQQVip() {
|
|
1144
|
+
if (qq.cookie === '') {
|
|
1145
|
+
qq.isVip = false
|
|
1146
|
+
return false
|
|
1147
|
+
}
|
|
1148
|
+
if (qq.isVip === null || qq.isVip === undefined) {
|
|
1149
|
+
try {
|
|
1150
|
+
qq.isVip = await QQ.detectVip(qq.cookie)
|
|
1151
|
+
} catch {
|
|
1152
|
+
qq.isVip = false
|
|
1153
|
+
}
|
|
1154
|
+
}
|
|
1155
|
+
return qq.isVip === true
|
|
1156
|
+
}
|
|
1157
|
+
|
|
1158
|
+
/**
|
|
1159
|
+
* 从取链返回的文件名推音质档位(母本 :38-49 同逻辑)。
|
|
1160
|
+
* `M800…mp3` 是 320k 档、`M500…mp3` 是 128k 档,返回中文标签给前端显示。
|
|
1161
|
+
*/
|
|
1162
|
+
function qqQualityLabel(filename) {
|
|
1163
|
+
const name = String(filename || '')
|
|
1164
|
+
const dot = name.lastIndexOf('.')
|
|
1165
|
+
const ext = dot === -1 ? '' : name.slice(dot + 1).toLowerCase()
|
|
1166
|
+
if (ext === 'flac') return '无损'
|
|
1167
|
+
if (ext === 'ogg') return '高音质'
|
|
1168
|
+
if (ext === 'mp3') {
|
|
1169
|
+
if (/^M800/i.test(name)) return '高音质'
|
|
1170
|
+
if (/^M500/i.test(name)) return '标准'
|
|
1171
|
+
}
|
|
1172
|
+
return ''
|
|
1173
|
+
}
|
|
1174
|
+
|
|
1175
|
+
/**
|
|
1176
|
+
* 取(并缓存)某首歌的播放直链(母本 :2621-2637)。
|
|
1177
|
+
* 直链带时效,5 分钟内复用;取不到(VIP/版权/掉登录)返回空 url,交给调用方回 404。
|
|
1178
|
+
*/
|
|
1179
|
+
async function qqTake(songmid) {
|
|
1180
|
+
const hit = qqTakeCache.get(songmid)
|
|
1181
|
+
if (hit !== undefined && Date.now() - hit.ts < QQ_TAKE_TTL_MS) return hit
|
|
1182
|
+
const dl = await QQ.getDownloadURL(songmid, qq.cookie, true)
|
|
1183
|
+
const entry = { url: dl?.url ?? '', filename: dl?.filename ?? '', quality: qqQualityLabel(dl?.filename), ts: Date.now() }
|
|
1184
|
+
if (entry.url !== '') {
|
|
1185
|
+
qqTakeCache.set(songmid, entry)
|
|
1186
|
+
if (qqTakeCache.size > 200) {
|
|
1187
|
+
const oldest = qqTakeCache.keys().next().value
|
|
1188
|
+
if (oldest !== undefined) qqTakeCache.delete(oldest)
|
|
1189
|
+
}
|
|
1190
|
+
}
|
|
1191
|
+
return entry
|
|
1192
|
+
}
|
|
1193
|
+
|
|
1194
|
+
/**
|
|
1195
|
+
* LRC 解析——**照抄母本 lib/index.js:1404-1432**。
|
|
1196
|
+
* 本文件 :505 那个是我们的本地版(不支持 [offset:]、不剥 `<...>`、无时间轴返回 null),
|
|
1197
|
+
* 形状不同,所以 QQ 路由单独用这一份,保证 /qq/lyric 的 lrc/trans 与母本逐字段一致。
|
|
1198
|
+
* 返回 [{t:秒,text}](无时间轴返回空数组)。
|
|
1199
|
+
*/
|
|
1200
|
+
function qqParseLrc(text) {
|
|
1201
|
+
const out = []
|
|
1202
|
+
let offsetS = 0
|
|
1203
|
+
const TIME_RE = /\[(\d{1,3}):(\d{1,2})(?:[.:](\d{1,3}))?\]/g
|
|
1204
|
+
for (const raw of String(text || '').split(/\r?\n/)) {
|
|
1205
|
+
const line = raw.replace(/^\uFEFF/, '')
|
|
1206
|
+
// [offset:±ms] 对整个文件生效(偏移量毫秒)。
|
|
1207
|
+
const om = /^\s*\[offset:\s*([+-]?\d+)\s*\]\s*$/.exec(line)
|
|
1208
|
+
if (om !== null) {
|
|
1209
|
+
offsetS = (parseInt(om[1], 10) || 0) / 1000
|
|
1210
|
+
continue
|
|
1211
|
+
}
|
|
1212
|
+
const tags = []
|
|
1213
|
+
let m
|
|
1214
|
+
TIME_RE.lastIndex = 0
|
|
1215
|
+
let contentStart = 0
|
|
1216
|
+
// 注意:exec 匹配失败后 lastIndex 会被重置为 0,所以文本起点要在循环里记录。
|
|
1217
|
+
while ((m = TIME_RE.exec(line)) !== null) {
|
|
1218
|
+
tags.push(m)
|
|
1219
|
+
contentStart = TIME_RE.lastIndex
|
|
1220
|
+
}
|
|
1221
|
+
if (tags.length === 0) continue
|
|
1222
|
+
const content = line.slice(contentStart).replace(/<[^>]+>/g, '').replace(/\s+/g, ' ').trim()
|
|
1223
|
+
if (content === '') continue
|
|
1224
|
+
for (const tag of tags) {
|
|
1225
|
+
const min = parseInt(tag[1], 10) || 0
|
|
1226
|
+
const sec = parseInt(tag[2], 10) || 0
|
|
1227
|
+
const fracS = tag[3] !== undefined && tag[3] !== '' ? Number('0.' + tag[3]) : 0
|
|
1228
|
+
out.push({ t: min * 60 + sec + fracS + offsetS, text: content })
|
|
1229
|
+
}
|
|
1230
|
+
}
|
|
1231
|
+
out.sort((a, b) => a.t - b.t || (a.text < b.text ? -1 : a.text > b.text ? 1 : 0))
|
|
1232
|
+
return out
|
|
1233
|
+
}
|
|
1234
|
+
|
|
1235
|
+
/** 读请求体并 JSON.parse;空体 / 坏 JSON 一律回 {}(拿不到字段就走默认值,同母本策略)。 */
|
|
1236
|
+
function readJsonBody(request) {
|
|
1237
|
+
return new Promise((resolve) => {
|
|
1238
|
+
const chunks = []
|
|
1239
|
+
let size = 0
|
|
1240
|
+
request.on('data', (chunk) => {
|
|
1241
|
+
size += chunk.length
|
|
1242
|
+
if (size > 1024 * 1024) {
|
|
1243
|
+
request.destroy()
|
|
1244
|
+
resolve({})
|
|
1245
|
+
return
|
|
1246
|
+
}
|
|
1247
|
+
chunks.push(chunk)
|
|
1248
|
+
})
|
|
1249
|
+
request.on('end', () => {
|
|
1250
|
+
if (chunks.length === 0) {
|
|
1251
|
+
resolve({})
|
|
1252
|
+
return
|
|
1253
|
+
}
|
|
1254
|
+
try {
|
|
1255
|
+
resolve(JSON.parse(Buffer.concat(chunks).toString('utf8')))
|
|
1256
|
+
} catch {
|
|
1257
|
+
resolve({})
|
|
1258
|
+
}
|
|
1259
|
+
})
|
|
1260
|
+
request.on('error', () => resolve({}))
|
|
1261
|
+
})
|
|
1262
|
+
}
|
|
1263
|
+
|
|
1264
|
+
/** 登录态四件套(母本 /qq/status 的字段集;别名路由复用)。 */
|
|
1265
|
+
function qqAuthPayload() {
|
|
1266
|
+
return { loggedIn: qq.cookie !== '', uin: qqUin(), nickname: qq.nickname, loginFrom: qq.loginFrom }
|
|
1267
|
+
}
|
|
1268
|
+
|
|
1269
|
+
/** 扫码成功后统一落库(母本 :4386-4392 的 Host 侧动作)。 */
|
|
1270
|
+
function qqApplyLogin(result, mode) {
|
|
1271
|
+
qq.cookie = result.cookie || (result.cookies ? QQ.joinCookieMap(result.cookies) : '')
|
|
1272
|
+
qq.cookies = result.cookies ?? null
|
|
1273
|
+
qq.nickname = (result.extra && result.extra.nickname) || qq.nickname || ''
|
|
1274
|
+
qq.loginFrom = mode === 'wx' ? 'wx' : 'qq'
|
|
1275
|
+
qq.isVip = null
|
|
1276
|
+
clearQQTakeCache()
|
|
1277
|
+
saveQQCookie()
|
|
1278
|
+
}
|
|
1279
|
+
|
|
1280
|
+
/** 上游异常统一成 `{ok:false,error:'字符串'}` + 502(母本各 catch 分支的取值)。 */
|
|
1281
|
+
function qqError(error) {
|
|
1282
|
+
return { ok: false, error: String((error && error.message) || error) }
|
|
1283
|
+
}
|
|
1284
|
+
|
|
1285
|
+
// ── MV(音乐视频)只读取链 + 同源流代理 ────────────────────────────────────
|
|
1286
|
+
// 前端绝不能把 CDN 直链塞给 <video>(主窗口 CSP default-src 'self' 无 media-src,跨域被拦),
|
|
1287
|
+
// 所以本插件的 /qq/mv/<vid> 做同源反代:现取直链 → 透传 Range/206 → 流式回吐。
|
|
1288
|
+
const QQ_MV_URL_TTL_MS = 60 * 60 * 1000 // 直链约 24h 有效;这里只做 ≤1h 内存缓存
|
|
1289
|
+
const QQ_MV_URL_CACHE_MAX = 200
|
|
1290
|
+
const qqMvUrlCache = new Map() // vid -> { url, ts }
|
|
1291
|
+
|
|
1292
|
+
/** 取 vid:fcg_play_single_song。无 MV 时返回 hasMv:false(不抛错,前端据此决定显示与否)。 */
|
|
1293
|
+
async function qqFetchMvVid(songmid) {
|
|
1294
|
+
const u = `https://c.y.qq.com/v8/fcg-bin/fcg_play_single_song.fcg?songmid=${encodeURIComponent(songmid)}&format=json&platform=yqq`
|
|
1295
|
+
const res = await fetch(u, { headers: { 'User-Agent': QQ_USER_AGENT, Referer: 'https://y.qq.com/' } })
|
|
1296
|
+
const j = await res.json().catch(() => null)
|
|
1297
|
+
const row = j && Array.isArray(j.data) && j.data.length > 0 ? j.data[0] : null
|
|
1298
|
+
if (row === null) return { hasMv: false, vid: '', mvid: 0, name: '' }
|
|
1299
|
+
const mv = row.mv || {}
|
|
1300
|
+
const vid = typeof mv.vid === 'string' ? mv.vid : ''
|
|
1301
|
+
return {
|
|
1302
|
+
hasMv: vid !== '',
|
|
1303
|
+
vid,
|
|
1304
|
+
mvid: Number(mv.id) || 0,
|
|
1305
|
+
name: String(row.name || row.title || mv.name || ''),
|
|
1306
|
+
}
|
|
1307
|
+
}
|
|
1308
|
+
|
|
1309
|
+
/** 现取 MV 直链(https mp4),≤1h 内存缓存。取不到返回 ''。 */
|
|
1310
|
+
async function qqFetchMvUrl(vid, cookie) {
|
|
1311
|
+
const now = Date.now()
|
|
1312
|
+
const hit = qqMvUrlCache.get(vid)
|
|
1313
|
+
if (hit !== undefined && now - hit.ts < QQ_MV_URL_TTL_MS) return hit.url
|
|
1314
|
+
const body = JSON.stringify({
|
|
1315
|
+
comm: { cv: 4747474, ct: 24, format: 'json', platform: 'yqq.json', needNewCode: 1, uin: qqUin() || '0' },
|
|
1316
|
+
mvUrl: { module: 'gosrf.Stream.MvUrlProxy', method: 'GetMvUrls', param: { vids: [vid], request_typet: 100001 } },
|
|
1317
|
+
})
|
|
1318
|
+
const res = await fetch('https://u.y.qq.com/cgi-bin/musicu.fcg', {
|
|
1319
|
+
method: 'POST',
|
|
1320
|
+
headers: {
|
|
1321
|
+
'User-Agent': QQ_USER_AGENT,
|
|
1322
|
+
Referer: 'https://y.qq.com/',
|
|
1323
|
+
'Content-Type': 'application/json',
|
|
1324
|
+
...(cookie ? { Cookie: cookie } : {}),
|
|
1325
|
+
},
|
|
1326
|
+
body,
|
|
1327
|
+
})
|
|
1328
|
+
const j = await res.json().catch(() => null)
|
|
1329
|
+
const data = j && j.mvUrl && j.mvUrl.data ? j.mvUrl.data[vid] : null
|
|
1330
|
+
if (!data) return ''
|
|
1331
|
+
const mp4 = Array.isArray(data.mp4) ? data.mp4 : []
|
|
1332
|
+
// 档位 i 越大越清;同一档内优先 https 的那条(j=1 通常是 https)。
|
|
1333
|
+
for (let i = mp4.length - 1; i >= 0; i--) {
|
|
1334
|
+
const urls = Array.isArray(mp4[i] && mp4[i].freeflow_url)
|
|
1335
|
+
? mp4[i].freeflow_url.filter((x) => typeof x === 'string' && x !== '')
|
|
1336
|
+
: []
|
|
1337
|
+
if (urls.length === 0) continue
|
|
1338
|
+
const chosen = urls.find((x) => x.startsWith('https://')) ?? urls[0]
|
|
1339
|
+
if (chosen) {
|
|
1340
|
+
if (qqMvUrlCache.size >= QQ_MV_URL_CACHE_MAX) {
|
|
1341
|
+
const oldest = qqMvUrlCache.keys().next().value
|
|
1342
|
+
if (oldest !== undefined) qqMvUrlCache.delete(oldest)
|
|
1343
|
+
}
|
|
1344
|
+
qqMvUrlCache.set(vid, { url: chosen, ts: now })
|
|
1345
|
+
return chosen
|
|
1346
|
+
}
|
|
1347
|
+
}
|
|
1348
|
+
return ''
|
|
1349
|
+
}
|
|
1350
|
+
|
|
1351
|
+
/**
|
|
1352
|
+
* 别名 /qq/qr 的响应:默认 JSON(带 key 与 data URL),`?format=png` 时直接吐 PNG 字节。
|
|
1353
|
+
* `createdAt/expiresAt` 一并给出,前端到点自己重取(服务端二维码 120 s 寿命)。
|
|
1354
|
+
*/
|
|
1355
|
+
function writeQQQrPayload(url, session, response) {
|
|
1356
|
+
if (url.searchParams.get('format') === 'png') {
|
|
1357
|
+
const base64 = String(session.imageDataUrl || '').replace(/^data:image\/png;base64,/, '')
|
|
1358
|
+
const body = Buffer.from(base64, 'base64')
|
|
1359
|
+
if (body.length === 0) throw new MediaError('qq-qr', '二维码出图为空', 502)
|
|
1360
|
+
response.writeHead(200, {
|
|
1361
|
+
'content-type': 'image/png',
|
|
1362
|
+
'content-length': String(body.length),
|
|
1363
|
+
'cache-control': 'no-store, no-cache, must-revalidate',
|
|
1364
|
+
})
|
|
1365
|
+
response.end(body)
|
|
1366
|
+
return
|
|
1367
|
+
}
|
|
1368
|
+
writeJson(response, 200, {
|
|
1369
|
+
ok: true,
|
|
1370
|
+
key: session.key,
|
|
1371
|
+
image: session.imageDataUrl,
|
|
1372
|
+
imageDataUrl: session.imageDataUrl,
|
|
1373
|
+
mode: session.mode,
|
|
1374
|
+
createdAt: session.createdAt ?? null,
|
|
1375
|
+
expiresAt: session.expiresAt ?? null,
|
|
1376
|
+
})
|
|
1377
|
+
}
|
|
1378
|
+
|
|
1379
|
+
/**
|
|
1380
|
+
* 同源代理播放(母本 :4420-4456 逐行对应):把 vkey 直链的字节流中继给浏览器,
|
|
1381
|
+
* 透传 Range 请求头与 206/content-range 响应头,并补 `Referer: http://y.qq.com` 绕防盗链。
|
|
1382
|
+
*/
|
|
1383
|
+
async function handleQQPlay(songmid, request, response) {
|
|
1384
|
+
if (!/^[A-Za-z0-9]+$/.test(songmid)) {
|
|
1385
|
+
// 母本:非法 mid 回 400 空体。
|
|
1386
|
+
response.writeHead(400)
|
|
1387
|
+
response.end()
|
|
1388
|
+
return
|
|
1389
|
+
}
|
|
1390
|
+
const dl = await qqTake(songmid)
|
|
1391
|
+
if (dl.url === '') {
|
|
1392
|
+
// 取不到直链(VIP / 版权限制 / 登录已失效):纯文本 404,不做登录过期判定(母本注释同此)。
|
|
1393
|
+
response.writeHead(404, { 'content-type': 'text/plain; charset=utf-8' })
|
|
1394
|
+
response.end('无法获取播放地址(可能是 VIP、版权限制,或登录已失效)')
|
|
1395
|
+
return
|
|
1396
|
+
}
|
|
1397
|
+
const upstreamHeaders = { 'User-Agent': QQ_USER_AGENT, Referer: 'http://y.qq.com' }
|
|
1398
|
+
if (typeof request.headers.range === 'string') upstreamHeaders.Range = request.headers.range
|
|
1399
|
+
let stream
|
|
1400
|
+
try {
|
|
1401
|
+
stream = await fetch(dl.url, { headers: upstreamHeaders })
|
|
1402
|
+
} catch {
|
|
1403
|
+
response.writeHead(502, { 'content-type': 'text/plain; charset=utf-8' })
|
|
1404
|
+
response.end()
|
|
1405
|
+
return
|
|
1406
|
+
}
|
|
1407
|
+
const headers = {
|
|
1408
|
+
'content-type': stream.headers.get('content-type') || 'audio/mpeg',
|
|
1409
|
+
'accept-ranges': 'bytes',
|
|
1410
|
+
'cache-control': 'no-store',
|
|
1411
|
+
}
|
|
1412
|
+
// 中文档位要 percent-encode:Node 的 writeHead 拒绝非 ASCII 头值。
|
|
1413
|
+
if (dl.quality !== '') headers['x-dsh-qq-quality'] = encodeURIComponent(dl.quality)
|
|
1414
|
+
const contentRange = stream.headers.get('content-range')
|
|
1415
|
+
if (contentRange !== null) headers['content-range'] = contentRange
|
|
1416
|
+
const contentLength = stream.headers.get('content-length')
|
|
1417
|
+
if (contentLength !== null) headers['content-length'] = contentLength
|
|
1418
|
+
response.writeHead(stream.status, headers)
|
|
1419
|
+
if (request.method === 'HEAD') {
|
|
1420
|
+
response.end()
|
|
1421
|
+
return
|
|
1422
|
+
}
|
|
1423
|
+
if (stream.body !== null) {
|
|
1424
|
+
for await (const chunk of stream.body) response.write(chunk)
|
|
1425
|
+
}
|
|
1426
|
+
response.end()
|
|
1427
|
+
}
|
|
1428
|
+
|
|
1429
|
+
/**
|
|
1430
|
+
* 逐字歌词(word-level)取数——**加法路由 /qq/lyric-words 专用**。
|
|
1431
|
+
* 请求与 lib/qq.js:537-601 的 getQrcLyric 完全相同(同一 module/method/param),
|
|
1432
|
+
* 唯一差别:上游把 QRC 的逐词时间轴在映射时丢掉了(只留 {t,end,text} 整行窗口,
|
|
1433
|
+
* 见 qq.js 注释「词级时间轴(words)当前不下发」),这里用同一个 lib/qrc.js 的
|
|
1434
|
+
* decryptHex + parseQrc 把 words 一并保留,供侧边栏逐字高亮。
|
|
1435
|
+
* 返回 [{t,end,text,words:[{t,dur,text}]}](秒);该曲没有逐字流时返回 null。
|
|
1436
|
+
*/
|
|
1437
|
+
async function qqFetchQrcWords(info, cookie) {
|
|
1438
|
+
const songid = Number(info && info.songid)
|
|
1439
|
+
if (!Number.isFinite(songid) || songid <= 0) return null
|
|
1440
|
+
const b64 = (s) => Buffer.from(String(s ?? ''), 'utf8').toString('base64')
|
|
1441
|
+
const param = {
|
|
1442
|
+
albumName: b64(info.album),
|
|
1443
|
+
crypt: 1,
|
|
1444
|
+
ct: 19,
|
|
1445
|
+
cv: 2111,
|
|
1446
|
+
interval: Math.max(0, Math.round(Number(info.interval) || 0)),
|
|
1447
|
+
lrc_t: 0,
|
|
1448
|
+
qrc: 1,
|
|
1449
|
+
qrc_t: 0,
|
|
1450
|
+
roma: 1,
|
|
1451
|
+
roma_t: 0,
|
|
1452
|
+
singerName: b64(info.artist),
|
|
1453
|
+
songID: songid,
|
|
1454
|
+
songName: b64(info.title),
|
|
1455
|
+
trans: 1,
|
|
1456
|
+
trans_t: 0,
|
|
1457
|
+
type: 0,
|
|
1458
|
+
}
|
|
1459
|
+
const body = JSON.stringify({
|
|
1460
|
+
comm: { ct: '19', cv: '2111', format: 'json' },
|
|
1461
|
+
req: { module: 'music.musichallSong.PlayLyricInfo', method: 'GetPlayLyricInfo', param },
|
|
1462
|
+
})
|
|
1463
|
+
const res = await fetch('https://u.y.qq.com/cgi-bin/musicu.fcg', {
|
|
1464
|
+
method: 'POST',
|
|
1465
|
+
headers: {
|
|
1466
|
+
'User-Agent': QQ_USER_AGENT,
|
|
1467
|
+
Referer: 'https://y.qq.com/',
|
|
1468
|
+
Origin: 'https://y.qq.com',
|
|
1469
|
+
'Content-Type': 'application/json',
|
|
1470
|
+
...(cookie ? { Cookie: cookie } : {}),
|
|
1471
|
+
},
|
|
1472
|
+
body,
|
|
1473
|
+
})
|
|
1474
|
+
const j = await res.json().catch(() => null)
|
|
1475
|
+
if (j === null || Number(j.code) !== 0) return null
|
|
1476
|
+
const r = j.req || {}
|
|
1477
|
+
if (Number(r.code) !== 0) return null
|
|
1478
|
+
const data = r.data || {}
|
|
1479
|
+
const cipherHex = typeof data.lyric === 'string' ? data.lyric : ''
|
|
1480
|
+
if (cipherHex === '') return null
|
|
1481
|
+
// 没有逐字流(qrc_t=0)时回 null,让前端回落 /qq/lyric 的整行歌词。
|
|
1482
|
+
if (String(data.qrc_t ?? '0') === '0') return null
|
|
1483
|
+
const rows = qrcParse(qrcDecryptHex(cipherHex))
|
|
1484
|
+
return rows.map((row) => ({
|
|
1485
|
+
t: Number(row.startMs) / 1000,
|
|
1486
|
+
end: (Number(row.startMs) + Number(row.durMs)) / 1000,
|
|
1487
|
+
text: String(row.text ?? ''),
|
|
1488
|
+
words: (Array.isArray(row.words) ? row.words : []).map((w) => ({
|
|
1489
|
+
t: Number(w.startMs) / 1000,
|
|
1490
|
+
dur: Number(w.durMs) / 1000,
|
|
1491
|
+
text: String(w.text ?? ''),
|
|
1492
|
+
})),
|
|
1493
|
+
}))
|
|
1494
|
+
}
|
|
1495
|
+
|
|
1496
|
+
/**
|
|
1497
|
+
* QQ 路由总入口(挂在 `${ROUTE_PREFIX}/qq` 下,走本插件 handleRequest,继承 trustedHosts 围栏)。
|
|
1498
|
+
* 路由集与响应形状逐条对齐母本 lib/index.js:4358-4634;别名与 /qq/lyric-words 是纯加法。
|
|
1499
|
+
*/
|
|
1500
|
+
async function handleQQ(url, request, response) {
|
|
1501
|
+
const pathname = url.pathname
|
|
1502
|
+
const method = request.method
|
|
1503
|
+
try {
|
|
1504
|
+
// ── 母本逐条对应区(前缀已换) ──────────────────────────────────────────
|
|
1505
|
+
if (pathname === `${QQ_PATH}/status` && method === 'GET') {
|
|
1506
|
+
loadQQCookie()
|
|
1507
|
+
// 无 ok 字段:与母本一致(前端照抄母本时读 loggedIn/uin/nickname/loginFrom)。
|
|
1508
|
+
writeJson(response, 200, qqAuthPayload())
|
|
1509
|
+
return
|
|
1510
|
+
}
|
|
1511
|
+
// ── VIP 判定(加法路由;母本无独立入口,只有 /qq/search 顺带回一个 isVip) ──
|
|
1512
|
+
// 前端用它拦「登录了但不是 VIP」的曲目:判据是 lib\qq.js 的 detectVip(:427-439)。
|
|
1513
|
+
// 未登录不报 4xx —— 前端要能区分「没登录」与「登录了但没有 VIP」。
|
|
1514
|
+
if (pathname === `${QQ_PATH}/vip` && method === 'GET') {
|
|
1515
|
+
loadQQCookie()
|
|
1516
|
+
const loggedIn = qq.cookie !== ''
|
|
1517
|
+
const isVip = await refreshQQVip()
|
|
1518
|
+
writeJson(response, 200, { ok: true, isVip, uin: qqUin(), loggedIn })
|
|
1519
|
+
return
|
|
1520
|
+
}
|
|
1521
|
+
if (pathname === `${QQ_PATH}/login/start` && method === 'POST') {
|
|
1522
|
+
const body = await readJsonBody(request)
|
|
1523
|
+
const mode = body && body.mode === 'qq' ? 'qq' : 'wx'
|
|
1524
|
+
const session = mode === 'qq' ? await QQ.createQRLogin() : await QQ.createWXQRLogin()
|
|
1525
|
+
qqLoginSession = {
|
|
1526
|
+
key: session.key,
|
|
1527
|
+
mode,
|
|
1528
|
+
expiresAt: session.expiresAt,
|
|
1529
|
+
imageDataUrl: session.imageDataUrl,
|
|
1530
|
+
createdAt: Date.now(),
|
|
1531
|
+
}
|
|
1532
|
+
writeJson(response, 200, { ok: true, key: session.key, image: session.imageDataUrl, mode, expiresAt: session.expiresAt })
|
|
1533
|
+
return
|
|
1534
|
+
}
|
|
1535
|
+
if (pathname === `${QQ_PATH}/login/check` && method === 'GET') {
|
|
1536
|
+
const key = (url.searchParams.get('key') || '').trim()
|
|
1537
|
+
if (key === '') {
|
|
1538
|
+
writeJson(response, 400, { ok: false, error: 'missing key' })
|
|
1539
|
+
return
|
|
1540
|
+
}
|
|
1541
|
+
const isWx = /(?:^|&)type=wx(?:&|$)/.test(key)
|
|
1542
|
+
const result = isWx ? await QQ.checkWXQRLogin(key) : await QQ.checkQRLogin(key)
|
|
1543
|
+
if (result.status === 'success') {
|
|
1544
|
+
qqApplyLogin(result, isWx ? 'wx' : 'qq')
|
|
1545
|
+
writeJson(response, 200, {
|
|
1546
|
+
ok: true,
|
|
1547
|
+
status: 'success',
|
|
1548
|
+
...qqAuthPayload(),
|
|
1549
|
+
message: result.message,
|
|
1550
|
+
extra: result.extra,
|
|
1551
|
+
})
|
|
1552
|
+
return
|
|
1553
|
+
}
|
|
1554
|
+
writeJson(response, 200, { ok: true, status: result.status, message: result.message, extra: result.extra })
|
|
1555
|
+
return
|
|
1556
|
+
}
|
|
1557
|
+
if (pathname === `${QQ_PATH}/login/logout` && method === 'POST') {
|
|
1558
|
+
clearQQCookie()
|
|
1559
|
+
writeJson(response, 200, { ok: true, loggedIn: false })
|
|
1560
|
+
return
|
|
1561
|
+
}
|
|
1562
|
+
if (pathname === `${QQ_PATH}/search` && method === 'GET') {
|
|
1563
|
+
const w = (url.searchParams.get('w') || '').trim()
|
|
1564
|
+
if (w === '') {
|
|
1565
|
+
writeJson(response, 400, { ok: false, error: 'missing query' })
|
|
1566
|
+
return
|
|
1567
|
+
}
|
|
1568
|
+
const page = Math.max(1, parseInt(url.searchParams.get('page') || '1', 10) || 1)
|
|
1569
|
+
loadQQCookie()
|
|
1570
|
+
const isVip = await refreshQQVip()
|
|
1571
|
+
const s = await QQ.search(w, qq.cookie, page)
|
|
1572
|
+
writeJson(response, 200, { ok: true, isVip, results: s.results, total: s.total, page: s.page })
|
|
1573
|
+
return
|
|
1574
|
+
}
|
|
1575
|
+
if (pathname.startsWith(`${QQ_PATH}/play/`) && (method === 'GET' || method === 'HEAD')) {
|
|
1576
|
+
const songmid = decodeURIComponent(pathname.slice(`${QQ_PATH}/play/`.length))
|
|
1577
|
+
await handleQQPlay(songmid, request, response)
|
|
1578
|
+
return
|
|
1579
|
+
}
|
|
1580
|
+
if (pathname === `${QQ_PATH}/playlist-categories` && method === 'GET') {
|
|
1581
|
+
loadQQCookie()
|
|
1582
|
+
writeJson(response, 200, { ok: true, categories: await QQ.getPlaylistCategories(qq.cookie) })
|
|
1583
|
+
return
|
|
1584
|
+
}
|
|
1585
|
+
if (pathname === `${QQ_PATH}/playlist-search` && method === 'GET') {
|
|
1586
|
+
const w = (url.searchParams.get('w') || '').trim()
|
|
1587
|
+
if (w === '') {
|
|
1588
|
+
writeJson(response, 400, { ok: false, error: 'missing query' })
|
|
1589
|
+
return
|
|
1590
|
+
}
|
|
1591
|
+
const page = Math.max(1, parseInt(url.searchParams.get('page') || '1', 10) || 1)
|
|
1592
|
+
loadQQCookie()
|
|
1593
|
+
const s = await QQ.searchPlaylist(w, qq.cookie, page)
|
|
1594
|
+
writeJson(response, 200, { ok: true, playlists: s.results, total: s.total, page: s.page })
|
|
1595
|
+
return
|
|
1596
|
+
}
|
|
1597
|
+
if (pathname === `${QQ_PATH}/playlists` && method === 'GET') {
|
|
1598
|
+
const category = (url.searchParams.get('category') || '').trim()
|
|
1599
|
+
loadQQCookie()
|
|
1600
|
+
if (category === '') {
|
|
1601
|
+
writeJson(response, 200, { ok: true, playlists: await QQ.getRecommendedPlaylists(qq.cookie) })
|
|
1602
|
+
return
|
|
1603
|
+
}
|
|
1604
|
+
const page = Math.max(1, parseInt(url.searchParams.get('page') || '1', 10) || 1)
|
|
1605
|
+
writeJson(response, 200, { ok: true, playlists: await QQ.getCategoryPlaylists(category, page, 20, qq.cookie) })
|
|
1606
|
+
return
|
|
1607
|
+
}
|
|
1608
|
+
if (pathname === `${QQ_PATH}/my-playlists` && method === 'GET') {
|
|
1609
|
+
loadQQCookie()
|
|
1610
|
+
writeJson(response, 200, { ok: true, playlists: await QQ.getMyPlaylists(qq.cookie), uin: qqUin() })
|
|
1611
|
+
return
|
|
1612
|
+
}
|
|
1613
|
+
if (pathname === `${QQ_PATH}/fav` && method === 'POST') {
|
|
1614
|
+
const body = await readJsonBody(request)
|
|
1615
|
+
const action = body && body.action === 'remove' ? 'remove' : 'add'
|
|
1616
|
+
loadQQCookie()
|
|
1617
|
+
const ok = action === 'remove' ? await QQ.removeQQFav(body.song, qq.cookie) : await QQ.addQQFav(body.song, qq.cookie)
|
|
1618
|
+
writeJson(response, 200, { ok, faved: action === 'add' ? ok : !ok })
|
|
1619
|
+
return
|
|
1620
|
+
}
|
|
1621
|
+
if (pathname === `${QQ_PATH}/playlist-add` && method === 'POST') {
|
|
1622
|
+
const body = await readJsonBody(request)
|
|
1623
|
+
loadQQCookie()
|
|
1624
|
+
const ok = await QQ.addSongToPlaylist(body.song, Number(body.dirId) || 0, Number(body.tid) || 0, qq.cookie)
|
|
1625
|
+
writeJson(response, 200, { ok })
|
|
1626
|
+
return
|
|
1627
|
+
}
|
|
1628
|
+
if (pathname === `${QQ_PATH}/playlist-remove` && method === 'POST') {
|
|
1629
|
+
const body = await readJsonBody(request)
|
|
1630
|
+
loadQQCookie()
|
|
1631
|
+
const ok = await QQ.deleteSongFromPlaylist(body.song, Number(body.dirId) || 0, Number(body.tid) || 0, qq.cookie)
|
|
1632
|
+
writeJson(response, 200, { ok })
|
|
1633
|
+
return
|
|
1634
|
+
}
|
|
1635
|
+
if (pathname === `${QQ_PATH}/playlist-create` && method === 'POST') {
|
|
1636
|
+
const body = await readJsonBody(request)
|
|
1637
|
+
const name = String((body && body.name) || '').trim()
|
|
1638
|
+
if (name === '') {
|
|
1639
|
+
writeJson(response, 400, { ok: false, error: '歌单名不能为空' })
|
|
1640
|
+
return
|
|
1641
|
+
}
|
|
1642
|
+
loadQQCookie()
|
|
1643
|
+
const created = await QQ.createPlaylist(name, qq.cookie)
|
|
1644
|
+
writeJson(response, 200, { ok: true, playlist: created })
|
|
1645
|
+
return
|
|
1646
|
+
}
|
|
1647
|
+
if (pathname === `${QQ_PATH}/playlist-delete` && method === 'POST') {
|
|
1648
|
+
const body = await readJsonBody(request)
|
|
1649
|
+
const dirId = Number(body && body.dirId) || 0
|
|
1650
|
+
if (!dirId) {
|
|
1651
|
+
writeJson(response, 400, { ok: false, error: '缺少歌单 dirId' })
|
|
1652
|
+
return
|
|
1653
|
+
}
|
|
1654
|
+
loadQQCookie()
|
|
1655
|
+
const ok = await QQ.deletePlaylist(dirId, qq.cookie)
|
|
1656
|
+
writeJson(response, 200, { ok })
|
|
1657
|
+
return
|
|
1658
|
+
}
|
|
1659
|
+
if (pathname === `${QQ_PATH}/liked` && method === 'GET') {
|
|
1660
|
+
loadQQCookie()
|
|
1661
|
+
const fav = await QQ.getQQFavIds(qq.cookie)
|
|
1662
|
+
writeJson(response, 200, { ok: true, ids: (fav && fav.ids) || [], mids: (fav && fav.mids) || [] })
|
|
1663
|
+
return
|
|
1664
|
+
}
|
|
1665
|
+
if (pathname === `${QQ_PATH}/top-lists` && method === 'GET') {
|
|
1666
|
+
loadQQCookie()
|
|
1667
|
+
writeJson(response, 200, { ok: true, groups: await QQ.getTopLists(qq.cookie) })
|
|
1668
|
+
return
|
|
1669
|
+
}
|
|
1670
|
+
if (pathname === `${QQ_PATH}/top-songs` && method === 'GET') {
|
|
1671
|
+
const topId = (url.searchParams.get('topId') || '').trim()
|
|
1672
|
+
if (!/^[0-9]+$/.test(topId)) {
|
|
1673
|
+
writeJson(response, 400, { ok: false, error: 'bad topId' })
|
|
1674
|
+
return
|
|
1675
|
+
}
|
|
1676
|
+
const offset = parseInt(url.searchParams.get('offset') || '0', 10)
|
|
1677
|
+
const num = parseInt(url.searchParams.get('num') || '30', 10)
|
|
1678
|
+
loadQQCookie()
|
|
1679
|
+
const toplist = await QQ.getTopListSongs(topId, qq.cookie, Number.isFinite(offset) ? offset : 0, Number.isFinite(num) ? num : 30)
|
|
1680
|
+
writeJson(response, 200, { ok: true, toplist })
|
|
1681
|
+
return
|
|
1682
|
+
}
|
|
1683
|
+
if (pathname === `${QQ_PATH}/new-songs` && method === 'GET') {
|
|
1684
|
+
const type = parseInt(url.searchParams.get('type') || '5', 10)
|
|
1685
|
+
loadQQCookie()
|
|
1686
|
+
writeJson(response, 200, { ok: true, result: await QQ.getNewSongs(Number.isFinite(type) ? type : 5, qq.cookie) })
|
|
1687
|
+
return
|
|
1688
|
+
}
|
|
1689
|
+
// ── 免费时长:自动化「看广告换免费时长」外壳 ──────────────────────────
|
|
1690
|
+
// 边界必须说清:QQ 音乐「浏览 15 秒免费听 5 分钟」是客户端内的私有机制,
|
|
1691
|
+
// 网页版没有对应入口 —— 所以这里做的是**自动化外壳**:开一个独立的浏览器
|
|
1692
|
+
// app 窗口(各自独立 user-data-dir,支持多开)→ 到秒数自动 taskkill。
|
|
1693
|
+
// 真实时长是否到账取决于 QQ 音乐服务端;本地累计由客户端负责,不伪造奖励。
|
|
1694
|
+
if (pathname === `${QQ_PATH}/free/open` && method === 'POST') {
|
|
1695
|
+
const body = await readJsonBody(request)
|
|
1696
|
+
const rawUrl = (body && typeof body.url === 'string' && body.url !== '') ? body.url : 'https://y.qq.com/'
|
|
1697
|
+
let u = null
|
|
1698
|
+
try { u = new URL(rawUrl) } catch { u = null }
|
|
1699
|
+
if (u === null || (u.protocol !== 'https:' && u.protocol !== 'http:')) {
|
|
1700
|
+
writeJson(response, 400, { ok: false, error: 'bad url' })
|
|
1701
|
+
return
|
|
1702
|
+
}
|
|
1703
|
+
const sec = Math.max(5, Math.min(120, Number(body && body.seconds) || 15))
|
|
1704
|
+
const want = Math.max(1, Math.min(6, Number(body && body.count) || 1))
|
|
1705
|
+
const browser = findBrowserExecutable()
|
|
1706
|
+
if (browser === '') {
|
|
1707
|
+
writeJson(response, 500, { ok: false, error: 'no-chromium-browser' })
|
|
1708
|
+
return
|
|
1709
|
+
}
|
|
1710
|
+
const opened = []
|
|
1711
|
+
for (let i = 0; i < want; i++) {
|
|
1712
|
+
try {
|
|
1713
|
+
const profileDir = join(homedir(), '.dsh', 'free-ad-profiles', 'p' + Date.now() + '_' + i + '_' + Math.random().toString(36).slice(2, 6))
|
|
1714
|
+
mkdirSync(profileDir, { recursive: true })
|
|
1715
|
+
const child = spawn(browser, [
|
|
1716
|
+
'--app=' + u.href,
|
|
1717
|
+
'--no-first-run',
|
|
1718
|
+
'--no-default-browser-check',
|
|
1719
|
+
'--disable-features=Translate',
|
|
1720
|
+
'--user-data-dir=' + profileDir
|
|
1721
|
+
], { detached: true, stdio: 'ignore' })
|
|
1722
|
+
child.unref()
|
|
1723
|
+
const pid = child.pid
|
|
1724
|
+
opened.push({ pid, profileDir })
|
|
1725
|
+
if (typeof pid === 'number' && pid > 0) {
|
|
1726
|
+
const t = setTimeout(function () {
|
|
1727
|
+
try { spawn('taskkill', ['/PID', String(pid), '/T', '/F'], { stdio: 'ignore' }) } catch { /* 进程可能已自行退出 */ }
|
|
1728
|
+
}, sec * 1000)
|
|
1729
|
+
if (t && typeof t.unref === 'function') t.unref()
|
|
1730
|
+
}
|
|
1731
|
+
} catch { /* 单个窗口开失败不影响其它 */ }
|
|
1732
|
+
}
|
|
1733
|
+
writeJson(response, 200, { ok: true, opened, seconds: sec })
|
|
1734
|
+
return
|
|
1735
|
+
}
|
|
1736
|
+
if (pathname === `${QQ_PATH}/lyric` && method === 'GET') {
|
|
1737
|
+
// 参数名 songmid(母本同名);别名 `mid` 也接受,别的什么都不认。
|
|
1738
|
+
const songmid = (url.searchParams.get('songmid') || url.searchParams.get('mid') || '').trim()
|
|
1739
|
+
if (songmid === '' || !/^[0-9A-Za-z_-]+$/.test(songmid)) {
|
|
1740
|
+
writeJson(response, 400, { ok: false, error: 'bad songmid' })
|
|
1741
|
+
return
|
|
1742
|
+
}
|
|
1743
|
+
loadQQCookie()
|
|
1744
|
+
let info = qqMidInfoCache.get(songmid)
|
|
1745
|
+
if (info === undefined) {
|
|
1746
|
+
try {
|
|
1747
|
+
info = await QQ.getSongInfoByMid(songmid, qq.cookie)
|
|
1748
|
+
} catch {
|
|
1749
|
+
info = null
|
|
1750
|
+
}
|
|
1751
|
+
qqMidInfoCache.set(songmid, info)
|
|
1752
|
+
if (qqMidInfoCache.size > QQ_MID_INFO_MAX) {
|
|
1753
|
+
const oldest = qqMidInfoCache.keys().next().value
|
|
1754
|
+
if (oldest !== undefined) qqMidInfoCache.delete(oldest)
|
|
1755
|
+
}
|
|
1756
|
+
}
|
|
1757
|
+
if (info) {
|
|
1758
|
+
try {
|
|
1759
|
+
const q = await QQ.getQrcLyric(info, qq.cookie)
|
|
1760
|
+
if (q !== null && Array.isArray(q.lines) && q.lines.length > 0) {
|
|
1761
|
+
writeJson(response, 200, {
|
|
1762
|
+
ok: true,
|
|
1763
|
+
hasLyric: true,
|
|
1764
|
+
source: 'qq-qrc',
|
|
1765
|
+
// 母本键名,逐字数据;照抄母本的前端读它做逐字高亮。
|
|
1766
|
+
wordLines: q.lines,
|
|
1767
|
+
// 加法(母本没有):同一份逐字数据投影成统一 {t,text} 形状,
|
|
1768
|
+
// 供我们自己的侧边栏歌词组件按时间轴直接消费。
|
|
1769
|
+
lines: q.lines.map((line) => ({ t: Number(line?.t ?? 0), end: Number(line?.end ?? 0), text: String(line?.text ?? '') })),
|
|
1770
|
+
})
|
|
1771
|
+
return
|
|
1772
|
+
}
|
|
1773
|
+
} catch {
|
|
1774
|
+
// QRC 取不到就静默回落 LRC(母本同策略,不打扰播放)。
|
|
1775
|
+
}
|
|
1776
|
+
}
|
|
1777
|
+
const { lyric, trans } = await QQ.getLyric(songmid, qq.cookie)
|
|
1778
|
+
const lrc = qqParseLrc(lyric)
|
|
1779
|
+
writeJson(response, 200, { ok: true, hasLyric: lrc.length > 0, lrc, trans: qqParseLrc(trans) })
|
|
1780
|
+
return
|
|
1781
|
+
}
|
|
1782
|
+
if (pathname === `${QQ_PATH}/lyric-words` && method === 'GET') {
|
|
1783
|
+
// 加法路由(母本没有,也没有删改母本任何形状):同样的 QRC 歌,把上游丢弃的
|
|
1784
|
+
// 逐词时间轴一并下发,供我们侧边栏做「一个字一个字点亮」。
|
|
1785
|
+
const songmid = (url.searchParams.get('songmid') || url.searchParams.get('mid') || '').trim()
|
|
1786
|
+
if (songmid === '' || !/^[0-9A-Za-z_-]+$/.test(songmid)) {
|
|
1787
|
+
writeJson(response, 400, { ok: false, error: 'bad songmid' })
|
|
1788
|
+
return
|
|
1789
|
+
}
|
|
1790
|
+
loadQQCookie()
|
|
1791
|
+
let rows = qqWordsCache.get(songmid)
|
|
1792
|
+
if (rows === undefined) {
|
|
1793
|
+
let info = qqMidInfoCache.get(songmid)
|
|
1794
|
+
if (info === undefined) {
|
|
1795
|
+
try {
|
|
1796
|
+
info = await QQ.getSongInfoByMid(songmid, qq.cookie)
|
|
1797
|
+
} catch {
|
|
1798
|
+
info = null
|
|
1799
|
+
}
|
|
1800
|
+
qqMidInfoCache.set(songmid, info)
|
|
1801
|
+
if (qqMidInfoCache.size > QQ_MID_INFO_MAX) {
|
|
1802
|
+
const oldest = qqMidInfoCache.keys().next().value
|
|
1803
|
+
if (oldest !== undefined) qqMidInfoCache.delete(oldest)
|
|
1804
|
+
}
|
|
1805
|
+
}
|
|
1806
|
+
rows = info === null ? null : await qqFetchQrcWords(info, qq.cookie).catch(() => null)
|
|
1807
|
+
qqWordsCache.set(songmid, rows)
|
|
1808
|
+
if (qqWordsCache.size > 50) {
|
|
1809
|
+
const oldest = qqWordsCache.keys().next().value
|
|
1810
|
+
if (oldest !== undefined) qqWordsCache.delete(oldest)
|
|
1811
|
+
}
|
|
1812
|
+
}
|
|
1813
|
+
if (rows === null || rows.length === 0) {
|
|
1814
|
+
writeJson(response, 200, { ok: true, hasWords: false, source: 'qq-qrc-words', wordLines: [], lines: [] })
|
|
1815
|
+
return
|
|
1816
|
+
}
|
|
1817
|
+
writeJson(response, 200, {
|
|
1818
|
+
ok: true,
|
|
1819
|
+
hasWords: true,
|
|
1820
|
+
source: 'qq-qrc-words',
|
|
1821
|
+
wordLines: rows,
|
|
1822
|
+
lines: rows.map((row) => ({ t: row.t, end: row.end, text: row.text })),
|
|
1823
|
+
})
|
|
1824
|
+
return
|
|
1825
|
+
}
|
|
1826
|
+
if (pathname.startsWith(`${QQ_PATH}/playlist/`) && method === 'GET') {
|
|
1827
|
+
const id = decodeURIComponent(pathname.slice(`${QQ_PATH}/playlist/`.length))
|
|
1828
|
+
if (id === '' || !/^[0-9A-Za-z:]+$/.test(id)) {
|
|
1829
|
+
writeJson(response, 400, { ok: false, error: 'bad id' })
|
|
1830
|
+
return
|
|
1831
|
+
}
|
|
1832
|
+
loadQQCookie()
|
|
1833
|
+
try {
|
|
1834
|
+
const detail = await QQ.getPlaylistSongs(id, qq.cookie)
|
|
1835
|
+
writeJson(response, 200, { ok: true, playlist: detail })
|
|
1836
|
+
} catch (error) {
|
|
1837
|
+
// 母本此处是 404(不是 502)。
|
|
1838
|
+
writeJson(response, 404, qqError(error))
|
|
1839
|
+
}
|
|
1840
|
+
return
|
|
1841
|
+
}
|
|
1842
|
+
// ── MV:取 vid(前端拿它决定是否显示 MV 按钮;无 MV 不是错误) ──────────
|
|
1843
|
+
if (pathname === `${QQ_PATH}/mv-vid` && method === 'GET') {
|
|
1844
|
+
const songmid = (url.searchParams.get('songmid') || url.searchParams.get('mid') || '').trim()
|
|
1845
|
+
if (songmid === '' || !/^[A-Za-z0-9]+$/.test(songmid)) {
|
|
1846
|
+
writeJson(response, 400, { ok: false, error: 'bad songmid' })
|
|
1847
|
+
return
|
|
1848
|
+
}
|
|
1849
|
+
try {
|
|
1850
|
+
const info = await qqFetchMvVid(songmid)
|
|
1851
|
+
writeJson(response, 200, { ok: true, hasMv: info.hasMv, vid: info.vid, mvid: info.mvid, name: info.name })
|
|
1852
|
+
} catch (error) {
|
|
1853
|
+
writeJson(response, 502, qqError(error))
|
|
1854
|
+
}
|
|
1855
|
+
return
|
|
1856
|
+
}
|
|
1857
|
+
// ── MV:同源流代理(透传 Range/206/Content-Range,支持 HEAD,可中途 abort) ──
|
|
1858
|
+
if (pathname.startsWith(`${QQ_PATH}/mv/`) && (method === 'GET' || method === 'HEAD')) {
|
|
1859
|
+
const vid = decodeURIComponent(pathname.slice(`${QQ_PATH}/mv/`.length))
|
|
1860
|
+
if (vid === '' || !/^[A-Za-z0-9]+$/.test(vid)) {
|
|
1861
|
+
writeJson(response, 400, { ok: false, error: 'bad vid' })
|
|
1862
|
+
return
|
|
1863
|
+
}
|
|
1864
|
+
loadQQCookie()
|
|
1865
|
+
let targetUrl = ''
|
|
1866
|
+
try {
|
|
1867
|
+
targetUrl = await qqFetchMvUrl(vid, qq.cookie)
|
|
1868
|
+
} catch {
|
|
1869
|
+
targetUrl = ''
|
|
1870
|
+
}
|
|
1871
|
+
if (targetUrl === '') {
|
|
1872
|
+
writeJson(response, 502, { ok: false, error: 'mv url unavailable' })
|
|
1873
|
+
return
|
|
1874
|
+
}
|
|
1875
|
+
const upstreamHeaders = { 'User-Agent': QQ_USER_AGENT, Referer: 'https://y.qq.com/' }
|
|
1876
|
+
if (typeof request.headers.range === 'string' && request.headers.range !== '') {
|
|
1877
|
+
upstreamHeaders.Range = request.headers.range
|
|
1878
|
+
}
|
|
1879
|
+
let upstream
|
|
1880
|
+
try {
|
|
1881
|
+
upstream = await fetch(targetUrl, { method: method === 'HEAD' ? 'HEAD' : 'GET', headers: upstreamHeaders })
|
|
1882
|
+
} catch {
|
|
1883
|
+
writeJson(response, 502, { ok: false, error: 'mv upstream failed' })
|
|
1884
|
+
return
|
|
1885
|
+
}
|
|
1886
|
+
const headers = { 'Content-Type': 'video/mp4', 'Accept-Ranges': 'bytes', 'Cache-Control': 'no-store' }
|
|
1887
|
+
const contentRange = upstream.headers.get('content-range')
|
|
1888
|
+
if (contentRange !== null) headers['Content-Range'] = contentRange
|
|
1889
|
+
const contentLength = upstream.headers.get('content-length')
|
|
1890
|
+
if (contentLength !== null) headers['Content-Length'] = contentLength
|
|
1891
|
+
response.writeHead(upstream.status, headers)
|
|
1892
|
+
if (method === 'HEAD' || upstream.body === null) {
|
|
1893
|
+
if (upstream.body !== null) {
|
|
1894
|
+
try { await upstream.body.cancel() } catch { /* 忽略 */ }
|
|
1895
|
+
}
|
|
1896
|
+
response.end()
|
|
1897
|
+
return
|
|
1898
|
+
}
|
|
1899
|
+
const stream = Readable.fromWeb(upstream.body)
|
|
1900
|
+
request.on('close', () => { try { stream.destroy() } catch { /* 客户端 seek 会反复 abort */ } })
|
|
1901
|
+
stream.on('error', () => { try { response.destroy() } catch { /* 忽略 */ } })
|
|
1902
|
+
stream.pipe(response)
|
|
1903
|
+
return
|
|
1904
|
+
}
|
|
1905
|
+
// ── 别名区(纯加法;母本没有这几个路径,形状不改动上面任何一条) ────────
|
|
1906
|
+
if (pathname === `${QQ_PATH}/qr` && method === 'GET') {
|
|
1907
|
+
// 服务端持有会话版:取二维码图(默认 JSON 带 data URL,?format=png 给原始 PNG)。
|
|
1908
|
+
// 复用窗口内的重复请求回同一把 key,`?fresh=1` 强制换新码。
|
|
1909
|
+
const fresh = url.searchParams.get('fresh') === '1'
|
|
1910
|
+
const now = Date.now()
|
|
1911
|
+
if (!fresh && qqLoginSession !== null && now - qqLoginSession.createdAt < QQ_QR_REUSE_MS) {
|
|
1912
|
+
writeQQQrPayload(url, qqLoginSession, response)
|
|
1913
|
+
return
|
|
1914
|
+
}
|
|
1915
|
+
const session = await QQ.createQRLogin()
|
|
1916
|
+
qqLoginSession = {
|
|
1917
|
+
key: session.key,
|
|
1918
|
+
mode: 'qq',
|
|
1919
|
+
expiresAt: session.expiresAt,
|
|
1920
|
+
imageDataUrl: session.imageDataUrl,
|
|
1921
|
+
createdAt: now,
|
|
1922
|
+
}
|
|
1923
|
+
writeQQQrPayload(url, qqLoginSession, response)
|
|
1924
|
+
return
|
|
1925
|
+
}
|
|
1926
|
+
if (pathname === `${QQ_PATH}/qr/status` && method === 'GET') {
|
|
1927
|
+
// 轮询服务端会话。**不设本地过期门**:服务端 120 s 自己判死并回 status='expired'。
|
|
1928
|
+
loadQQCookie()
|
|
1929
|
+
if (qq.cookie !== '') {
|
|
1930
|
+
writeJson(response, 200, { ok: true, status: 'logged-in', ...qqAuthPayload() })
|
|
1931
|
+
return
|
|
1932
|
+
}
|
|
1933
|
+
const session = qqLoginSession
|
|
1934
|
+
if (session === null) {
|
|
1935
|
+
writeJson(response, 200, { ok: true, status: 'idle', ...qqAuthPayload(), message: '尚未获取二维码' })
|
|
1936
|
+
return
|
|
1937
|
+
}
|
|
1938
|
+
const result = session.mode === 'wx' ? await QQ.checkWXQRLogin(session.key) : await QQ.checkQRLogin(session.key)
|
|
1939
|
+
if (result.status === 'success') {
|
|
1940
|
+
qqApplyLogin(result, session.mode)
|
|
1941
|
+
writeJson(response, 200, { ok: true, status: 'success', ...qqAuthPayload(), message: result.message, extra: result.extra })
|
|
1942
|
+
return
|
|
1943
|
+
}
|
|
1944
|
+
writeJson(response, 200, { ok: true, status: result.status, ...qqAuthPayload(), message: result.message, extra: result.extra })
|
|
1945
|
+
return
|
|
1946
|
+
}
|
|
1947
|
+
if (pathname === `${QQ_PATH}/playlist` && method === 'GET') {
|
|
1948
|
+
// 别名:查询串写 id(母本用路径式 /qq/playlist/<id>,两者等价)。
|
|
1949
|
+
const id = (url.searchParams.get('id') || '').trim()
|
|
1950
|
+
if (id === '' || !/^[0-9A-Za-z:]+$/.test(id)) {
|
|
1951
|
+
writeJson(response, 400, { ok: false, error: 'bad id' })
|
|
1952
|
+
return
|
|
1953
|
+
}
|
|
1954
|
+
loadQQCookie()
|
|
1955
|
+
try {
|
|
1956
|
+
const detail = await QQ.getPlaylistSongs(id, qq.cookie)
|
|
1957
|
+
writeJson(response, 200, { ok: true, playlist: detail })
|
|
1958
|
+
} catch (error) {
|
|
1959
|
+
writeJson(response, 404, qqError(error))
|
|
1960
|
+
}
|
|
1961
|
+
return
|
|
1962
|
+
}
|
|
1963
|
+
throw new MediaError('not-found', `unknown qq route ${pathname}`, 404)
|
|
1964
|
+
} catch (error) {
|
|
1965
|
+
if (response.headersSent) {
|
|
1966
|
+
try {
|
|
1967
|
+
response.destroy()
|
|
1968
|
+
} catch {
|
|
1969
|
+
// 连接已断,忽略。
|
|
1970
|
+
}
|
|
1971
|
+
return
|
|
1972
|
+
}
|
|
1973
|
+
// QQ 路由内一律 `{ok:false,error:'字符串'}`(同母本);取不到上游就给 502。
|
|
1974
|
+
writeJson(response, error instanceof MediaError ? error.status : 502, qqError(error))
|
|
1975
|
+
}
|
|
1976
|
+
}
|
|
1977
|
+
|
|
526
1978
|
async function handleRequest(request, response, ctx) {
|
|
527
1979
|
try {
|
|
528
|
-
|
|
1980
|
+
// 不读取 ctx.webRuntime:本插件 inject 已不含该服务,Cordis 下对未 inject 的 ctx 服务即使短路读取属性
|
|
1981
|
+
// 也会抛 "cannot get property \"webRuntime\" without inject",导致 handleRequest 全路由 500。
|
|
1982
|
+
// 桌面端请求全部走 127.0.0.1(loopback),isTrustedApiRequest 对 loopback 无条件放行,故 trustedHosts 固定空数组。
|
|
1983
|
+
const trustedHosts = []
|
|
529
1984
|
if (!isTrustedApiRequest(request, trustedHosts)) {
|
|
530
1985
|
throw new MediaError('forbidden', 'untrusted host', 403)
|
|
531
1986
|
}
|
|
532
1987
|
const url = new URL(request.url ?? '/', 'http://localhost')
|
|
1988
|
+
// 诊断回写(临时):客户端把激活/注册进度打到 ~/.dsh/data/smp-diag.log,
|
|
1989
|
+
// 用来定位「侧边栏页签没出现」这类渲染侧静默失败。只写本机文件,不联网。
|
|
1990
|
+
if (url.pathname === `${ROUTE_PREFIX}/diag`) {
|
|
1991
|
+
try {
|
|
1992
|
+
const { mkdirSync, appendFileSync } = await import('node:fs')
|
|
1993
|
+
const { homedir } = await import('node:os')
|
|
1994
|
+
const { join } = await import('node:path')
|
|
1995
|
+
const dir = join(homedir(), '.dsh', 'data')
|
|
1996
|
+
mkdirSync(dir, { recursive: true })
|
|
1997
|
+
appendFileSync(join(dir, 'smp-diag.log'), `${new Date().toISOString()} ${url.searchParams.get('m') ?? ''}\n`, 'utf8')
|
|
1998
|
+
} catch (e) {}
|
|
1999
|
+
writeJson(response, 200, { ok: true })
|
|
2000
|
+
return
|
|
2001
|
+
}
|
|
533
2002
|
if (url.pathname === MEDIA_PATH) {
|
|
534
2003
|
await handleMedia(url, ctx, request, response)
|
|
535
2004
|
return
|
|
@@ -542,6 +2011,22 @@ async function handleRequest(request, response, ctx) {
|
|
|
542
2011
|
await handleSubtitle(url, ctx, request, response)
|
|
543
2012
|
return
|
|
544
2013
|
}
|
|
2014
|
+
if (url.pathname === LIBRARY_PATH) {
|
|
2015
|
+
await handleLibrary(url, ctx, request, response)
|
|
2016
|
+
return
|
|
2017
|
+
}
|
|
2018
|
+
if (url.pathname === DIR_PATH) {
|
|
2019
|
+
await handleDir(url, ctx, request, response)
|
|
2020
|
+
return
|
|
2021
|
+
}
|
|
2022
|
+
if (url.pathname === DURATION_PATH) {
|
|
2023
|
+
await handleDuration(url, ctx, request, response)
|
|
2024
|
+
return
|
|
2025
|
+
}
|
|
2026
|
+
if (url.pathname === QQ_PATH || url.pathname.startsWith(`${QQ_PATH}/`)) {
|
|
2027
|
+
await handleQQ(url, request, response)
|
|
2028
|
+
return
|
|
2029
|
+
}
|
|
545
2030
|
throw new MediaError('not-found', `unknown route ${url.pathname}`, 404)
|
|
546
2031
|
} catch (error) {
|
|
547
2032
|
writeError(response, error)
|
|
@@ -575,6 +2060,10 @@ export const __internals = {
|
|
|
575
2060
|
MEDIA_PATH,
|
|
576
2061
|
LYRIC_PATH,
|
|
577
2062
|
SUBTITLE_PATH,
|
|
2063
|
+
LIBRARY_PATH,
|
|
2064
|
+
DIR_PATH,
|
|
2065
|
+
DURATION_PATH,
|
|
2066
|
+
probeDurationFromBuffer,
|
|
578
2067
|
MEDIA_TYPES,
|
|
579
2068
|
parseRange,
|
|
580
2069
|
isWithin,
|
|
@@ -584,4 +2073,7 @@ export const __internals = {
|
|
|
584
2073
|
srtToVtt,
|
|
585
2074
|
assToVtt,
|
|
586
2075
|
assTimeToVtt,
|
|
2076
|
+
allowedBases,
|
|
2077
|
+
isAllowedTarget,
|
|
2078
|
+
musicLibraryRoot,
|
|
587
2079
|
}
|