koishi-plugin-rocom 1.0.10 → 1.0.11

package/lib/activities-service.d.ts

@@ -0,0 +1,72 @@
+type ActivityReward = {
+    kind: string;
+    name: string;
+};
+type ActivityItem = {
+    id: string;
+    name: string;
+    desc: string;
+    description: string;
+    cover: string;
+    start_ts: number;
+    end_ts: number;
+    start: string;
+    end: string;
+    statusText: string;
+    statusClass: string;
+    is_unlimited: boolean;
+    is_perm: boolean;
+    rewards: ActivityReward[];
+    rewards_text: string;
+    sort: number;
+    time_label: string;
+    hide_start?: boolean;
+    left_pct?: number;
+    width_pct?: number;
+    theme?: string;
+};
+export declare class ActivitiesService {
+    extractActivities(payload: any): ActivityItem[];
+    buildRenderData(payload: any): {
+        title: string;
+        subtitle: string;
+        activity_count: number;
+        activities: ActivityItem[];
+        lanes: {
+            theme: string;
+            id: string;
+            name: string;
+            desc: string;
+            description: string;
+            cover: string;
+            start_ts: number;
+            end_ts: number;
+            start: string;
+            end: string;
+            statusText: string;
+            statusClass: string;
+            is_unlimited: boolean;
+            is_perm: boolean;
+            rewards: ActivityReward[];
+            rewards_text: string;
+            sort: number;
+            time_label: string;
+            hide_start?: boolean;
+            left_pct?: number;
+            width_pct?: number;
+        }[][];
+        axis_dates: {
+            label: string;
+            left_pct: number;
+        }[];
+        now_line: {
+            label: string;
+            left_pct: number;
+        };
+        empty: boolean;
+        commandHint: string;
+        copyright: string;
+    };
+    buildFallbackText(payload: any): string;
+}
+export {};

package/lib/activities-service.js

@@ -0,0 +1,293 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ActivitiesService = void 0;
+const CHINA_TIMEZONE = 'Asia/Shanghai';
+const DAY_MS = 24 * 60 * 60 * 1000;
+const ACTIVITY_THEMES = ['gold', 'green', 'brown'];
+const LOOKBACK_DAYS = 10;
+const MAX_LOOKAHEAD_DAYS = 50;
+const TRAILING_DAYS_AFTER_LAST_ACTIVITY = 3;
+const MIN_LOOKAHEAD_DAYS = 7;
+const chinaDateFormatter = new Intl.DateTimeFormat('zh-CN', {
+    timeZone: CHINA_TIMEZONE,
+    month: '2-digit',
+    day: '2-digit',
+});
+const chinaDateTimeFormatter = new Intl.DateTimeFormat('zh-CN', {
+    timeZone: CHINA_TIMEZONE,
+    month: '2-digit',
+    day: '2-digit',
+    hour: '2-digit',
+    minute: '2-digit',
+    hour12: false,
+});
+const chinaDatePartsFormatter = new Intl.DateTimeFormat('zh-CN', {
+    timeZone: CHINA_TIMEZONE,
+    year: 'numeric',
+    month: '2-digit',
+    day: '2-digit',
+});
+function trimText(value) {
+    return String(value ?? '').trim();
+}
+function isPlainObject(value) {
+    return !!value && typeof value === 'object' && !Array.isArray(value);
+}
+function clamp(value, min, max) {
+    return Math.max(min, Math.min(max, value));
+}
+function formatDateText(timestampMs, withTime = false) {
+    const numeric = Number(timestampMs);
+    if (!Number.isFinite(numeric) || numeric <= 0)
+        return '--';
+    const formatter = withTime ? chinaDateTimeFormatter : chinaDateFormatter;
+    return formatter.format(new Date(numeric)).replace(/\//g, '.');
+}
+function getChinaDateParts(date = new Date()) {
+    const parts = {};
+    for (const item of chinaDatePartsFormatter.formatToParts(date)) {
+        if (item.type !== 'literal')
+            parts[item.type] = Number(item.value);
+    }
+    return parts;
+}
+function chinaDateToTimestampMs(year, month, day, hour = 0, minute = 0, second = 0) {
+    return Date.UTC(year, month - 1, day, hour - 8, minute, second);
+}
+function parseChinaDateText(value = '', endOfDay = false) {
+    const text = trimText(value);
+    if (!text)
+        return 0;
+    const localMatch = text.match(/^(\d{4})-(\d{1,2})-(\d{1,2})(?:[ T](\d{1,2}):(\d{1,2})(?::(\d{1,2}))?)?$/);
+    if (localMatch) {
+        const [, year, month, day, hour, minute, second] = localMatch;
+        const hasTime = hour !== undefined;
+        return chinaDateToTimestampMs(Number(year), Number(month), Number(day), hasTime ? Number(hour) : endOfDay ? 23 : 0, hasTime ? Number(minute) : endOfDay ? 59 : 0, hasTime ? Number(second || 0) : endOfDay ? 59 : 0);
+    }
+    const parsed = Date.parse(text);
+    return Number.isFinite(parsed) ? parsed : 0;
+}
+function parseActivityTimestampMs(value, fallbackDate = '', endOfDay = false) {
+    const numeric = Number(value);
+    if (Number.isFinite(numeric) && numeric > 0) {
+        return numeric > 10000000000 ? numeric : numeric * 1000;
+    }
+    return parseChinaDateText(trimText(value) || fallbackDate, endOfDay);
+}
+function extractActivitySource(payload) {
+    if (!isPlainObject(payload))
+        return [];
+    for (const key of ['activityCalendar', 'calendar', 'otherActivities', 'other_activities', 'activities', 'list', 'items']) {
+        if (Array.isArray(payload[key]))
+            return payload[key];
+    }
+    if (isPlainObject(payload.data))
+        return extractActivitySource(payload.data);
+    return [];
+}
+function rewardName(item) {
+    if (isPlainObject(item)) {
+        return trimText(item.name || item.goods_name || item.pet_name || item.title);
+    }
+    return trimText(item);
+}
+function extractRewards(activity) {
+    const rewards = [];
+    for (const [kind, key] of [
+        ['prop', 'get_props'],
+        ['prop', 'get_extra_props'],
+        ['pet', 'get_pets'],
+        ['reward', 'rewards'],
+    ]) {
+        const value = Array.isArray(activity?.[key]) ? activity[key] : [];
+        for (const item of value) {
+            const name = rewardName(item);
+            if (name)
+                rewards.push({ kind, name });
+        }
+    }
+    return rewards;
+}
+function buildRewardText(rewards) {
+    return rewards.length
+        ? rewards.slice(0, 6).map(item => item.name).join('、')
+        : '暂无奖励信息';
+}
+function buildActivityTimeLabel(activity) {
+    if (activity.is_perm)
+        return `${activity.start} 开启`;
+    if (activity.hide_start)
+        return `截止 ${activity.end}`;
+    return `${activity.start} - ${activity.end}`;
+}
+function packLanes(items) {
+    const lanes = [];
+    for (const item of items) {
+        const lane = lanes.find(current => item.start_ts >= current[current.length - 1].end_ts + DAY_MS);
+        if (lane) {
+            lane.push(item);
+        }
+        else {
+            lanes.push([item]);
+        }
+    }
+    return lanes;
+}
+class ActivitiesService {
+    extractActivities(payload) {
+        const source = extractActivitySource(payload);
+        const nowMs = Date.now();
+        return source
+            .filter(item => isPlainObject(item) && !item.is_deleted)
+            .map((item) => {
+            let startTs = parseActivityTimestampMs(item.start_time || item.startAt || item.start_at || item.start_ts, item.start_date || '');
+            let endTs = parseActivityTimestampMs(item.end_time || item.endAt || item.end_at || item.end_ts, item.end_date || '', true);
+            const isUnlimited = Boolean(item.is_unlimited);
+            if (!startTs && !endTs && !isUnlimited)
+                return null;
+            if (isUnlimited && !endTs) {
+                endTs = startTs ? startTs + 365 * DAY_MS : nowMs + 365 * DAY_MS;
+            }
+            if (!startTs)
+                startTs = nowMs;
+            if (!endTs || endTs <= startTs)
+                endTs = startTs + DAY_MS;
+            const isPermanent = isUnlimited || endTs - startTs >= 300 * DAY_MS;
+            const rewards = extractRewards(item);
+            let statusText = '进行中';
+            let statusClass = 'active';
+            if (nowMs < startTs) {
+                statusText = '未开始';
+                statusClass = 'upcoming';
+            }
+            else if (nowMs > endTs && !isUnlimited) {
+                statusText = '已结束';
+                statusClass = 'ended';
+            }
+            else if (isPermanent) {
+                statusText = '常驻';
+                statusClass = 'permanent';
+            }
+            return {
+                id: trimText(item._id || item.id),
+                name: trimText(item.name || item.title) || '未命名活动',
+                desc: trimText(item.description || item.desc) || '活动',
+                description: trimText(item.description || item.desc),
+                cover: trimText(item.cover_url || item.cover || item.pic),
+                start_ts: startTs,
+                end_ts: endTs,
+                start: formatDateText(startTs, true),
+                end: formatDateText(endTs, true),
+                statusText,
+                statusClass,
+                is_unlimited: isUnlimited,
+                is_perm: isPermanent,
+                rewards,
+                rewards_text: buildRewardText(rewards),
+                sort: Number(item.sort) || 999,
+                time_label: formatDateText(startTs) === formatDateText(endTs)
+                    ? formatDateText(startTs)
+                    : `${formatDateText(startTs)} ~ ${formatDateText(endTs)}`,
+            };
+        })
+            .filter((item) => !!item)
+            .sort((a, b) => Number(a.is_perm) - Number(b.is_perm) || a.start_ts - b.start_ts || a.sort - b.sort);
+    }
+    buildRenderData(payload) {
+        const activities = this.extractActivities(payload);
+        const now = new Date();
+        const nowMs = now.getTime();
+        const today = getChinaDateParts(now);
+        const todayMidnightMs = chinaDateToTimestampMs(today.year, today.month, today.day);
+        const minTs = todayMidnightMs - LOOKBACK_DAYS * DAY_MS;
+        const defaultMaxTs = todayMidnightMs + MAX_LOOKAHEAD_DAYS * DAY_MS;
+        const minFutureMaxTs = todayMidnightMs + MIN_LOOKAHEAD_DAYS * DAY_MS;
+        const lastActivityEndTs = activities
+            .filter(activity => !activity.is_perm)
+            .reduce((max, activity) => Math.max(max, activity.end_ts), 0);
+        const maxTs = lastActivityEndTs
+            ? Math.min(defaultMaxTs, Math.max(minFutureMaxTs, lastActivityEndTs + TRAILING_DAYS_AFTER_LAST_ACTIVITY * DAY_MS))
+            : defaultMaxTs;
+        const totalDuration = Math.max(maxTs - minTs, 1);
+        const normalItems = [];
+        const permanentItems = [];
+        const keyDates = new Set();
+        for (const activity of activities) {
+            const item = { ...activity };
+            let leftPct = (item.start_ts - minTs) / totalDuration * 100;
+            let rightPct = (item.end_ts - minTs) / totalDuration * 100;
+            if (item.is_perm)
+                rightPct = 100;
+            leftPct = clamp(leftPct, 0, 100);
+            rightPct = clamp(rightPct, 0, 100);
+            let widthPct = Math.max(12.5, rightPct - leftPct);
+            if (leftPct + widthPct > 100) {
+                leftPct = Math.max(0, 100 - widthPct);
+            }
+            item.left_pct = Number(leftPct.toFixed(3));
+            item.width_pct = Number(widthPct.toFixed(3));
+            item.hide_start = item.start_ts < minTs;
+            item.time_label = buildActivityTimeLabel(item);
+            if (item.is_perm) {
+                permanentItems.push(item);
+            }
+            else {
+                normalItems.push(item);
+                if (minTs <= item.start_ts && item.start_ts <= maxTs)
+                    keyDates.add(item.start_ts);
+            }
+        }
+        const lanes = [...packLanes(normalItems), ...packLanes(permanentItems)]
+            .map((lane, laneIndex) => lane.map((item, itemIndex) => ({
+            ...item,
+            theme: ACTIVITY_THEMES[(laneIndex + itemIndex) % ACTIVITY_THEMES.length],
+        })));
+        const axisDates = [];
+        let lastTs = 0;
+        for (const ts of [...keyDates].sort((a, b) => a - b)) {
+            if (ts - lastTs < 4 * DAY_MS)
+                continue;
+            lastTs = ts;
+            axisDates.push({
+                label: formatDateText(ts),
+                left_pct: Number(((ts - minTs) / totalDuration * 100).toFixed(3)),
+            });
+        }
+        const nowPct = (nowMs - minTs) / totalDuration * 100;
+        const nowLine = nowPct >= 0 && nowPct <= 100
+            ? { label: 'TODAY', left_pct: Number(nowPct.toFixed(3)) }
+            : null;
+        return {
+            title: '洛克活动日历',
+            subtitle: `显示 ${formatDateText(nowMs)} 前 ${LOOKBACK_DAYS} 天至 ${formatDateText(maxTs)} 活动`,
+            activity_count: activities.length,
+            activities,
+            lanes,
+            axis_dates: axisDates,
+            now_line: nowLine,
+            empty: activities.length === 0,
+            commandHint: '发送 洛克日历 / 洛克活动',
+            copyright: 'Koishi & WeGame Roco Kingdom Plugin',
+        };
+    }
+    buildFallbackText(payload) {
+        const activities = this.extractActivities(payload);
+        if (!activities.length) {
+            return ['洛克活动日历', '', '暂无进行中的活动。'].join('\n');
+        }
+        const lines = ['洛克活动日历', `当前共 ${activities.length} 个活动`, ''];
+        activities.forEach((activity, index) => {
+            lines.push(`${index + 1}. ${activity.name}`);
+            lines.push(`状态：${activity.statusText}`);
+            lines.push(`时间：${activity.time_label}`);
+            if (activity.description)
+                lines.push(`说明：${activity.description}`);
+            if (activity.rewards.length)
+                lines.push(`奖励：${activity.rewards.map(item => item.name).join('、')}`);
+            if (index !== activities.length - 1)
+                lines.push('');
+        });
+        return lines.join('\n');
+    }
+}
+exports.ActivitiesService = ActivitiesService;

package/lib/client.d.ts

@@ -20,6 +20,7 @@ export declare class RocomClient {
     private logRequestFailureDetails;
     private get;
     private post;
+    private scopedParams;
     private delete;
     private requestWithStatus;
     private requestIngameWithFallback;
@@ -32,6 +33,8 @@ export declare class RocomClient {
     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>;
+    getAccounts(ctx: Context, userIdentifier?: string, accountType?: number): Promise<any>;
+    bindUid(ctx: Context, uid: string, userIdentifier?: string): Promise<any>;
     getRole(ctx: Context, fwToken: string, accountType?: number, userIdentifier?: string): Promise<any>;
     getEvaluation(ctx: Context, fwToken: string, userIdentifier?: string): Promise<any>;
     getLastError(defaultMessage?: string): string;
@@ -47,10 +50,38 @@ export declare class RocomClient {
     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>;
+    queryPetSize(ctx: Context, diameter: number, weight: number, sameRideEgg?: boolean, userIdentifier?: string): Promise<any>;
+    getActivitiesInfo(ctx: Context, refresh?: boolean, userIdentifier?: string): Promise<any>;
+    syncConfig(ctx: Context, userIdentifier?: string): Promise<any>;
+    getAnnouncementList(ctx: Context, params?: {
+        category_id?: number | string;
+        page?: number;
+        limit?: number;
+        order?: string;
+    }, userIdentifier?: string): Promise<any>;
+    getLatestAnnouncement(ctx: Context, params?: {
+        category_id?: number | string;
+        order?: string;
+    }, userIdentifier?: string): Promise<any>;
+    getAnnouncementDetail(ctx: Context, threadId: number | string, userIdentifier?: string): Promise<any>;
+    getEggSearch(ctx: Context, height: number, weight: number, pageNo?: number, pageSize?: number, userIdentifier?: string): Promise<any>;
+    getEggGroups(ctx: Context, userIdentifier?: string): Promise<any>;
+    getEggGroupPets(ctx: Context, groupIds: string | number[], matchMode?: 'any' | 'all', pageNo?: number, pageSize?: number, userIdentifier?: string): Promise<any>;
+    getEggPetGroups(ctx: Context, query: string, limit?: number, userIdentifier?: string): Promise<any>;
+    getEggExchanges(ctx: Context, params?: Record<string, any>, userIdentifier?: string): Promise<any>;
+    postEggExchange(ctx: Context, data: Record<string, any>, userIdentifier?: string): Promise<any>;
+    getMyEggExchanges(ctx: Context, params?: Record<string, any>, userIdentifier?: string): Promise<any>;
+    getEggExchangeReviewStatus(ctx: Context, postId: string | number, userIdentifier?: string): Promise<any>;
+    closeEggExchange(ctx: Context, postId: string | number, closeReason?: string, userIdentifier?: string): Promise<any>;
+    createEggExchangeSubscription(ctx: Context, filters: Record<string, any>, userIdentifier?: string): Promise<any>;
+    getEggExchangeSubscriptions(ctx: Context, userIdentifier?: string): Promise<any>;
+    deleteEggExchangeSubscription(ctx: Context, subscriptionId: string | number, userIdentifier?: string): Promise<any>;
+    getEggExchangeEvents(ctx: Context, subscriptionId: string | number, afterEventId?: string, limit?: number, userIdentifier?: string): 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>;
     getWikiPetDetail(ctx: Context, options: {

package/lib/client.js

@@ -244,13 +244,19 @@ class RocomClient {
             return null;
         }
     }
-    async delete(ctx, path, headers) {
+    scopedParams(params = {}, userIdentifier = '') {
+        const result = { ...params };
+        if (userIdentifier)
+            result.user_identifier = this.sanitizeUid(userIdentifier);
+        return result;
+    }
+    async delete(ctx, path, headers, params) {
         try {
-            const resp = await ctx.http("DELETE", `${this.baseUrl}${path}`, { headers, timeout: this.timeout });
+            const resp = await ctx.http("DELETE", `${this.baseUrl}${path}`, { headers, params, 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);
+                this.logRequestFailureDetails('DELETE', path, headers, params, undefined, resp);
                 return null;
             }
             return resp?.data ?? {};
@@ -258,7 +264,7 @@ class RocomClient {
         catch (e) {
             const message = this.formatHttpError(e);
             this.setLastError(message);
-            this.logRequestFailureDetails('DELETE', path, headers, undefined, undefined, e);
+            this.logRequestFailureDetails('DELETE', path, headers, params, undefined, e);
             const err = e;
             if (err?.response) {
                 logger.warn('DELETE ' + path + ' failed: ' + message);
@@ -384,6 +390,21 @@ class RocomClient {
         const res = await this.delete(ctx, `/api/v1/user/bindings/${bindingId}`, this.wegameHeaders('', userIdentifier));
         return res !== null;
     }
+    async getAccounts(ctx, userIdentifier = '', accountType) {
+        const params = this.scopedParams({}, userIdentifier);
+        if (accountType !== undefined)
+            params.account_type = accountType;
+        return this.get(ctx, '/api/v1/games/rocom/accounts', this.wegameHeaders('', userIdentifier, 'bot', 'koishi'), params);
+    }
+    async bindUid(ctx, uid, userIdentifier = '') {
+        const sanitizedUid = this.sanitizeUid(uid);
+        if (!/^\d+$/.test(sanitizedUid)) {
+            this.setLastError('UID 必须为纯数字');
+            return null;
+        }
+        const params = this.scopedParams({ client_type: 'bot', client_id: 'koishi' }, userIdentifier);
+        return this.post(ctx, '/api/v1/games/rocom/uid/bind', this.wegameHeaders('', userIdentifier, 'bot', 'koishi'), { uid: sanitizedUid }, params);
+    }
     // 洛克王国游戏数据接口
     async getRole(ctx, fwToken, accountType, userIdentifier = '') {
         const params = {};
@@ -477,8 +498,69 @@ class RocomClient {
     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 queryPetSize(ctx, diameter, weight, sameRideEgg = false, userIdentifier = '') {
+        const params = this.scopedParams({ diameter, weight }, userIdentifier);
+        if (sameRideEgg)
+            params.sameRideEgg = 1;
+        return this.get(ctx, '/api/v1/games/rocom/pet/size-query', this.wegameHeaders('', userIdentifier, 'bot', 'koishi'), params);
+    }
+    async getActivitiesInfo(ctx, refresh = false, userIdentifier = '') {
+        return this.get(ctx, '/api/v1/games/rocom/activities/info', this.wegameHeaders('', userIdentifier, 'bot', 'koishi'), this.scopedParams({ refresh: refresh ? 'true' : 'false' }, userIdentifier));
+    }
+    async syncConfig(ctx, userIdentifier = '') {
+        return this.post(ctx, '/api/v1/games/rocom/config/sync', this.wegameHeaders('', userIdentifier, 'bot', 'koishi'), {}, this.scopedParams({}, userIdentifier));
+    }
+    async getAnnouncementList(ctx, params = {}, userIdentifier = '') {
+        return this.get(ctx, '/api/v1/games/rocom/announcement/list', this.wegameHeaders('', userIdentifier, 'bot', 'koishi'), this.scopedParams(params, userIdentifier));
+    }
+    async getLatestAnnouncement(ctx, params = {}, userIdentifier = '') {
+        return this.get(ctx, '/api/v1/games/rocom/announcement/latest', this.wegameHeaders('', userIdentifier, 'bot', 'koishi'), this.scopedParams(params, userIdentifier));
+    }
+    async getAnnouncementDetail(ctx, threadId, userIdentifier = '') {
+        return this.get(ctx, '/api/v1/games/rocom/announcement/detail', this.wegameHeaders('', userIdentifier, 'bot', 'koishi'), this.scopedParams({ thread_id: threadId }, userIdentifier));
+    }
+    async getEggSearch(ctx, height, weight, pageNo = 1, pageSize = 20, userIdentifier = '') {
+        return this.get(ctx, '/api/v1/games/rocom/egg/search', this.wegameHeaders('', userIdentifier, 'bot', 'koishi'), this.scopedParams({ height, weight, page_no: pageNo, page_size: pageSize }, userIdentifier));
+    }
+    async getEggGroups(ctx, userIdentifier = '') {
+        return this.get(ctx, '/api/v1/games/rocom/egg/groups', this.wegameHeaders('', userIdentifier, 'bot', 'koishi'), this.scopedParams({}, userIdentifier));
+    }
+    async getEggGroupPets(ctx, groupIds, matchMode = 'any', pageNo = 1, pageSize = 20, userIdentifier = '') {
+        const normalizedGroupIds = Array.isArray(groupIds) ? groupIds.join(',') : String(groupIds || '');
+        return this.get(ctx, '/api/v1/games/rocom/egg/group-pets', this.wegameHeaders('', userIdentifier, 'bot', 'koishi'), this.scopedParams({ group_ids: normalizedGroupIds, match_mode: matchMode, page_no: pageNo, page_size: pageSize }, userIdentifier));
+    }
+    async getEggPetGroups(ctx, query, limit = 20, userIdentifier = '') {
+        return this.get(ctx, '/api/v1/games/rocom/egg/pet-groups', this.wegameHeaders('', userIdentifier, 'bot', 'koishi'), this.scopedParams({ q: query, limit }, userIdentifier));
+    }
+    async getEggExchanges(ctx, params = {}, userIdentifier = '') {
+        return this.get(ctx, '/api/v1/games/rocom/community/egg-exchanges', this.wegameHeaders('', userIdentifier, 'bot', 'koishi'), this.scopedParams(params, userIdentifier));
+    }
+    async postEggExchange(ctx, data, userIdentifier = '') {
+        return this.post(ctx, '/api/v1/games/rocom/community/egg-exchanges', this.wegameHeaders('', userIdentifier, 'bot', 'koishi'), data, this.scopedParams({}, userIdentifier));
+    }
+    async getMyEggExchanges(ctx, params = {}, userIdentifier = '') {
+        return this.get(ctx, '/api/v1/games/rocom/community/egg-exchanges/my', this.wegameHeaders('', userIdentifier, 'bot', 'koishi'), this.scopedParams(params, userIdentifier));
+    }
+    async getEggExchangeReviewStatus(ctx, postId, userIdentifier = '') {
+        return this.get(ctx, `/api/v1/games/rocom/community/egg-exchanges/${encodeURIComponent(String(postId))}/review-status`, this.wegameHeaders('', userIdentifier, 'bot', 'koishi'), this.scopedParams({}, userIdentifier));
+    }
+    async closeEggExchange(ctx, postId, closeReason = 'cancel', userIdentifier = '') {
+        return this.post(ctx, `/api/v1/games/rocom/community/egg-exchanges/${encodeURIComponent(String(postId))}/close`, this.wegameHeaders('', userIdentifier, 'bot', 'koishi'), { close_reason: closeReason }, this.scopedParams({}, userIdentifier));
+    }
+    async createEggExchangeSubscription(ctx, filters, userIdentifier = '') {
+        return this.post(ctx, '/api/v1/games/rocom/community/egg-exchange-subscriptions', this.wegameHeaders('', userIdentifier, 'bot', 'koishi'), { filters }, this.scopedParams({}, userIdentifier));
+    }
+    async getEggExchangeSubscriptions(ctx, userIdentifier = '') {
+        return this.get(ctx, '/api/v1/games/rocom/community/egg-exchange-subscriptions', this.wegameHeaders('', userIdentifier, 'bot', 'koishi'), this.scopedParams({}, userIdentifier));
+    }
+    async deleteEggExchangeSubscription(ctx, subscriptionId, userIdentifier = '') {
+        return this.delete(ctx, `/api/v1/games/rocom/community/egg-exchange-subscriptions/${encodeURIComponent(String(subscriptionId))}`, this.wegameHeaders('', userIdentifier, 'bot', 'koishi'), this.scopedParams({}, userIdentifier));
+    }
+    async getEggExchangeEvents(ctx, subscriptionId, afterEventId = '', limit = 50, userIdentifier = '') {
+        const params = { subscription_id: subscriptionId, limit };
+        if (afterEventId)
+            params.after_event_id = afterEventId;
+        return this.get(ctx, '/api/v1/games/rocom/community/egg-exchange-events', this.wegameHeaders('', userIdentifier, 'bot', 'koishi'), this.scopedParams(params, userIdentifier));
     }
     async ingameHomeInfo(ctx, uid, waitMs = 5000) {
         const sanitizedUid = this.sanitizeUid(uid);
@@ -516,6 +598,20 @@ class RocomClient {
     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/pet/list', this.wegameHeaders(), { q: query, page_size: limit });
     }

package/lib/commands/account.js

@@ -41,6 +41,7 @@ function formatLoginType(loginType) {
         qq: 'QQ',
         wechat: '微信',
         manual: '手动导入',
+        uid: 'UID 绑定',
     };
     return typeMap[loginType] || loginType || '未知';
 }
@@ -191,6 +192,49 @@ function register(deps) {
         const png = await deps.renderer.renderHtml(ctx, 'bind-list', data);
         await (0, send_image_1.sendImageWithFallback)(session, png, fallbackLines.join('\n'), 'account:bind-list', deps.config);
     });
+    ctx.command('洛克').subcommand('.绑定UID <uid:string>', '绑定洛克 UID')
+        .alias('洛克绑定UID')
+        .alias('绑定UID')
+        .action(async ({ session }, uid) => {
+        const userId = session.userId;
+        const targetUid = String(uid || '').trim();
+        if (!/^\d{4,20}$/.test(targetUid))
+            return '用法：洛克.绑定UID <UID>，UID 必须为 4 到 20 位数字。';
+        const res = await client.bindUid(ctx, targetUid, userId);
+        if (!res)
+            return `绑定 UID 失败：${client.getLastErrorBrief()}`;
+        const bindingPayload = res?.binding || {};
+        const bindingId = String(bindingPayload?.id || bindingPayload?.binding_id || `uid:${targetUid}`).trim();
+        const frameworkToken = String(res?.frameworkToken || res?.framework_token || '').trim();
+        const binding = {
+            binding_id: bindingId,
+            login_type: 'uid',
+            role_id: targetUid,
+            nickname: `UID ${targetUid}`,
+            bind_time: Date.now(),
+            is_primary: true,
+        };
+        const existing = userMgr.getUserBindings(userId)
+            .filter(item => item.binding_id !== bindingId && item.role_id !== targetUid)
+            .map(item => ({ ...item, is_primary: false }));
+        userMgr.saveUserBindings(userId, [...existing, binding]);
+        if (frameworkToken) {
+            await (0, role_token_1.upsertRoleToken)(ctx, {
+                userId,
+                fwt: frameworkToken,
+                bindingId,
+                roleId: targetUid,
+                loginType: 'uid',
+            });
+        }
+        const source = String(bindingPayload?.source || '').trim();
+        return [
+            'UID 绑定成功。',
+            `UID：${targetUid}`,
+            source ? `来源：${source}` : '',
+            frameworkToken ? '已生成凭证，后续 ingame 查询会优先使用该账号。' : '已保存为本地主账号，可用于默认 UID 查询。',
+        ].filter(Boolean).join('\n');
+    });
     ctx.command('洛克').subcommand('.切换 <index:number>', '切换主账号')
         .alias('洛克切换')
         .action(async ({ session }, index) => {

package/lib/commands/community.d.ts

@@ -0,0 +1,12 @@
+import { PluginDeps } from '../types';
+export declare function createCommunityHandlers(deps: PluginDeps): {
+    queryExchangeList: ({ session }: any, page?: number) => Promise<string>;
+    postExchange: ({ session }: any, args?: string) => Promise<string>;
+    queryMyPosts: ({ session }: any) => Promise<string>;
+    closePost: ({ session }: any, postIdArg: string, reason?: string) => Promise<string>;
+    reviewStatus: ({ session }: any, postIdArg: string) => Promise<string>;
+    subscribeEgg: ({ session }: any, filtersText?: string) => Promise<string>;
+    listSubscriptions: ({ session }: any) => Promise<string>;
+    unsubscribeEgg: ({ session }: any, subscriptionId?: string) => Promise<string>;
+    queryEvents: ({ session }: any, subscriptionId: string, afterEventId?: string) => Promise<string>;
+};