koishi-plugin-ll-schedule 1.0.9 → 1.2.0

package/index.js

@@ -1,54 +1,236 @@
 'use strict'
 
 // koishi-plugin-ll-schedule
-// 定时发送插件：设置时间自动向指定群发送文字
+// 定时提醒插件：到点自动向订阅群发送"提醒"（文字/图片/QQ官方Markdown卡片）
 // v1.0.6：一个任务支持多个时间（逗号分隔），群内"订阅"关键词自动注册推送群
+// v1.1.0：新增排班表 slots + QQ 官方 Markdown 卡片 + 模板变量
+// v1.2.0：设置页重做 —— 任务 = "时间段列表，每行 = 星期 + 时间 + 内容"，删掉零散子字段，更直观
+//         （向后兼容：旧 time/text、旧 slots(days) 配置仍能识别）
 
 const { Schema, h } = require('koishi')
 
 exports.name = 'll-schedule'
 
-exports.usage = `定时发送插件：设置时间自动向指定群发送文字。
+exports.usage = `定时提醒插件：到时间自动向订阅了该任务的群发送提醒。每个任务 = 一张"时间段列表"，点 + 添加一行，每行填 星期 / 时间 / 内容。
 
-## 快速上手（推荐用法）
+## 快速上手
 
-1. 在插件设置页的 \`tasks\` 表格中添加任务：**键=任务名**，设置 \`time\`（发送时间，**可多个**）和 \`text\`（推送内容）
-2. 在任意群里 @机器人 发：\`订阅 任务名\` → 这个群就加入了该任务的推送列表（自动记录，重启不丢）
-3. 到点后插件自动把内容推送到所有订阅了该任务的群
+1. 在插件设置页的 \`tasks\` 里**添加任务**（键=任务名），在任务里 **添加时间段**：每行填 星期（留空=每天）/ 时间 / 内容
+2. 在任意群 @机器人 发：\`订阅 任务名\` → 该群加入此任务的订阅列表
+3. 到时间，插件自动把该时间段的内容发给所有订阅群
 
-## 任务配置
+## 每个时间段三格子
 
-- \`time\`：发送时间（24小时制 HH:MM），**可填多个，用逗号分隔**，如 \`09:00, 21:30\`（一条内容会在每个时间点各发一次）
-- \`text\`：推送内容（文字，可留空）
-- \`groups\`：手动指定的目标群列表（**推荐留空**，用群内"订阅"命令添加更省事；留空且无订阅 = 发给所有已知群）
-- \`enabled\`：是否启用
+- **星期**：留空 = 每天；写 \`周一\` \`周六\`...、\`工作日\`（周一到周五）、\`周末\`（周六日）、或 \`1,3,5\` 数字
+- **时间**：\`HH:MM\`，可填多个用逗号分隔，如 \`12:20, 18:20, 21:20\`（这些时间点都发同一段内容）
+- **内容**：到点发送的话；支持 Markdown 语法和模板变量 \`{date}\` \`{time}\` \`{week}\` \`{task}\`
+
+## 示例：每天定时提醒
+
+任务「轻功」，添加 1 行： 星期=空（每天） 时间=\`12:20, 18:20, 21:20\` 内容=\`⏰ 轻功时间到了！\`
+→ 每天这三个点都发这句。
+
+## 示例：按天/按时段发不同内容（如世界BOSS）
+
+任务「世界BOSS」，添加多行：
+\`\`\`
+周一  21:00   世界BOSS刷新！仙幻岛 → 白青山脉
+周二  21:00   世界BOSS刷新！仙幻岛 → 大漠
+周三  21:00   世界BOSS刷新！仙幻岛 → 御龙林
+周四  21:00   世界BOSS刷新！仙幻岛 → 水月平原
+周五  21:00   世界BOSS刷新！白青山脉 → 大漠
+周六  15:00   世界BOSS刷新！仙幻岛 → 白青山脉
+周六  21:00   世界BOSS刷新！仙幻岛 → 御龙林
+周日  15:00   世界BOSS刷新！仙幻岛 → 大漠
+周日  21:00   世界BOSS刷新！仙幻岛 → 水月平原
+\`\`\`
+每行对应一个时间段，内容各不相同。
+
+## Markdown 卡片（官方QQ机器人）
+
+任务勾选 \`markdown\` 后，会用 QQ 官方 Markdown 卡片发送（仅官机生效，失败自动回退纯文本；其他平台始终纯文本）。内容里可用标题/加粗/引用/链接/图片，模板变量自动替换。任务填 \`image\` 图片 URL 也会随消息发出（markdown 模式自动嵌入）。
+
+## 其他配置
+
+- \`groups\`：手动指定目标群（推荐留空，用群内"订阅"命令自动添加）
+- \`enabled\`：是否启用该任务
 
 ## 群内命令
 
-- \`订阅 [任务名]\`：当前群订阅指定任务的推送（不填任务名时，只有一个启用任务则自动选它）
+- \`订阅 [任务名]\`：当前群订阅指定任务
 - \`取消订阅 [任务名]\`：当前群取消订阅
 - \`订阅列表\`：查看所有任务的订阅群
-- \`schedule.list\`：查看任务列表
+- \`schedule.list\`：查看任务列表（含每段时间段）
 - \`schedule.test <任务名>\`：立即测试发送
-- \`lls.*\`：以上命令的备用入口（lls.sub / lls.unsub / lls.sublist / lls.list / lls.test）
-
-订阅/取消订阅所需权限等级在设置页 \`subscribeAuthority\` 调整（默认 1=所有人都能订阅）。\`subscribeAdminBypass\`（默认开启）：群主/群管理可无视权限等级直接订阅——插件从群消息自带的成员角色判断（\`owner\`/\`admin\`），**不需要申请接口权限**。想验证自己角色可发 \`我的ID\`。
+- \`lls.*\`：以上命令的备用入口
 
 ## 官机（官方QQ机器人）说明
 
-官方平台没有"群号"，只有 openid——用群内"订阅"命令即可，插件会自动记录当前群的 openid，无需手动填写。手动填 \`groups\` 时可用 \`schedule.groups\` 查看已知群的 openid。官机主动发群消息有平台频率限制，且机器人需在群里。
+官方平台没有群号只有 openid——用群内"订阅"命令即可，插件自动记录当前群 openid。手动填 \`groups\` 时用 \`schedule.groups\` 查看已知群 openid。官机主动发群消息有平台频率限制，且机器人需在群里。
 `
 
-const TaskItem = Schema.object({
+// ===== 纯函数（可单测） =====
+
+// 解析时间：支持多个时间，逗号/顿号/空格分隔，如 "09:00, 21:30"
+function parseTimes(timeStr) {
+  if (!timeStr) return []
+  return String(timeStr).split(/[，,、;；\s]+/)
+    .map(s => s.trim())
+    .filter(s => /^\d{1,2}:\d{2}$/.test(s))
+    .map(s => (s.length === 4 ? '0' + s : s))
+}
+
+// 今天星期几（1=周一 ... 7=周日）
+function todayDay(date) {
+  const d = date || new Date()
+  const day = d.getDay()
+  return day === 0 ? 7 : day
+}
+
+const WEEK_CN = ['', '一', '二', '三', '四', '五', '六', '日']
+
+// 解析星期配置：返回 Set(1..7) 或 null（null = 每天）
+// 支持：留空/每天/每日、1-7 数字逗号分隔、范围 1-5、中文 一,三,五 / 星期X / 周X / 每周X、工作日、周末
+function parseDays(daysStr) {
+  if (daysStr === undefined || daysStr === null) return null
+  const s = String(daysStr).trim()
+  if (!s) return null
+  const alias = { '每天': null, '每日': null, '天天': null, '工作日': new Set([1, 2, 3, 4, 5]), '周末': new Set([6, 7]), '休息日': new Set([6, 7]) }
+  if (Object.prototype.hasOwnProperty.call(alias, s)) return alias[s]
+  const set = new Set()
+  const cnMap = { '一': 1, '二': 2, '三': 3, '四': 4, '五': 5, '六': 6, '日': 7, '天': 7 }
+  for (const part of s.split(/[，,、;；\s]+/)) {
+    const p = part.trim()
+    if (!p) continue
+    const range = p.match(/^(\d{1,2})\s*[-~]\s*(\d{1,2})$/)
+    if (range) {
+      for (let i = parseInt(range[1], 10); i <= parseInt(range[2], 10); i++) {
+        if (i >= 1 && i <= 7) set.add(i)
+      }
+      continue
+    }
+    const cn = p.match(/^(?:每)?(?:星期|周|礼拜)?([一二三四五六日天])$/)
+    if (cn) {
+      set.add(cnMap[cn[1]])
+      continue
+    }
+    const num = p.match(/^([1-7])$/)
+    if (num) {
+      set.add(parseInt(num[1], 10))
+      continue
+    }
+  }
+  return set.size ? set : null
+}
+
+// 某天是否命中排班（null=每天 恒命中）
+function dayMatches(daysSet, day) {
+  return !daysSet || daysSet.has(day)
+}
+
+// 把任务的时间段解析成统一行列表：[{ idx, wd(星期), time, text }]
+// 兼容三种写法：新 slots 数组（优先）、旧 time/text（每天）、旧 slots(days)
+function parseScheduleRows(task) {
+  if (!task) return []
+  if (Array.isArray(task.slots) && task.slots.length) {
+    return task.slots
+      .map((s, i) => ({
+        idx: i,
+        wd: s.wd !== undefined ? s.wd : s.days, // 兼容旧 slots 的 days 字段
+        time: s.time,
+        text: s.text || '',
+      }))
+      .filter(r => r.time)
+  }
+  if (task.time) {
+    return [{ idx: 0, wd: '', time: task.time, text: task.text || '' }]
+  }
+  return []
+}
+
+// 计算"现在这一刻该发什么"：返回 [{ name, key, text, markdown, image }]
+function computeFires(tasks, date, hm) {
+  const day = todayDay(date)
+  const fires = []
+  for (const [name, task] of Object.entries(tasks || {})) {
+    if (!task || task.enabled === false) continue
+    const rows = parseScheduleRows(task)
+    for (const row of rows) {
+      if (!dayMatches(parseDays(row.wd), day)) continue
+      const timeList = parseTimes(row.time)
+      if (!timeList.includes(hm)) continue
+      fires.push({
+        name,
+        key: `${name}@${hm}@${row.idx}`,
+        text: row.text || '',
+        markdown: !!task.markdown,
+        image: task.image,
+      })
+    }
+  }
+  return fires
+}
+
+// 模板变量渲染：{date} {time} {week} {task}
+function renderText(text, ctx) {
+  return String(text || '')
+    .replace(/\{date\}/g, ctx.date)
+    .replace(/\{time\}/g, ctx.time)
+    .replace(/\{week\}/g, ctx.week)
+    .replace(/\{task\}/g, ctx.task)
+}
+
+// 组装 markdown：文本 + 图片
+function buildMd(text, image) {
+  let md = String(text || '').trim()
+  if (image) md += (md ? '\n\n' : '') + `![图片](${image})`
+  return md
+}
+
+// markdown 转纯文本（发送时兜底）
+function buildTextFromMd(md) {
+  return String(md || '')
+    .replace(/<qqbot-at-user[^>]*\/>/g, '')
+    .replace(/^#{1,6}\s*/gm, '')
+    .replace(/\*\*([^*]+)\*\*/g, '$1')
+    .replace(/\*([^*]+)\*/g, '$1')
+    .replace(/`([^`]+)`/g, '$1')
+    .replace(/!\[([^\]]*)\]\(([^)]+)\)/g, '[$1]($2)')
+    .replace(/\[([^\]]+)\]\(([^)]+)\)/g, '$1: $2')
+    .replace(/^>\s?/gm, '')
+    .replace(/\n{3,}/g, '\n\n')
+    .trim()
+}
+
+exports._test = { parseTimes, todayDay, parseDays, dayMatches, parseScheduleRows, computeFires, renderText, buildMd, buildTextFromMd }
+
+// ===== 配置 Schema =====
+
+const SlotItem = Schema.object({
+  wd: Schema.string()
+    .default('')
+    .description('星期：留空=每天；周一/周二...；工作日（周一到五）/周末（周六日）；或 1,3,5 / 1-5'),
   time: Schema.string()
     .required()
-    .description('发送时间（24小时制 HH:MM），可填多个用逗号分隔，如 09:00, 21:30'),
+    .description('时间（24小时制 HH:MM），可多个用逗号分隔，如 12:20, 18:20, 21:20'),
+  text: Schema.string()
+    .default('')
+    .description('内容：到点发送的话，支持 Markdown 和模板变量 {date} {time} {week} {task}'),
+})
+
+const TaskItem = Schema.object({
+  slots: Schema.array(SlotItem)
+    .default([])
+    .description('📅 时间段列表：每行 = 星期 + 时间 + 内容，点 + 可添加多行；每行内容各自独立'),
   groups: Schema.array(Schema.string())
     .default([])
     .description('手动指定的目标群 ID（可留空；推荐用群内"订阅"命令自动添加，无需手动填 openid）'),
-  text: Schema.string()
+  markdown: Schema.boolean()
+    .default(false)
+    .description('用 QQ官方 Markdown 卡片发送（仅官方QQ机器人生效，失败自动回退纯文本；其他平台始终纯文本）'),
+  image: Schema.string()
     .default('')
-    .description('推送内容（文字，可留空）'),
+    .description('图片 URL（可选）：随内容一起发送（markdown 模式自动嵌入为图片）'),
   enabled: Schema.boolean()
     .default(true)
     .description('是否启用'),
@@ -57,7 +239,7 @@ const TaskItem = Schema.object({
 const Config = Schema.object({
   tasks: Schema.dict(TaskItem)
     .default({})
-    .description('📋 定时任务表格（键=任务名，设置时间和推送内容）'),
+    .description('📋 推送任务表格（键=任务名；每个任务 = 时间段列表：星期/时间/内容）'),
   subscribeKeyword: Schema.string()
     .default('订阅')
     .description('群内订阅推送的关键词（如"订阅 任务名"，只输关键词则订阅唯一启用的任务）'),
@@ -81,19 +263,17 @@ const Config = Schema.object({
 exports.Config = Config
 
 // 需要数据库：持久化学习到的群（重启不丢）
-// 必须声明 required：确保插件在数据库就绪后才启动，模型表能正常注册建表
 exports.inject = { required: ['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 groupNameCache = new Map()
   const TTL = 60 * 60 * 1000
 
   function cacheGet(map, key) {
@@ -104,7 +284,7 @@ function apply(ctx, config) {
     map.set(key, { v: value, t: Date.now() })
   }
 
-  // 数据库模型（可选）
+  // 数据库模型
   if (ctx.database) {
     ctx.model.extend('ll_schedule_groups', {
       botSid: 'string',
@@ -112,7 +292,6 @@ function apply(ctx, config) {
       platform: 'string',
       learnedAt: 'unsigned',
     }, { primary: ['botSid', 'guildId'] })
-    // 群订阅表：taskName + botSid + guildId（群内"订阅"命令注册的推送目标）
     ctx.model.extend('ll_schedule_subs', {
       taskName: 'string',
       botSid: 'string',
@@ -121,8 +300,7 @@ function apply(ctx, config) {
     }, { primary: ['taskName', 'botSid', 'guildId'] })
   }
 
-  // ===== 群订阅（群内发关键词注册推送目标） =====
-  // subs: Map<taskName, Map<`${botSid}:${guildId}`, { botSid, guildId, createdAt }>>
+  // ===== 群订阅 =====
   const subs = new Map()
 
   function getTaskSubs(taskName) {
@@ -236,76 +414,82 @@ function apply(ctx, config) {
     return ''
   }
 
-  // 从消息事件学习群
   ctx.on('message', (session) => {
     learnGroup(session)
   })
 
-  function nowHM() {
-    const d = new Date()
+  function nowHM(date) {
+    const d = date || new Date()
     return `${String(d.getHours()).padStart(2, '0')}:${String(d.getMinutes()).padStart(2, '0')}`
   }
 
-  // 解析任务时间：支持多个时间，逗号/顿号/空格分隔，如 "09:00, 21:30"
-  function parseTimes(timeStr) {
-    if (!timeStr) return []
-    return String(timeStr).split(/[，,、;；\s]+/)
-      .map(s => s.trim())
-      .filter(s => /^\d{1,2}:\d{2}$/.test(s))
-      .map(s => (s.length === 4 ? '0' + s : s))
-  }
-
-  function todayStr() {
-    const d = new Date()
+  function todayStr(date) {
+    const d = date || new Date()
     return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, '0')}-${String(d.getDate()).padStart(2, '0')}`
   }
 
-  async function checkAndSend() {
-    const today = todayStr()
-    // 跨天重置
-    if (firedToday.date !== today) {
-      firedToday = { date: today }
-    }
+  // ===== 发送 =====
+  const KNOWN_IGNORE_CODES = new Set([11293, 40034101, 40034105, 304101, 304102])
 
-    const hm = nowHM()
-    const tasks = config.tasks || {}
+  function errCode(e) {
+    const d = e && e.response && e.response.data
+    if (!d) return undefined
+    return d.code !== undefined ? d.code : d.err_code
+  }
 
-    for (const [name, task] of Object.entries(tasks)) {
-      if (!task || task.enabled === false) continue
-      const timeList = parseTimes(task.time)
-      if (!timeList.includes(hm)) continue
-      // 今天这个时间点已经发过这个任务 → 跳过
-      const fireKey = `${name}@${hm}`
-      if (firedToday[fireKey]) continue
-      firedToday[fireKey] = true
+  function isKnownIgnoreError(e) {
+    const code = errCode(e)
+    return typeof code === 'number' && KNOWN_IGNORE_CODES.has(code)
+  }
 
-      logger.info(`[schedule] 触发任务 "${name}" @ ${hm}`)
-      await sendTask(name, task)
+  async function sendOne(bot, target, text, { markdown, image }) {
+    if (markdown && bot.platform === 'qq' && bot.internal && typeof bot.internal.sendMessage === 'function') {
+      const md = buildMd(text, image)
+      const plain = buildTextFromMd(md) || ' '
+      try {
+        await bot.internal.sendMessage(target, { msg_type: 2, msg_seq: 0, content: plain, markdown: { content: md } })
+        return true
+      }
+      catch (e) {
+        if (isKnownIgnoreError(e)) {
+          if (config.verbose) logger.debug(`[schedule] 主动消息受限 (code=${errCode(e)})，跳过 ${bot.sid}:${target}`)
+          return false
+        }
+        logger.warn(`[schedule] markdown 发送失败，回退纯文本 (${bot.sid}:${target}):`, e.message || e)
+      }
     }
+    const parts = []
+    if (text) parts.push(text)
+    if (image) parts.push(h.image(image))
+    if (!parts.length) return false
+    await bot.sendMessage(target, parts)
+    return true
   }
 
-  async function sendTask(name, task, onlyBotSid) {
-    // 组装消息
-    const parts = []
-    if (task.text) parts.push(task.text)
-    if (task.image) {
-      if (parts.length) parts.push('\n')
-      parts.push(h.image(task.image))
-    }
-    if (!parts.length) {
+  async function sendTask(name, task, opts = {}) {
+    const now = new Date()
+    const text = opts.text !== undefined ? opts.text : (task.text || '')
+    const markdown = opts.markdown !== undefined ? !!opts.markdown : !!task.markdown
+    const image = task.image
+    const rendered = renderText(text, {
+      date: todayStr(now),
+      time: nowHM(now),
+      week: '星期' + WEEK_CN[todayDay(now)],
+      task: name,
+    })
+    if (!rendered && !image) {
       logger.warn(`[schedule] 任务 "${name}" 没有文字也没有图片，跳过`)
       return
     }
 
     let bots = (ctx.bots || []).filter(b => b.online)
-    if (onlyBotSid) bots = bots.filter(b => b.sid === onlyBotSid)
+    if (opts.onlyBotSid) bots = bots.filter(b => b.sid === opts.onlyBotSid)
     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) {
-      // 该任务下、该机器人订阅的群（群内"订阅"命令注册的）
       const subTargets = taskSubs
         ? [...taskSubs.values()].filter(s => s.botSid === bot.sid).map(s => s.guildId)
         : []
@@ -314,13 +498,12 @@ function apply(ctx, config) {
         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)
+            await sendOne(bot, target, rendered, { markdown, image })
             if (config.verbose) logger.info(`[schedule] 已发送任务 "${name}" 到 ${bot.sid}:${target}`)
           }
           catch (e) {
@@ -329,7 +512,7 @@ function apply(ctx, config) {
         }
         for (const target of subTargets) {
           try {
-            await bot.sendMessage(target, parts)
+            await sendOne(bot, target, rendered, { markdown, image })
             if (config.verbose) logger.info(`[schedule] 已发送任务 "${name}" 到订阅群 ${bot.sid}:${target}`)
           }
           catch (e) {
@@ -338,7 +521,6 @@ function apply(ctx, config) {
         }
       }
       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 查看）`)
@@ -346,7 +528,7 @@ function apply(ctx, config) {
         }
         for (const g of targets) {
           try {
-            await bot.sendMessage(g.guildId, parts)
+            await sendOne(bot, g.guildId, rendered, { markdown, image })
             if (config.verbose) logger.info(`[schedule] 已发送任务 "${name}" 到 ${bot.sid}:${g.guildId}`)
           }
           catch (e) {
@@ -360,7 +542,27 @@ function apply(ctx, config) {
     }
   }
 
-  // 每 20 秒检查一次（保证同一分钟内能触发）
+  async function checkAndSend() {
+    const now = new Date()
+    const today = todayStr(now)
+    if (firedToday.date !== today) {
+      firedToday = { date: today }
+    }
+
+    const hm = nowHM(now)
+    const fires = computeFires(config.tasks, now, hm)
+
+    for (const f of fires) {
+      if (firedToday[f.key]) continue
+      firedToday[f.key] = true
+
+      logger.info(`[schedule] 触发任务 "${f.name}" @ ${hm}`)
+      const task = (config.tasks || {})[f.name]
+      if (!task) continue
+      await sendTask(f.name, task, { text: f.text, markdown: f.markdown })
+    }
+  }
+
   const timer = setInterval(checkAndSend, 20000)
 
   ctx.on('dispose', () => clearInterval(timer))
@@ -381,24 +583,27 @@ function apply(ctx, config) {
   function formatTaskList() {
     const tasks = config.tasks || {}
     const keys = Object.keys(tasks)
-    if (!keys.length) return '暂无定时任务\n请在插件设置页的 tasks 表格中添加'
+    if (!keys.length) return '暂无定时任务\n请在插件设置页的 tasks 表格中添加任务'
     return keys.map(k => {
       const t = tasks[k]
       const s = t.enabled === false ? '⛔' : '✅'
-      const content = [t.text && '文字'].filter(Boolean).join('+') || '(空)'
       const staticGroups = (t.groups || []).join(',')
       const subCount = (subs.get(k) || new Map()).size
       const target = staticGroups ? staticGroups : (subCount ? `订阅${subCount}群` : '所有已知群')
-      const times = parseTimes(t.time)
-      const timeStr = times.length ? times.join(', ') : (t.time || '(无时间)')
-      return `${s} ${k} @ ${timeStr} → ${content} → 群:${target}${subCount && staticGroups ? ` +订阅${subCount}群` : ''}`
+      const rows = parseScheduleRows(t)
+      const lines = rows.map((r, i) => {
+        const wd = r.wd || '每天'
+        return `  ${i + 1}. ${wd} ${r.time} → ${r.text || '(空)'}`
+      })
+      const head = `${s} ${k} → ${rows.length} 个时间段 → 群:${target}${t.markdown ? ' (md卡片)' : ''}`
+      return [head, ...lines].join('\n')
     }).join('\n')
   }
 
   ctx.command('schedule', '定时发送管理')
     .action(() => {
       logger.info('[schedule] 命令被调用: schedule')
-      return '⚙️ 管理：插件设置页 → ll-schedule → tasks 表格设置时间和内容\n' +
+      return '⚙️ 管理：插件设置页 → ll-schedule → tasks 添加任务和时间段（星期/时间/内容）\n' +
         `群内发"${config.subscribeKeyword} 任务名"即可让本群订阅推送\n` +
         `命令：${config.subscribeKeyword} | ${config.unsubscribeKeyword} | 订阅列表 | schedule.list | schedule.groups | schedule.test <任务名>`
     })
@@ -421,19 +626,20 @@ function apply(ctx, config) {
       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)
+      // 发"今天会命中的第一行"的内容，更贴近真实
+      const rows = parseScheduleRows(task)
+      const day = todayDay()
+      const hit = rows.find(r => dayMatches(parseDays(r.wd), day))
+      const sendText = hit ? (hit.text || '') : (task.text || '')
+      await sendTask(name, testTask, { text: sendText, markdown: task.markdown, onlyBotSid: session.bot?.sid })
       return `✅ 已发送任务 "${name}"`
     })
 
   // ===== 群内订阅命令 =====
-  // 判断发送者是否群主/群管理：
-  // 1) 优先用消息事件自带的成员角色（官机/OneBot 群消息都会带，零 API 调用，不受接口权限限制）
-  // 2) 兜底调 getGuildMember（需要接口权限，拿不到就忽略）
   async function isGroupAdmin(session) {
     if (!session.guildId || !session.userId) return false
     const role = session.author?.roles?.[0]?.id || session.event?.member?.roles?.[0]?.id
@@ -460,7 +666,6 @@ function apply(ctx, config) {
       (config.subscribeAdminBypass ? '，或为本群群主/群管理' : '')
   }
 
-  // 解析订阅命令的任务名：明确指定 → 用它；不填且只有一个启用任务 → 用它；否则返回提示
   function resolveSubscribeTaskName(taskName) {
     const tasks = config.tasks || {}
     if (taskName) {
@@ -486,8 +691,8 @@ function apply(ctx, config) {
     taskSubs.set(key, entry)
     persistSub(name, entry)
     logger.info(`[schedule] 群 ${session.guildId} 已订阅任务 "${name}"`)
-    const times = parseTimes(task.time)
-    return `✅ 本群已加入任务 "${name}" 的推送列表\n时间：${times.length ? times.join(', ') : '(未设置)'}\n内容：${task.text || '（空）'}`
+    const rows = parseScheduleRows(task)
+    return `✅ 本群已加入任务 "${name}" 的推送列表\n时间段：${rows.length} 个（schedule.list 查看详情）`
   }
 
   async function unsubscribeCurrentGroup(session, taskName) {
@@ -567,11 +772,7 @@ function apply(ctx, config) {
       logger.info('[schedule] 命令被调用: 我的ID')
       const role = session.author?.roles?.[0]?.id || session.event?.member?.roles?.[0]?.id
       const roleName = role === 'owner' ? '群主' : role === 'admin' ? '群管理' : role === 'member' ? '普通成员' : (role || '未知')
-      const lines = [
-        '👤 我的账号信息：',
-        `平台：${session.platform}`,
-        `用户ID：${session.userId}`,
-      ]
+      const lines = ['👤 我的账号信息：', `平台：${session.platform}`, `用户ID：${session.userId}`]
       if (session.guildId) lines.push(`当前群ID：${session.guildId}`)
       if (session.guildId) lines.push(`本群角色：${roleName}`)
       if (session.channelId && session.channelId !== session.guildId) lines.push(`频道ID：${session.channelId}`)
@@ -583,18 +784,13 @@ function apply(ctx, config) {
       logger.info('[schedule] 命令被调用: lls.me')
       const role = session.author?.roles?.[0]?.id || session.event?.member?.roles?.[0]?.id
       const roleName = role === 'owner' ? '群主' : role === 'admin' ? '群管理' : role === 'member' ? '普通成员' : (role || '未知')
-      const lines = [
-        '👤 我的账号信息：',
-        `平台：${session.platform}`,
-        `用户ID：${session.userId}`,
-      ]
+      const lines = ['👤 我的账号信息：', `平台：${session.platform}`, `用户ID：${session.userId}`]
       if (session.guildId) lines.push(`当前群ID：${session.guildId}`)
       if (session.guildId) lines.push(`本群角色：${roleName}`)
       if (session.channelId && session.channelId !== session.guildId) lines.push(`频道ID：${session.channelId}`)
       return lines.join('\n')
     })
 
-  // 备用命令入口（避免与其他插件的 schedule 命令冲突）
   ctx.command('lls', 'll-schedule 管理（备用入口）')
     .action(() => {
       logger.info('[schedule] 命令被调用: lls')
@@ -623,14 +819,17 @@ function apply(ctx, config) {
       if (!testTask.groups || !testTask.groups.length) {
         testTask.groups = session.guildId ? [String(session.guildId)] : []
       }
-      await sendTask(name, testTask, session.bot?.sid)
+      const rows = parseScheduleRows(task)
+      const day = todayDay()
+      const hit = rows.find(r => dayMatches(parseDays(r.wd), day))
+      const sendText = hit ? (hit.text || '') : (task.text || '')
+      await sendTask(name, testTask, { text: sendText, markdown: task.markdown, onlyBotSid: session.bot?.sid })
       return `✅ 已发送任务 "${name}"`
     })
 
   logger.info('[schedule] 命令已注册: schedule / schedule.list / schedule.groups / schedule.test / ' +
     `"${config.subscribeKeyword}" / "${config.unsubscribeKeyword}" / 订阅列表 / lls.*`)
 
-  // 启动时：加载已知群 + 订阅 + 立即检查一次
   Promise.all([loadKnownGroups(), loadSubs()]).then(() => checkAndSend())
 }
 

package/package.json

@@ -1,20 +1,21 @@
 {
   "name": "koishi-plugin-ll-schedule",
-  "version": "1.0.9",
-  "description": "Scheduled message sender with text/image support, works with official QQ bot",
+  "version": "1.2.0",
+  "description": "Scheduled message sender with weekly slots (per-day time & content), QQ official markdown card support",
   "main": "index.js",
   "files": [
     "index.js"
   ],
   "license": "MIT",
-  "keywords": ["koishi", "koishi-plugin", "schedule", "timer", "定时"],
+  "keywords": ["koishi", "koishi-plugin", "schedule", "timer", "定时", "markdown", "排班"],
   "peerDependencies": {
     "koishi": "^4.18.0"
   },
   "koishi": {
     "description": {
-      "zh": "定时发送插件。设置时间后自动发送文字/图片到指定群，兼容官方QQ机器人（官机）。",
-      "en": "Scheduled message sender. Auto-send text/image to groups at set times, works with official QQ bot."
+      "zh": "定时发送插件：设置时间自动发送文字/图片/QQ官方Markdown卡片到指定群，支持排班表（按星期设置不同时间与内容），兼容官方QQ机器人（官机）。",
+      "en": "Scheduled message sender. Auto-send text/image/markdown card to groups at set times, with weekly slots for per-day schedule, works with official QQ bot."
     }
   }
 }
+