@lzwme/m3u8-dl 0.0.2 → 0.0.4

package/README.MD

@@ -12,16 +12,19 @@
 [![GitHub forks][forks-badge]][forks-url]
 [![GitHub stars][stars-badge]][stars-url]
 
-一个 m3u8 文件批量下载工具。
+一个 m3u8 文件视频批量下载工具。
+
+![](./examples/img/m3u8dl-search-demo.png)
 
 ## 功能特性(Features)
 
 - 多线程下载。线程池模式的多线程下载。
 - `边下边播模式`。支持使用已下载的 ts 缓存文件在线播放。
 - 支持指定多个 m3u8 地址批量下载。
-- 支持缓存续传。下载失败则保留缓存，重试时只下载失败的片段。
-- 支持常见的 AES 解密。
-- 支持转换为 mp4。**需全局安装 ffmpeg**
+- 支持缓存续传。下载失败会保留缓存，重试时只下载失败的片段。
+- 支持常见的 AES 加密视频流解密。
+- 自动转换为 mp4。**需全局安装 ffmpeg**
+- `[NEW!]`支持指定采集站标准 API，以命令行交互的方式搜索和下载。
 
 ## 安装(Install)
 
@@ -36,7 +39,7 @@ m3u8dl -h
 npx @lzwme/m3u8-dl -h
 ```
 
-## 使用(Useage)
+## Useage
 
 提示：如需要下载并转换为 `mp4` 视频格式，您需全局安装 [ffmpeg](https://ffmpeg.org/download.html)。
 
@@ -46,20 +49,20 @@ npx @lzwme/m3u8-dl -h
 m3u8dl --help
 ```
 
-**下载指定 URL 的 m3u8 文件：**
+#### 下载指定 URL 的 m3u8 文件：
 
 ```bash
 m3u8dl https://lzw.me/x/m3u8-player/test.m3u8
 ```
 
-**批量下载示例一：**
+#### 批量下载示例一：
 
 ```bash
 # 下载多个文件：
 m3u8dl "第1集｜https://s.xlzys.com/play/zbqMZYRb/index.m3u8" "第2集｜https://s.xlzys.com/play/PdyJXrwe/index.m3u8" --filename "三体"
 ```
 
-**批量下载示例二：**
+#### 批量下载示例二：
 
 新建文件 `三体.txt`，内容格式：
 
@@ -77,6 +80,17 @@ m3u8dl 三体.txt
 
 提示：可创建并指定多个 txt 文件实现对多个影视剧集的一键批量下载。
 
+#### 指定采集站 API 搜索并下载
+
+```bash
+m3u8dl search -h
+
+# 指定采集站 API url 地址（会缓存），然后按提示操作
+m3u8dl s -u https://jyzyapi.com/provide/vod/
+```
+
+**声明：** 以上仅作示例，请自行搜索查找可用的采集站 API。本工具仅用作技术研究学习，不提供任何具体资源类信息。
+
 ### API 调用
 
 ```ts
@@ -93,10 +107,6 @@ for (const filepath of fileList) {
 }
 ```
 
-## API 文档
-
-- [https://lzwme.github.io/m3u8-dl/](https://lzwme.github.io/m3u8-dl/)
-
 ## 开发(Development)
 
 本地二次开发：

package/cjs/cli.js

@@ -4,9 +4,19 @@ const node_path_1 = require("node:path");
 const commander_1 = require("commander");
 const console_log_colors_1 = require("console-log-colors");
 const fe_utils_1 = require("@lzwme/fe-utils");
+const enquirer_1 = require("enquirer");
 const utils_js_1 = require("./lib/utils.js");
 const m3u8_batch_download_1 = require("./m3u8-batch-download");
+const video_search_js_1 = require("./lib/video-search.js");
 const pkg = (0, fe_utils_1.readJsonFileSync)((0, node_path_1.resolve)(__dirname, '../package.json'));
+process.on('unhandledRejection', (r, p) => {
+    console.log('[退出]UnhandledPromiseRejection', r, p);
+    process.exit();
+});
+process.on('SIGINT', signal => {
+    utils_js_1.logger.info('强制退出', signal);
+    process.exit();
+});
 commander_1.program
     .version(pkg.version, '-v, --version')
     .description((0, console_log_colors_1.cyanBright)(pkg.description))
@@ -21,14 +31,8 @@ commander_1.program
     .option('-C, --cache-dir <dirpath>', `临时文件保存目录。默认为 cache`)
     .option('-S, --save-dir <dirpath>', `下载文件保存的路径。默认为当前目录`)
     .option('--no-del-cache', `下载成功后是否删除临时文件。默认为 true。保存临时文件可以在重复下载时识别缓存`, true)
-    .action(async (urls, options) => {
-    if (options.debug) {
-        utils_js_1.logger.updateOptions({ levelType: 'debug' });
-    }
-    else if (options.silent) {
-        utils_js_1.logger.updateOptions({ levelType: 'silent' });
-        options.progress = false;
-    }
+    .action(async (urls) => {
+    const options = getOptions();
     utils_js_1.logger.debug(urls, options);
     if (options.progress != null)
         options.showProgress = options.progress;
@@ -38,4 +42,115 @@ commander_1.program
     else
         commander_1.program.help();
 });
+commander_1.program
+    .command('search [keyword]')
+    .alias('s')
+    .option('-u,--url <api...>', '影视搜索的接口地址(m3u8采集站标准接口)')
+    .description('m3u8视频在线搜索与下载')
+    .action(async (keyword, options) => {
+    VideoSerachAndDL(keyword, options, getOptions());
+});
 commander_1.program.parse(process.argv);
+function getOptions() {
+    const options = commander_1.program.opts();
+    if (options.debug) {
+        utils_js_1.logger.updateOptions({ levelType: 'debug' });
+    }
+    else if (options.silent) {
+        utils_js_1.logger.updateOptions({ levelType: 'silent' });
+        options.progress = false;
+    }
+    return options;
+}
+async function VideoSerachAndDL(keyword, options, baseOpts) {
+    const vs = new video_search_js_1.VideoSearch();
+    await vs.updateOptions({ api: options.url || [] });
+    let apiUrl = vs.api[0];
+    if (!options.url && vs.api.length > 0) {
+        await (0, enquirer_1.prompt)({
+            type: 'select',
+            name: 'k',
+            message: '请选择 API 站点',
+            choices: vs.api.map(d => ({ name: d, message: d })),
+            validate: value => value.length >= 1,
+        }).then(v => (apiUrl = v.k));
+    }
+    await (0, enquirer_1.prompt)({
+        type: 'input',
+        name: 'k',
+        message: '请输入关键字',
+        validate: value => value.length > 1,
+        initial: keyword,
+    }).then(v => (keyword = v.k));
+    const sRes = await vs.search(keyword, apiUrl);
+    utils_js_1.logger.debug(sRes);
+    if (!sRes.total) {
+        console.log(console_log_colors_1.color.green(`[${keyword}]`), `没有搜到结果`);
+        return VideoSerachAndDL(keyword, options, baseOpts);
+    }
+    const choices = sRes.list.map((d, idx) => ({
+        name: d.vod_id,
+        message: `${idx + 1}. [${d.type_name}] ${d.vod_name}`,
+        hint: `${d.vod_remarks}(${d.vod_time})`,
+    }));
+    const answer1 = await (0, enquirer_1.prompt)({
+        type: 'select',
+        name: 'vid',
+        pointer: '👉',
+        message: `查找到了 ${console_log_colors_1.color.greenBright(sRes.list.length)} 条结果，请选择：`,
+        choices: choices.concat({ name: -1, message: (0, console_log_colors_1.greenBright)('重新搜索'), hint: '' }),
+    });
+    if (answer1.vid === -1)
+        return VideoSerachAndDL(keyword, options, baseOpts);
+    const vResult = await vs.getVideoList(answer1.vid, apiUrl);
+    if (!vResult.list?.length) {
+        utils_js_1.logger.error('获取视频信息失败!', vResult.msg);
+        return VideoSerachAndDL(keyword, options, baseOpts);
+    }
+    else {
+        const info = vResult.list[0];
+        const urls = info.vod_play_url
+            .split(info.vod_play_note)
+            .find(d => d.includes('.m3u8'))
+            .split('#');
+        utils_js_1.logger.debug(info, urls);
+        const r = (key, desc) => (info[key] ? `  [${desc}] ${(0, console_log_colors_1.greenBright)(info[key])}` : '');
+        console.log([
+            `\n  [名称] ${(0, console_log_colors_1.cyanBright)(info.vod_name)}`,
+            r('vod_sub', '别名'),
+            `  [更新] ${(0, console_log_colors_1.greenBright)(info.vod_remarks)}(${(0, console_log_colors_1.gray)(info.vod_time)})`,
+            r('vod_total', '总集数'),
+            r('type_name', '分类'),
+            r('vod_class', '类别'),
+            r('vod_writer', '作者'),
+            r('vod_area', '地区'),
+            r('vod_lang', '语言'),
+            r('vod_year', '年份'),
+            r('vod_douban_score', '评分'),
+            r('vod_pubdate', '上映日期'),
+            `\n${(0, console_log_colors_1.green)((info.vod_content || info.vod_blurb).replace(/<\/?.+?>/g, ''))}\n`, // 描述
+        ]
+            .filter(Boolean)
+            .join('\n'), '\n');
+        const answer = await (0, enquirer_1.prompt)({
+            type: 'select',
+            name: 'url',
+            choices: [
+                { name: '1', message: (0, console_log_colors_1.green)('全部下载') },
+                { name: '-1', message: (0, console_log_colors_1.cyanBright)('重新搜索') },
+            ].concat(urls.map((d, i) => ({ name: d, message: `${i + 1}. ${d}` }))),
+            message: `获取到了 ${console_log_colors_1.color.magentaBright(urls.length)} 条视频下载地址，请选择：`,
+        });
+        if (answer.url !== '-1') {
+            const p = await (0, enquirer_1.prompt)({
+                type: 'confirm',
+                name: 'play',
+                initial: baseOpts.play,
+                message: `【${(0, console_log_colors_1.greenBright)(info.vod_name)}】是否边下边播？`,
+            });
+            baseOpts.play = p.play;
+            await (0, m3u8_batch_download_1.m3u8BatchDownload)(answer.url === '1' ? urls : [answer.url], { filename: info.vod_name.replaceAll(' ', '_'), ...baseOpts });
+        }
+        return VideoSerachAndDL(keyword, options, baseOpts);
+    }
+}

package/cjs/lib/local-play.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="node" />
-import { M3u8DLOptions, TsItemInfo } from '../type';
+import { M3u8DLOptions, TsItemInfo } from '../types/m3u8';
 /**
  * 边下边看
  */

package/cjs/lib/local-play.js

@@ -68,6 +68,7 @@ async function createLocalServer(baseDir) {
         res.writeHead(404, { 'Content-Type': 'text/plain; charset=utf-8' });
         res.end('Not found');
     }).listen(port, () => {
+        console.log();
         utils_1.logger.info('Created Local Server:', console_log_colors_1.color.greenBright(origin));
     });
     return { port, origin, server };

package/cjs/lib/m3u8-convert.d.ts

@@ -1,2 +1,2 @@
-import type { M3u8DLOptions, TsItemInfo } from '../type';
+import type { M3u8DLOptions, TsItemInfo } from '../types/m3u8';
 export declare function m3u8Convert(options: M3u8DLOptions, data: TsItemInfo[]): Promise<string>;

package/cjs/lib/m3u8-convert.js

@@ -11,13 +11,15 @@ async function m3u8Convert(options, data) {
     let ffmpegSupport = (0, utils_1.isSupportFfmpeg)();
     let filepath = (0, node_path_1.resolve)(options.saveDir, options.filename);
     if (!ffmpegSupport)
-        filepath = filepath.replace('.mp4', '.ts');
+        filepath = filepath.replace(/\.mp4$/, '.ts');
     if (!options.force && (0, node_fs_1.existsSync)(filepath))
         return filepath;
     utils_1.logger.info(`Starting ${ffmpegSupport ? 'convert to mp4' : 'merge into ts'} file:`, (0, console_log_colors_1.greenBright)(filepath));
     if (ffmpegSupport) {
         const inputFilePath = (0, node_path_1.resolve)(options.cacheDir, 'input.txt');
-        const filesAllArr = data.map(d => (0, node_path_1.resolve)(d.tsOut)).filter(d => (0, node_fs_1.existsSync)(d));
+        let filesAllArr = data.map(d => (0, node_path_1.resolve)(d.tsOut)).filter(d => (0, node_fs_1.existsSync)(d));
+        if (process.platform === 'win32')
+            filesAllArr = filesAllArr.map(d => d.replaceAll('\\', '/'));
         await node_fs_1.promises.writeFile(inputFilePath, 'ffconcat version 1.0\nfile ' + filesAllArr.join('\nfile '));
         const cmd = `ffmpeg -y -f concat -safe 0 -i ${inputFilePath} -acodec copy -vcodec copy -absf aac_adtstoasc ${filepath}`;
         utils_1.logger.debug('[convert to mp4]cmd:', (0, console_log_colors_1.cyan)(cmd));
@@ -26,12 +28,13 @@ async function m3u8Convert(options, data) {
         if (r.error)
             utils_1.logger.error('Conversion to mp4 failed. Please confirm that `ffmpeg` is installed!', r.stderr);
     }
-    else {
+    if (!ffmpegSupport) {
+        filepath = filepath.replace(/\.mp4$/, '.ts');
         await node_fs_1.promises.writeFile(filepath, Buffer.concat(data.map(d => (0, node_fs_1.readFileSync)(d.tsOut))));
     }
-    if ((0, node_fs_1.existsSync)(filepath)) {
-        utils_1.logger.info(`File saved[${(0, console_log_colors_1.magentaBright)((0, helper_1.formatByteSize)((0, node_fs_1.statSync)(filepath).size))}]:`, (0, console_log_colors_1.greenBright)(filepath));
-    }
+    if (!(0, node_fs_1.existsSync)(filepath))
+        return '';
+    utils_1.logger.info(`File saved[${(0, console_log_colors_1.magentaBright)((0, helper_1.formatByteSize)((0, node_fs_1.statSync)(filepath).size))}]:`, (0, console_log_colors_1.greenBright)(filepath));
     return filepath;
 }
 exports.m3u8Convert = m3u8Convert;

package/cjs/lib/m3u8-download.d.ts

@@ -1,4 +1,10 @@
-import type { M3u8DLOptions, TsItemInfo } from '../type';
+import { WorkerPool } from './worker_pool';
+import type { M3u8DLOptions, TsItemInfo, WorkerTaskInfo } from '../types/m3u8';
+export declare const workPoll: WorkerPool<WorkerTaskInfo, {
+    success: boolean;
+    info: TsItemInfo;
+}>;
+export declare function preDownLoad(url: string, options: M3u8DLOptions): Promise<void>;
 export declare function m3u8Download(url: string, options?: M3u8DLOptions): Promise<{
     options: M3u8DLOptions;
     m3u8Info: {
@@ -6,7 +12,7 @@ export declare function m3u8Download(url: string, options?: M3u8DLOptions): Prom
         tsCount: number;
         durationSecond: number;
         data: TsItemInfo[];
-        crypto: import("../type").M3u8Crypto;
+        crypto: import("../types/m3u8").M3u8Crypto;
     };
     filepath: string;
 }>;

package/cjs/lib/m3u8-download.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.m3u8Download = void 0;
+exports.m3u8Download = exports.preDownLoad = exports.workPoll = void 0;
 const node_path_1 = require("node:path");
 const node_fs_1 = require("node:fs");
 const node_os_1 = require("node:os");
@@ -12,15 +12,21 @@ const worker_pool_1 = require("./worker_pool");
 const parseM3u8_1 = require("./parseM3u8");
 const m3u8_convert_1 = require("./m3u8-convert");
 const local_play_1 = require("./local-play");
+const cache = {
+    m3u8Info: {},
+    downloading: new Set(),
+};
 const tsDlFile = (0, node_path_1.resolve)(__dirname, './ts-download.js');
+exports.workPoll = new worker_pool_1.WorkerPool(tsDlFile);
 async function formatOptions(url, opts) {
     const options = {
         delCache: !opts.debug,
         saveDir: process.cwd(),
+        showProgress: true,
         ...opts,
     };
     if (!url.startsWith('http')) {
-        url = url.replace('$', '|').replace(/\|\|+/, '|');
+        url = url.replace(/\$+/, '|').replace(/\|\|+/, '|');
         if (url.includes('|')) {
             const r = url.split('|');
             url = r[1];
@@ -39,35 +45,65 @@ async function formatOptions(url, opts) {
         options.filename += '.mp4';
     if (!options.cacheDir)
         options.cacheDir = `cache/${urlMd5}`;
-    if (!(0, node_fs_1.existsSync)(options.cacheDir))
-        await node_fs_1.promises.mkdir(options.cacheDir, { recursive: true });
     if (options.headers)
         utils_1.request.setHeaders(options.headers);
     if (options.debug) {
         utils_1.logger.updateOptions({ levelType: 'debug' });
-        utils_1.logger.debug('[m3u8-DL]options', options);
+        utils_1.logger.debug('[m3u8-DL]options', options, url);
     }
     return [url, options];
 }
-async function m3u8Download(url, options = {}) {
-    utils_1.logger.info('Starting download for', (0, console_log_colors_1.cyanBright)(url));
+async function m3u8InfoParse(url, options = {}) {
     [url, options] = await formatOptions(url, options);
     const ext = (0, utils_1.isSupportFfmpeg)() ? '.mp4' : '.ts';
     let filepath = (0, node_path_1.resolve)(options.saveDir, options.filename);
     if (!filepath.endsWith(ext))
         filepath += ext;
     const result = { options, m3u8Info: null, filepath };
-    if (!options.force && (0, node_fs_1.existsSync)(filepath)) {
-        utils_1.logger.info('file already exist:', filepath);
+    if (cache.m3u8Info[url]) {
+        Object.assign(result, cache.m3u8Info[url]);
         return result;
     }
+    if (!options.force && (0, node_fs_1.existsSync)(filepath))
+        return result;
     const m3u8Info = await (0, parseM3u8_1.parseM3U8)('', url, options.cacheDir).catch(e => utils_1.logger.error(e));
-    if (m3u8Info && m3u8Info?.tsCount > 0) {
+    if (m3u8Info && m3u8Info?.tsCount > 0)
         result.m3u8Info = m3u8Info;
+    return result;
+}
+async function preDownLoad(url, options) {
+    const result = await m3u8InfoParse(url, options);
+    if (!result.m3u8Info)
+        return;
+    for (const info of result.m3u8Info.data) {
+        if (!exports.workPoll.freeNum)
+            return;
+        if (!cache.downloading.has(info.uri)) {
+            cache.downloading.add(info.uri);
+            exports.workPoll.runTask({ info, options: JSON.parse(JSON.stringify(result.options)), crypto: result.m3u8Info.crypto }, () => {
+                cache.downloading.delete(info.uri);
+            });
+        }
+    }
+}
+exports.preDownLoad = preDownLoad;
+async function m3u8Download(url, options = {}) {
+    utils_1.logger.info('Starting download for', (0, console_log_colors_1.cyanBright)(url));
+    const result = await m3u8InfoParse(url, options);
+    options = result.options;
+    if (!options.force && (0, node_fs_1.existsSync)(result.filepath) && !result.m3u8Info) {
+        utils_1.logger.info('file already exist:', result.filepath);
+        return result;
+    }
+    if (result.m3u8Info?.tsCount > 0) {
+        let n = options.threadNum - exports.workPoll.numThreads;
+        if (n > 0)
+            while (n--)
+                exports.workPoll.addNewWorker();
+        const { m3u8Info } = result;
         const startTime = Date.now();
-        const pool = new worker_pool_1.WorkerPool(tsDlFile, options.threadNum);
         const barrier = new fe_utils_1.Barrier();
-        const playStart = Math.min(options.threadNum + 2, m3u8Info.tsCount);
+        const playStart = Math.min(options.threadNum + 2, result.m3u8Info.tsCount);
         const stats = {
             /** 下载成功的 ts 数量 */
             tsSuccess: 0,
@@ -78,7 +114,7 @@ async function m3u8Download(url, options = {}) {
         };
         const runTask = (data) => {
             for (const info of data) {
-                pool.runTask({ info, options: JSON.parse(JSON.stringify(options)), crypto: m3u8Info.crypto }, (err, res) => {
+                exports.workPoll.runTask({ info, options: JSON.parse(JSON.stringify(options)), crypto: m3u8Info.crypto }, (err, res) => {
                     if (!res || err) {
                         if (err) {
                             console.log('\n');
@@ -98,26 +134,29 @@ async function m3u8Download(url, options = {}) {
                         info.tsSize = res.info.tsSize;
                         info.success = 1;
                         stats.tsSuccess++;
-                        stats.duration = +(stats.duration + info.duration).toFixed(2);
+                        stats.duration += info.duration;
                     }
                     else {
                         stats.tsFailed++;
                     }
                     const finished = stats.tsFailed + stats.tsSuccess;
-                    if (options.showProgress !== false) {
+                    if (options.showProgress) {
+                        const timeCost = Date.now() - startTime;
                         const downloadedSize = m3u8Info.data.reduce((a, b) => a + (b.tsSize || 0), 0);
-                        const avgSpeed = (0, helper_1.formatByteSize)((downloadedSize / (Date.now() - startTime)) * 1000);
+                        const downloadedDuration = m3u8Info.data.reduce((a, b) => a + (b.tsSize ? b.duration : 0), 0);
+                        const avgSpeed = (0, helper_1.formatByteSize)((downloadedSize / timeCost) * 1000);
+                        const restTime = downloadedDuration ? (timeCost * (m3u8Info.durationSecond - stats.duration)) / downloadedDuration : 0;
                         const percent = Math.floor((finished / m3u8Info.tsCount) * 100);
                         const processBar = '='.repeat(Math.floor(percent * 0.2)).padEnd(20, '-');
                         utils_1.logger.logInline(`${percent}% [${(0, console_log_colors_1.greenBright)(processBar)}] ${(0, console_log_colors_1.cyan)(finished)} ` +
-                            `${(0, console_log_colors_1.green)(stats.duration + 'sec')} ` +
-                            `${(0, console_log_colors_1.blueBright)((0, helper_1.formatByteSize)(downloadedSize))} ${(0, console_log_colors_1.yellowBright)((0, fe_utils_1.formatTimeCost)(startTime))} ${(0, console_log_colors_1.magentaBright)(avgSpeed + '/s')}` +
-                            (finished === m3u8Info.tsCount ? '\n' : ''));
+                            `${(0, console_log_colors_1.green)(stats.duration.toFixed(2) + 'sec')} ` +
+                            `${(0, console_log_colors_1.blueBright)((0, helper_1.formatByteSize)(downloadedSize))} ${(0, console_log_colors_1.yellowBright)((0, fe_utils_1.formatTimeCost)(startTime))} ${(0, console_log_colors_1.magentaBright)(avgSpeed + '/s')} ` +
+                            (finished === m3u8Info.tsCount ? '\n' : restTime ? `${(0, console_log_colors_1.cyan)((0, fe_utils_1.formatTimeCost)(Date.now() - Math.ceil(restTime)))}` : ''));
                     }
                     if (options.onProgress)
                         options.onProgress(finished, m3u8Info.tsCount, info);
                     if (finished === m3u8Info.tsCount) {
-                        pool.close();
+                        // pool.close();
                         barrier.open();
                     }
                     if (options.play && finished === playStart) {
@@ -127,13 +166,13 @@ async function m3u8Download(url, options = {}) {
             }
         };
         if (options.showProgress) {
-            console.info(`Total segments: ${(0, console_log_colors_1.cyan)(m3u8Info.tsCount)}, duration: ${(0, console_log_colors_1.green)(m3u8Info.durationSecond + 'sec')}.`, `Parallel jobs: ${(0, console_log_colors_1.magenta)(options.threadNum)}`);
+            console.info(`\nTotal segments: ${(0, console_log_colors_1.cyan)(m3u8Info.tsCount)}, duration: ${(0, console_log_colors_1.green)(m3u8Info.durationSecond + 'sec')}.`, `Parallel jobs: ${(0, console_log_colors_1.magenta)(options.threadNum)}`);
         }
         runTask(m3u8Info.data);
         await barrier.wait();
         if (stats.tsFailed === 0) {
             result.filepath = await (0, m3u8_convert_1.m3u8Convert)(options, m3u8Info.data);
-            if ((0, node_fs_1.existsSync)(options.cacheDir) && options.delCache)
+            if (result.filepath && (0, node_fs_1.existsSync)(options.cacheDir) && options.delCache)
                 (0, fe_utils_1.rmrfAsync)(options.cacheDir);
         }
         else

package/cjs/lib/parseM3u8.d.ts

@@ -1,4 +1,4 @@
-import type { M3u8Crypto, TsItemInfo } from '../type';
+import type { M3u8Crypto, TsItemInfo } from '../types/m3u8';
 export declare function parseM3U8(content: string, url?: string, cacheDir?: string): Promise<{
     manifest: any;
     /** ts 文件数量 */

package/cjs/lib/parseM3u8.js

@@ -19,8 +19,9 @@ async function parseM3U8(content, url = process.cwd(), cacheDir = './cache') {
     let parser = new m3u8_parser_1.Parser();
     parser.push(content);
     parser.end();
+    utils_1.logger.debug('parser.manifest', parser.manifest);
     if (parser.manifest.playlists?.length > 0) {
-        url = new URL(url, parser.manifest.playlists[0].uri).toString();
+        url = new URL(parser.manifest.playlists[0].uri, url).toString();
         content = (await (0, utils_1.getRetry)(url)).data;
         parser = new m3u8_parser_1.Parser();
         parser.push(content);
@@ -70,6 +71,7 @@ async function parseM3U8(content, url = process.cwd(), cacheDir = './cache') {
         });
         result.durationSecond += tsList[i].duration;
     }
+    result.durationSecond = +Number(result.durationSecond).toFixed(2);
     return result;
 }
 exports.parseM3U8 = parseM3U8;

package/cjs/lib/storage.d.ts

@@ -0,0 +1,7 @@
+import { LiteStorage } from '@lzwme/fe-utils';
+import { type VSOptions } from './video-search';
+export interface M3u8StorConfig extends VSOptions {
+    /** 播放地址缓存 */
+    api?: string[];
+}
+export declare const stor: LiteStorage<M3u8StorConfig>;

package/cjs/lib/storage.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stor = void 0;
+const fe_utils_1 = require("@lzwme/fe-utils");
+const node_path_1 = require("node:path");
+const node_os_1 = require("node:os");
+exports.stor = fe_utils_1.LiteStorage.getInstance({ uuid: 'm3u8dl', filepath: (0, node_path_1.resolve)((0, node_os_1.homedir)(), '.liteStorage/m3u8dl.json') });

package/cjs/lib/ts-download.d.ts

@@ -1,2 +1,2 @@
-import type { M3u8Crypto, TsItemInfo } from '../type';
+import type { M3u8Crypto, TsItemInfo } from '../types/m3u8';
 export declare function tsDownload(info: TsItemInfo, cryptoInfo: M3u8Crypto): Promise<boolean>;

package/cjs/lib/ts-download.js

@@ -3,7 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.tsDownload = void 0;
 const node_crypto_1 = require("node:crypto");
 const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
 const node_worker_threads_1 = require("node:worker_threads");
+const fe_utils_1 = require("@lzwme/fe-utils");
 const utils_1 = require("./utils");
 async function tsDownload(info, cryptoInfo) {
     try {
@@ -13,6 +15,7 @@ async function tsDownload(info, cryptoInfo) {
         if (r.response.statusCode === 200) {
             utils_1.logger.debug('\n', info);
             const data = cryptoInfo.key ? aesDecrypt(r.buffer, cryptoInfo) : r.buffer;
+            (0, fe_utils_1.mkdirp)((0, node_path_1.dirname)(info.tsOut));
             await node_fs_1.promises.writeFile(info.tsOut, data);
             info.tsSize = r.buffer.byteLength;
             return true;

package/cjs/lib/utils.js

@@ -5,7 +5,8 @@ const fe_utils_1 = require("@lzwme/fe-utils");
 exports.request = new fe_utils_1.Request('', {
     'content-type': 'application/x-www-form-urlencoded; charset=UTF-8',
 });
-const getRetry = (url, retries = 3) => (0, fe_utils_1.retry)(() => exports.request.get(url), 1000, retries, r => r.response.statusCode === 200);
+// process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0';
+const getRetry = (url, retries = 3) => (0, fe_utils_1.retry)(() => exports.request.get(url, null, {}, { rejectUnauthorized: false }), 1000, retries, r => r.response.statusCode === 200);
 exports.getRetry = getRetry;
 exports.logger = fe_utils_1.NLogger.getLogger('[M3U8-DL]', { color: fe_utils_1.color });
 let _isSupportFfmpeg = null;

package/cjs/lib/video-search.d.ts

@@ -0,0 +1,14 @@
+import { VideoListResult, VideoSearchResult } from '../types';
+export interface VSOptions {
+    /** 播放地址缓存 */
+    api?: string[];
+}
+export declare class VideoSearch {
+    protected options: VSOptions;
+    get api(): string[];
+    constructor(options?: VSOptions);
+    updateOptions(options: VSOptions): Promise<this>;
+    search(wd: string, api?: string): Promise<VideoSearchResult>;
+    getVideoList(ids: number | string | (number | string)[], api?: string): Promise<VideoListResult>;
+    formatUrl(url: string | string[]): Promise<string[]>;
+}

package/cjs/lib/video-search.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VideoSearch = void 0;
+const fe_utils_1 = require("@lzwme/fe-utils");
+const storage_1 = require("./storage");
+const req = new fe_utils_1.Request(null, {
+    'content-type': 'application/json; charset=UTF-8',
+});
+class VideoSearch {
+    options;
+    get api() {
+        return this.options.api;
+    }
+    constructor(options = {}) {
+        this.options = options;
+        if (!options.api?.length)
+            options.api = [];
+        if (process.env.VAPI)
+            options.api.push(...process.env.VAPI.split('$$$'));
+        this.updateOptions(options).then(() => {
+            if (!this.api.length)
+                throw Error('没有可用站点，请添加或指定');
+        });
+    }
+    async updateOptions(options) {
+        const cache = storage_1.stor.get();
+        if (Array.isArray(cache.api))
+            this.options.api.push(...cache.api);
+        if (options.api?.length) {
+            this.options.api.unshift(...options.api);
+            this.options.api = await this.formatUrl(this.options.api);
+            storage_1.stor.set({ api: this.options.api });
+        }
+        return this;
+    }
+    async search(wd, api = this.api[0]) {
+        let { data } = await req.get(api, { wd }, null, { rejectUnauthorized: false });
+        if (typeof data == 'string')
+            data = JSON.parse(data);
+        return data;
+    }
+    async getVideoList(ids, api = this.api[0]) {
+        let { data } = await req.get(api, {
+            ac: 'videolist',
+            ids: Array.isArray(ids) ? ids.join(',') : ids,
+        }, null, { rejectUnauthorized: false });
+        if (typeof data == 'string')
+            data = JSON.parse(data);
+        return data;
+    }
+    async formatUrl(url) {
+        const urls = [];
+        if (!url)
+            return urls;
+        if (typeof url === 'string')
+            url = [url];
+        for (let u of url) {
+            u = String(u || '').trim();
+            if (!u)
+                continue;
+            if (u.endsWith('.json')) {
+                const { data } = await req.get(u, null, null, { rejectUnauthorized: false });
+                if (Array.isArray(data)) {
+                    urls.push(...(await this.formatUrl(data)));
+                }
+                else {
+                    urls.push(...Object.values(data));
+                }
+            }
+            else if (u.startsWith('http')) {
+                if (u.endsWith('provide/'))
+                    u += 'vod/';
+                if (u.endsWith('provide/vod'))
+                    u += '/';
+                urls.push(u.replace('/at/xml/', '/'));
+            }
+        }
+        return [...new Set(urls)];
+    }
+}
+exports.VideoSearch = VideoSearch;
+// const v = new VideoSearch({ api: ['https://api.xinlangapi.com/xinlangapi.php/provide/vod/'] });
+// v.search('三体')
+//   .then(d => {
+//     console.log(d.total, d.list);
+//     return v.getVideoList(d.list[0].vod_id);
+//   })
+//   .then(d => {
+//     console.log('detail:', d.total, d.list[0]);
+//   });

package/cjs/lib/worker_pool.d.ts

@@ -7,6 +7,9 @@ export declare class WorkerPool<T = unknown, R = unknown> extends EventEmitter {
     private freeWorkers;
     private workerTaskInfo;
     private tasks;
+    get totalTask(): number;
+    get totalNum(): number;
+    get freeNum(): number;
     constructor(processorFile: string, numThreads?: number);
     addNewWorker(processorFile?: string): void;
     runTask(task: T, callback: (err: Error | null, result: R) => void): void;

package/cjs/lib/worker_pool.js

@@ -26,6 +26,15 @@ class WorkerPool extends node_events_1.EventEmitter {
     freeWorkers = [];
     workerTaskInfo = new Map();
     tasks = [];
+    get totalTask() {
+        return this.tasks.length;
+    }
+    get totalNum() {
+        return this.workers.length;
+    }
+    get freeNum() {
+        return this.freeWorkers.length;
+    }
     constructor(processorFile, numThreads = 0) {
         super();
         this.processorFile = processorFile;
@@ -51,10 +60,10 @@ class WorkerPool extends node_events_1.EventEmitter {
             // 如果成功：调用传递给`runTask`的回调，删除与Worker关联的`TaskInfo`，并再次将其标记为空闲。
             const r = this.workerTaskInfo.get(worker);
             if (r) {
-                r.done(null, result);
                 this.workerTaskInfo.delete(worker);
                 this.freeWorkers.push(worker);
                 this.emit(kWorkerFreedEvent);
+                r.done(null, result);
             }
         });
         worker.on('error', err => {
@@ -73,6 +82,8 @@ class WorkerPool extends node_events_1.EventEmitter {
         this.workers.push(worker);
         this.freeWorkers.push(worker);
         this.emit(kWorkerFreedEvent);
+        if (this.numThreads < this.workers.length)
+            this.numThreads = this.workers.length;
     }
     runTask(task, callback) {
         if (this.freeWorkers.length === 0) {

package/cjs/m3u8-batch-download.d.ts

@@ -1,2 +1,2 @@
-import { M3u8DLOptions } from './type';
+import { M3u8DLOptions } from './types/m3u8';
 export declare function m3u8BatchDownload(urls: string[], options: M3u8DLOptions): Promise<void>;

package/cjs/m3u8-batch-download.js

@@ -4,7 +4,9 @@ exports.m3u8BatchDownload = void 0;
 const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
 const m3u8_download_1 = require("./lib/m3u8-download");
-async function m3u8BatchDownload(urls, options) {
+const utils_1 = require("./lib/utils");
+async function formatUrls(urls, options) {
+    const taskset = new Map();
     for (const url of urls) {
         if ((0, node_fs_1.existsSync)(url)) {
             const content = await node_fs_1.promises.readFile(url, 'utf8');
@@ -17,13 +19,42 @@ async function m3u8BatchDownload(urls, options) {
                         href = `${idx}|${href}`;
                     return href;
                 });
-                if (!options.filename)
-                    options.filename = (0, node_path_1.basename)(url).split('.')[0];
-                await m3u8BatchDownload(list, options);
+                const o = { ...options };
+                if (!o.filename)
+                    o.filename = (0, node_path_1.basename)(url).split('.')[0];
+                const t = await formatUrls(list, o);
+                for (const d of t.entries())
+                    taskset.set(d[0], d[1]);
                 continue;
             }
         }
-        await (0, m3u8_download_1.m3u8Download)(url, options);
+        taskset.set(url, options);
     }
+    return taskset;
+}
+async function m3u8BatchDownload(urls, options) {
+    const tasks = await formatUrls(urls, options);
+    return new Promise(rs => {
+        let preDLing = false;
+        const run = async () => {
+            const [key, keyNext] = [...tasks.keys()];
+            if (key) {
+                const o = { ...tasks.get(key) };
+                tasks.delete(key);
+                const p = o.onProgress;
+                o.onProgress = (finished, total, info) => {
+                    if (p)
+                        p(finished, total, info);
+                    if (!preDLing && keyNext && tasks.size && m3u8_download_1.workPoll.freeNum > 1 && total - finished < options.threadNum) {
+                        utils_1.logger.debug('\n[预下载下一集]', 'freeNum:', m3u8_download_1.workPoll.freeNum, 'totalNum:', m3u8_download_1.workPoll.totalNum, 'totalTask:', m3u8_download_1.workPoll.totalTask, tasks.size);
+                        preDLing = true;
+                        (0, m3u8_download_1.preDownLoad)(keyNext, options).then(() => (preDLing = false));
+                    }
+                };
+                (0, m3u8_download_1.m3u8Download)(key, o).then(() => (tasks.size === 0 ? rs() : run()));
+            }
+        };
+        run();
+    });
 }
 exports.m3u8BatchDownload = m3u8BatchDownload;

package/cjs/types/index.d.ts

@@ -0,0 +1,2 @@
+export * from './m3u8';
+export * from './video-search';

package/cjs/types/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./m3u8"), exports);
+__exportStar(require("./video-search"), exports);

package/cjs/{type.d.ts → types/m3u8.d.ts}

@@ -1,4 +1,4 @@
-/// <reference path="../global.d.ts" />
+/// <reference path="../../global.d.ts" />
 /// <reference types="node" />
 /// <reference types="node" />
 import type { IncomingHttpHeaders } from 'node:http';

package/cjs/types/m3u8.js

@@ -0,0 +1,4 @@
+"use strict";
+/* eslint-disable @typescript-eslint/triple-slash-reference */
+/// <reference path="../../global.d.ts"/>
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/types/video-search.d.ts

@@ -0,0 +1,122 @@
+/** 模糊搜索返回的结果(?wd=<wd>) */
+export interface VideoSearchResult {
+    code: number;
+    msg: string;
+    page: number;
+    pagecount: number;
+    limit: string;
+    total: number;
+    list: VodList[];
+    class: {
+        type_id: number;
+        type_pid: number;
+        type_name: string;
+    }[];
+}
+interface VodList {
+    vod_id: number;
+    vod_name: string;
+    type_id: number;
+    type_name: string;
+    vod_en: string;
+    vod_time: string;
+    vod_remarks: string;
+    vod_play_from: string;
+    vod_play_url: string;
+}
+/** 按 id 搜素返回的详情列表 */
+export interface VideoListResult {
+    code: number;
+    msg: string;
+    page: number;
+    pagecount: number;
+    limit: string;
+    total: number;
+    list: VideoDetails[];
+}
+export interface VideoDetails {
+    vod_id: number;
+    type_id: number;
+    type_id_1: number;
+    group_id: number;
+    vod_name: string;
+    vod_sub: string;
+    vod_en: string;
+    vod_status: number;
+    vod_letter: string;
+    vod_color: string;
+    vod_tag: string;
+    vod_class: string;
+    vod_pic: string;
+    vod_pic_thumb: string;
+    vod_pic_slide: string;
+    vod_pic_screenshot: null;
+    vod_actor: string;
+    vod_director: string;
+    vod_writer: string;
+    vod_behind: string;
+    vod_blurb: string;
+    vod_remarks: string;
+    vod_pubdate: string;
+    vod_total: number;
+    vod_serial: string;
+    vod_tv: string;
+    vod_weekday: string;
+    vod_area: string;
+    vod_lang: string;
+    vod_year: string;
+    vod_version: string;
+    vod_state: string;
+    vod_author: string;
+    vod_jumpurl: string;
+    vod_tpl: string;
+    vod_tpl_play: string;
+    vod_tpl_down: string;
+    vod_isend: number;
+    vod_lock: number;
+    vod_level: number;
+    vod_copyright: number;
+    vod_points: number;
+    vod_points_play: number;
+    vod_points_down: number;
+    vod_hits: number;
+    vod_hits_day: number;
+    vod_hits_week: number;
+    vod_hits_month: number;
+    vod_duration: string;
+    vod_up: number;
+    vod_down: number;
+    vod_score: string;
+    vod_score_all: number;
+    vod_score_num: number;
+    vod_time: string;
+    vod_time_add: number;
+    vod_time_hits: number;
+    vod_time_make: number;
+    vod_trysee: number;
+    vod_douban_id: number;
+    vod_douban_score: string;
+    vod_reurl: string;
+    vod_rel_vod: string;
+    vod_rel_art: string;
+    vod_pwd: string;
+    vod_pwd_url: string;
+    vod_pwd_play: string;
+    vod_pwd_play_url: string;
+    vod_pwd_down: string;
+    vod_pwd_down_url: string;
+    vod_content: string;
+    vod_play_from: string;
+    vod_play_server: string;
+    vod_play_note: string;
+    vod_play_url: string;
+    vod_down_from: string;
+    vod_down_server: string;
+    vod_down_note: string;
+    vod_down_url: string;
+    vod_plot: number;
+    vod_plot_name: string;
+    vod_plot_detail: string;
+    type_name: string;
+}
+export {};

package/cjs/types/video-search.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lzwme/m3u8-dl",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "description": "Batch download of m3u8 files and convert to mp4",
   "main": "cjs/index.js",
   "types": "cjs/index.d.ts",
@@ -44,23 +44,24 @@
     "registry": "https://registry.npmjs.com"
   },
   "devDependencies": {
-    "@lzwme/fed-lint-helper": "^2.2.0",
-    "@types/node": "^18.11.18",
-    "@typescript-eslint/eslint-plugin": "^5.49.0",
-    "@typescript-eslint/parser": "^5.49.0",
-    "eslint": "^8.32.0",
-    "eslint-config-prettier": "^8.6.0",
+    "@lzwme/fed-lint-helper": "^2.3.2",
+    "@types/node": "^20.2.0",
+    "@typescript-eslint/eslint-plugin": "^5.59.6",
+    "@typescript-eslint/parser": "^5.59.6",
+    "eslint": "^8.40.0",
+    "eslint-config-prettier": "^8.8.0",
     "eslint-plugin-prettier": "^4.2.1",
     "husky": "^8.0.3",
-    "prettier": "^2.8.3",
+    "prettier": "^2.8.8",
     "standard-version": "^9.5.0",
-    "typescript": "^4.9.4"
+    "typescript": "^5.0.4"
   },
   "dependencies": {
-    "@lzwme/fe-utils": "^1.3.3",
-    "commander": "^10.0.0",
-    "console-log-colors": "^0.3.3",
-    "m3u8-parser": "^6.0.0"
+    "@lzwme/fe-utils": "^1.5.1",
+    "commander": "^10.0.1",
+    "console-log-colors": "^0.4.0",
+    "enquirer": "^2.3.6",
+    "m3u8-parser": "^6.1.0"
   },
   "files": [
     "cjs",