koishi-plugin-ll-schedule 1.0.2 → 1.0.4

package/index.js

@@ -2,9 +2,7 @@
 
 // koishi-plugin-ll-schedule
 // 定时发送插件：设置时间自动向指定群发送文字/图片
-// v1.0.1：兼容官方QQ机器人（官机）
-//   官机的群 ID 是 openid（不是数字群号），本插件通过"学习"机器人收到的群消息来记录群，
-//   用 schedule.groups 命令查看已知群并填入 tasks.groups；留空则发送给所有已知群。
+// v1.0.4：群内订阅（发关键词即可让本群加入推送列表，官机自动用 openid，无需手动填群号）
 
 const { Schema, h } = require('koishi')
 
@@ -12,30 +10,34 @@ exports.name = 'll-schedule'
 
 exports.usage = `定时发送插件：设置时间自动向指定群发送文字/图片。
 
-## 任务配置
+## 快速上手（推荐用法）
+
+1. 在插件设置页的 \`tasks\` 表格中添加任务：**键=任务名**，设置 \`time\`（发送时间）和 \`text\`/\`image\`（推送内容）
+2. 在任意群里 @机器人 发：\`订阅 任务名\` → 这个群就加入了该任务的推送列表（自动记录，重启不丢）
+3. 到点后插件自动把内容推送到所有订阅了该任务的群
+
+## 群内命令
+
+- \`订阅 [任务名]\`：当前群订阅指定任务的推送（不填任务名时，只有一个启用任务则自动选它）
+- \`取消订阅 [任务名]\`：当前群取消订阅
+- \`订阅列表\`：查看所有任务的订阅群
+- \`schedule.list\`：查看任务列表
+- \`schedule.test <任务名>\`：立即测试发送
+- \`lls.*\`：以上命令的备用入口（lls.sub / lls.unsub / lls.sublist / lls.list / lls.test）
 
-在插件设置页的 \`tasks\` 表格中添加任务（键=任务名），每项：
+订阅/取消订阅的权限等级可在设置页 \`subscribeAuthority\` 调整（默认 2=群管理）。
+
+## 任务配置
 
 - \`time\`：发送时间，HH:MM 格式（24小时制）
-- \`groups\`：目标群列表（**留空=发送给所有已知群**）
+- \`groups\`：手动指定的目标群列表（**推荐留空**，用群内"订阅"命令添加更省事；留空且无订阅 = 发给所有已知群）
 - \`text\`：文字内容（可留空）
 - \`image\`：图片 URL（可留空）
 - \`enabled\`：是否启用
 
 ## 官机（官方QQ机器人）说明
 
-官方平台没有"群号"，只有 openid。机器人收到过消息的群会被自动记录：
-
-- 命令 \`schedule.groups\` 查看所有已知群（显示群名和 openid）
-- 把 openid 填进任务的 \`groups\` 里即可
-- 注意：官机主动发群消息有平台频率限制，且机器人需在群里
-
-## 命令
-
-- \`schedule\` 帮助
-- \`schedule.list\` 查看任务
-- \`schedule.groups\` 查看机器人已知的群（官机显示 openid）
-- \`schedule.test <任务名>\` 立即测试发送
+官方平台没有"群号"，只有 openid——用群内"订阅"命令即可，插件会自动记录当前群的 openid，无需手动填写。手动填 \`groups\` 时可用 \`schedule.groups\` 查看已知群的 openid。官机主动发群消息有平台频率限制，且机器人需在群里。
 `
 
 const TaskItem = Schema.object({
@@ -44,7 +46,7 @@ const TaskItem = Schema.object({
     .description('发送时间，HH:MM 格式（24小时制），如 08:30、21:00'),
   groups: Schema.array(Schema.string())
     .default([])
-    .description('目标群 ID（留空=所有已知群；官机填 openid，OneBot 填数字群号）'),
+    .description('手动指定的目标群 ID（可留空；推荐用群内"订阅"命令自动添加，无需手动填 openid）'),
   text: Schema.string()
     .default('')
     .description('文字内容（可留空）'),
@@ -59,10 +61,19 @@ const TaskItem = Schema.object({
 const Config = Schema.object({
   tasks: Schema.dict(TaskItem)
     .default({})
-    .description('📋 定时任务表格（键=任务名）'),
+    .description('📋 定时任务表格（键=任务名，设置时间和推送内容）'),
+  subscribeKeyword: Schema.string()
+    .default('订阅')
+    .description('群内订阅推送的关键词（如"订阅 任务名"，只输关键词则订阅唯一启用的任务）'),
+  unsubscribeKeyword: Schema.string()
+    .default('取消订阅')
+    .description('群内取消订阅的关键词（如"取消订阅 任务名"）'),
+  subscribeAuthority: Schema.number()
+    .min(1).max(4).default(2)
+    .description('订阅/取消订阅所需权限等级（1=所有人 2=群管理 3=群主 4=管理员）'),
   sendAllWhenEmpty: Schema.boolean()
     .default(true)
-    .description('任务未指定群时，发送给该机器人所有已知群'),
+    .description('任务未指定群也没有群订阅时，发送给该机器人所有已知群'),
   verbose: Schema.boolean()
     .default(false)
     .description('调试：控制台打印每次发送详情'),
@@ -102,6 +113,64 @@ function apply(ctx, config) {
       platform: 'string',
       learnedAt: 'unsigned',
     }, { primary: ['botSid', 'guildId'] })
+    // 群订阅表：taskName + botSid + guildId（群内"订阅"命令注册的推送目标）
+    ctx.model.extend('ll_schedule_subs', {
+      taskName: 'string',
+      botSid: 'string',
+      guildId: 'string',
+      createdAt: 'unsigned',
+    }, { primary: ['taskName', 'botSid', 'guildId'] })
+  }
+
+  // ===== 群订阅（群内发关键词注册推送目标） =====
+  // subs: Map<taskName, Map<`${botSid}:${guildId}`, { botSid, guildId, createdAt }>>
+  const subs = new Map()
+
+  function getTaskSubs(taskName) {
+    let taskSubs = subs.get(taskName)
+    if (!taskSubs) {
+      taskSubs = new Map()
+      subs.set(taskName, taskSubs)
+    }
+    return taskSubs
+  }
+
+  async function loadSubs() {
+    if (!ctx.database) return
+    try {
+      const rows = await ctx.database.get('ll_schedule_subs', {})
+      for (const row of rows) {
+        getTaskSubs(row.taskName).set(`${row.botSid}:${row.guildId}`, {
+          botSid: row.botSid,
+          guildId: row.guildId,
+          createdAt: row.createdAt,
+        })
+      }
+      if (rows.length) logger.info(`[schedule] 已从数据库加载 ${rows.length} 条群订阅`)
+    }
+    catch (e) {
+      logger.warn('[schedule] 加载群订阅失败:', e)
+    }
+  }
+
+  async function persistSub(taskName, entry) {
+    if (!ctx.database) return
+    try {
+      await ctx.database.upsert('ll_schedule_subs', [{ ...entry, taskName }], ['taskName', 'botSid', 'guildId'])
+    }
+    catch (e) {
+      logger.warn('[schedule] 保存群订阅失败:', e)
+    }
+  }
+
+  async function removeSub(taskName, botSid, guildId) {
+    if (!ctx.database) return
+    try {
+      await ctx.database.remove('ll_schedule_subs', { taskName, botSid, guildId })
+    }
+    catch (e) {
+      logger.warn('[schedule] 删除群订阅失败:', e)
+    }
   }
 
   async function loadKnownGroups() {
@@ -145,6 +214,7 @@ function apply(ctx, config) {
       learnedAt: Date.now(),
     }
     knownGroups.set(key, entry)
+    logger.info(`[schedule] 学习到新群 ${bot.sid} (${bot.platform}) → ${session.guildId}`)
     persistGroup(entry)
   }
 
@@ -223,15 +293,21 @@ function apply(ctx, config) {
     if (!bots.length) return
 
     const groups = (task.groups && task.groups.length > 0) ? task.groups : null
+    const taskSubs = subs.get(name)
 
     for (const bot of bots) {
-      if (groups) {
-        for (const rawTarget of groups) {
+      // 该任务下、该机器人订阅的群（群内"订阅"命令注册的）
+      const subTargets = taskSubs
+        ? [...taskSubs.values()].filter(s => s.botSid === bot.sid).map(s => s.guildId)
+        : []
+
+      if (groups || subTargets.length) {
+        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 填入`)
+            logger.warn(`[schedule] 任务 "${name}"：官方QQ机器人不能用数字群号 "${target}" 发送，请用群内"订阅"命令或 schedule.groups 查看 openid`)
             continue
           }
           try {
@@ -242,9 +318,18 @@ function apply(ctx, config) {
             logger.error(`[schedule] 发送到 ${bot.sid}:${target} 失败: ${e.message}`)
           }
         }
+        for (const target of subTargets) {
+          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 if (config.sendAllWhenEmpty) {
-        // 未指定群 → 发送给该 bot 所有已知群
+        // 未指定群也没有订阅 → 发送给该 bot 所有已知群
         const targets = [...knownGroups.values()].filter(g => g.botSid === bot.sid)
         if (!targets.length) {
           logger.warn(`[schedule] 任务 "${name}" 未指定群且机器人 ${bot.sid} 暂无已知群（先让机器人收过该群消息，或用 schedule.groups 查看）`)
@@ -272,44 +357,195 @@ function apply(ctx, config) {
   ctx.on('dispose', () => clearInterval(timer))
 
   // ===== 命令 =====
+  async function listKnownGroups() {
+    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 即可）'
+  }
+
+  function formatTaskList() {
+    const tasks = config.tasks || {}
+    const keys = Object.keys(tasks)
+    if (!keys.length) return '暂无定时任务\n请在插件设置页的 tasks 表格中添加'
+    return keys.map(k => {
+      const t = tasks[k]
+      const s = t.enabled === false ? '⛔' : '✅'
+      const content = [t.text && '文字', t.image && '图片'].filter(Boolean).join('+') || '(空)'
+      const staticGroups = (t.groups || []).join(',')
+      const subCount = (subs.get(k) || new Map()).size
+      const target = staticGroups ? staticGroups : (subCount ? `订阅${subCount}群` : '所有已知群')
+      return `${s} ${k} @ ${t.time} → ${content} → 群:${target}${subCount && staticGroups ? ` +订阅${subCount}群` : ''}`
+    }).join('\n')
+  }
+
   ctx.command('schedule', '定时发送管理')
-    .action(() =>
-      '⚙️ 管理：插件设置页 → ll-schedule → tasks 表格\n' +
-      '命令：schedule.list 查看任务 | schedule.groups 查看已知群 | schedule.test <任务名> 立即测试发送'
-    )
+    .action(() => {
+      logger.info('[schedule] 命令被调用: schedule')
+      return '⚙️ 管理：插件设置页 → ll-schedule → tasks 表格设置时间和内容\n' +
+        `群内发"${config.subscribeKeyword} 任务名"即可让本群订阅推送\n` +
+        `命令：${config.subscribeKeyword} | ${config.unsubscribeKeyword} | 订阅列表 | schedule.list | schedule.groups | schedule.test <任务名>`
+    })
 
   ctx.command('schedule.list', '查看定时任务')
     .action(() => {
-      const tasks = config.tasks || {}
-      const keys = Object.keys(tasks)
-      if (!keys.length) return '暂无定时任务\n请在插件设置页的 tasks 表格中添加'
-      return keys.map(k => {
-        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(',') || '所有已知群'}`
-      }).join('\n')
+      logger.info('[schedule] 命令被调用: schedule.list')
+      return formatTaskList()
     })
 
   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 即可）'
+      logger.info('[schedule] 命令被调用: schedule.groups')
+      return await listKnownGroups()
     })
 
   ctx.command('schedule.test <name>', '立即测试发送指定任务')
     .action(async ({ session }, name) => {
+      logger.info(`[schedule] 命令被调用: schedule.test name=${name}`)
       const tasks = config.tasks || {}
       const task = tasks[name]
       if (!task) return `未找到任务 "${name}"，可用 schedule.list 查看任务名`
-      // 测试时：任务没配群就发到当前群
+      // 测试时：任务没配群也没订阅就发到当前群
+      const testTask = { ...task }
+      if (!testTask.groups || !testTask.groups.length) {
+        testTask.groups = session.guildId ? [String(session.guildId)] : []
+      }
+      await sendTask(name, testTask, session.bot?.sid)
+      return `✅ 已发送任务 "${name}"`
+    })
+
+  // ===== 群内订阅命令 =====
+  // 解析订阅命令的任务名：明确指定 → 用它；不填且只有一个启用任务 → 用它；否则返回提示
+  function resolveSubscribeTaskName(taskName) {
+    const tasks = config.tasks || {}
+    if (taskName) {
+      if (!tasks[taskName]) return { name: null, hint: `未找到任务 "${taskName}"，可用"订阅列表"或 lls.list 查看任务名` }
+      return { name: taskName, hint: null }
+    }
+    const names = Object.keys(tasks).filter(k => tasks[k] && tasks[k].enabled !== false)
+    if (names.length === 1) return { name: names[0], hint: null }
+    if (names.length === 0) return { name: null, hint: '暂无启用的任务，请先在插件设置页的 tasks 表格中添加' }
+    return { name: null, hint: `有多个任务，请指定任务名：${names.join(' / ')}` }
+  }
+
+  async function subscribeCurrentGroup(session, taskName) {
+    logger.info(`[schedule] 命令被调用: 订阅 taskName=${taskName || '(自动)'}`)
+    if (!session.guildId || !session.bot) return '❌ 订阅只能在群聊里使用'
+    const { name, hint } = resolveSubscribeTaskName(taskName)
+    if (!name) return hint
+    const task = config.tasks[name]
+    const key = `${session.bot.sid}:${session.guildId}`
+    const taskSubs = getTaskSubs(name)
+    if (taskSubs.has(key)) return `ℹ️ 本群已在任务 "${name}" 的推送列表里`
+    const entry = { botSid: session.bot.sid, guildId: session.guildId, createdAt: Date.now() }
+    taskSubs.set(key, entry)
+    persistSub(name, entry)
+    logger.info(`[schedule] 群 ${session.guildId} 已订阅任务 "${name}"`)
+    return `✅ 本群已加入任务 "${name}" 的推送列表\n时间：${task.time}\n内容：${task.text || '（图片）'}`
+  }
+
+  async function unsubscribeCurrentGroup(session, taskName) {
+    logger.info(`[schedule] 命令被调用: 取消订阅 taskName=${taskName || '(自动)'}`)
+    if (!session.guildId || !session.bot) return '❌ 取消订阅只能在群聊里使用'
+    const { name, hint } = resolveSubscribeTaskName(taskName)
+    if (!name) return hint
+    const taskSubs = subs.get(name)
+    const key = `${session.bot.sid}:${session.guildId}`
+    if (!taskSubs || !taskSubs.has(key)) return `ℹ️ 本群不在任务 "${name}" 的推送列表里`
+    taskSubs.delete(key)
+    removeSub(name, session.bot.sid, session.guildId)
+    logger.info(`[schedule] 群 ${session.guildId} 已取消订阅任务 "${name}"`)
+    return `✅ 本群已取消订阅任务 "${name}"`
+  }
+
+  ctx.command(config.subscribeKeyword + ' [taskName:text]', '让当前群订阅指定任务的推送')
+    .authority(config.subscribeAuthority)
+    .action(async ({ session }, taskName) => {
+      return await subscribeCurrentGroup(session, taskName)
+    })
+
+  ctx.command('lls.sub [taskName:text]', '订阅推送（备用入口）')
+    .authority(config.subscribeAuthority)
+    .action(async ({ session }, taskName) => {
+      return await subscribeCurrentGroup(session, taskName)
+    })
+
+  ctx.command(config.unsubscribeKeyword + ' [taskName:text]', '让当前群取消订阅指定任务的推送')
+    .authority(config.subscribeAuthority)
+    .action(async ({ session }, taskName) => {
+      return await unsubscribeCurrentGroup(session, taskName)
+    })
+
+  ctx.command('lls.unsub [taskName:text]', '取消订阅（备用入口）')
+    .authority(config.subscribeAuthority)
+    .action(async ({ session }, taskName) => {
+      return await unsubscribeCurrentGroup(session, taskName)
+    })
+
+  ctx.command('订阅列表', '查看所有任务的订阅群')
+    .action(async () => {
+      logger.info('[schedule] 命令被调用: 订阅列表')
+      if (!subs.size) return '暂无任何群订阅。群内发"' + config.subscribeKeyword + ' 任务名"即可订阅'
+      const lines = []
+      for (const [taskName, taskSubs] of subs) {
+        const entries = [...taskSubs.values()]
+        lines.push(`【${taskName}】${entries.length} 个群`)
+        for (const s of entries) {
+          const bot = ctx.bots.find(b => b.sid === s.botSid)
+          const name = bot ? await resolveGroupName(bot, s.guildId) : ''
+          lines.push(`  · ${name || '未知群名'} (${s.guildId})`)
+        }
+      }
+      return '📋 订阅列表：\n' + lines.join('\n')
+    })
+
+  ctx.command('lls.sublist', '查看订阅列表（备用入口）')
+    .action(async () => {
+      logger.info('[schedule] 命令被调用: lls.sublist')
+      if (!subs.size) return '暂无任何群订阅。群内发"' + config.subscribeKeyword + ' 任务名"即可订阅'
+      const lines = []
+      for (const [taskName, taskSubs] of subs) {
+        const entries = [...taskSubs.values()]
+        lines.push(`【${taskName}】${entries.length} 个群`)
+        for (const s of entries) {
+          const bot = ctx.bots.find(b => b.sid === s.botSid)
+          const name = bot ? await resolveGroupName(bot, s.guildId) : ''
+          lines.push(`  · ${name || '未知群名'} (${s.guildId})`)
+        }
+      }
+      return '📋 订阅列表：\n' + lines.join('\n')
+    })
+
+  // 备用命令入口（避免与其他插件的 schedule 命令冲突）
+  ctx.command('lls', 'll-schedule 管理（备用入口）')
+    .action(() => {
+      logger.info('[schedule] 命令被调用: lls')
+      return `⚙️ 备用入口：lls.list / lls.groups / lls.test <任务名> / lls.sub / lls.unsub / lls.sublist`
+    })
+
+  ctx.command('lls.list', '查看定时任务（备用入口）')
+    .action(() => {
+      logger.info('[schedule] 命令被调用: lls.list')
+      return formatTaskList()
+    })
+
+  ctx.command('lls.groups', '查看机器人已知的群（备用入口，官机显示 openid）')
+    .action(async () => {
+      logger.info('[schedule] 命令被调用: lls.groups')
+      return await listKnownGroups()
+    })
+
+  ctx.command('lls.test <name>', '立即测试发送指定任务（备用入口）')
+    .action(async ({ session }, name) => {
+      logger.info(`[schedule] 命令被调用: lls.test name=${name}`)
+      const tasks = config.tasks || {}
+      const task = tasks[name]
+      if (!task) return `未找到任务 "${name}"，可用 lls.list 查看任务名`
       const testTask = { ...task }
       if (!testTask.groups || !testTask.groups.length) {
         testTask.groups = session.guildId ? [String(session.guildId)] : []
@@ -318,8 +554,11 @@ function apply(ctx, config) {
       return `✅ 已发送任务 "${name}"`
     })
 
-  // 启动时：加载已知群 + 立即检查一次
-  loadKnownGroups().then(() => checkAndSend())
+  logger.info('[schedule] 命令已注册: schedule / schedule.list / schedule.groups / schedule.test / ' +
+    `"${config.subscribeKeyword}" / "${config.unsubscribeKeyword}" / 订阅列表 / lls.*`)
+
+  // 启动时：加载已知群 + 订阅 + 立即检查一次
+  Promise.all([loadKnownGroups(), loadSubs()]).then(() => checkAndSend())
 }
 
 exports.apply = apply

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "koishi-plugin-ll-schedule",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "Scheduled message sender with text/image support, works with official QQ bot",
   "main": "index.js",
   "files": [