koishi-plugin-steam-info-check 1.0.0

package/src/index.ts

@@ -0,0 +1,304 @@
+import { Context, Schema, Logger, Service, Session, h } from 'koishi'
+import { SteamService } from './service'
+import { DrawService } from './drawer'
+import { SteamBind, SteamChannel } from './database'
+
+export const name = 'steam-info'
+export const inject = ['model', 'http', 'puppeteer', 'database']
+
+export interface Config {
+  steamApiKey: string[]
+  proxy?: string
+  steamRequestInterval: number
+  steamBroadcastType: 'all' | 'part' | 'none'
+  steamDisableBroadcastOnStartup: boolean
+  fonts: {
+    regular: string
+    light: string
+    bold: string
+  }
+  commandAuthority: {
+    bind: number
+    unbind: number
+    info: number
+    check: number
+    enable: number
+    disable: number
+    update: number
+    nickname: number
+  }
+}
+
+export const Config: Schema<Config> = Schema.object({
+  steamApiKey: Schema.array(String).required().description('Steam API Key (supports multiple)'),
+  proxy: Schema.string().description('Proxy URL (e.g., http://127.0.0.1:7890)'),
+  steamRequestInterval: Schema.number().default(300).description('Polling interval in seconds'),
+  steamBroadcastType: Schema.union(['all', 'part', 'none']).default('part').description('Broadcast type: all (list), part (gaming only), none (text only)'),
+  steamDisableBroadcastOnStartup: Schema.boolean().default(false).description('Disable broadcast on startup'),
+  fonts: Schema.object({
+    regular: Schema.string().default('fonts/MiSans-Regular.ttf'),
+    light: Schema.string().default('fonts/MiSans-Light.ttf'),
+    bold: Schema.string().default('fonts/MiSans-Bold.ttf'),
+  }).description('Font paths relative to the plugin resource directory or absolute paths'),
+  commandAuthority: Schema.object({
+    bind: Schema.number().default(1).description('Authority for bind command'),
+    unbind: Schema.number().default(1).description('Authority for unbind command'),
+    info: Schema.number().default(1).description('Authority for info command'),
+    check: Schema.number().default(1).description('Authority for check command'),
+    enable: Schema.number().default(2).description('Authority for enable broadcast'),
+    disable: Schema.number().default(2).description('Authority for disable broadcast'),
+    update: Schema.number().default(2).description('Authority for update group info'),
+    nickname: Schema.number().default(1).description('Authority for nickname command'),
+  }).description('Command Authorities'),
+})
+
+export const logger = new Logger('steam-info')
+
+declare module 'koishi' {
+  interface Context {
+    steam: SteamService
+    drawer: DrawService
+  }
+}
+
+export function apply(ctx: Context, config: Config) {
+  // Localization
+  ctx.i18n.define('zh-CN', require('./locales/zh-CN'))
+
+  // Services
+  ctx.plugin(SteamService, config)
+  ctx.plugin(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: string | null = 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(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(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: any = { 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<string, any>()
+
+async function broadcast(ctx: Context) {
+  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: string[] = []
+    const startGamingPlayers: any[] = []
+
+    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 : 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) as any[]
+            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 : 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/src/locales/zh-CN.yml

@@ -0,0 +1,14 @@
+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/src/service.ts

@@ -0,0 +1,162 @@
+import { Context, Service } from 'koishi'
+import { Config } from './index'
+import cheerio from 'cheerio'
+
+// Constants
+const STEAM_ID_OFFSET = BigInt('76561197960265728')
+
+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 class SteamService extends Service {
+  constructor(ctx: Context, public config: Config) {
+    super(ctx, 'steam', true)
+  }
+
+  async getSteamId(input: string): Promise<string | null> {
+    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: string[]): Promise<PlayerSummary[]> {
+    if (steamIds.length === 0) return []
+    
+    // Split into chunks of 100
+    const chunks: string[][] = []
+    for (let i = 0; i < steamIds.length; i += 100) {
+      chunks.push(steamIds.slice(i, i + 100))
+    }
+
+    const players: PlayerSummary[] = []
+    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: string): Promise<SteamProfile> {
+    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.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: GameData[] = []
+    $('.recent_game').each((i: number, el: any) => {
+      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: Achievement[] = []
+      $(el).find('.game_info_achievement').each((j: number, achEl: any) => {
+        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
+    }
+  }
+}

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "module": "commonjs",
+    "target": "es2020",
+    "outDir": "dist",
+    "rootDir": "src",
+    "declaration": true,
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "moduleResolution": "node"
+  },
+  "include": [
+    "src/**/*"
+  ]
+}