@lf_maple/koishi-plugin-phi-plugin-full 0.1.80

package/core/model/api/makeRequestFnc.js

@@ -0,0 +1,17 @@
+import fCompute from '../game/fCompute.js'
+
+export default class makeRequestFnc {
+    /**
+     * 
+    * @param {import('../../components/baseClass.js').botEvent } e
+     * @returns {import('./makeRequest.js').platformAuth}
+     */
+    static makePlatform(e) {
+        return {
+            platform: fCompute.getAdapterName(e),
+            platform_id: typeof e.user_id == 'string' ? e.user_id.replace('', ':') : `${e.user_id}`,
+            _local_user_id: `${e.user_id}`,
+        }
+    }
+
+}

package/core/model/api/phiApiClient.js

@@ -0,0 +1,53 @@
+import { Config } from '../../components/index.js'
+import logger from '../../components/Logger.js'
+import autoSeekApi from './autoSeekApi.js'
+import botApiAuth from './botApiAuth.js'
+import {
+    classifyApiConnectionError,
+    isApiConnectionError,
+    PhiApiError,
+} from './phiApiErrors.js'
+import { isApiVersionBlocked } from './apiVersion.js'
+
+/**
+ * 发送带 Bot HMAC 的底层 phi-plugin-api 请求。
+ * 用户身份由请求体中的 sessionToken 或 API ID确定，本函数只负责 Bot HMAC 传输。
+ * @param {string} originalPath 包含查询参数的 API 原始路径
+ * @param {any} [params] 最终发送的请求参数
+ * @param {'POST'|'GET'|'PUT'} [method='POST'] HTTP 方法
+ * @param {{timeout?:number}} [transportOptions] 端点专用传输选项
+ * @returns {Promise<any>} API JSON 响应
+ */
+async function request(originalPath, params = {}, method = 'POST', transportOptions = {}) {
+    if (isApiVersionBlocked()) {
+        throw new PhiApiError(
+            'API协议大版本不兼容，请更新 phi-plugin 后重启',
+            0,
+            'api_version_incompatible',
+        )
+    }
+    try {
+        await botApiAuth.initialize()
+        const json = await botApiAuth.signedRequest(originalPath, params, method, undefined, {}, transportOptions)
+        if (Config.getUserCfg('config', 'debug') > 3) {
+            logger.info(`[phi-plugin] API请求成功: ${originalPath}`)
+        }
+        return json
+    } catch (/** @type {any} */ error) {
+        if (error instanceof PhiApiError) {
+            logger.warn(`[phi-plugin] API请求失败 ${originalPath}: ${error.code} (${error.status})`)
+            if (isApiConnectionError(error)) autoSeekApi.seekApi()
+            throw error
+        }
+        logger.error(`[phi-plugin] API网络错误 ${originalPath}: ${error?.message || String(error)}`)
+        autoSeekApi.seekApi()
+        throw classifyApiConnectionError(error)
+    }
+}
+
+/**
+ * phi-plugin-api 的全局请求实例。业务模块统一导入该实例，不传递请求函数。
+ */
+export const phiApiClient = { request }
+
+export default phiApiClient

package/core/model/api/phiApiErrors.js

@@ -0,0 +1,121 @@
+import Config from '../../components/Config.js'
+
+export class PhiApiError extends Error {
+    /** @param {string} message @param {number} [status] @param {string} [code] @param {any} [data] */
+    constructor(message, status = 0, code = 'api_request_failed', data = undefined) {
+        super(message)
+        this.name = 'PhiApiError'
+        this.status = status
+        this.code = code
+        this.data = data
+    }
+}
+
+const FATAL_IDENTITY_ERROR_CODES = new Set([
+    'bot_client_unknown',
+    'bot_client_revoked',
+    'bot_key_version_invalid',
+    'bot_signature_invalid',
+])
+
+const CONNECTION_ERROR_CODES = new Set([
+    'api_timeout',
+    'api_dns_error',
+    'api_connection_refused',
+    'api_tls_error',
+    'api_network_error',
+    'api_offline',
+])
+
+/** @type {Record<string, string | (() => string)>} */
+const USER_ERROR_MESSAGES = {
+    api_timeout: 'API请求超时，请稍后重试。',
+    api_dns_error: '无法解析API地址，请Bot主人检查网络或API地址配置。',
+    api_connection_refused: 'API暂时拒绝连接，插件会自动重试。',
+    api_tls_error: 'API证书校验失败，请Bot主人检查系统时间或证书配置。',
+    api_network_error: '连接API时网络异常，插件会自动重试。',
+    api_offline: '暂时无法连接API，插件会自动重试。',
+    api_version_incompatible: 'API协议大版本不兼容，API功能已自动关闭，请更新 phi-plugin 后重启。',
+    bot_identity_missing: 'Bot尚未获得API身份，API恢复后会自动注册。',
+    bot_client_unknown: '本地Bot凭证不被API识别，请Bot主人执行“重置API Bot身份”。',
+    bot_client_revoked: '该Bot身份已被撤销，请Bot主人执行“重置API Bot身份”。',
+    bot_key_version_invalid: 'Bot密钥版本已失效，请Bot主人执行“重置API Bot身份”。',
+    bot_signature_invalid: 'Bot凭证签名校验失败，请Bot主人执行“重置API Bot身份”。',
+    bot_registration_rate_limited: 'Bot身份申请过于频繁，插件稍后会自动重试。',
+    invalid_registration_response: 'API返回的Bot身份数据无效，插件稍后会自动重试。',
+    theme_store_bot_not_whitelisted: '当前 Bot 未被主题商店授权安装该主题。',
+    theme_not_allowed_by_bot: 'Bot 主人设置的主题范围不允许使用该主题。',
+    theme_not_found: '主题商店中未找到该主题，或主题尚未发布。',
+    theme_version_not_found: '主题商店中未找到可安装的主题版本。',
+    theme_version_incompatible: '当前 phi-plugin 版本与该主题不兼容。',
+    theme_download_rate_limited: '主题下载请求过于频繁，请稍后重试。',
+    theme_store_invalid_response: '主题商店返回了无效数据，请稍后重试。',
+    theme_store_unavailable: '主题商店暂时不可用，请稍后重试。',
+    integration_not_configured: '主题商店集成尚未配置，请联系服务管理员。',
+    binding_not_found: '当前平台账号尚未绑定，请使用sessionToken绑定。',
+    bot_user_credential_required: '当前请求缺少 sessionToken 或 API ID，请重新绑定。',
+    binding_conflict_requires_sstk: '当前平台已绑定其他查分ID，请使用sessionToken重新绑定。',
+    user_id_binding_disabled: () => {
+        const commandHead = `${Config.getUserCfg('config', 'cmdhead')}`
+        return `该用户未开启API ID绑定，请使用 /${commandHead} bind <sessionToken> 或 /${commandHead} bind qrcode 扫码重新绑定。`
+    },
+    user_not_found: '未找到对应的查分ID，请检查后重试。',
+}
+
+/** @param {any} error */
+export function classifyApiConnectionError(error) {
+    if (error instanceof PhiApiError) return error
+    const nativeCode = String(error?.code || error?.cause?.code || '').toUpperCase()
+    const nativeMessage = String(error?.message || error?.cause?.message || '').toLowerCase()
+
+    if (nativeCode === 'ECONNABORTED' || nativeCode === 'ETIMEDOUT' || nativeMessage.includes('timeout')) {
+        return new PhiApiError('API请求超时', 0, 'api_timeout')
+    }
+    if (nativeCode === 'ENOTFOUND' || nativeCode === 'EAI_AGAIN') {
+        return new PhiApiError('无法解析API地址', 0, 'api_dns_error')
+    }
+    if (nativeCode === 'ECONNREFUSED') {
+        return new PhiApiError('API拒绝连接', 0, 'api_connection_refused')
+    }
+    if (
+        nativeCode.startsWith('ERR_TLS_')
+        || nativeCode.startsWith('CERT_')
+        || nativeCode === 'DEPTH_ZERO_SELF_SIGNED_CERT'
+        || nativeCode === 'UNABLE_TO_VERIFY_LEAF_SIGNATURE'
+        || nativeMessage.includes('certificate')
+        || nativeMessage.includes('tls')
+    ) {
+        return new PhiApiError('API证书校验失败', 0, 'api_tls_error')
+    }
+    if (
+        ['ECONNRESET', 'ENETUNREACH', 'EHOSTUNREACH', 'ENETDOWN', 'ERR_NETWORK'].includes(nativeCode)
+        || nativeMessage.includes('network error')
+        || nativeMessage.includes('socket hang up')
+    ) {
+        return new PhiApiError('API网络连接异常', 0, 'api_network_error')
+    }
+    return new PhiApiError('无法连接API', 0, 'api_offline')
+}
+
+/** @param {any} error */
+export function isApiConnectionError(error) {
+    return CONNECTION_ERROR_CODES.has(String(error?.code || ''))
+}
+
+/** @param {any} error */
+export function isFatalBotIdentityError(error) {
+    return FATAL_IDENTITY_ERROR_CODES.has(String(error?.code || ''))
+}
+
+/** @param {any} error */
+export function hasPhiApiUserMessage(error) {
+    return Object.hasOwn(USER_ERROR_MESSAGES, String(error?.code || ''))
+}
+
+/** @param {any} error */
+export function getPhiApiUserMessage(error) {
+    const code = String(error?.code || '')
+    const message = USER_ERROR_MESSAGES[code]
+    if (typeof message === 'function') return message()
+    return message || error?.message || String(error?.cause || error || '未知错误')
+}

package/core/model/filesystem/getFile.js

@@ -0,0 +1,256 @@
+import fs from 'node:fs'
+import YAML from 'yaml'
+import { dataPath, pluginDataPath, savePath } from "./path.js";
+import path from 'node:path';
+import getRksRank from '../game/getRksRank.js';
+import logger from '../../components/Logger.js';
+import userCredentialStore from '../user/userCredentialStore.js';
+
+
+
+export default class readFile {
+
+    /**
+     * 读取文件
+     * @param {string} filePath 完整路径
+     * @param {'JSON'|'YAML'|'CSV'|'TSV'|'TXT'} [style=undefined] 强制设置文件格式
+     * @returns {Promise<any>|any}
+     */
+    static FileReader(filePath, style = undefined) {
+        try {
+            if (!fs.existsSync(filePath)) { return false }
+            // console.info(filePath)
+            if (!style) {
+                style = /** @type {any} */(path.extname(filePath).toUpperCase().replace('.', ''))
+            }
+            switch (style) {
+                case 'JSON': {
+                    return JSON.parse(fs.readFileSync(filePath, 'utf8'))
+                }
+                case 'YAML': {
+                    return YAML.parse(fs.readFileSync(filePath, 'utf8'))
+                }
+                case 'CSV':
+                case 'TSV': {
+                    const csvData = fs.readFileSync(filePath, 'utf8').replace(/\r/g, '');
+                    const lines = csvData.split('\n');
+                    /**@type {any[]} */
+                    const result = [];
+                    const headers = lines[0].split('\t');
+                    for (let i = 1; i < lines.length; i++) {
+                        if (!lines[i]) continue;
+                        /**@type {any} */
+                        const obj = {};
+                        const currentline = lines[i].split('\t');
+                        for (let j = 0; j < headers.length; j++) {
+                            obj[headers[j]] = currentline[j];
+                        }
+                        result.push(obj);
+                    }
+                    return result;
+                }
+                case 'TXT': {
+                    return fs.readFileSync(filePath, 'utf8')
+                }
+                default: {
+                    logger.error(`[phi-plugin][Read]不支持的文件格式`, style, filePath)
+                    return fs.readFileSync(filePath, 'utf8')
+                }
+            }
+        } catch (error) {
+            logger.warn(`[phi-plugin][${filePath}] 读取失败`)
+            logger.warn(error)
+            return false
+        }
+    }
+
+    /**
+     * 存储文件
+     * @param {string} filepath 文件名，含后缀
+     * @param {any} data 目标数据
+     * @param {'JSON'|'YAML'|'TXT'} [style=undefined] 强制指定保存格式
+     */
+    static SetFile(filepath, data, style = undefined) {
+        try {
+            const fatherPath = path.dirname(filepath)
+            const fileName = path.basename(filepath)
+            // console.info(filepath, fatherPath, fileName)
+            if (!fs.existsSync(fatherPath)) {
+                // 递归创建目录
+                fs.mkdirSync(fatherPath, { recursive: true });
+            }
+            if (!style) {
+                style = /** @type {any} */(path.extname(filepath).toUpperCase().replace('.', ''))
+            }
+            switch (style) {
+                case 'JSON': {
+                    fs.writeFileSync(filepath, JSON.stringify(data), 'utf8')
+                    break
+                }
+                case 'YAML': {
+                    fs.writeFileSync(filepath, YAML.stringify(data), 'utf8')
+                    break
+                }
+                case 'TXT': {
+                    fs.writeFileSync(filepath, data, 'utf8')
+                }
+                default: {
+                    // logger.error(`[phi-plugin][Set]不支持的文件格式`, style, filepath)
+                    fs.writeFileSync(filepath, data, 'utf8')
+                    break
+                }
+            }
+            return true
+        } catch (error) {
+            console.info(error)
+            logger.warn(`[phi-plugin]写入文件 ${filepath} 时遇到错误`)
+            logger.warn(error)
+            return false
+        }
+    }
+
+    /**
+     * 删除指定文件
+     * @param {string} path 
+     */
+    static async DelFile(path) {
+        try {
+            if (!fs.existsSync(`${path}`)) { return false }
+            fs.unlink(`${path}`, (err) => {
+                if (err) throw err
+            })
+            return true
+        } catch (error) {
+            logger.warn(`[phi-plugin][${path}] 删除失败`)
+            logger.warn(error)
+            return false
+        }
+    }
+
+    /**
+     * 删除指定路径下的所有空文件夹
+     * @param {*} _path 
+     */
+    static async rmEmptyDir(_path, level = 0) {
+        if (!fs.existsSync(_path)) return false
+        if (!fs.lstatSync(_path).isDirectory()) return false
+        const files = fs.readdirSync(_path);
+        if (files.length > 0) {
+            let tempFile = 0;
+            files.forEach(file => {
+                tempFile++;
+                this.rmEmptyDir(`${_path}/${file}`, 1);
+            });
+            if (tempFile === files.length && level !== 0 && fs.lstatSync(_path).isDirectory()) {
+                try {
+                    fs.rmdirSync(_path);
+                } catch { }
+            }
+        }
+        else {
+            if (fs.lstatSync(_path).isDirectory()) {
+                try {
+                    fs.rmdirSync(_path);
+                } catch { }
+            }
+        }
+    }
+
+    /**
+     * 更改数据储存位置,user_id和sessionToken关系转移到redis中 
+     * @param {string} _path 旧存储路径
+     */
+    static async movJsonFile(_path) {
+        let user_token = await this.FileReader(path.join(_path, 'user_token.json')) || {}
+        if (!fs.existsSync(`${_path}`)) { return false }
+        const files = fs.readdirSync(_path);
+
+        if (files.length > 0) {
+
+            let tot = 0
+            let already = 0
+            files.forEach(file => {
+                if (!fs.lstatSync(`${_path}/${file}`).isDirectory() && file != 'user_token.json') {
+                    ++tot
+                }
+            });
+            files.forEach(file => {
+                if (!fs.lstatSync(`${_path}/${file}`).isDirectory() && file != 'user_token.json') {
+                    let user_id = file.replace('.json', '')
+                    this.FileReader(`${_path}/${file}`).then((/** @type {any} */ json) => {
+                        if (json) {
+                            let session = json.session
+                            /**保存user_id和session映射 */
+                            user_token[user_id] = session
+                            ++already
+                            if (this.SetFile(path.join(savePath, session, 'save.json'), json)) {
+                                this.FileReader(path.join(pluginDataPath, `${user_id}_.json`)).then((/** @type {any} */ json_) => {
+                                    if (json_) {
+                                        let tem_file = {
+                                            data: json_.data,
+                                            rks: json_.rks,
+                                            scoreHistory: json_.scoreHistory,
+                                            CLGMOD: json_.CLGMOD,
+                                            version: json_.version,
+                                        }
+                                        this.SetFile(path.join(savePath, session, 'history.json'), tem_file)
+                                    }
+                                })
+                                fs.rmSync(path.join(_path, file))
+                            }
+                        }
+                    })
+                }
+            });
+
+            async function check() {
+                while (already < tot) {
+                    logger.mark('[phi-plugin][数据整合，请勿中断进程]', `${already}/${tot}`)
+                    await new Promise(resolve => setTimeout(resolve, 1000));
+                }
+                logger.mark('[phi-plugin][数据整合]', `${already}/${tot}`)
+            }
+
+            await check();
+
+            // let list = await getRksRank.getAllRank()
+
+            // for (let i = 0; i < list.length; i++) {
+            //     await getRksRank.delUserRks(list[i])
+            // }
+
+            await this.SetFile("user_token.json", user_token)
+
+            already = 0
+            tot = Object.keys(user_token).length
+            for (let id in user_token) {
+                try {
+                    logger.mark('[phi-plugin][数据转移，请勿中断进程]', `${already}/${tot}`)
+                    await userCredentialStore.setSessionToken(id, user_token[id])
+                    const save = await this.FileReader(path.join(savePath, user_token[id], 'save.json'))
+                    const rks = Number(save?.saveInfo?.summary?.rankingScore)
+                    if (!save) continue
+                    if (!Number.isFinite(rks)) {
+                        logger.mark('[phi-plugin][数据转移，请勿中断进程]', `奇怪的rks ${save?.saveInfo?.summary?.rankingScore}`)
+                        continue
+                    }
+                    await getRksRank.addUserRks(user_token[id], rks)
+                } catch (err) {
+                    logger.error('[phi-plugin][数据转移，请勿中断进程]', err, `跳过该用户${id} ${user_token[id]}`)
+                } finally {
+                    ++already
+                }
+            }
+            logger.mark('[phi-plugin][数据转移，请勿中断进程]', `${already}/${tot}`)
+
+            // list = await getRksRank.getAllRank()
+
+
+            await this.DelFile(path.join(dataPath, 'user_token.json'));
+
+
+        }
+    }
+
+
+}

package/core/model/filesystem/path.js

@@ -0,0 +1,84 @@
+import path from 'path'
+import { fileURLToPath } from 'url'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = path.dirname(__filename)
+
+/**宿主进程根目录 */
+export const _path = process.cwd()
+
+/**插件根目录 */
+export const pluginRoot = path.resolve(__dirname, '..', '..')
+
+/**插件名 */
+export const pluginName = path.basename(pluginRoot)
+
+/**
+ * Koishi 移植专用：运行数据根目录。
+ * 由 koishi 插件入口在加载 core 之前设置，指向 Koishi 的
+ * `<ctx.baseDir>/data/<plugin>`，避免把存档/配置写在 node_modules 内。
+ */
+const koishiRoot = process.env.PHI_PLUGIN_KOISHI_ROOT
+  ? path.resolve(process.env.PHI_PLUGIN_KOISHI_ROOT)
+  : null
+
+/**插件临时文件目录 */
+export const tempPath = koishiRoot
+  ? path.join(koishiRoot, 'temp')
+  : path.join(pluginRoot, 'temp')
+
+/**插件资源目录 */
+export const pluginResources = path.join(pluginRoot, 'resources')
+
+/**曲绘资源、曲目信息路径 */
+export const infoPath = path.join(pluginResources, 'info')
+
+/**额外曲目名称信息（开字母用） */
+export const DlcInfoPath = path.join(pluginResources, 'info', 'DLC')
+
+/**上个版本曲目信息 */
+export const oldInfoPath = path.join(pluginResources, 'info', 'oldInfo')
+
+/**数据路径 */
+export const dataPath = koishiRoot
+  ? path.join(koishiRoot, 'data')
+  : path.join(pluginRoot, 'data')
+
+/**用户娱乐数据路径 */
+export const pluginDataPath = path.join(dataPath, 'pluginData')
+
+/**用户存档数据路径 */
+export const savePath = path.join(dataPath, 'saveData')
+
+/**API用户存档数据路径 */
+export const apiSavePath = path.join(dataPath, 'apiSaveData')
+
+/**其他插件数据路径 */
+export const otherDataPath = path.join(dataPath, 'otherData')
+
+/**用户设置路径 */
+export const configPath = koishiRoot
+  ? path.join(koishiRoot, 'config', 'config')
+  : path.join(pluginRoot, 'config', 'config')
+
+/**默认设置路径 */
+export const defaultPath = path.join(pluginRoot, 'config', 'default_config')
+
+/**默认图片路径 */
+export const imgPath = path.join(pluginResources, 'html', 'otherimg')
+
+/**用户图片路径 */
+export const ortherIllPath = path.join(pluginResources, 'otherill')
+
+/**原画资源 */
+export const originalIllPath = koishiRoot
+  ? path.join(koishiRoot, 'cache', 'original_ill')
+  : path.join(pluginResources, 'original_ill')
+
+/**音频资源 */
+export const guessMicPath = path.join(pluginResources, 'splited_music')
+
+/**备份路径 */
+export const backupPath = koishiRoot
+  ? path.join(koishiRoot, 'backup')
+  : path.join(pluginRoot, 'backup')

package/core/model/game/Chart.js

@@ -0,0 +1,57 @@
+
+export default class Chart {
+    /**
+     * @param {any} data 原始数据
+     */
+    constructor(data) {
+        /** @type {idString} */
+        this.id = data?.id
+
+        /** @type {allLevelKind} */
+        this.rank = data?.rank
+
+        /** @type {string} */
+        this.charter = data.charter
+
+        /** @type {number} */
+        this.difficulty = Number(data.difficulty)
+
+        // /** @type {number | undefined} */
+        // this.tap = Number(data.tap)
+
+        // /** @type {number | undefined} */
+        // this.hold = Number(data.hold)
+
+        // /** @type {number | undefined} */
+        // this.flick = Number(data.flick)
+
+        // /** @type {number | undefined} */
+        // this.combo = Number(data.combo)
+
+        // /** @type {number | undefined} */
+        // this.maxTime = Number(data.maxTime)
+
+        // /** @type {[number,number,number,number,number][]} [tap,drag,hold,flick,tot] */
+        // this.distribution = data.distribution
+
+        if (data.tap) {
+
+            this.tap = Number(data.tap)
+
+            this.drag = Number(data.drag)
+
+            this.hold = Number(data.hold)
+
+            this.flick = Number(data.flick)
+
+            this.combo = Number(data.combo)
+
+            /** s */
+            this.maxTime = Number(data.maxTime)
+
+            /** @type {[number,number,number,number,number][]} [tap,drag,hold,flick,tot] */
+            this.distribution = data.distribution
+        }
+
+    }
+}