koishi-plugin-ll-schedule 1.0.0 → 1.0.1

package/index.js

@@ -1,13 +1,50 @@
+'use strict'
+
+// koishi-plugin-ll-schedule
+// 定时发送插件：设置时间自动向指定群发送文字/图片
+// v1.0.1：兼容官方QQ机器人（官机）
+//   官机的群 ID 是 openid（不是数字群号），本插件通过"学习"机器人收到的群消息来记录群，
+//   用 schedule.groups 命令查看已知群并填入 tasks.groups；留空则发送给所有已知群。
+
 const { Schema, h } = require('koishi')
 
-// 定时任务项
+exports.name = 'll-schedule'
+
+exports.usage = `定时发送插件：设置时间自动向指定群发送文字/图片。
+
+## 任务配置
+
+在插件设置页的 \`tasks\` 表格中添加任务（键=任务名），每项：
+
+- \`time\`：发送时间，HH:MM 格式（24小时制）
+- \`groups\`：目标群列表（**留空=发送给所有已知群**）
+- \`text\`：文字内容（可留空）
+- \`image\`：图片 URL（可留空）
+- \`enabled\`：是否启用
+
+## 官机（官方QQ机器人）说明
+
+官方平台没有"群号"，只有 openid。机器人收到过消息的群会被自动记录：
+
+- 命令 \`schedule.groups\` 查看所有已知群（显示群名和 openid）
+- 把 openid 填进任务的 \`groups\` 里即可
+- 注意：官机主动发群消息有平台频率限制，且机器人需在群里
+
+## 命令
+
+- \`schedule\` 帮助
+- \`schedule.list\` 查看任务
+- \`schedule.groups\` 查看机器人已知的群（官机显示 openid）
+- \`schedule.test <任务名>\` 立即测试发送
+`
+
 const TaskItem = Schema.object({
   time: Schema.string()
     .required()
     .description('发送时间，HH:MM 格式（24小时制），如 08:30、21:00'),
   groups: Schema.array(Schema.string())
     .default([])
-    .description('目标群号（留空=所有群）'),
+    .description('目标群 ID（留空=所有已知群；官机填 openid，OneBot 填数字群号）'),
   text: Schema.string()
     .default('')
     .description('文字内容（可留空）'),
@@ -23,12 +60,117 @@ const Config = Schema.object({
   tasks: Schema.dict(TaskItem)
     .default({})
     .description('📋 定时任务表格（键=任务名）'),
+  sendAllWhenEmpty: Schema.boolean()
+    .default(true)
+    .description('任务未指定群时，发送给该机器人所有已知群'),
+  verbose: Schema.boolean()
+    .default(false)
+    .description('调试：控制台打印每次发送详情'),
 })
 
+exports.Config = Config
+
+// 可选数据库：持久化学习到的群（重启不丢）
+exports.inject = { optional: ['database'] }
+
 function apply(ctx, config) {
+  const logger = ctx.logger('ll-schedule')
+
   // 记录当天已发送的任务，防止同一分钟重复发
   let firedToday = {}
 
+  // ===== 已知群（从收到的消息中学习） =====
+  // key: `${botSid}:${guildId}` -> { botSid, guildId, platform, learnedAt }
+  const knownGroups = new Map()
+  const groupNameCache = new Map() // key: botSid:guildId -> { v, t }
+  const TTL = 60 * 60 * 1000
+
+  function cacheGet(map, key) {
+    const item = map.get(key)
+    return item && Date.now() - item.t < TTL ? item.v : undefined
+  }
+  function cacheSet(map, key, value) {
+    map.set(key, { v: value, t: Date.now() })
+  }
+
+  // 数据库模型（可选）
+  if (ctx.database) {
+    ctx.model.extend('ll_schedule_groups', {
+      botSid: 'string',
+      guildId: 'string',
+      platform: 'string',
+      learnedAt: 'unsigned',
+    }, { primary: ['botSid', 'guildId'] })
+  }
+
+  async function loadKnownGroups() {
+    if (!ctx.database) return
+    try {
+      const rows = await ctx.database.get('ll_schedule_groups', {})
+      for (const row of rows) {
+        knownGroups.set(`${row.botSid}:${row.guildId}`, {
+          botSid: row.botSid,
+          guildId: row.guildId,
+          platform: row.platform,
+          learnedAt: row.learnedAt,
+        })
+      }
+      if (rows.length) logger.info(`[schedule] 已从数据库加载 ${rows.length} 个已知群`)
+    }
+    catch (e) {
+      logger.warn('[schedule] 加载已知群失败:', e)
+    }
+  }
+
+  async function persistGroup(entry) {
+    if (!ctx.database) return
+    try {
+      await ctx.database.upsert('ll_schedule_groups', [entry], ['botSid', 'guildId'])
+    }
+    catch (e) {
+      logger.warn('[schedule] 保存已知群失败:', e)
+    }
+  }
+
+  function learnGroup(session) {
+    const bot = session.bot
+    if (!bot || !session.guildId) return
+    const key = `${bot.sid}:${session.guildId}`
+    if (knownGroups.has(key)) return
+    const entry = {
+      botSid: bot.sid,
+      guildId: session.guildId,
+      platform: bot.platform,
+      learnedAt: Date.now(),
+    }
+    knownGroups.set(key, entry)
+    persistGroup(entry)
+  }
+
+  async function resolveGroupName(bot, guildId) {
+    const key = `${bot.sid}:${guildId}`
+    const cached = cacheGet(groupNameCache, key)
+    if (cached != null) return cached
+    try {
+      if (typeof bot.getGuild === 'function') {
+        const guild = await bot.getGuild(guildId)
+        if (guild?.name) {
+          cacheSet(groupNameCache, key, guild.name)
+          return guild.name
+        }
+      }
+    }
+    catch (e) {
+      logger.warn(`[schedule] 获取群名失败 ${guildId}:`, e)
+    }
+    return ''
+  }
+
+  // 从消息事件学习群
+  ctx.on('message', (session) => {
+    learnGroup(session)
+  })
+
   function nowHM() {
     const d = new Date()
     return `${String(d.getHours()).padStart(2, '0')}:${String(d.getMinutes()).padStart(2, '0')}`
@@ -57,12 +199,12 @@ function apply(ctx, config) {
       if (firedToday[fireKey]) continue
       firedToday[fireKey] = true
 
-      ctx.logger.info(`[schedule] 触发任务 "${name}" @ ${hm}`)
+      logger.info(`[schedule] 触发任务 "${name}" @ ${hm}`)
       await sendTask(name, task)
     }
   }
 
-  async function sendTask(name, task) {
+  async function sendTask(name, task, onlyBotSid) {
     // 组装消息
     const parts = []
     if (task.text) parts.push(task.text)
@@ -71,32 +213,60 @@ function apply(ctx, config) {
       parts.push(h.image(task.image))
     }
     if (!parts.length) {
-      ctx.logger.warn(`[schedule] 任务 "${name}" 没有文字也没有图片，跳过`)
+      logger.warn(`[schedule] 任务 "${name}" 没有文字也没有图片，跳过`)
       return
     }
 
-    const bots = ctx.bots || []
+    let bots = (ctx.bots || []).filter(b => b.online)
+    if (onlyBotSid) bots = bots.filter(b => b.sid === onlyBotSid)
     if (!bots.length) return
 
     const groups = (task.groups && task.groups.length > 0) ? task.groups : null
 
     for (const bot of bots) {
       if (groups) {
-        for (const gid of groups) {
-          try { await bot.sendMessage(gid, parts) } catch (e) {
-            ctx.logger.error(`[schedule] 发送到群 ${gid} 失败: ${e.message}`)
+        for (const rawTarget of groups) {
+          const target = String(rawTarget).trim()
+          if (!target) continue
+          // 官机：群 ID 是 openid；数字群号在官机上无法直接使用
+          if (bot.platform === 'qq' && /^\d+$/.test(target)) {
+            logger.warn(`[schedule] 任务 "${name}"：官方QQ机器人不能用数字群号 "${target}" 发送，请用 schedule.groups 查看 openid 填入`)
+            continue
+          }
+          try {
+            await bot.sendMessage(target, parts)
+            if (config.verbose) logger.info(`[schedule] 已发送任务 "${name}" 到 ${bot.sid}:${target}`)
+          }
+          catch (e) {
+            logger.error(`[schedule] 发送到 ${bot.sid}:${target} 失败: ${e.message}`)
           }
         }
-      } else {
-        ctx.logger.warn(`[schedule] 任务 "${name}" 未指定群号，跳过（请配置目标群）`)
+      }
+      else if (config.sendAllWhenEmpty) {
+        // 未指定群 → 发送给该 bot 所有已知群
+        const targets = [...knownGroups.values()].filter(g => g.botSid === bot.sid)
+        if (!targets.length) {
+          logger.warn(`[schedule] 任务 "${name}" 未指定群且机器人 ${bot.sid} 暂无已知群（先让机器人收过该群消息，或用 schedule.groups 查看）`)
+          continue
+        }
+        for (const g of targets) {
+          try {
+            await bot.sendMessage(g.guildId, parts)
+            if (config.verbose) logger.info(`[schedule] 已发送任务 "${name}" 到 ${bot.sid}:${g.guildId}`)
+          }
+          catch (e) {
+            logger.error(`[schedule] 发送到 ${bot.sid}:${g.guildId} 失败: ${e.message}`)
+          }
+        }
+      }
+      else {
+        logger.warn(`[schedule] 任务 "${name}" 未指定群号，跳过`)
       }
     }
   }
 
   // 每 20 秒检查一次（保证同一分钟内能触发）
   const timer = setInterval(checkAndSend, 20000)
-  // 启动时立即检查一次
-  checkAndSend()
 
   ctx.on('dispose', () => clearInterval(timer))
 
@@ -104,7 +274,7 @@ function apply(ctx, config) {
   ctx.command('schedule', '定时发送管理')
     .action(() =>
       '⚙️ 管理：插件设置页 → ll-schedule → tasks 表格\n' +
-      '命令：schedule.list 查看任务 | schedule.test <任务名> 立即测试发送'
+      '命令：schedule.list 查看任务 | schedule.groups 查看已知群 | schedule.test <任务名> 立即测试发送'
     )
 
   ctx.command('schedule.list', '查看定时任务')
@@ -116,10 +286,23 @@ function apply(ctx, config) {
         const t = tasks[k]
         const s = t.enabled === false ? '⛔' : '✅'
         const content = [t.text && '文字', t.image && '图片'].filter(Boolean).join('+') || '(空)'
-        return `${s} ${k} @ ${t.time} → ${content} → 群:${(t.groups || []).join(',') || '未指定'}`
+        return `${s} ${k} @ ${t.time} → ${content} → 群:${(t.groups || []).join(',') || '所有已知群'}`
       }).join('\n')
     })
 
+  ctx.command('schedule.groups', '查看机器人已知的群（官机显示 openid）')
+    .action(async () => {
+      if (!knownGroups.size) return '暂无已知群。机器人收到过消息的群才会被记录（官机需要先把机器人拉进群并让它收消息）'
+      const lines = []
+      for (const g of knownGroups.values()) {
+        const bot = ctx.bots.find(b => b.sid === g.botSid)
+        const name = bot ? await resolveGroupName(bot, g.guildId) : ''
+        const platformTag = g.platform === 'qq' ? '[官机]' : `[${g.platform}]`
+        lines.push(`${platformTag} ${name || '未知群名'} ${g.guildId}`)
+      }
+      return '📋 机器人已知群：\n' + lines.join('\n') + '\n（官机的群 ID 是 openid，填入任务 groups 即可）'
+    })
+
   ctx.command('schedule.test <name>', '立即测试发送指定任务')
     .action(async ({ session }, name) => {
       const tasks = config.tasks || {}
@@ -130,9 +313,12 @@ function apply(ctx, config) {
       if (!testTask.groups || !testTask.groups.length) {
         testTask.groups = session.guildId ? [String(session.guildId)] : []
       }
-      await sendTask(name, testTask)
+      await sendTask(name, testTask, session.bot?.sid)
       return `✅ 已发送任务 "${name}"`
     })
+
+  // 启动时：加载已知群 + 立即检查一次
+  loadKnownGroups().then(() => checkAndSend())
 }
 
-module.exports = { Config, apply }
+exports.apply = apply

package/package.json

@@ -1,8 +1,11 @@
 {
   "name": "koishi-plugin-ll-schedule",
-  "version": "1.0.0",
-  "description": "Scheduled message sender with text/image support",
+  "version": "1.0.1",
+  "description": "Scheduled message sender with text/image support, works with official QQ bot",
   "main": "index.js",
+  "files": [
+    "index.js"
+  ],
   "license": "MIT",
   "keywords": ["koishi", "koishi-plugin", "schedule", "timer", "定时"],
   "peerDependencies": {
@@ -10,8 +13,8 @@
   },
   "koishi": {
     "description": {
-      "zh": "定时发送插件。设置时间后自动发送文字/图片到指定群。",
-      "en": "Scheduled message sender. Auto-send text/image to groups at set times."
+      "zh": "定时发送插件。设置时间后自动发送文字/图片到指定群，兼容官方QQ机器人（官机）。",
+      "en": "Scheduled message sender. Auto-send text/image to groups at set times, works with official QQ bot."
     }
   }
 }

package/.github/workflows/publish.yml

@@ -1,16 +0,0 @@
-name: Publish to npm
-on:
-  push:
-    branches: [master]
-jobs:
-  publish:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-node@v4
-        with:
-          node-version: '22'
-          registry-url: 'https://registry.npmjs.org'
-      - run: npm publish
-        env:
-          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}