koishi-plugin-rocom 1.0.1

package/lib/client.d.ts

@@ -0,0 +1,53 @@
+import { Context } from 'koishi';
+export declare class RocomClient {
+    private baseUrl;
+    private apiKey;
+    private timeout;
+    private lastError;
+    constructor(baseUrl: string, apiKey: string, timeout?: number);
+    private sanitizeUid;
+    private wegameHeaders;
+    private rocomHeaders;
+    private formatHttpError;
+    private isSensitiveLogKey;
+    private maskSensitiveValue;
+    private sanitizeForLog;
+    private headersForLog;
+    private stringifyForLog;
+    private logRequestFailureDetails;
+    private get;
+    private post;
+    private delete;
+    private requestWithStatus;
+    private getIngameTask;
+    qqQrLogin(ctx: Context, userIdentifier: string): Promise<any>;
+    qqQrStatus(ctx: Context, fwToken: string, userIdentifier: string): Promise<any>;
+    wechatQrLogin(ctx: Context, userIdentifier: string): Promise<any>;
+    wechatQrStatus(ctx: Context, fwToken: string, userIdentifier: string): Promise<any>;
+    importToken(ctx: Context, tgpId: string, tgpTicket: string, userIdentifier: string): Promise<any>;
+    createBinding(ctx: Context, fwToken: string, userIdentifier: string): Promise<any>;
+    refreshBinding(ctx: Context, bindingId: string, userIdentifier: string): Promise<any>;
+    deleteBinding(ctx: Context, bindingId: string, userIdentifier: string): Promise<boolean>;
+    getRole(ctx: Context, fwToken: string, accountType?: number, userIdentifier?: string): Promise<any>;
+    getEvaluation(ctx: Context, fwToken: string, userIdentifier?: string): Promise<any>;
+    getLastError(defaultMessage?: string): string;
+    private setLastError;
+    getPetSummary(ctx: Context, fwToken: string, userIdentifier?: string): Promise<any>;
+    getCollection(ctx: Context, fwToken: string, userIdentifier?: string): Promise<any>;
+    getBattleOverview(ctx: Context, fwToken: string, userIdentifier?: string): Promise<any>;
+    getBattleList(ctx: Context, fwToken: string, pageSize?: number, afterTime?: string, userIdentifier?: string): Promise<any>;
+    private isIngamePlayerPayload;
+    ingamePlayerSearch(ctx: Context, uid: string): Promise<any>;
+    getPets(ctx: Context, fwToken: string, petSubset?: number, pageNo?: number, pageSize?: number, userIdentifier?: string): Promise<any>;
+    getLineupList(ctx: Context, fwToken: string, pageNo?: number, category?: string, userIdentifier?: string): Promise<any>;
+    getExchangePosters(ctx: Context, fwToken: string, pageNo?: number, userIdentifier?: string): Promise<any>;
+    getMerchantInfo(ctx: Context, refresh?: boolean): Promise<any>;
+    queryPetSize(ctx: Context, diameter: number, weight: number): Promise<any>;
+    ingameHomeInfo(ctx: Context, uid: string, waitMs?: number): Promise<any>;
+    ingameMerchantInfo(ctx: Context, shopId: string | number): Promise<any>;
+    getFriendship(ctx: Context, fwToken: string, userIds: string, userIdentifier?: string): Promise<any>;
+    getStudentState(ctx: Context, fwToken: string, accountType?: number, userIdentifier?: string): Promise<any>;
+    getStudentPerks(ctx: Context, fwToken: string, area?: number, accountType?: number, userIdentifier?: string): Promise<any>;
+    searchWikiPet(ctx: Context, query: string, limit?: number): Promise<any>;
+    searchWikiSkill(ctx: Context, query: string, limit?: number): Promise<any>;
+}

package/lib/client.js

@@ -0,0 +1,473 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RocomClient = void 0;
+const koishi_1 = require("koishi");
+const logger = new koishi_1.Logger('rocom-client');
+class RocomClient {
+    baseUrl;
+    apiKey;
+    timeout;
+    lastError = '接口异常';
+    constructor(baseUrl, apiKey, timeout = 15000) {
+        this.baseUrl = baseUrl.replace(/\/$/, '');
+        this.apiKey = apiKey;
+        this.timeout = timeout;
+    }
+    sanitizeUid(uid) {
+        if (!uid)
+            return '';
+        return uid.trim().replace(/[^a-zA-Z0-9_\- \u4e00-\u9fa5]/g, '').trim();
+    }
+    wegameHeaders(fwToken = '', userIdentifier = '', clientType = '', clientId = '') {
+        const headers = {};
+        if (this.apiKey)
+            headers['X-API-Key'] = this.apiKey;
+        if (fwToken)
+            headers['X-Framework-Token'] = fwToken;
+        if (userIdentifier)
+            headers['X-User-Identifier'] = this.sanitizeUid(userIdentifier);
+        if (clientType)
+            headers['X-Client-Type'] = clientType;
+        if (clientId)
+            headers['X-Client-ID'] = clientId;
+        return headers;
+    }
+    rocomHeaders(fwToken, userIdentifier = '') {
+        const headers = { 'X-Framework-Token': fwToken };
+        if (this.apiKey)
+            headers['X-API-Key'] = this.apiKey;
+        if (userIdentifier)
+            headers['X-User-Identifier'] = this.sanitizeUid(userIdentifier);
+        return headers;
+    }
+    formatHttpError(e) {
+        const err = e;
+        const response = err?.response;
+        if (response) {
+            const body = response.data;
+            const bodyMessage = body && typeof body === 'object'
+                ? body.message || body.msg || body.error || JSON.stringify(body)
+                : body;
+            const prefix = response.status ? `HTTP ${response.status}` : 'HTTP error';
+            return bodyMessage ? `${prefix}: ${bodyMessage}` : `${prefix}: ${response.statusText || err?.message || 'unknown'}`;
+        }
+        return err?.message || String(e);
+    }
+    isSensitiveLogKey(key) {
+        return /api[-_]?key|authorization|cookie|framework[-_]?token|password|secret|ticket|token/i.test(key);
+    }
+    maskSensitiveValue(value) {
+        if (typeof value !== 'string')
+            return value;
+        if (!value)
+            return value;
+        if (value.length <= 8)
+            return '***';
+        return `${value.slice(0, 4)}...${value.slice(-4)}`;
+    }
+    sanitizeForLog(value, key = '') {
+        if (this.isSensitiveLogKey(key))
+            return this.maskSensitiveValue(value);
+        if (!value || typeof value !== 'object')
+            return value;
+        if (Array.isArray(value))
+            return value.map(item => this.sanitizeForLog(item));
+        const result = {};
+        for (const [entryKey, entryValue] of Object.entries(value)) {
+            result[entryKey] = this.sanitizeForLog(entryValue, entryKey);
+        }
+        return result;
+    }
+    headersForLog(headers) {
+        if (!headers || typeof headers !== 'object')
+            return headers;
+        const iterableHeaders = headers;
+        if (typeof iterableHeaders.forEach === 'function') {
+            const result = {};
+            iterableHeaders.forEach((value, key) => {
+                result[key] = this.sanitizeForLog(value, key);
+            });
+            return result;
+        }
+        return this.sanitizeForLog(headers);
+    }
+    stringifyForLog(value) {
+        try {
+            return JSON.stringify(value, null, 2);
+        }
+        catch {
+            return String(value);
+        }
+    }
+    logRequestFailureDetails(method, path, headers, params, body, errorOrResponse) {
+        const err = errorOrResponse;
+        const response = err?.response;
+        const details = {
+            request: {
+                method,
+                url: `${this.baseUrl}${path}`,
+                path,
+                params: this.sanitizeForLog(params),
+                body: this.sanitizeForLog(body),
+                headers: this.sanitizeForLog(headers),
+                timeout: this.timeout,
+            },
+            response: response ? {
+                status: response.status,
+                statusText: response.statusText,
+                headers: this.headersForLog(response.headers),
+                body: this.sanitizeForLog(response.data),
+            } : undefined,
+            apiResponse: response ? undefined : this.sanitizeForLog(errorOrResponse),
+            error: response || err?.message || err?.stack ? {
+                name: err?.name,
+                message: err?.message,
+                code: err?.code,
+                stack: err?.stack,
+            } : undefined,
+        };
+        console.warn(`[rocom-client] ${method} ${path} detailed failure\n${this.stringifyForLog(details)}`);
+    }
+    async get(ctx, path, headers, params, options) {
+        try {
+            const resp = await ctx.http.get(`${this.baseUrl}${path}`, {
+                headers,
+                params,
+                timeout: this.timeout,
+            });
+            if (resp?.code !== 0) {
+                this.setLastError(resp?.message || '接口返回异常');
+                logger.warn(path + ' error: ' + (resp?.message || 'unknown'));
+                if (!options?.silentFailureDetails) {
+                    this.logRequestFailureDetails('GET', path, headers, params, undefined, resp);
+                }
+                return null;
+            }
+            return resp?.data ?? {};
+        }
+        catch (e) {
+            const message = this.formatHttpError(e);
+            this.setLastError(message);
+            if (!options?.silentFailureDetails) {
+                this.logRequestFailureDetails('GET', path, headers, params, undefined, e);
+            }
+            const err = e;
+            if (err?.response) {
+                logger.warn('GET ' + path + ' failed: ' + message);
+            }
+            else {
+                logger.error('GET ' + path + ' failed: ' + message);
+            }
+            return null;
+        }
+    }
+    async post(ctx, path, headers, json, params) {
+        try {
+            const resp = await ctx.http.post(`${this.baseUrl}${path}`, json, {
+                headers,
+                params,
+                timeout: this.timeout,
+            });
+            if (resp?.code !== 0) {
+                this.setLastError(resp?.message || '接口返回异常');
+                logger.warn(path + ' error: ' + (resp?.message || 'unknown'));
+                this.logRequestFailureDetails('POST', path, headers, params, json, resp);
+                return null;
+            }
+            return resp?.data ?? {};
+        }
+        catch (e) {
+            const message = this.formatHttpError(e);
+            this.setLastError(message);
+            this.logRequestFailureDetails('POST', path, headers, params, json, e);
+            const err = e;
+            if (err?.response) {
+                logger.warn('POST ' + path + ' failed: ' + message);
+            }
+            else {
+                logger.error('POST ' + path + ' failed: ' + message);
+            }
+            return null;
+        }
+    }
+    async delete(ctx, path, headers) {
+        try {
+            const resp = await ctx.http("DELETE", `${this.baseUrl}${path}`, { headers, timeout: this.timeout });
+            if (resp?.code !== 0) {
+                this.setLastError(resp?.message || '接口返回异常');
+                logger.warn(path + ' error: ' + (resp?.message || 'unknown'));
+                this.logRequestFailureDetails('DELETE', path, headers, undefined, undefined, resp);
+                return null;
+            }
+            return resp?.data ?? {};
+        }
+        catch (e) {
+            const message = this.formatHttpError(e);
+            this.setLastError(message);
+            this.logRequestFailureDetails('DELETE', path, headers, undefined, undefined, e);
+            const err = e;
+            if (err?.response) {
+                logger.warn('DELETE ' + path + ' failed: ' + message);
+            }
+            else {
+                logger.error('DELETE ' + path + ' failed: ' + message);
+            }
+            return null;
+        }
+    }
+    // Login and binding APIs.
+    async requestWithStatus(ctx, method, path, headers, options = {}) {
+        const acceptedStatuses = options.acceptedStatuses || [200];
+        try {
+            const response = await ctx.http(method, `${this.baseUrl}${path}`, {
+                headers,
+                params: options.params,
+                data: options.json,
+                timeout: this.timeout,
+                validateStatus: () => true,
+            });
+            const status = Number(response?.status ?? response?.statusCode ?? 200);
+            const body = response?.data !== undefined ? response.data : response;
+            if (body?.code !== undefined && body.code !== 0) {
+                this.setLastError(body.message || body.msg || '接口返回异常');
+                this.logRequestFailureDetails(method, path, headers, options.params, options.json, body);
+                return { status: null, data: null };
+            }
+            const data = body?.code !== undefined ? (body.data ?? {}) : (body ?? {});
+            if (!acceptedStatuses.includes(status)) {
+                this.setLastError(`HTTP ${status}`);
+                this.logRequestFailureDetails(method, path, headers, options.params, options.json, response);
+            }
+            return { status, data };
+        }
+        catch (e) {
+            const message = this.formatHttpError(e);
+            this.setLastError(message);
+            this.logRequestFailureDetails(method, path, headers, options.params, options.json, e);
+            return { status: null, data: null };
+        }
+    }
+    async getIngameTask(ctx, taskId) {
+        return this.requestWithStatus(ctx, 'GET', `/api/v1/games/rocom/ingame/tasks/${taskId}`, this.wegameHeaders(), { acceptedStatuses: [200, 202] });
+    }
+    async qqQrLogin(ctx, userIdentifier) {
+        const params = { client_type: 'bot', client_id: 'koishi', provider: 'rocom' };
+        if (userIdentifier)
+            params.user_identifier = this.sanitizeUid(userIdentifier);
+        return this.get(ctx, '/api/v1/login/wegame/qr', this.wegameHeaders('', userIdentifier, 'bot', 'koishi'), params);
+    }
+    async qqQrStatus(ctx, fwToken, userIdentifier) {
+        const params = {};
+        if (userIdentifier)
+            params.user_identifier = this.sanitizeUid(userIdentifier);
+        return this.get(ctx, '/api/v1/login/wegame/status', this.wegameHeaders(fwToken, userIdentifier, 'bot', 'koishi'), params);
+    }
+    async wechatQrLogin(ctx, userIdentifier) {
+        const params = { client_type: 'bot', client_id: 'koishi', provider: 'rocom' };
+        if (userIdentifier)
+            params.user_identifier = this.sanitizeUid(userIdentifier);
+        return this.get(ctx, '/api/v1/login/wegame/wechat/qr', this.wegameHeaders('', userIdentifier, 'bot', 'koishi'), params);
+    }
+    async wechatQrStatus(ctx, fwToken, userIdentifier) {
+        const params = {};
+        if (userIdentifier)
+            params.user_identifier = this.sanitizeUid(userIdentifier);
+        return this.get(ctx, '/api/v1/login/wegame/wechat/status', this.wegameHeaders(fwToken, userIdentifier, 'bot', 'koishi'), params);
+    }
+    async importToken(ctx, tgpId, tgpTicket, userIdentifier) {
+        const body = { tgp_id: tgpId, tgp_ticket: tgpTicket, provider: 'rocom', client_type: 'bot', client_id: 'koishi' };
+        if (userIdentifier)
+            body.user_identifier = this.sanitizeUid(userIdentifier);
+        return this.post(ctx, '/api/v1/login/wegame/token', this.wegameHeaders('', userIdentifier, 'bot', 'koishi'), body);
+    }
+    async createBinding(ctx, fwToken, userIdentifier) {
+        const payload = { framework_token: fwToken, user_identifier: this.sanitizeUid(userIdentifier), client_type: 'bot', client_id: 'koishi' };
+        return this.post(ctx, '/api/v1/user/bindings', this.wegameHeaders('', userIdentifier, 'bot', 'koishi'), payload);
+    }
+    async refreshBinding(ctx, bindingId, userIdentifier) {
+        return this.post(ctx, `/api/v1/user/bindings/${bindingId}/refresh`, this.wegameHeaders('', userIdentifier), {});
+    }
+    async deleteBinding(ctx, bindingId, userIdentifier) {
+        const res = await this.delete(ctx, `/api/v1/user/bindings/${bindingId}`, this.wegameHeaders('', userIdentifier));
+        return res !== null;
+    }
+    // 洛克王国游戏数据接口
+    async getRole(ctx, fwToken, accountType, userIdentifier = '') {
+        const params = {};
+        if (accountType)
+            params.account_type = accountType;
+        return this.get(ctx, '/api/v1/games/rocom/profile/role', this.rocomHeaders(fwToken, userIdentifier), params);
+    }
+    async getEvaluation(ctx, fwToken, userIdentifier = '') {
+        return this.get(ctx, '/api/v1/games/rocom/profile/evaluation', this.rocomHeaders(fwToken, userIdentifier), undefined, { silentFailureDetails: true });
+    }
+    getLastError(defaultMessage = '接口异常') {
+        return this.lastError || defaultMessage;
+    }
+    setLastError(message) {
+        this.lastError = message || '接口异常';
+    }
+    async getPetSummary(ctx, fwToken, userIdentifier = '') {
+        return this.get(ctx, '/api/v1/games/rocom/profile/pet-summary', this.rocomHeaders(fwToken, userIdentifier));
+    }
+    async getCollection(ctx, fwToken, userIdentifier = '') {
+        return this.get(ctx, '/api/v1/games/rocom/profile/collection', this.rocomHeaders(fwToken, userIdentifier));
+    }
+    async getBattleOverview(ctx, fwToken, userIdentifier = '') {
+        return this.get(ctx, '/api/v1/games/rocom/profile/battle-overview', this.rocomHeaders(fwToken, userIdentifier));
+    }
+    async getBattleList(ctx, fwToken, pageSize = 4, afterTime = '', userIdentifier = '') {
+        const params = { page_size: pageSize };
+        if (afterTime)
+            params.after_time = afterTime;
+        return this.get(ctx, '/api/v1/games/rocom/battle/list', this.rocomHeaders(fwToken, userIdentifier), params);
+    }
+    isIngamePlayerPayload(data) {
+        if (!data || typeof data !== 'object')
+            return false;
+        return Boolean(Array.isArray(data.rows)
+            || Array.isArray(data.notes)
+            || data.title
+            || data.nickname
+            || data.uid);
+    }
+    async ingamePlayerSearch(ctx, uid) {
+        const sanitizedUid = this.sanitizeUid(uid);
+        if (!sanitizedUid) {
+            this.setLastError('UID 涓嶈兘涓虹┖');
+            return null;
+        }
+        const path = '/api/v1/games/rocom/ingame/player/search';
+        const headers = this.wegameHeaders();
+        const payload = { uid: sanitizedUid, wait_ms: 5000 };
+        let { status, data } = await this.requestWithStatus(ctx, 'POST', path, headers, {
+            json: payload,
+            acceptedStatuses: [200, 202],
+        });
+        if (status === 200 && data && this.isIngamePlayerPayload(data))
+            return data;
+        if (status === null) {
+            const fallback = await this.requestWithStatus(ctx, 'GET', path, headers, {
+                params: payload,
+                acceptedStatuses: [200, 202],
+            });
+            status = fallback.status;
+            data = fallback.data;
+            if (status === 200 && data && this.isIngamePlayerPayload(data))
+                return data;
+        }
+        if (!data)
+            return null;
+        if (this.isIngamePlayerPayload(data))
+            return data;
+        const taskId = data.task_id || data.taskId || data.taskID;
+        if (!taskId) {
+            if (status === 202)
+                this.setLastError('玩家搜索任务已入队，但未返回 task_id');
+            return data;
+        }
+        for (let i = 0; i < 8; i++) {
+            await new Promise(resolve => setTimeout(resolve, 1000));
+            const task = await this.getIngameTask(ctx, taskId);
+            if (task.status === 200)
+                return task.data;
+            if (task.status === null)
+                return null;
+        }
+        this.setLastError('Player search task is still queued, please retry later (task_id: ' + taskId + ')');
+        return null;
+    }
+    async getPets(ctx, fwToken, petSubset = 0, pageNo = 1, pageSize = 10, userIdentifier = '') {
+        const params = { pet_subset: petSubset, page_no: pageNo, page_size: pageSize };
+        return this.get(ctx, '/api/v1/games/rocom/battle/pets', this.rocomHeaders(fwToken, userIdentifier), params);
+    }
+    async getLineupList(ctx, fwToken, pageNo = 1, category = '', userIdentifier = '') {
+        const params = { page_no: pageNo };
+        if (category)
+            params.category = category;
+        return this.get(ctx, '/api/v1/games/rocom/lineup/list', this.rocomHeaders(fwToken, userIdentifier), params);
+    }
+    async getExchangePosters(ctx, fwToken, pageNo = 1, userIdentifier = '') {
+        const params = { page_no: Math.max(pageNo, 1), refresh: 'false' };
+        return this.get(ctx, '/api/v1/games/rocom/exchange/posters', this.wegameHeaders(fwToken, userIdentifier), params);
+    }
+    async getMerchantInfo(ctx, refresh = false) {
+        return this.get(ctx, '/api/v1/games/rocom/merchant/info', this.wegameHeaders(), { refresh: refresh ? 'true' : 'false' });
+    }
+    async queryPetSize(ctx, diameter, weight) {
+        return this.get(ctx, '/api/v1/games/rocom/pet/size-query', this.wegameHeaders(), { diameter, weight });
+    }
+    async ingameHomeInfo(ctx, uid, waitMs = 5000) {
+        const sanitizedUid = this.sanitizeUid(uid);
+        if (!sanitizedUid) {
+            this.setLastError('UID 涓嶈兘涓虹┖');
+            return null;
+        }
+        const path = '/api/v1/games/rocom/ingame/home/info';
+        const headers = this.wegameHeaders();
+        const payload = { uid: sanitizedUid, wait_ms: waitMs };
+        let { status, data } = await this.requestWithStatus(ctx, 'POST', path, headers, {
+            json: payload,
+            acceptedStatuses: [200, 202],
+        });
+        if (status === 200 && data && !(data.task_id || data.taskId || data.taskID))
+            return data;
+        if (status === null) {
+            const fallback = await this.requestWithStatus(ctx, 'GET', path, headers, {
+                params: payload,
+                acceptedStatuses: [200, 202],
+            });
+            status = fallback.status;
+            data = fallback.data;
+            if (status === 200 && data && !(data.task_id || data.taskId || data.taskID))
+                return data;
+        }
+        const taskId = data?.task_id || data?.taskId || data?.taskID;
+        if (!taskId) {
+            if (status === 202)
+                this.setLastError('家园查询任务已入队，但未返回 task_id');
+            return null;
+        }
+        for (let i = 0; i < 10; i++) {
+            await new Promise(resolve => setTimeout(resolve, 1000));
+            const task = await this.getIngameTask(ctx, taskId);
+            if (task.status === 200)
+                return task.data;
+            if (task.status === null)
+                return null;
+        }
+        this.setLastError(`Home query task is still queued, please retry later (task_id: ${taskId})`);
+        return null;
+    }
+    async ingameMerchantInfo(ctx, shopId) {
+        const params = { shop_id: shopId };
+        const data = await this.get(ctx, '/api/v1/games/rocom/ingame/merchant/info', this.wegameHeaders(), params, { silentFailureDetails: true });
+        if (data)
+            return data;
+        return this.post(ctx, '/api/v1/games/rocom/ingame/merchant/info', this.wegameHeaders(), params);
+    }
+    async getFriendship(ctx, fwToken, userIds, userIdentifier = '') {
+        return this.get(ctx, '/api/v1/games/rocom/social/friendship', this.rocomHeaders(fwToken, userIdentifier), { user_ids: userIds });
+    }
+    async getStudentState(ctx, fwToken, accountType, userIdentifier = '') {
+        const params = {};
+        if (accountType !== undefined)
+            params.account_type = accountType;
+        return this.get(ctx, '/api/v1/games/rocom/activity/student-state', this.rocomHeaders(fwToken, userIdentifier), params);
+    }
+    async getStudentPerks(ctx, fwToken, area, accountType, userIdentifier = '') {
+        const params = {};
+        if (area !== undefined)
+            params.area = area;
+        if (accountType !== undefined)
+            params.account_type = accountType;
+        return this.get(ctx, '/api/v1/games/rocom/activity/perks', this.rocomHeaders(fwToken, userIdentifier), params);
+    }
+    async searchWikiPet(ctx, query, limit = 10) {
+        return this.get(ctx, '/api/v1/games/rocom/wiki/pet', this.wegameHeaders(), { q: query, limit });
+    }
+    async searchWikiSkill(ctx, query, limit = 10) {
+        return this.get(ctx, '/api/v1/games/rocom/wiki/skill', this.wegameHeaders(), { q: query, limit });
+    }
+}
+exports.RocomClient = RocomClient;

package/lib/commands/account.d.ts

@@ -0,0 +1,5 @@
+import { PluginDeps } from '../types';
+export declare function getPrimaryToken(deps: PluginDeps, userId: string): Promise<string>;
+export declare function notLoggedInHint(): string;
+export declare function saveBindingWithRoleInfo(deps: PluginDeps, session: any, fwToken: string, loginType: string, userId: string): Promise<void>;
+export declare function register(deps: PluginDeps): void;