koishi-plugin-steam-info-check 1.0.0

package/dist/index.js

@@ -0,0 +1,265 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logger = exports.Config = exports.inject = exports.name = void 0;
+exports.apply = apply;
+const koishi_1 = require("koishi");
+const service_1 = require("./service");
+const drawer_1 = require("./drawer");
+exports.name = 'steam-info';
+exports.inject = ['model', 'http', 'puppeteer', 'database'];
+exports.Config = koishi_1.Schema.object({
+    steamApiKey: koishi_1.Schema.array(String).required().description('Steam API Key (supports multiple)'),
+    proxy: koishi_1.Schema.string().description('Proxy URL (e.g., http://127.0.0.1:7890)'),
+    steamRequestInterval: koishi_1.Schema.number().default(300).description('Polling interval in seconds'),
+    steamBroadcastType: koishi_1.Schema.union(['all', 'part', 'none']).default('part').description('Broadcast type: all (list), part (gaming only), none (text only)'),
+    steamDisableBroadcastOnStartup: koishi_1.Schema.boolean().default(false).description('Disable broadcast on startup'),
+    fonts: koishi_1.Schema.object({
+        regular: koishi_1.Schema.string().default('fonts/MiSans-Regular.ttf'),
+        light: koishi_1.Schema.string().default('fonts/MiSans-Light.ttf'),
+        bold: koishi_1.Schema.string().default('fonts/MiSans-Bold.ttf'),
+    }).description('Font paths relative to the plugin resource directory or absolute paths'),
+    commandAuthority: koishi_1.Schema.object({
+        bind: koishi_1.Schema.number().default(1).description('Authority for bind command'),
+        unbind: koishi_1.Schema.number().default(1).description('Authority for unbind command'),
+        info: koishi_1.Schema.number().default(1).description('Authority for info command'),
+        check: koishi_1.Schema.number().default(1).description('Authority for check command'),
+        enable: koishi_1.Schema.number().default(2).description('Authority for enable broadcast'),
+        disable: koishi_1.Schema.number().default(2).description('Authority for disable broadcast'),
+        update: koishi_1.Schema.number().default(2).description('Authority for update group info'),
+        nickname: koishi_1.Schema.number().default(1).description('Authority for nickname command'),
+    }).description('Command Authorities'),
+});
+exports.logger = new koishi_1.Logger('steam-info');
+function apply(ctx, config) {
+    // Localization
+    ctx.i18n.define('zh-CN', require('./locales/zh-CN'));
+    // Services
+    ctx.plugin(service_1.SteamService, config);
+    ctx.plugin(drawer_1.DrawService, config);
+    // Database
+    ctx.model.extend('steam_bind', {
+        id: 'unsigned',
+        userId: 'string',
+        channelId: 'string',
+        steamId: 'string',
+        nickname: 'string',
+    }, {
+        primary: 'id',
+        autoInc: true,
+    });
+    ctx.model.extend('steam_channel', {
+        id: 'string', // channelId
+        enable: 'boolean',
+        name: 'string',
+        avatar: 'string',
+    }, {
+        primary: 'id',
+    });
+    // Commands
+    ctx.command('steam', 'Steam Information');
+    ctx.command('steam.bind <steamId:string>', 'Bind Steam ID', { authority: config.commandAuthority.bind })
+        .alias('steambind', '绑定steam')
+        .action(async ({ session }, steamId) => {
+        if (!session)
+            return;
+        if (!steamId || !/^\d+$/.test(steamId))
+            return session.text('.invalid_id');
+        const targetId = await ctx.steam.getSteamId(steamId);
+        if (!targetId)
+            return session.text('.id_not_found');
+        await ctx.database.upsert('steam_bind', [
+            {
+                userId: session.userId,
+                channelId: session.channelId,
+                steamId: targetId,
+            }
+        ], ['userId', 'channelId']);
+        return session.text('.bind_success', [targetId]);
+    });
+    ctx.command('steam.unbind', 'Unbind Steam ID', { authority: config.commandAuthority.unbind })
+        .alias('steamunbind', '解绑steam')
+        .action(async ({ session }) => {
+        if (!session)
+            return;
+        const result = await ctx.database.remove('steam_bind', {
+            userId: session.userId,
+            channelId: session.channelId,
+        });
+        return result ? session.text('.unbind_success') : session.text('.not_bound');
+    });
+    ctx.command('steam.info [target:text]', 'View Steam Profile', { authority: config.commandAuthority.info })
+        .alias('steaminfo', 'steam信息')
+        .action(async ({ session }, target) => {
+        if (!session)
+            return;
+        let steamId = null;
+        if (target) {
+            // Check if target is mention
+            const [platform, userId] = session.resolve(target);
+            if (userId) {
+                const bind = await ctx.database.get('steam_bind', { userId, channelId: session.channelId });
+                if (bind.length)
+                    steamId = bind[0].steamId;
+            }
+            else if (/^\d+$/.test(target)) {
+                steamId = await ctx.steam.getSteamId(target);
+            }
+        }
+        else {
+            const bind = await ctx.database.get('steam_bind', { userId: session.userId, channelId: session.channelId });
+            if (bind.length)
+                steamId = bind[0].steamId;
+        }
+        if (!steamId)
+            return session.text('.user_not_found');
+        const profile = await ctx.steam.getUserData(steamId);
+        const image = await ctx.drawer.drawPlayerStatus(profile, steamId);
+        if (typeof image === 'string')
+            return session.send(image);
+        return session.send(koishi_1.h.image(image, 'image/png'));
+    });
+    ctx.command('steam.check', 'Check Friends Status', { authority: config.commandAuthority.check })
+        .alias('steamcheck', '查看steam', '查steam')
+        .action(async ({ session }) => {
+        if (!session)
+            return;
+        const binds = await ctx.database.get('steam_bind', { channelId: session.channelId });
+        if (binds.length === 0)
+            return session.text('.no_binds');
+        const steamIds = binds.map(b => b.steamId);
+        const summaries = await ctx.steam.getPlayerSummaries(steamIds);
+        if (summaries.length === 0)
+            return session.text('.api_error');
+        const channelInfo = await ctx.database.get('steam_channel', { id: session.channelId });
+        const parentAvatar = channelInfo[0]?.avatar
+            ? Buffer.from(channelInfo[0].avatar, 'base64')
+            : await ctx.drawer.getDefaultAvatar();
+        const parentName = channelInfo[0]?.name || session.channelId || 'Unknown';
+        const image = await ctx.drawer.drawFriendsStatus(parentAvatar, parentName, summaries, binds);
+        if (typeof image === 'string')
+            return session.send(image);
+        return session.send(koishi_1.h.image(image, 'image/png'));
+    });
+    ctx.command('steam.enable', 'Enable Broadcast', { authority: config.commandAuthority.enable })
+        .alias('steamenable', '启用steam')
+        .action(async ({ session }) => {
+        if (!session)
+            return;
+        await ctx.database.upsert('steam_channel', [{ id: session.channelId, enable: true }]);
+        return session.text('.enable_success');
+    });
+    ctx.command('steam.disable', 'Disable Broadcast', { authority: config.commandAuthority.disable })
+        .alias('steamdisable', '禁用steam')
+        .action(async ({ session }) => {
+        if (!session)
+            return;
+        await ctx.database.upsert('steam_channel', [{ id: session.channelId, enable: false }]);
+        return session.text('.disable_success');
+    });
+    ctx.command('steam.update [name:string] [avatar:image]', 'Update Group Info', { authority: config.commandAuthority.update })
+        .alias('steamupdate', '更新群信息')
+        .action(async ({ session }, name, avatar) => {
+        if (!session)
+            return;
+        const img = session.elements && session.elements.find(e => e.type === 'img');
+        const imgUrl = img?.attrs?.src;
+        let avatarBase64 = null;
+        if (imgUrl) {
+            const buffer = await ctx.http.get(imgUrl, { responseType: 'arraybuffer' });
+            avatarBase64 = Buffer.from(buffer).toString('base64');
+        }
+        if (!name && !avatarBase64)
+            return session.text('.args_missing');
+        const update = { id: session.channelId };
+        if (name)
+            update.name = name;
+        if (avatarBase64)
+            update.avatar = avatarBase64;
+        await ctx.database.upsert('steam_channel', [update]);
+        return session.text('.update_success');
+    });
+    ctx.command('steam.nickname <nickname:string>', 'Set Steam Nickname', { authority: config.commandAuthority.nickname })
+        .alias('steamnickname', 'steam昵称')
+        .action(async ({ session }, nickname) => {
+        if (!session)
+            return;
+        const bind = await ctx.database.get('steam_bind', { userId: session.userId, channelId: session.channelId });
+        if (!bind.length)
+            return session.text('.not_bound');
+        await ctx.database.upsert('steam_bind', [{ ...bind[0], nickname }]);
+        return session.text('.nickname_set', [nickname]);
+    });
+    // Scheduler
+    ctx.setInterval(async () => {
+        await broadcast(ctx);
+    }, config.steamRequestInterval * 1000);
+}
+// Broadcast Logic
+const statusCache = new Map();
+async function broadcast(ctx) {
+    const channels = await ctx.database.get('steam_channel', { enable: true });
+    if (channels.length === 0)
+        return;
+    const channelIds = channels.map(c => c.id);
+    const binds = await ctx.database.get('steam_bind', { channelId: channelIds });
+    if (binds.length === 0)
+        return;
+    const steamIds = [...new Set(binds.map(b => b.steamId))];
+    const currentSummaries = await ctx.steam.getPlayerSummaries(steamIds);
+    const currentMap = new Map(currentSummaries.map(p => [p.steamid, p]));
+    for (const channel of channels) {
+        const channelBinds = binds.filter(b => b.channelId === channel.id);
+        const msgs = [];
+        const startGamingPlayers = [];
+        for (const bind of channelBinds) {
+            const current = currentMap.get(bind.steamId);
+            const old = statusCache.get(bind.steamId);
+            if (!current)
+                continue;
+            if (!old)
+                continue;
+            const oldGame = old.gameextrainfo;
+            const newGame = current.gameextrainfo;
+            const name = bind.nickname || current.personaname;
+            if (newGame && !oldGame) {
+                msgs.push(`${name} 开始玩 ${newGame} 了`);
+                startGamingPlayers.push({ ...current, nickname: bind.nickname });
+            }
+            else if (!newGame && oldGame) {
+                msgs.push(`${name} 玩了 ${oldGame} 后不玩了`);
+            }
+            else if (newGame && oldGame && newGame !== oldGame) {
+                msgs.push(`${name} 停止玩 ${oldGame}，开始玩 ${newGame} 了`);
+            }
+        }
+        if (msgs.length > 0) {
+            const bot = ctx.bots[0];
+            if (!bot)
+                continue;
+            if (ctx.config.steamBroadcastType === 'none') {
+                await bot.sendMessage(channel.id, msgs.join('\n'));
+            }
+            else if (ctx.config.steamBroadcastType === 'part') {
+                if (startGamingPlayers.length > 0) {
+                    const images = await Promise.all(startGamingPlayers.map(p => ctx.drawer.drawStartGaming(p, p.nickname)));
+                    const combined = await ctx.drawer.concatImages(images);
+                    const img = combined ? (typeof combined === 'string' ? combined : koishi_1.h.image(combined, 'image/png')) : '';
+                    await bot.sendMessage(channel.id, msgs.join('\n') + img);
+                }
+                else {
+                    await bot.sendMessage(channel.id, msgs.join('\n'));
+                }
+            }
+            else if (ctx.config.steamBroadcastType === 'all') {
+                const channelPlayers = channelBinds.map(b => currentMap.get(b.steamId)).filter(Boolean);
+                const parentAvatar = channel.avatar ? Buffer.from(channel.avatar, 'base64') : await ctx.drawer.getDefaultAvatar();
+                const image = await ctx.drawer.drawFriendsStatus(parentAvatar, channel.name || channel.id, channelPlayers, channelBinds);
+                const img = image ? (typeof image === 'string' ? image : koishi_1.h.image(image, 'image/png')) : '';
+                await bot.sendMessage(channel.id, msgs.join('\n') + img);
+            }
+        }
+    }
+    for (const p of currentSummaries) {
+        statusCache.set(p.steamid, p);
+    }
+}

package/dist/locales/zh-CN.json

@@ -0,0 +1 @@
+{"invalid_id":"请输入有效的 Steam ID。","id_not_found":"无法找到该 Steam ID。","bind_success":"绑定成功！Steam ID: {0}","unbind_success":"解绑成功。","not_bound":"你还没有绑定 Steam ID。","user_not_found":"未找到用户信息。","error":"发生错误。","no_binds":"本群尚无绑定用户。","api_error":"连接 Steam API 失败。","enable_success":"已开启本群播报。","disable_success":"已关闭本群播报。","args_missing":"参数缺失。","update_success":"更新群信息成功。","nickname_set":"昵称已设置为 {0}。"}

package/dist/service.d.ts

@@ -0,0 +1,42 @@
+import { Context, Service } from 'koishi';
+import { Config } from './index';
+export interface PlayerSummary {
+    steamid: string;
+    personaname: string;
+    profileurl: string;
+    avatar: string;
+    avatarmedium: string;
+    avatarfull: string;
+    personastate: number;
+    gameextrainfo?: string;
+    lastlogoff?: number;
+}
+export interface SteamProfile {
+    steamid: string;
+    player_name: string;
+    avatar: string | Buffer;
+    background: string | Buffer;
+    description: string;
+    recent_2_week_play_time: string;
+    game_data: GameData[];
+}
+export interface GameData {
+    game_name: string;
+    game_image: string | Buffer;
+    play_time: string;
+    last_played: string;
+    achievements: Achievement[];
+    completed_achievement_number?: number;
+    total_achievement_number?: number;
+}
+export interface Achievement {
+    name: string;
+    image: string | Buffer;
+}
+export declare class SteamService extends Service {
+    config: Config;
+    constructor(ctx: Context, config: Config);
+    getSteamId(input: string): Promise<string | null>;
+    getPlayerSummaries(steamIds: string[]): Promise<PlayerSummary[]>;
+    getUserData(steamId: string): Promise<SteamProfile>;
+}

package/dist/service.js

@@ -0,0 +1,119 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SteamService = void 0;
+const koishi_1 = require("koishi");
+const cheerio_1 = __importDefault(require("cheerio"));
+// Constants
+const STEAM_ID_OFFSET = BigInt('76561197960265728');
+class SteamService extends koishi_1.Service {
+    constructor(ctx, config) {
+        super(ctx, 'steam', true);
+        this.config = config;
+    }
+    async getSteamId(input) {
+        if (!/^\d+$/.test(input))
+            return null;
+        const id = BigInt(input);
+        if (id < STEAM_ID_OFFSET) {
+            return (id + STEAM_ID_OFFSET).toString();
+        }
+        return input;
+    }
+    async getPlayerSummaries(steamIds) {
+        if (steamIds.length === 0)
+            return [];
+        // Split into chunks of 100
+        const chunks = [];
+        for (let i = 0; i < steamIds.length; i += 100) {
+            chunks.push(steamIds.slice(i, i + 100));
+        }
+        const players = [];
+        for (const chunk of chunks) {
+            // Try keys
+            for (const key of this.config.steamApiKey) {
+                try {
+                    const url = `http://api.steampowered.com/ISteamUser/GetPlayerSummaries/v0002/?key=${key}&steamids=${chunk.join(',')}`;
+                    const data = await this.ctx.http.get(url);
+                    if (data?.response?.players) {
+                        players.push(...data.response.players);
+                        break; // Success for this chunk
+                    }
+                }
+                catch (e) {
+                    this.ctx.logger('steam').warn(`API key ${key} failed: ${e}`);
+                }
+            }
+        }
+        return players;
+    }
+    async getUserData(steamId) {
+        const url = `https://steamcommunity.com/profiles/${steamId}`;
+        // Cookie for timezone
+        const headers = {
+            'Accept-Language': 'zh-CN,zh;q=0.9,en;q=0.8',
+            'Cookie': 'timezoneOffset=28800,0'
+        };
+        const html = await this.ctx.http.get(url, { headers });
+        const $ = cheerio_1.default.load(html);
+        const player_name = $('.actual_persona_name').text().trim() || $('title').text().replace('Steam 社区 :: ', '');
+        const description = $('.profile_summary').text().trim().replace(/\t/g, '');
+        let background = '';
+        const bgStyle = $('.no_header.profile_page').attr('style') || '';
+        const bgMatch = bgStyle.match(/background-image:\s*url\(\s*['"]?([^'" ]+)['"]?\s*\)/);
+        if (bgMatch)
+            background = bgMatch[1];
+        const avatar = $('.playerAvatarAutoSizeInner > img').attr('src') || '';
+        const recent_2_week_play_time = $('.recentgame_quicklinks.recentgame_recentplaytime > div').text().trim();
+        const game_data = [];
+        $('.recent_game').each((i, el) => {
+            const game_name = $(el).find('.game_name').text().trim();
+            const game_image = $(el).find('.game_capsule').attr('src') || '';
+            const details = $(el).find('.game_info_details').text();
+            const play_time_match = details.match(/总时数\s*([\d\.]+)\s*小时/);
+            const play_time = play_time_match ? play_time_match[1] : '';
+            const last_played_match = details.match(/最后运行日期：(.*) 日/);
+            const last_played = last_played_match ? `最后运行日期：${last_played_match[1]} 日` : '当前正在游戏';
+            const achievements = [];
+            $(el).find('.game_info_achievement').each((j, achEl) => {
+                if ($(achEl).hasClass('plus_more'))
+                    return;
+                achievements.push({
+                    name: $(achEl).attr('data-tooltip-text') || '',
+                    image: $(achEl).find('img').attr('src') || ''
+                });
+            });
+            const summary = $(el).find('.game_info_achievement_summary').find('.ellipsis').text();
+            let completed_achievement_number = 0;
+            let total_achievement_number = 0;
+            if (summary) {
+                const parts = summary.split('/');
+                if (parts.length === 2) {
+                    completed_achievement_number = parseInt(parts[0]);
+                    total_achievement_number = parseInt(parts[1]);
+                }
+            }
+            game_data.push({
+                game_name,
+                game_image,
+                play_time,
+                last_played,
+                achievements,
+                completed_achievement_number,
+                total_achievement_number
+            });
+        });
+        return {
+            steamid: steamId,
+            player_name,
+            avatar,
+            background,
+            description,
+            recent_2_week_play_time,
+            game_data
+        };
+    }
+}
+exports.SteamService = SteamService;

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "koishi-plugin-steam-info-check",
+  "version": "1.0.0",
+  "description": "Steam friends status broadcast plugin for Koishi",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "start": "koishi start"
+  },
+  "keywords": [
+    "koishi",
+    "plugin",
+    "steam",
+    "game",
+    "bot",
+    "chatbot"
+  ],
+  "author": "MuxYang <tlnkmc.b@gmail.com>",
+  "license": "MIT",
+  "homepage": "https://github.com/MuxYang/koishi-plugin-steam-info",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/MuxYang/koishi-plugin-steam-info.git"
+  },
+  "bugs": {
+    "url": "https://github.com/MuxYang/koishi-plugin-steam-info/issues"
+  },
+  "koishi": {
+    "description": {
+      "en": "Steam friends status broadcast plugin for Koishi",
+      "zh-CN": "Koishi 的 Steam 好友状态播报插件"
+    },
+    "service": {
+      "required": [
+        "model",
+        "http",
+        "puppeteer",
+        "database"
+      ]
+    }
+  },
+  "peerDependencies": {
+    "koishi": "^4.16.0",
+    "koishi-plugin-puppeteer": "*"
+  },
+  "dependencies": {
+    "cheerio": "^1.0.0-rc.12",
+    "luxon": "^3.4.4"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "typescript": "^5.0.0",
+    "koishi": "^4.16.0"
+  }
+}

package/readme.md

@@ -0,0 +1,5 @@
+# koishi-plugin-steam-info-check
+
+[![npm](https://img.shields.io/npm/v/koishi-plugin-steam-info-check?style=flat-square)](https://www.npmjs.com/package/koishi-plugin-steam-info-check)
+
+Steam 好友状态播报 koishi 插件 (基于nonebot版本修改，https://github.com/zhaomaoniu/nonebot-plugin-steam-info）

package/src/database.ts

@@ -0,0 +1,21 @@
+export interface SteamBind {
+  id: number
+  userId: string
+  channelId: string
+  steamId: string
+  nickname?: string
+}
+
+export interface SteamChannel {
+  id: string
+  enable: boolean
+  name?: string
+  avatar?: string
+}
+
+declare module 'koishi' {
+  interface Tables {
+    steam_bind: SteamBind
+    steam_channel: SteamChannel
+  }
+}