koishi-plugin-ll-schedule 1.6.3 → 1.7.1

package/index.js

@@ -11,28 +11,16 @@ const { Schema, h } = require('koishi')
 
 exports.name = 'll-schedule'
 
-exports.usage = `定时提醒：每个任务一个大文本框(schedule)。每段 = 一行"星期 时间"，下面几行是内容。
+exports.usage = `剑灵活动提醒：全部活动写在 activities 活动表里，群里发「订阅」即可收到所有活动的提前提醒。
 
-例：
-周一 21:00
-# 世界BOSS马上刷新啦！
-> 地点1：仙幻岛
-> 地点2：白青山脉
-游戏下方有遁地按钮可以直达～
-
-星期：周一/周六/每天/工作日/周末/1,3,5   时间：12:20, 18:20, 21:20（可多个）
-内容支持 Markdown 卡片、模板变量 {date} {time} {week} {task}
-
-群命令：
-  订阅            → 列出可以订阅的推送
-  订阅 任务名      → 本群订阅
-  取消订阅         → 列出本群已订阅的推送
-  取消订阅 任务名   → 本群取消订阅
-  订阅列表 / schedule.list / schedule.groups / schedule.test 任务名 / schedule.testcur 任务名(只发当前群) / 我的ID
-管理员：schedule.unsuball 任务名（取消该任务全部群订阅并通知各群；填 all 清空全部）
-
-推送接口：POST /ll-schedule/push  {"secret":"密钥","task":"任务名","place1":"xxx","delay":0}
+活动表格式（一份表管所有活动）：
+[世界BOSS] 提前：5分钟
+周一 21:00-22:00 地点：白青山脉 / 仙幻岛
+[寻宝] 提前：2分钟
+每天 13:00-13:30
 
+群命令：订阅 / 取消订阅 / 订阅列表 / schedule.list / schedule.test
+管理员：schedule.unsuball（取消所有群的订阅）
 `
 
 // ===== 纯函数（可单测） =====
@@ -242,46 +230,164 @@ function buildTextFromMd(md) {
     .trim()
 }
 
-exports._test = { parseTimes, todayDay, parseDays, dayMatches, parseScheduleBlocks, parseScheduleRows, summarizeRows, computeFires, renderText, renderPushTemplate, buildMd, buildTextFromMd }
+// ===== 活动表（剑灵提醒）=====
+// 文本格式：
+//   [世界BOSS] 提前：5分钟
+//   周一 21:00-22:00 地点：白青山脉 / 仙幻岛
+//   每天 13:00-13:30
+function hmToMin(hm) {
+  const [h, m] = String(hm).split(':').map(Number)
+  return (h || 0) * 60 + (m || 0)
+}
+
+function parseActivities(text) {
+  const lines = String(text || '').split(/\r?\n/)
+  const acts = []
+  let cur = null
+  const pad = (s) => (String(s).length === 4 ? '0' + s : String(s))
+  for (const raw of lines) {
+    const line = raw.trim()
+    if (!line) continue
+    // [活动名] 可带 提前：N分钟
+    const head = line.match(/^[[【]([^\]】]+)[\]】]\s*(.*)$/)
+    if (head) {
+      const name = head[1].trim()
+      const rest = head[2] || ''
+      const adv = rest.match(/提前\s*[:：]?\s*(\d+)\s*分钟?/)
+      cur = { name, advance: adv ? parseInt(adv[1], 10) : 2, slots: [] }
+      acts.push(cur)
+      continue
+    }
+    if (!cur) continue
+    if (/^[#/]/.test(line)) continue // 注释行
+    // 时段行：星期 开始-结束 [地点：xxx]
+    const m = line.match(/^(\S+)\s+(\d{1,2}:\d{2})\s*[-~—至]\s*(\d{1,2}:\d{2})\s*(.*)$/)
+    if (!m) continue
+    const rest = (m[4] || '').trim()
+    const pm = rest.match(/地点\s*[:：]\s*(.+)$/)
+    cur.slots.push({ wd: m[1], start: pad(m[2]), end: pad(m[3]), place: pm ? pm[1].trim() : rest })
+  }
+  return acts.filter(a => a.slots.length > 0)
+}
+
+// 展开成"周内实例"（星期 × 时段）
+function expandInstances(activities) {
+  const out = []
+  for (const act of activities || []) {
+    for (const s of act.slots || []) {
+      const days = parseDays(s.wd)
+      const list = days ? [...days] : [1, 2, 3, 4, 5, 6, 7]
+      for (const d of list) {
+        out.push({
+          activity: act.name,
+          advance: act.advance,
+          day: d,
+          start: s.start,
+          end: s.end,
+          place: s.place,
+          startMin: hmToMin(s.start),
+        })
+      }
+    }
+  }
+  return out
+}
+
+// 找"下一场"（跨天、跨周都算）
+function findNextInstance(instances, current) {
+  let best = null
+  let bestKey = Infinity
+  for (const inst of instances) {
+    if (inst === current) continue
+    let offset = (inst.day - current.day + 7) % 7
+    if (offset === 0 && inst.startMin <= current.startMin) offset = 7
+    const key = offset * 1440 + inst.startMin
+    if (key < bestKey) {
+      bestKey = key
+      best = inst
+    }
+  }
+  return best
+}
+
+// 计算"现在这一分钟该发哪些提前提醒"
+function computeReminders(activities, date, hm) {
+  const day = todayDay(date)
+  const instances = expandInstances(activities)
+  const nowMin = hmToMin(hm)
+  const fires = []
+  for (const inst of instances) {
+    if (inst.day !== day) continue
+    const fireMin = inst.startMin - (inst.advance || 0)
+    if (fireMin !== nowMin) continue
+    fires.push({
+      key: `${inst.activity}@${hm}@${inst.start}`,
+      inst,
+      next: findNextInstance(instances, inst),
+    })
+  }
+  return fires
+}
+
+const DEFAULT_REMIND_TPL = [
+  '⏰ 提醒：距离 [{activity}] 还有 {advance} 分钟！',
+  '🕐 活动时间：{start}-{end}',
+  '📍 活动地点：{place}',
+  '{{#next}}',
+  '────────────',
+  '▶ 下一时段活动：[{next}]',
+  '📅 活动时间：{nextStart}-{nextEnd}',
+  '{{/next}}',
+].join('\n')
+
+// 渲染提醒模板：{变量} 替换；含空变量的整行自动删除；{{#key}}...{{/key}} 条件块（变量为空则整块删除）
+function renderRemindTemplate(tpl, vars) {
+  let out = String(tpl || DEFAULT_REMIND_TPL)
+  out = out.replace(/\{\{#(\w+)\}\}([\s\S]*?)\{\{\/\1\}\}/g, (m, key, body) => {
+    const v = vars[key]
+    return (v === undefined || v === null || String(v).trim() === '') ? '' : body
+  })
+  const kept = []
+  for (const line of out.split('\n')) {
+    const names = [...line.matchAll(/\{(\w+)\}/g)].map(x => x[1])
+    const hasEmpty = names.some((n) => {
+      const v = vars[n]
+      return v === undefined || v === null || String(v).trim() === ''
+    })
+    if (names.length && hasEmpty) continue
+    kept.push(line.replace(/\{(\w+)\}/g, (m, n) => (vars[n] === undefined || vars[n] === null ? '' : String(vars[n]))))
+  }
+  return kept.join('\n').replace(/\n{3,}/g, '\n\n').trim()
+}
+
+exports._test = { parseTimes, todayDay, parseDays, dayMatches, parseScheduleBlocks, parseScheduleRows, summarizeRows, computeFires, renderText, renderPushTemplate, hmToMin, parseActivities, expandInstances, findNextInstance, computeReminders, renderRemindTemplate, DEFAULT_REMIND_TPL, buildMd, buildTextFromMd }
 
 // ===== 配置 Schema =====
 
-const TaskItem = Schema.object({
-  schedule: Schema.string()
-    .role('textarea', { rows: [6, 16] })
+const Config = Schema.object({
+  activities: Schema.string()
+    .role('textarea', { rows: [8, 20] })
     .default('')
-    .description('📅 日程：多行文本框，直接写整张日程。每个时间段分两段：第一行写 星期 时间，下面几行写内容（可多行 markdown）。示例见 usage。'),
-  groups: Schema.array(Schema.string())
-    .default([])
-    .description('手动指定的目标群 ID（可留空；推荐用群内"订阅"命令自动添加，无需手动填 openid）'),
-  markdown: Schema.boolean()
-    .default(false)
-    .description('用 QQ官方 Markdown 卡片发送（仅官方QQ机器人生效，失败自动回退纯文本；其他平台始终纯文本）'),
-  pushTemplate: Schema.string()
-    .role('textarea', { rows: [3, 8] })
+    .description('📅 剑灵活动表（全部活动写这里，一份表管所有提醒）。格式：[活动名] 提前：N分钟，下面每行 = 星期 开始-结束 地点：xxx'),
+  remindTemplate: Schema.string()
+    .role('textarea', { rows: [6, 14] })
     .default('')
-    .description('接口推送模板（可选）：HTTP 接口推送时套用的卡片模板。变量 {place1} {place2} 等 = 推送方传入的字段；留空用默认模板。多行 markdown，例见 usage'),
-  enabled: Schema.boolean()
+    .description('提醒文案模板（留空用默认）。变量：{activity} {advance} {start} {end} {place} {next} {nextStart} {nextEnd} {date} {week}；含空变量的整行会自动省略'),
+  remindMarkdown: Schema.boolean()
     .default(true)
-    .description('是否启用'),
-})
-
-const Config = Schema.object({
-  tasks: Schema.dict(TaskItem)
-    .default({})
-    .description('📋 推送任务表格（键=任务名；每个任务 = 一个日程大文本框 schedule：星期/时间/内容）'),
-  pushSecret: Schema.string()
-    .default('')
-    .description('🔑 HTTP 推送接口密钥：外部系统调用 POST /ll-schedule/push 时须携带相同 secret（留空则接口拒绝所有推送）'),
+    .description('活动提醒是否用 QQ官方 Markdown 卡片发送（仅官机生效，失败自动回退纯文本）'),
+  globalGroups: Schema.array(Schema.string())
+    .default([])
+    .description('额外固定推送群（可选）：这些群无需订阅也会收到活动提醒（留空即可，一般用群内"订阅"命令）'),
   unsubAllNotice: Schema.string()
-    .default('本群已取消「{task}」的推送')
-    .description('管理员用 schedule.unsuball 取消全部订阅时，发到每个被取消群的提示语（{task}=任务名；留空则不发送提示）'),
+    .default('本群已取消剑灵提醒推送')
+    .description('管理员用 schedule.unsuball 取消全部订阅时，发到每个被取消群的提示语（留空则不发送提示）'),
   permDeniedHint: Schema.string()
     .default('❌ 权限不足，请联系李浅浅，或成为群主/管理员')
     .description('权限不足时的提示语（管理命令/订阅命令都会用它；可改成你自己的联系方式）'),
   subscribeAuthority: Schema.number()
     .min(1).max(4).default(1)
-    .description('执行订阅命令所需的最低权限等级（Koishi 用户权限等级，与QQ群主/管理员身份无关；默认 1=所有人都能订阅。如需限制，先在控制台"用户管理"给指定账号提权，再调高此值）'),
+    .description('执行订阅命令所需的最低权限等级（默认 1 = 所有人都能订阅。如需限制：先在控制台给指定账号提权，再把这里调高）'),
   subscribeAdminBypass: Schema.boolean()
     .default(true)
     .description('群主/群管理可无视上面的权限等级直接订阅（从消息自带的成员角色判断，无需申请接口权限）'),
@@ -290,7 +396,7 @@ const Config = Schema.object({
     .description('任务未指定群也没有群订阅时，发送给该机器人所有已知群'),
   verbose: Schema.boolean()
     .default(false)
-    .description('调试：控制台打印每次发送详情'),
+    .description('调试：控制台打印每次发送详情（一般不用开）'),
 })
 
 exports.Config = Config
@@ -334,6 +440,8 @@ function apply(ctx, config) {
   }
 
   // ===== 群订阅 =====
+  // 现在订阅是全局的：订阅一次 = 收全部剑灵提醒（存在特殊任务名 ALL 下）
+  const ALL = '__all__'
   const subs = new Map()
 
   function getTaskSubs(taskName) {
@@ -345,6 +453,46 @@ function apply(ctx, config) {
     return taskSubs
   }
 
+  // 把已有订阅（老的按任务订阅）自动升级为「全部订阅」：按群去重，不重不漏
+  async function migrateToAll() {
+    if (!ctx.database) return
+    try {
+      const rows = await ctx.database.get('ll_schedule_subs', {})
+      const groupMap = new Map()
+      for (const r of rows) {
+        if (r.taskName === ALL) continue
+        groupMap.set(`${r.botSid}:${r.guildId}`, { botSid: r.botSid, guildId: r.guildId })
+      }
+      if (!groupMap.size) {
+        // 没有老记录：清理内存里可能残留的老键
+        for (const k of [...subs.keys()]) if (k !== ALL) subs.delete(k)
+        return
+      }
+      const allSubs = getTaskSubs(ALL)
+      const now = Date.now()
+      const toInsert = []
+      for (const [key, g] of groupMap) {
+        if (allSubs.has(key)) continue
+        const entry = { botSid: g.botSid, guildId: g.guildId, createdAt: now }
+        allSubs.set(key, entry)
+        toInsert.push({ taskName: ALL, ...entry })
+      }
+      if (toInsert.length) {
+        await ctx.database.upsert('ll_schedule_subs', toInsert, ['taskName', 'botSid', 'guildId'])
+      }
+      // 删除老记录 + 清理内存老键
+      for (const r of rows) {
+        if (r.taskName === ALL) continue
+        await removeSub(r.taskName, r.botSid, r.guildId)
+      }
+      for (const k of [...subs.keys()]) if (k !== ALL) subs.delete(k)
+      logger.info(`[schedule] 订阅已升级为「全部订阅」：${groupMap.size} 个群（其中新增 ${toInsert.length}）`)
+    }
+    catch (e) {
+      logger.warn('[schedule] 订阅升级失败:', e)
+    }
+  }
+
   async function loadSubs() {
     if (!ctx.database) return
     try {
@@ -520,14 +668,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)
+    // 订阅目标 = 该任务的订阅群 ∪ 订阅了"全部提醒"的群（去重）
+    const allSubsMap = subs.get(ALL)
     // 测试模式（skipSubs）时忽略所有订阅群，只发 groups（即当前测试群）
     const useSubs = !opts.skipSubs
 
     for (const bot of bots) {
-      const subTargets = (useSubs && taskSubs)
-        ? [...taskSubs.values()].filter(s => s.botSid === bot.sid).map(s => s.guildId)
-        : []
+      const subTargets = []
+      if (useSubs) {
+        for (const m of [subs.get(name), allSubsMap]) {
+          if (!m) continue
+          for (const s of m.values()) {
+            if (s.botSid === bot.sid && !subTargets.includes(s.guildId)) subTargets.push(s.guildId)
+          }
+        }
+      }
 
       if (groups || subTargets.length) {
         for (const rawTarget of groups || []) {
@@ -577,55 +732,71 @@ function apply(ctx, config) {
     }
   }
 
-  // ===== HTTP 推送接口：外部系统 POST 数据 → 转为卡片发给该任务订阅群 =====
-  if (ctx.router) {
-    ctx.router.post('/ll-schedule/push', async (ctx) => {
-      const respond = (status, body) => { ctx.status = status; ctx.body = body }
-      let body = null
-      try {
-        body = (typeof ctx.request.body === 'string') ? JSON.parse(ctx.request.body) : (ctx.request.body || {})
-      }
-      catch (e) {
-        return respond(400, { ok: false, error: 'invalid json body' })
-      }
-      // 密钥校验（未配置密钥则一律拒绝）
-      if (!config.pushSecret) return respond(403, { ok: false, error: 'pushSecret not configured' })
-      if (body.secret !== config.pushSecret) return respond(403, { ok: false, error: 'invalid secret' })
-
-      const taskName = String(body.task || '')
-      const task = (config.tasks || {})[taskName]
-      if (!taskName || !task) return respond(404, { ok: false, error: `task "${taskName}" not found` })
-
-      // 除 secret/task/delay 外的字段都作为模板变量（place1/place2/time/...）
-      const data = { ...body }
-      delete data.secret
-      delete data.task
-      delete data.delay
-      const now = new Date()
-      const rendered = renderPushTemplate(task.pushTemplate, data, {
-        date: todayStr(now),
-        time: nowHM(now),
-        week: '星期' + WEEK_CN[todayDay(now)],
-        task: taskName,
-      })
-      if (!rendered.trim()) return respond(400, { ok: false, error: 'empty content' })
+  // ===== 活动提醒（活动表模式）=====
 
-      const delay = Math.max(0, parseInt(body.delay, 10) || 0)
-      const push = async () => {
-        // 只发给订阅群（含手动 groups），不发全量已知群
-        await sendTask(taskName, task, { text: rendered, markdown: task.markdown })
+  // 发给所有"订阅了全部提醒"的群（+ 额外固定群）
+  async function sendToSubscribers(text, { markdown, image } = {}) {
+    if (!text) return 0
+    const allSubs = subs.get(ALL)
+    const fixed = Array.isArray(config.globalGroups) ? config.globalGroups : []
+    let bots = (ctx.bots || []).filter(b => b.online)
+    if (!bots.length) return 0
+    let sent = 0
+    for (const bot of bots) {
+      const list = []
+      if (allSubs) {
+        for (const t of allSubs.values()) {
+          if (t.botSid === bot.sid && !list.includes(t.guildId)) list.push(t.guildId)
+        }
       }
-      if (delay > 0) {
-        setTimeout(push, delay * 60 * 1000)
-        logger.info(`[schedule] 接口已接收任务 "${taskName}"，${delay} 分钟后推送`)
+      for (const g of fixed) {
+        const gs = String(g).trim()
+        if (gs && !list.includes(gs)) list.push(gs)
       }
-      else {
-        await push()
-        logger.info(`[schedule] 接口已推送任务 "${taskName}"`)
+      // 一个订阅群都没有时，按配置兜底发给所有已知群
+      if (!list.length && config.sendAllWhenEmpty) {
+        for (const g of knownGroups.values()) {
+          if (g.botSid === bot.sid && !list.includes(g.guildId)) list.push(g.guildId)
+        }
       }
-      return respond(200, { ok: true, delay, task: taskName })
-    })
-    logger.info('[schedule] HTTP 推送接口已注册: POST /ll-schedule/push')
+      for (const target of list) {
+        try {
+          await sendOne(bot, target, text, { markdown, image })
+          sent++
+          if (config.verbose) logger.info(`[schedule] 提醒已发 ${bot.sid}:${target}`)
+        }
+        catch (e) {
+          logger.error(`[schedule] 提醒发送失败 ${bot.sid}:${target}: ${e.message}`)
+        }
+      }
+    }
+    return sent
+  }
+
+  // 组装提醒模板变量
+  function makeRemindVars(inst, next, now, hm) {
+    return {
+      activity: inst.activity,
+      advance: String(inst.advance || 0),
+      start: inst.start,
+      end: inst.end,
+      place: inst.place || '',
+      date: todayStr(now),
+      time: hm,
+      week: '星期' + WEEK_CN[todayDay(now)],
+      next: next ? next.activity : '',
+      nextStart: next ? next.start : '',
+      nextEnd: next ? next.end : '',
+      nextPlace: next ? (next.place || '') : '',
+    }
+  }
+
+  // 渲染并发送一条活动提醒
+  async function sendReminder(inst, next, now, hm) {
+    const text = renderRemindTemplate(config.remindTemplate, makeRemindVars(inst, next, now, hm))
+    if (!text) return
+    logger.info(`[schedule] 活动提醒「${inst.activity}」开始于 ${inst.start}（提前 ${inst.advance} 分钟）`)
+    await sendToSubscribers(text, { markdown: !!config.remindMarkdown })
   }
 
   async function checkAndSend() {
@@ -636,6 +807,20 @@ function apply(ctx, config) {
     }
 
     const hm = nowHM(now)
+
+    // ① 活动表模式（有新活动表就只跑它，避免和旧任务重复发）
+    const activities = parseActivities(config.activities)
+    if (activities.length) {
+      const reminds = computeReminders(activities, now, hm)
+      for (const r of reminds) {
+        if (firedToday[r.key]) continue
+        firedToday[r.key] = true
+        await sendReminder(r.inst, r.next, now, hm)
+      }
+      return
+    }
+
+    // ② 旧任务模式
     const fires = computeFires(config.tasks, now, hm)
 
     for (const f of fires) {
@@ -667,14 +852,29 @@ function apply(ctx, config) {
   }
 
   function formatTaskList() {
+    // 活动表模式
+    const acts = parseActivities(config.activities)
+    if (acts.length) {
+      const lines = ['📅 活动表（订阅后全部活动都会提前提醒）：', '']
+      for (const a of acts) {
+        lines.push(`【${a.name}】提前 ${a.advance} 分钟`)
+        for (const s of a.slots) {
+          lines.push(`  · ${s.wd} ${s.start}-${s.end}${s.place ? '　地点：' + s.place : ''}`)
+        }
+      }
+      const subCount = (subs.get(ALL) || new Map()).size
+      lines.push('', `已订阅的群：${subCount} 个（发送"订阅列表"查看）`)
+      return lines.join('\n')
+    }
+    // 旧任务模式
     const tasks = config.tasks || {}
     const keys = Object.keys(tasks)
-    if (!keys.length) return '暂无定时任务\n请在插件设置页的 tasks 表格中添加任务'
+    if (!keys.length) return '暂无活动\n请在插件设置页的 activities 活动表里添加活动'
     return keys.map(k => {
       const t = tasks[k]
       const s = t.enabled === false ? '⛔' : '✅'
       const staticGroups = (t.groups || []).join(',')
-      const subCount = (subs.get(k) || new Map()).size
+      const subCount = (subs.get(ALL) || new Map()).size
       const target = staticGroups ? staticGroups : (subCount ? `订阅${subCount}群` : '所有已知群')
       const rows = parseScheduleRows(t)
       const lines = rows.map((r, i) => {
@@ -686,51 +886,73 @@ function apply(ctx, config) {
     }).join('\n')
   }
 
-  ctx.command('schedule', '定时发送管理')
+  ctx.command('schedule', '定时提醒管理')
     .action(() => {
       logger.info('[schedule] 命令被调用: schedule')
-      return '⚙️ 管理：插件设置页 → ll-schedule → tasks 添加任务和时间段（星期/时间/内容）\n' +
-        `群内发"订阅 任务名"即可让本群订阅推送\n` +
-        `命令：订阅 | 取消订阅 | 订阅列表 | schedule.list | schedule.groups | schedule.test <任务名>`
+      return '⚙️ 活动表在插件设置页的 activities 里配置\n' +
+        '群内发"订阅"即可让本群收到全部提醒\n' +
+        '命令：订阅 | 取消订阅 | 订阅列表 | schedule.list | schedule.groups | schedule.test'
     })
 
-  ctx.command('schedule.list', '查看定时任务')
+  ctx.command('schedule.list', '查看活动表')
     .action(() => {
       logger.info('[schedule] 命令被调用: schedule.list')
       return formatTaskList()
     })
 
-  ctx.command('schedule.groups', '查看机器人已知的群（官机显示 openid）')
+  ctx.command('schedule.groups', '查看机器人已知的群')
     .action(async () => {
       logger.info('[schedule] 命令被调用: schedule.groups')
       return await listKnownGroups()
     })
 
-  ctx.command('schedule.test <name>', '立即测试发送指定任务')
+  // 活动表模式下：把某个活动的提醒测试发到当前群；返回 null 表示当前不是活动表模式
+  async function testActivityToGroup(session, name) {
+    const acts = parseActivities(config.activities)
+    if (!acts.length) return null
+    const act = name
+      ? (acts.find(a => a.name === name) || acts.find(a => a.name.includes(name)))
+      : acts[0]
+    if (!act) return `未找到活动 "${name}"，可用 schedule.list 查看活动表`
+    const instances = expandInstances(acts)
+    const inst = instances.find(i => i.activity === act.name)
+    const now = new Date()
+    const text = renderRemindTemplate(config.remindTemplate, makeRemindVars(inst, findNextInstance(instances, inst), now, nowHM(now)))
+    const bot = (ctx.bots || []).find(b => b.sid === session.bot?.sid)
+    if (!bot || !session.guildId) return '❌ 只能在群里测试'
+    await sendOne(bot, String(session.guildId), text, { markdown: !!config.remindMarkdown })
+    return `✅ 已向本群测试发送「${act.name}」的提醒`
+  }
+
+  ctx.command('schedule.test [name:text]', '测试发送提醒（发到当前群）')
     .action(async ({ session }, name) => {
-      logger.info(`[schedule] 命令被调用: schedule.test name=${name}`)
+      logger.info(`[schedule] 命令被调用: schedule.test name=${name || '(第一个)'}`)
+      const actResult = await testActivityToGroup(session, name)
+      if (actResult !== null) return actResult
+      // 旧任务模式
       const tasks = config.tasks || {}
       const task = tasks[name]
-      if (!task) return `未找到任务 "${name}"，可用 schedule.list 查看任务名`
+      if (!task) return `未找到任务 "${name}"，可用 schedule.list 查看`
       const testTask = { ...task }
       if (!testTask.groups || !testTask.groups.length) {
         testTask.groups = session.guildId ? [String(session.guildId)] : []
       }
-      // 优先发"今天会命中的行"，否则发第一条（保证测试总能发出内容）
       const rows = parseScheduleRows(task)
       const day = todayDay()
       const hit = rows.find(r => dayMatches(parseDays(r.wd), day))
       const sendText = hit ? (hit.text || '') : (rows.length ? (rows[0].text || '') : '')
-      await sendTask(name, testTask, { text: sendText, markdown: task.markdown, onlyBotSid: session.bot?.sid })
-      return `✅ 已发送任务 "${name}"`
+      await sendTask(name, testTask, { text: sendText, markdown: task.markdown, onlyBotSid: session.bot?.sid, skipSubs: true })
+      return `✅ 已向本群测试发送任务 "${name}"`
     })
 
-  ctx.command('schedule.testcur <name>', '只向当前群测试发送（不发订阅群）')
+  ctx.command('schedule.testcur [name:text]', '只向当前群测试发送提醒（不发订阅群）')
     .action(async ({ session }, name) => {
-      logger.info(`[schedule] 命令被调用: schedule.testcur name=${name}`)
+      logger.info(`[schedule] 命令被调用: schedule.testcur name=${name || '(第一个)'}`)
+      const actResult = await testActivityToGroup(session, name)
+      if (actResult !== null) return actResult
       const tasks = config.tasks || {}
       const task = tasks[name]
-      if (!task) return `未找到任务 "${name}"，可用 schedule.list 查看任务名`
+      if (!task) return `未找到任务 "${name}"，可用 schedule.list 查看`
       if (!session.guildId) return '❌ 只能在群里使用'
       const testTask = { ...task, groups: [String(session.guildId)] }
       const rows = parseScheduleRows(task)
@@ -767,124 +989,107 @@ function apply(ctx, config) {
     return config.permDeniedHint || '❌ 权限不足，请联系李浅浅，或成为群主/管理员'
   }
 
-  // 列出所有可订阅的任务（含时间概览 + 本群是否已订阅）
-  function listSubscribable(session) {
+  // 当前活动/任务的概览清单文本
+  function activityOverview() {
+    const acts = parseActivities(config.activities)
+    if (acts.length) {
+      return acts.map(a => `【${a.name}】${a.slots.map(s => `${s.wd} ${s.start}-${s.end}`).join('、')}`).join('\n')
+    }
     const tasks = config.tasks || {}
     const names = Object.keys(tasks).filter(k => tasks[k] && tasks[k].enabled !== false)
-    if (!names.length) return '暂无任何可订阅的推送（请在插件设置页的 tasks 里添加任务）'
+    if (names.length) {
+      return names.map(n => `【${n}】${summarizeRows(parseScheduleRows(tasks[n]))}`).join('\n')
+    }
+    return '（暂无活动，请在插件设置页的 activities 活动表里添加）'
+  }
+
+  function isSubscribed(session) {
     const key = (session.bot && session.guildId) ? `${session.bot.sid}:${session.guildId}` : null
-    const lines = ['📋 可以订阅的推送：', '']
-    names.forEach((n, i) => {
-      const rows = parseScheduleRows(tasks[n])
-      const subbed = (key && subs.get(n) && subs.get(n).has(key)) ? '  ✅本群已订阅' : ''
-      lines.push(`${i + 1}. ${n} —— ${summarizeRows(rows)}${subbed}`)
-    })
-    lines.push('', `发送「订阅 任务名」即可订阅，例如：订阅 ${names[0]}`)
+    const allSubs = subs.get(ALL)
+    return !!(key && allSubs && allSubs.has(key))
+  }
+
+  // 列出当前有哪些提醒可以订阅（含本群是否已订阅）
+  function listSubscribable(session) {
+    const lines = ['📋 剑灵提醒（订阅一次，全部活动都会收到）：', '', activityOverview()]
+    if (session.bot && session.guildId) {
+      lines.push('', isSubscribed(session) ? '✅ 本群已订阅（发送「取消订阅」可退订）' : '发送「订阅」即可让本群收到全部提醒')
+    }
     return lines.join('\n')
   }
 
-  // 列出本群已订阅的任务
+  // 列出本群订阅状态
   function listMySubs(session) {
-    const key = `${session.bot.sid}:${session.guildId}`
-    const mine = []
-    for (const [tn, m] of subs) {
-      if (m.has(key)) mine.push(tn)
-    }
-    if (!mine.length) return '本群还没有订阅任何推送\n发送「订阅」可查看有哪些可以订阅'
-    return '📋 本群已订阅：\n' + mine.map((n, i) => `${i + 1}. ${n}`).join('\n') +
-      '\n\n发送「取消订阅 任务名」可取消'
+    if (!isSubscribed(session)) return '本群还没有订阅提醒\n发送「订阅」即可订阅全部活动提醒'
+    return '📋 本群已订阅全部剑灵提醒：\n\n' + activityOverview() + '\n\n发送「取消订阅」可退订'
   }
 
-  async function subscribeCurrentGroup(session, taskName) {
-    logger.info(`[schedule] 命令被调用: 订阅 taskName=${taskName || '(列表)'}`)
+  async function subscribeCurrentGroup(session) {
+    logger.info('[schedule] 命令被调用: 订阅')
     if (!session.guildId || !session.bot) return '❌ 订阅只能在群聊里使用'
-    // 不带任务名 → 直接列出可以订阅什么
-    if (!taskName) return listSubscribable(session)
-    const tasks = config.tasks || {}
-    if (!tasks[taskName]) return `未找到任务 "${taskName}"\n发送「订阅」可查看可以订阅的列表`
-    if (tasks[taskName].enabled === false) return `任务 "${taskName}" 已停用，暂时不能订阅`
-    const name = taskName
-    const task = tasks[name]
     const key = `${session.bot.sid}:${session.guildId}`
-    const taskSubs = getTaskSubs(name)
-    if (taskSubs.has(key)) return `ℹ️ 本群已在任务 "${name}" 的推送列表里`
+    const allSubs = getTaskSubs(ALL)
+    if (allSubs.has(key)) {
+      return `ℹ️ 本群已经订阅了剑灵提醒（全部活动都会收到）\n\n${activityOverview()}`
+    }
     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}"`)
-    const rows = parseScheduleRows(task)
-    return `✅ 本群已订阅「${name}」\n时间：${summarizeRows(rows)}`
+    allSubs.set(key, entry)
+    persistSub(ALL, entry)
+    logger.info(`[schedule] 群 ${session.guildId} 已订阅全部提醒`)
+    return `✅ 本群已订阅剑灵提醒（以后所有活动都会提前提醒，新活动也自动包含）\n\n${activityOverview()}`
   }
 
-  async function unsubscribeCurrentGroup(session, taskName) {
-    logger.info(`[schedule] 命令被调用: 取消订阅 taskName=${taskName || '(列表)'}`)
+  async function unsubscribeCurrentGroup(session) {
+    logger.info('[schedule] 命令被调用: 取消订阅')
     if (!session.guildId || !session.bot) return '❌ 取消订阅只能在群聊里使用'
-    // 不带任务名 → 列出本群订阅了哪些
-    if (!taskName) return listMySubs(session)
-    const taskSubs = subs.get(taskName)
     const key = `${session.bot.sid}:${session.guildId}`
-    if (!taskSubs || !taskSubs.has(key)) return `ℹ️ 本群没有订阅「${taskName}」\n发送「取消订阅」可查看本群已订阅的推送`
-    taskSubs.delete(key)
-    removeSub(taskName, session.bot.sid, session.guildId)
-    logger.info(`[schedule] 群 ${session.guildId} 已取消订阅任务 "${taskName}"`)
-    return `✅ 本群已取消订阅「${taskName}」`
+    const allSubs = subs.get(ALL)
+    if (!allSubs || !allSubs.has(key)) return 'ℹ️ 本群还没有订阅提醒'
+    allSubs.delete(key)
+    removeSub(ALL, session.bot.sid, session.guildId)
+    logger.info(`[schedule] 群 ${session.guildId} 已取消订阅全部提醒`)
+    return '✅ 本群已取消全部剑灵提醒'
   }
 
-  ctx.command('订阅 [taskName:text]', '让当前群订阅指定任务的推送')
+  ctx.command('订阅 [taskName:text]', '订阅全部剑灵提醒')
     .action(async ({ session }, taskName) => {
       if (!(await checkSubscribePerm(session))) return permDeniedHint()
-      return await subscribeCurrentGroup(session, taskName)
+      // 兼容旧用法「订阅 任务名」：现在一律按"订阅全部"处理
+      return await subscribeCurrentGroup(session)
     })
 
-  ctx.command('取消订阅 [taskName:text]', '让当前群取消订阅指定任务的推送')
+  ctx.command('取消订阅 [taskName:text]', '取消本群的全部剑灵提醒')
     .action(async ({ session }, taskName) => {
       if (!(await checkSubscribePerm(session))) return permDeniedHint()
       return await unsubscribeCurrentGroup(session, taskName)
     })
 
-  ctx.command('订阅列表', '查看所有任务的订阅群')
+  ctx.command('订阅列表', '查看订阅了提醒的群')
     .action(async () => {
       logger.info('[schedule] 命令被调用: 订阅列表')
-      if (!subs.size) return '暂无任何群订阅。群内发"订阅 任务名"即可订阅'
-      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})`)
-        }
+      const allSubs = subs.get(ALL)
+      if (!allSubs || !allSubs.size) return '暂无任何群订阅。群内发"订阅"即可订阅全部提醒'
+      const lines = [`📋 已订阅提醒的群（共 ${allSubs.size} 个）：`]
+      for (const s of allSubs.values()) {
+        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')
+      return lines.join('\n')
     })
 
-  // 管理员：取消指定任务的全部群订阅（并通知每个被取消的群）
-  // 任务名可填 all / * 表示清空所有任务的全部订阅
-  ctx.command('schedule.unsuball <name>', '取消某任务的全部群订阅（管理员；填 all 清空全部）')
-    .action(async ({ session }, name) => {
-      logger.info(`[schedule] 命令被调用: schedule.unsuball name=${name}`)
-      // 权限：Koishi 权限 ≥ 3，或（开启群主绕过时）本群群主/群管理
+  // 管理员：取消所有群的提醒订阅（并通知每个被取消的群）
+  ctx.command('schedule.unsuball', '取消所有群的提醒订阅（管理员）')
+    .action(async ({ session }) => {
+      logger.info('[schedule] 命令被调用: schedule.unsuball')
+      // 权限：权限等级 ≥ 3，或（开启群主绕过时）本群群主/群管理
       const isAdmin = (session.user?.authority >= 3) ||
         (config.subscribeAdminBypass && await isGroupAdmin(session))
       if (!isAdmin) return permDeniedHint()
-      const tasks = config.tasks || {}
-      const all = name === 'all' || name === '*'
-      if (!all && (!name || !tasks[name])) {
-        return `未找到任务 "${name}"，可用 schedule.list 查看任务名（也可以填 all 清空全部任务的订阅）`
-      }
-      // 收集要取消的订阅
-      const targets = []
-      if (all) {
-        for (const [tn, m] of subs) {
-          for (const e of m.values()) targets.push({ taskName: tn, botSid: e.botSid, guildId: e.guildId })
-        }
-      }
-      else {
-        const m = subs.get(name)
-        if (m) for (const e of m.values()) targets.push({ taskName: name, botSid: e.botSid, guildId: e.guildId })
-      }
-      if (!targets.length) return all ? 'ℹ️ 当前没有任何群订阅' : `ℹ️ 任务 "${name}" 当前没有任何群订阅`
+
+      const allSubs = subs.get(ALL)
+      if (!allSubs || !allSubs.size) return 'ℹ️ 当前没有任何群订阅'
+      const targets = [...allSubs.values()].map(e => ({ botSid: e.botSid, guildId: e.guildId }))
 
       // 逐群发送"已取消"提示
       let notified = 0
@@ -892,7 +1097,7 @@ function apply(ctx, config) {
         for (const t of targets) {
           const bot = (ctx.bots || []).find(b => b.sid === t.botSid)
           if (!bot || !bot.online) continue
-          const text = String(config.unsubAllNotice).split('{task}').join(t.taskName)
+          const text = String(config.unsubAllNotice).split('{task}').join('剑灵提醒')
           try {
             await bot.sendMessage(t.guildId, [text])
             notified++
@@ -904,24 +1109,18 @@ function apply(ctx, config) {
       }
 
       // 清空订阅（内存 + 数据库）
-      if (all) {
-        for (const m of subs.values()) m.clear()
-        if (ctx.database) {
-          try {
-            await ctx.database.remove('ll_schedule_subs', {})
-          }
-          catch (e) {
-            logger.warn('[schedule] 清空订阅表失败:', e)
-          }
+      allSubs.clear()
+      for (const k of [...subs.keys()]) if (k !== ALL) subs.delete(k)
+      if (ctx.database) {
+        try {
+          await ctx.database.remove('ll_schedule_subs', {})
+        }
+        catch (e) {
+          logger.warn('[schedule] 清空订阅表失败:', e)
         }
       }
-      else {
-        const m = subs.get(name)
-        if (m) m.clear()
-        for (const t of targets) await removeSub(t.taskName, t.botSid, t.guildId)
-      }
-      logger.info(`[schedule] 已取消 ${targets.length} 个群订阅（通知 ${notified} 个群）${all ? '（全部任务）' : `任务 "${name}"`}`)
-      return `✅ 已取消 ${targets.length} 个群订阅${all ? '（全部任务）' : `（任务「${name}」）`}\n已向 ${notified} 个群发送取消提示`
+      logger.info(`[schedule] 已取消 ${targets.length} 个群的订阅（通知 ${notified} 个群）`)
+      return `✅ 已取消 ${targets.length} 个群的订阅\n已向 ${notified} 个群发送取消提示`
     })
 
   ctx.command('我的ID', '查看自己的账号信息（openid/群ID/角色）')
@@ -939,7 +1138,9 @@ function apply(ctx, config) {
   logger.info('[schedule] 命令已注册: schedule / schedule.list / schedule.groups / schedule.test / ' +
     `"订阅" / "取消订阅" / 订阅列表 / 我的ID`)
 
-  Promise.all([loadKnownGroups(), loadSubs()]).then(() => checkAndSend())
+  Promise.all([loadKnownGroups(), loadSubs()])
+    .then(() => migrateToAll())
+    .then(() => checkAndSend())
 }
 
 exports.apply = apply

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "koishi-plugin-ll-schedule",
-  "version": "1.6.3",
+  "version": "1.7.1",
   "description": "Scheduled message sender with weekly slots (per-day time & content), QQ official markdown card support",
   "main": "index.js",
   "files": [
@@ -31,3 +31,5 @@
 
 
 
+
+