@ikenxuan/amagi 1.4.3

package/lib/model/config.d.ts

@@ -0,0 +1,70 @@
+import YAML from 'yaml';
+declare class Config {
+    config: any;
+    watcher: any;
+    constructor();
+    /** 初始化配置 */
+    initCfg(): void;
+    get douyin(): any;
+    get bilibili(): any;
+    /** 默认配置和用户配置 */
+    getDefOrConfig(name: string): any;
+    /** 默认配置 */
+    getdefSet(name: any): any;
+    /** 用户配置 */
+    getConfig(name: any): any;
+    /**
+     * 获取配置yaml
+     * @param type 默认跑配置-defSet，用户配置-config
+     * @param name 名称
+     */
+    getYaml(type: string | undefined, name: any): any;
+    /** 监听配置文件 */
+    watch(file: string, name: string, type?: string): void;
+    /**
+     * 修改设置
+     * @param {'douoyin','bilibili'} name 文件名
+     * @param {String} key 修改的key值
+     * @param {String|Number} value 修改的value值
+     * @param {'config'|'default_config'} type 配置文件或默认
+     */
+    modify(name: string, key: string, value: any, type?: string): void;
+    mergeObjectsWithPriority(objA: any, objB: any): {
+        differences: boolean;
+        result: any;
+    };
+}
+/**
+ * YamlReader类提供了对YAML文件的动态读写功能
+ */
+export declare class YamlReader {
+    filePath: string;
+    document: any;
+    /**
+    * 创建一个YamlReader实例。
+    * @param {string} filePath - 文件路径
+    */
+    constructor(filePath: string);
+    /**
+    * 解析YAML文件并返回Document对象，保留注释。
+    * @returns {Document} 包含YAML数据和注释的Document对象
+    */
+    parseDocument(): YAML.Document.Parsed<YAML.Alias.Parsed, true> | YAML.Document.Parsed<YAML.Scalar.Parsed, true> | YAML.Document.Parsed<YAML.YAMLMap.Parsed<YAML.ParsedNode, YAML.ParsedNode | null>, true> | YAML.Document.Parsed<YAML.YAMLSeq.Parsed<YAML.ParsedNode>, true>;
+    /**
+     * 修改指定参数的值。
+     * @param {string} key - 参数键名
+     * @param {any} value - 新的参数值
+     */
+    set(key: any, value: any): void;
+    /**
+     * 从YAML文件中删除指定参数。
+     * @param {string} key - 要删除的参数键名
+     */
+    rm(key: any): void;
+    /**
+       * 将更新后的Document对象写入YAML文件中。
+       */
+    write(): void;
+}
+declare const _default: Config;
+export default _default;

package/lib/model/config.js

@@ -0,0 +1,173 @@
+import _ from 'lodash';
+import YAML from 'yaml';
+import fs from 'node:fs';
+import { logger } from '../model/index.js';
+import chokidar from 'chokidar';
+class Config {
+    config;
+    watcher;
+    constructor() {
+        this.config = {};
+        /** 监听文件 */
+        this.watcher = { config: {}, defSet: {} };
+        this.initCfg();
+    }
+    /** 初始化配置 */
+    initCfg() {
+        const path = `${process.cwd()}/config/`;
+        if (!fs.existsSync(path))
+            fs.mkdirSync(path);
+        const pathDef = `${process.cwd()}/config/`;
+        const files = fs.readdirSync(pathDef).filter(file => file.endsWith('.yaml'));
+        for (const file of files) {
+            if (!fs.existsSync(`${path}config.yaml`)) {
+                fs.copyFileSync(`${pathDef}${file}`, `${pathDef}config.yaml`);
+            }
+            else {
+                const config = YAML.parse(fs.readFileSync(`${path}${file}`, 'utf8'));
+                const defConfig = YAML.parse(fs.readFileSync(`${pathDef}${file}`, 'utf8'));
+                const { differences, result } = this.mergeObjectsWithPriority(config, defConfig);
+                if (differences) {
+                    fs.copyFileSync(`${pathDef}${file}`, `${path}${file}`);
+                    for (const key in result) {
+                        this.modify(file.replace('.yaml', ''), key, result[key]);
+                    }
+                }
+            }
+            // 检查是否在 PM2 环境中运行
+            if (process.env.pm_id) {
+                // 如果是 PM2 运行，则执行 watch 方法
+                this.watch(`${path}${file}`, file.replace('.yaml', ''), 'config');
+            }
+        }
+    }
+    get douyin() {
+        const cfg = this.getDefOrConfig('config');
+        return cfg.douyin;
+    }
+    get bilibili() {
+        const cfg = this.getDefOrConfig('config');
+        return cfg.bilibili;
+    }
+    /** 默认配置和用户配置 */
+    getDefOrConfig(name) {
+        const config = this.getConfig(name);
+        return config;
+    }
+    /** 默认配置 */
+    getdefSet(name) {
+        return this.getYaml('default_config', name);
+    }
+    /** 用户配置 */
+    getConfig(name) {
+        return this.getYaml('config', name);
+    }
+    /**
+     * 获取配置yaml
+     * @param type 默认跑配置-defSet，用户配置-config
+     * @param name 名称
+     */
+    getYaml(type, name) {
+        const file = `${process.cwd()}/${type}/${name}.yaml`;
+        const key = `${type}.${name}`;
+        if (this.config['config.config'])
+            return this.config[key];
+        const cfg = YAML.parse(fs.readFileSync(file, 'utf8'));
+        this.watch(file, name, type);
+        return cfg;
+    }
+    /** 监听配置文件 */
+    watch(file, name, type = 'default_config') {
+        const key = `${type}.${name}`;
+        if (this.watcher[key])
+            return;
+        const watcher = chokidar.watch(file);
+        watcher.on('change', async (path) => {
+            delete this.config[key];
+            logger.mark(`[${process.cwd()}][修改配置文件][${type}][${name}]`);
+        });
+        this.watcher[key] = watcher;
+    }
+    /**
+     * 修改设置
+     * @param {'douoyin','bilibili'} name 文件名
+     * @param {String} key 修改的key值
+     * @param {String|Number} value 修改的value值
+     * @param {'config'|'default_config'} type 配置文件或默认
+     */
+    modify(name, key, value, type = 'config') {
+        const path = `${process.cwd()}/config/${name}.yaml`;
+        new YamlReader(path).set(key, value);
+        delete this.config[`${type}.${name}`];
+    }
+    mergeObjectsWithPriority(objA, objB) {
+        let differences = false;
+        function customizer(objValue, srcValue, key, object, source, stack) {
+            if (_.isArray(objValue) && _.isArray(srcValue)) {
+                return objValue;
+            }
+            else if (_.isPlainObject(objValue) && _.isPlainObject(srcValue)) {
+                if (!_.isEqual(objValue, srcValue)) {
+                    return _.mergeWith({}, objValue, srcValue, customizer);
+                }
+            }
+            else if (!_.isEqual(objValue, srcValue)) {
+                differences = true;
+                return objValue !== undefined ? objValue : srcValue;
+            }
+            return objValue !== undefined ? objValue : srcValue;
+        }
+        const result = _.mergeWith({}, objA, objB, customizer);
+        return {
+            differences,
+            result,
+        };
+    }
+}
+/**
+ * YamlReader类提供了对YAML文件的动态读写功能
+ */
+export class YamlReader {
+    filePath;
+    document;
+    /**
+    * 创建一个YamlReader实例。
+    * @param {string} filePath - 文件路径
+    */
+    constructor(filePath) {
+        this.filePath = filePath;
+        this.document = this.parseDocument();
+    }
+    /**
+    * 解析YAML文件并返回Document对象，保留注释。
+    * @returns {Document} 包含YAML数据和注释的Document对象
+    */
+    parseDocument() {
+        const fileContent = fs.readFileSync(this.filePath, 'utf8');
+        return YAML.parseDocument(fileContent);
+    }
+    /**
+     * 修改指定参数的值。
+     * @param {string} key - 参数键名
+     * @param {any} value - 新的参数值
+     */
+    set(key, value) {
+        this.document.set(key, value);
+        this.write();
+    }
+    /**
+     * 从YAML文件中删除指定参数。
+     * @param {string} key - 要删除的参数键名
+     */
+    rm(key) {
+        this.document.delete(key);
+        this.write();
+    }
+    /**
+       * 将更新后的Document对象写入YAML文件中。
+       */
+    write() {
+        fs.writeFileSync(this.filePath, this.document.toString(), 'utf8');
+    }
+}
+export default new Config();

package/lib/model/index.d.ts

@@ -0,0 +1,4 @@
+import logger from './logger.js';
+import Networks from './networks.js';
+import Config from './config.js';
+export { logger, Networks, Config };

package/lib/model/index.js

@@ -0,0 +1,4 @@
+import logger from './logger.js';
+import Networks from './networks.js';
+import Config from './config.js';
+export { logger, Networks, Config };

package/lib/model/logger.d.ts

@@ -0,0 +1,3 @@
+import log4js from 'log4js';
+declare const logger: log4js.Logger;
+export default logger;

package/lib/model/logger.js

@@ -0,0 +1,28 @@
+import log4js from 'log4js';
+log4js.configure({
+    appenders: {
+        console: {
+            type: 'stdout',
+            layout: {
+                type: 'pattern',
+                pattern: '%[[amagi][%d{hh:mm:ss.SSS}][%4.4p]%] %m',
+            },
+        },
+        command: {
+            type: 'dateFile', // 可以是console,dateFile,file,Logstash等
+            filename: 'logs/command', // 将会按照filename和pattern拼接文件名
+            pattern: 'yyyy-MM-dd.log',
+            numBackups: 15,
+            alwaysIncludePattern: true,
+            layout: {
+                type: 'pattern',
+                pattern: '[%d{hh:mm:ss.SSS}][%4.4p] %m',
+            },
+        },
+    },
+    categories: {
+        default: { appenders: ['console'], level: 'debug' },
+    },
+});
+const logger = log4js.getLogger();
+export default logger;

package/lib/model/networks.d.ts

@@ -0,0 +1,38 @@
+import { Response } from 'node-fetch';
+import { NetworksConfigType } from '../types/index.js';
+interface HeadersObject {
+    [key: string]: string;
+}
+export default class Networks {
+    url: string | URL;
+    method: string;
+    Headers: any;
+    type: string;
+    body?: string;
+    fetch: any;
+    isGetResult: boolean;
+    timeout: number;
+    timer: NodeJS.Timeout | undefined;
+    data: {};
+    redirect: string;
+    constructor(data: NetworksConfigType);
+    get config(): NetworksConfigType;
+    getfetch(): Promise<Response | boolean>;
+    returnResult(): Promise<Response>;
+    /** 最终地址（跟随重定向） */
+    getLongLink(): Promise<string>;
+    /** 获取首个302 */
+    getLocation(): Promise<string>;
+    /** 获取数据并处理数据的格式化，默认json */
+    getData(new_fetch?: string): Promise<any | boolean>;
+    /** 获取响应头 */
+    getHeaders(): Promise<HeadersObject | null>;
+    /** 一次性获取响应头和响应体 */
+    getHeadersAndData(): Promise<object>;
+    Tojson(): Promise<any>;
+    ToText(): Promise<void>;
+    ToArrayBuffer(): Promise<void>;
+    ToBlob(): Promise<void>;
+    timeoutPromise(timeout: number): Promise<Response>;
+}
+export {};

package/lib/model/networks.js

@@ -0,0 +1,224 @@
+import fetch, { Response } from 'node-fetch';
+import { logger } from '../model/index.js';
+export default class Networks {
+    url;
+    method;
+    Headers;
+    type;
+    body;
+    fetch;
+    isGetResult;
+    timeout;
+    timer;
+    data;
+    redirect;
+    constructor(data) {
+        this.Headers = new Headers();
+        if (data.headers && Object.keys(data.headers).length > 0) {
+            for (const [key, value] of Object.entries(data.headers)) {
+                this.Headers.append(key, value);
+            }
+        }
+        else
+            this.Headers = {};
+        this.url = data.url || '';
+        this.type = data.type || 'json';
+        this.method = data.method || 'GET';
+        this.body = data.body || ''; // 用于POST请求
+        this.data = {};
+        this.timeout = data.timeout || 15000;
+        this.isGetResult = false;
+        this.timer = undefined;
+        this.redirect = 'follow'; // 默认跟随重定向
+    }
+    get config() {
+        let data = {
+            headers: this.Headers,
+            method: this.method,
+        };
+        if (this.method === 'POST') {
+            data = { ...data, body: JSON.stringify(this.body) || '' };
+        }
+        return data;
+    }
+    async getfetch() {
+        try {
+            const result = await this.returnResult();
+            if (result.status === 504) {
+                return result;
+            }
+            this.isGetResult = true;
+            return result;
+        }
+        catch (error) {
+            logger.warn(error);
+            return false;
+        }
+    }
+    async returnResult() {
+        return await fetch(this.url, this.config);
+    }
+    /** 最终地址（跟随重定向） */
+    async getLongLink() {
+        try {
+            const result = await this.returnResult();
+            return result.url;
+        }
+        catch (error) {
+            logger.error(error);
+            return '';
+        }
+    }
+    /** 获取首个302 */
+    async getLocation() {
+        try {
+            const response = await fetch(this.url, {
+                method: 'GET',
+                redirect: 'manual', // 不跟随重定向
+            });
+            // 取location返回
+            return response.headers.get('location');
+        }
+        catch (error) {
+            logger.error(error);
+            return '';
+        }
+    }
+    /** 获取数据并处理数据的格式化，默认json */
+    async getData(new_fetch = '') {
+        try {
+            if (!new_fetch) {
+                const result = await this.returnResult();
+                if (result.status === 504) {
+                    return result;
+                }
+                this.fetch = result;
+                this.isGetResult = true;
+            }
+            else {
+                this.fetch = new_fetch;
+            }
+            switch (this.type) {
+                case 'json':
+                    await this.Tojson();
+                    break;
+                case 'text':
+                    await this.ToText();
+                    break;
+                case 'arrayBuffer':
+                    await this.ToArrayBuffer();
+                    break;
+                case 'blob':
+                    await this.ToBlob();
+                    break;
+            }
+            return this.fetch;
+        }
+        catch (error) {
+            logger.error(error);
+            return false;
+        }
+    }
+    /** 获取响应头 */
+    async getHeaders() {
+        try {
+            this.fetch = await this.returnResult();
+            if (this.fetch) {
+                if (this.fetch.headers) {
+                    const headers = this.fetch.headers;
+                    const headersObject = {};
+                    for (const [key, value] of headers.entries()) {
+                        headersObject[key] = value;
+                    }
+                    return headersObject;
+                }
+                else {
+                    logger.error('未获取到响应头');
+                    return null;
+                }
+            }
+            else {
+                logger.error('未获取到响应对象');
+                return null;
+            }
+        }
+        catch (error) {
+            logger.error('获取响应头失败:', error);
+            return null;
+        }
+    }
+    /** 一次性获取响应头和响应体 */
+    async getHeadersAndData() {
+        try {
+            // 发起网络请求获取响应对象
+            this.fetch = await this.returnResult();
+            // 初始化响应头和响应数据
+            let headers = null;
+            let data = null;
+            if (this.fetch) {
+                // 获取响应头
+                if (this.fetch.headers) {
+                    headers = {};
+                    const fetchHeaders = this.fetch.headers;
+                    for (const [key, value] of fetchHeaders.entries()) {
+                        headers[key] = value;
+                    }
+                }
+                else {
+                    logger.error('未获取到响应头');
+                }
+                // 获取响应数据
+                switch (this.type) {
+                    case 'json':
+                        data = await this.fetch.json();
+                        break;
+                    case 'text':
+                        data = await this.fetch.text();
+                        break;
+                    case 'arrayBuffer':
+                        data = await this.ToArrayBuffer();
+                        break;
+                    case 'blob':
+                        data = await this.ToBlob();
+                        break;
+                }
+            }
+            else {
+                logger.error('未获取到响应对象');
+            }
+            return { headers, data };
+        }
+        catch (error) {
+            logger.error('获取响应头和数据失败:', error);
+            return { headers: null, data: null };
+        }
+    }
+    async Tojson() {
+        if (this.fetch.headers.get('content-type').includes('json')) {
+            this.fetch = await this.fetch.json();
+        }
+        else {
+            this.fetch = await this.fetch.text();
+            this.type = 'text';
+        }
+    }
+    async ToText() {
+        this.fetch = await this.fetch.text();
+    }
+    async ToArrayBuffer() {
+        this.fetch = await this.fetch.arrayBuffer();
+    }
+    async ToBlob() {
+        this.fetch = await this.fetch.blob();
+    }
+    timeoutPromise(timeout) {
+        const controller = new AbortController();
+        return new Promise((resolve, reject) => {
+            this.timer = setTimeout(() => {
+                logger.mark('执行力');
+                controller.abort();
+                resolve(new Response('timeout', { status: 504, statusText: 'timeout' }));
+            }, timeout);
+        });
+    }
+}

package/lib/types/ConfigType.d.ts

@@ -0,0 +1,10 @@
+export interface ConfigType {
+    /**
+     * 抖音cookie
+     */
+    douyin: string;
+    /**
+     * bilibili cookie
+     */
+    bilibili: string;
+}

package/lib/types/ConfigType.js

@@ -0,0 +1 @@
+export {};

package/lib/types/DataType.d.ts

@@ -0,0 +1,32 @@
+/**
+ * 抖音接口类型
+ */
+export declare const enum DouyinDataType {
+    二级评论数据 = "CommentReplyData",
+    用户主页数据 = "UserInfoData",
+    单个视频作品数据 = "VideoData",
+    评论数据 = "CommentData",
+    用户主页视频列表数据 = "UserVideosListData",
+    热点词数据 = "SuggestWordsData",
+    搜索数据 = "SearchData",
+    官方emoji数据 = "EmojiData",
+    动态表情数据 = "ExpressionPlusData",
+    音乐数据 = "MusicData",
+    图集作品数据 = "NoteData",
+    实况图片图集数据 = "LiveImageData"
+}
+/**
+ * B站接口类型
+ */
+export declare const enum BilibiliDataType {
+    单个视频作品数据 = "VideoData",
+    评论数据 = "CommentData",
+    用户主页数据 = "UserInfoData",
+    用户主页动态列表数据 = "UserDynamicListData",
+    搜索数据 = "SearchData",
+    emoji数据 = "EmojiData",
+    番剧基本信息数据 = "BangumiVideoData",
+    番剧下载信息数据 = "BangumiVideoDownloadLinkData",
+    动态详情数据 = "DynamicInfoData",
+    动态卡片数据 = "DynamicCardData"
+}

package/lib/types/DataType.js

@@ -0,0 +1 @@
+export {};

package/lib/types/GetDataResponseType.d.ts

@@ -0,0 +1,17 @@
+/**
+ * 最终返回数据
+ */
+export type GetDataResponseType = {
+    /**
+     * 响应状态码
+     */
+    code: number;
+    /**
+     * 响应信息
+     */
+    message: string;
+    /**
+     * 响应数据
+     */
+    data: any;
+};

package/lib/types/GetDataResponseType.js

@@ -0,0 +1 @@
+export {};

package/lib/types/NetworksConfigType.d.ts

@@ -0,0 +1,30 @@
+export type NetworksConfigType = {
+    /**
+     * 请求地址
+     */
+    url?: string | URL;
+    /**
+     * 请求方法
+     */
+    method?: string;
+    /**
+     * 请求头
+     */
+    headers?: any;
+    /**
+     * 返回数据类型，默认json
+     */
+    type?: string;
+    /**
+     * 请求体
+     */
+    body?: string;
+    /**
+     * 超时时间，单位毫秒
+     */
+    timeout?: number;
+    /**
+     * 默认跟随重定向到: 'follow'，不跟随: manual
+     */
+    redirect?: RequestRedirect;
+};

package/lib/types/NetworksConfigType.js

@@ -0,0 +1 @@
+export {};