koishi-plugin-ll-schedule 1.0.8 → 1.1.0

package/index.js

@@ -3,12 +3,13 @@
 // koishi-plugin-ll-schedule
 // 定时发送插件：设置时间自动向指定群发送文字
 // v1.0.6：一个任务支持多个时间（逗号分隔），群内"订阅"关键词自动注册推送群
+// v1.1.0：新增"排班表 slots"（按星期设置不同时间/内容）+ QQ官方Markdown卡片 + 模板变量
 
 const { Schema, h } = require('koishi')
 
 exports.name = 'll-schedule'
 
-exports.usage = `定时发送插件：设置时间自动向指定群发送文字。
+exports.usage = `定时发送插件：设置时间自动向指定群发送文字/卡片。
 
 ## 快速上手（推荐用法）
 
@@ -16,10 +17,55 @@ exports.usage = `定时发送插件：设置时间自动向指定群发送文字
 2. 在任意群里 @机器人 发：\`订阅 任务名\` → 这个群就加入了该任务的推送列表（自动记录，重启不丢）
 3. 到点后插件自动把内容推送到所有订阅了该任务的群
 
+## 排班表 slots（按星期设置不同的时间/内容）
+
+每个任务除了简单的 \`time\` + \`text\`，还可以填一张**排班表 \`slots\`**。每行 = 星期 + 时间 + 内容，互不影响：
+
+\`\`\`yaml
+tasks:
+  每日推送:
+    slots:
+      - time: "12:20, 18:20, 21:20"   # 时间（可多个，逗号分隔）
+        days: ""                       # 星期：留空=每天；1,2,3=周一~周三；工作日；周末；一,三,五
+        text: "这段内容在设定的星期和时间发送"
+      - time: "20:55"                  # 同一任务可加任意多行
+        days: "工作日"
+        text: "工作日晚上说的话"
+      - time: "14:55, 20:55"
+        days: "周末"
+        text: "周末说的话（周六日各发两次）"
+\`\`\`
+
+- \`days\` 填写规则：留空 = **每天**；数字 \`1\`~\`7\`（1=周一，逗号分隔如 \`1,3,5\`）；中文 \`一,三,五\`；快捷词 \`工作日\`（周一~周五）/ \`周末\`（周六日）；也支持范围 \`1-5\`
+- **任务一旦填了 slots，就完全以 slots 为准**，旧的 \`time\`/\`text\` 自动忽略（不会重复发）；不填 slots 则行为和旧版完全一样
+- 以后要加时段/改内容，直接增删改表格行即可，群订阅不用重新弄
+
+## Markdown 卡片（官方QQ机器人）
+
+任务或排班行勾选 \`markdown\` 后，推送会用 **QQ官方 Markdown 卡片**发送（仅官机生效；失败自动回退纯文本，其他平台始终纯文本）。支持标题、加粗、引用、链接、图片等：
+
+\`\`\`markdown
+# 🎉 每日公告
+
+> 今天是 **{date}**（{week}），现在是 {time}
+
+[官网点此访问](https://example.com)
+![配图](https://example.com/pic.jpg)
+\`\`\`
+
+\`text\` 中可用模板变量（发送时自动替换）：
+- \`{date}\`：今天日期（如 2026-08-23）
+- \`{time}\`：当前时间（如 12:20）
+- \`{week}\`：今天星期（如 星期三）
+- \`{task}\`：任务名
+
 ## 任务配置
 
 - \`time\`：发送时间（24小时制 HH:MM），**可填多个，用逗号分隔**，如 \`09:00, 21:30\`（一条内容会在每个时间点各发一次）
-- \`text\`：推送内容（文字，可留空）
+- \`text\`：推送内容（文字，可留空；支持 Markdown 语法和模板变量）
+- \`image\`：图片 URL（可选，随文本一起发送；markdown 模式自动嵌入为图片）
+- \`markdown\`：是否用 QQ官方 Markdown 卡片发送（默认关闭）
+- \`slots\`：排班表（可选，见上方说明；填了就以排班表为准）
 - \`groups\`：手动指定的目标群列表（**推荐留空**，用群内"订阅"命令添加更省事；留空且无订阅 = 发给所有已知群）
 - \`enabled\`：是否启用
 
@@ -28,30 +74,184 @@ exports.usage = `定时发送插件：设置时间自动向指定群发送文字
 - \`订阅 [任务名]\`：当前群订阅指定任务的推送（不填任务名时，只有一个启用任务则自动选它）
 - \`取消订阅 [任务名]\`：当前群取消订阅
 - \`订阅列表\`：查看所有任务的订阅群
-- \`schedule.list\`：查看任务列表
+- \`schedule.list\`：查看任务列表（含排班表详情）
 - \`schedule.test <任务名>\`：立即测试发送
 - \`lls.*\`：以上命令的备用入口（lls.sub / lls.unsub / lls.sublist / lls.list / lls.test）
 
-订阅/取消订阅所需权限等级在设置页 \`subscribeAuthority\` 调整（默认 1=所有人都能订阅；Koishi 的权限等级是独立的用户权限体系，与QQ群主/管理员身份无关）。
+订阅/取消订阅所需权限等级在设置页 \`subscribeAuthority\` 调整（默认 1=所有人都能订阅）。\`subscribeAdminBypass\`（默认开启）：群主/群管理可无视权限等级直接订阅——插件从群消息自带的成员角色判断（\`owner\`/\`admin\`），**不需要申请接口权限**。想验证自己角色可发 \`我的ID\`。
 
 ## 官机（官方QQ机器人）说明
 
 官方平台没有"群号"，只有 openid——用群内"订阅"命令即可，插件会自动记录当前群的 openid，无需手动填写。手动填 \`groups\` 时可用 \`schedule.groups\` 查看已知群的 openid。官机主动发群消息有平台频率限制，且机器人需在群里。
 `
 
+// ===== 纯函数（可单测） =====
+
+// 解析时间：支持多个时间，逗号/顿号/空格分隔，如 "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、工作日、周末
+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)
+}
+
+// 计算"现在这一刻该发什么"：返回 [{ name, key, text, markdown, image }]
+// date 为 Date 对象、hm 为 "HH:MM" 字符串；纯函数便于测试
+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 slots = Array.isArray(task.slots) && task.slots.length ? task.slots : null
+    if (slots) {
+      slots.forEach((slot, idx) => {
+        if (!slot || !dayMatches(parseDays(slot.days), day)) return
+        const timeList = parseTimes(slot.time)
+        if (!timeList.includes(hm)) return
+        fires.push({
+          name,
+          key: `${name}@${hm}@${idx}`,
+          text: slot.text || '',
+          markdown: slot.markdown !== undefined ? !!slot.markdown : !!task.markdown,
+          image: task.image,
+        })
+      })
+    }
+    else {
+      const timeList = parseTimes(task.time)
+      if (!timeList.includes(hm)) continue
+      fires.push({
+        name,
+        key: `${name}@${hm}`,
+        text: task.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, computeFires, renderText, buildMd, buildTextFromMd }
+
+// ===== 配置 Schema =====
+
+const TimeSlot = Schema.object({
+  time: Schema.string()
+    .required()
+    .description('发送时间（24小时制 HH:MM），可多个用逗号分隔，如 09:00, 21:30'),
+  days: Schema.string()
+    .default('')
+    .description('星期几生效：留空=每天；1-7（1=周一）逗号分隔如 1,3,5；快捷词"工作日"（周一~五）/"周末"（周六日）；中文"一,三,五"'),
+  text: Schema.string()
+    .default('')
+    .description('该时段发送的内容（文字，可留空；支持 Markdown 语法和模板变量 {date} {time} {week} {task}）'),
+  markdown: Schema.boolean()
+    .description('用 QQ官方 Markdown 卡片发送（留空则跟随任务级 markdown 设置）'),
+})
+
 const TaskItem = Schema.object({
   time: Schema.string()
     .required()
-    .description('发送时间（24小时制 HH:MM），可填多个用逗号分隔，如 09:00, 21:30'),
+    .description('发送时间（24小时制 HH:MM），可填多个用逗号分隔，如 09:00, 21:30；填了下方 slots 排班表时此项自动忽略'),
   groups: Schema.array(Schema.string())
     .default([])
     .description('手动指定的目标群 ID（可留空；推荐用群内"订阅"命令自动添加，无需手动填 openid）'),
   text: Schema.string()
     .default('')
-    .description('推送内容（文字，可留空）'),
+    .description('推送内容（文字，可留空；支持 Markdown 语法和模板变量 {date} {time} {week} {task}）'),
+  image: Schema.string()
+    .default('')
+    .description('图片 URL（可选）：随文本一起发送（markdown 模式自动嵌入为图片）'),
+  markdown: Schema.boolean()
+    .default(false)
+    .description('用 QQ官方 Markdown 卡片发送（仅官方QQ机器人生效，失败自动回退纯文本；其他平台始终纯文本）'),
   enabled: Schema.boolean()
     .default(true)
     .description('是否启用'),
+  slots: Schema.array(TimeSlot)
+    .default([])
+    .description('📅 排班表（可选）：每行=星期+时间+内容，按星期设置不同时段/内容；一旦填写就完全以排班表为准，上方 time/text 自动忽略'),
 })
 
 const Config = Schema.object({
@@ -67,6 +267,9 @@ const Config = Schema.object({
   subscribeAuthority: Schema.number()
     .min(1).max(4).default(1)
     .description('执行订阅命令所需的最低权限等级（Koishi 用户权限等级，与QQ群主/管理员身份无关；默认 1=所有人都能订阅。如需限制，先在控制台"用户管理"给指定账号提权，再调高此值）'),
+  subscribeAdminBypass: Schema.boolean()
+    .default(true)
+    .description('群主/群管理可无视上面的权限等级直接订阅（从消息自带的成员角色判断，无需申请接口权限）'),
   sendAllWhenEmpty: Schema.boolean()
     .default(true)
     .description('任务未指定群也没有群订阅时，发送给该机器人所有已知群'),
@@ -238,64 +441,74 @@ function apply(ctx, config) {
     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 }
-    }
+  // ===== 发送 =====
+  // 官机 markdown 发送时忽略的已知错误码（主动消息受限等）
+  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)
+  // 向一个目标发送一段内容；markdown 模式仅官机生效，失败自动回退纯文本
+  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
@@ -317,7 +530,7 @@ function apply(ctx, config) {
             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) {
@@ -326,7 +539,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) {
@@ -343,7 +556,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) {
@@ -357,6 +570,29 @@ function apply(ctx, config) {
     }
   }
 
+  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 })
+    }
+  }
+
   // 每 20 秒检查一次（保证同一分钟内能触发）
   const timer = setInterval(checkAndSend, 20000)
 
@@ -382,13 +618,29 @@ function apply(ctx, config) {
     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 slots = Array.isArray(t.slots) && t.slots.length ? t.slots : null
+
+      let timeStr, contentStr
+      if (slots) {
+        const lines = slots.map((sl, i) => {
+          const ds = sl.days ? `[${sl.days}]` : '[每天]'
+          const ts = parseTimes(sl.time).join(',')
+          return `  ${i + 1}. ${ds} ${ts} → ${sl.text || '(空)'}${sl.markdown || t.markdown ? ' (md卡片)' : ''}`
+        })
+        timeStr = `排班表 ${slots.length} 行`
+        contentStr = lines.join('\n')
+      }
+      else {
+        const times = parseTimes(t.time)
+        timeStr = times.length ? times.join(', ') : (t.time || '(无时间)')
+        contentStr = [t.text && '文字', t.image && '图片'].filter(Boolean).join('+') || '(空)'
+        if (t.markdown) contentStr += ' (md卡片)'
+      }
+
+      return `${s} ${k} @ ${timeStr} → ${contentStr} → 群:${target}${subCount && staticGroups ? ` +订阅${subCount}群` : ''}`
     }).join('\n')
   }
 
@@ -423,11 +675,53 @@ 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 slots = Array.isArray(task.slots) && task.slots.length ? task.slots : null
+      let sendText, sendMarkdown
+      if (slots) {
+        const day = todayDay()
+        const hit = slots.find(sl => dayMatches(parseDays(sl.days), day))
+        sendText = hit ? (hit.text || '') : (task.text || '')
+        sendMarkdown = hit ? (hit.markdown !== undefined ? !!hit.markdown : !!task.markdown) : !!task.markdown
+      }
+      else {
+        sendText = task.text || ''
+        sendMarkdown = !!task.markdown
+      }
+      await sendTask(name, testTask, { text: sendText, markdown: sendMarkdown, 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
+    if (role) return role === 'owner' || role === 'admin' || role === '1' || role === '2'
+    if (session.bot && typeof session.bot.getGuildMember === 'function') {
+      try {
+        const member = await session.bot.getGuildMember(session.guildId, session.userId)
+        const r = member?.roles?.[0]?.id
+        return r === 'owner' || r === 'admin' || r === '1' || r === '2'
+      }
+      catch (e) { /* 无接口权限等，忽略 */ }
+    }
+    return false
+  }
+
+  async function checkSubscribePerm(session) {
+    if (session.user?.authority >= config.subscribeAuthority) return true
+    if (config.subscribeAdminBypass) return await isGroupAdmin(session)
+    return false
+  }
+
+  function permDeniedHint() {
+    return '❌ 权限不足：需要 Koishi 用户权限等级 ≥ ' + config.subscribeAuthority +
+      (config.subscribeAdminBypass ? '，或为本群群主/群管理' : '')
+  }
+
   // 解析订阅命令的任务名：明确指定 → 用它；不填且只有一个启用任务 → 用它；否则返回提示
   function resolveSubscribeTaskName(taskName) {
     const tasks = config.tasks || {}
@@ -454,8 +748,16 @@ 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 slots = Array.isArray(task.slots) && task.slots.length ? task.slots : null
+    let timeDesc
+    if (slots) {
+      timeDesc = `排班表 ${slots.length} 个时段（schedule.list 查看详情）`
+    }
+    else {
+      const times = parseTimes(task.time)
+      timeDesc = times.length ? times.join(', ') : '(未设置)'
+    }
+    return `✅ 本群已加入任务 "${name}" 的推送列表\n时间：${timeDesc}\n内容：${task.text || '（空）'}`
   }
 
   async function unsubscribeCurrentGroup(session, taskName) {
@@ -472,23 +774,27 @@ function apply(ctx, config) {
     return `✅ 本群已取消订阅任务 "${name}"`
   }
 
-  ctx.command(config.subscribeKeyword + ' [taskName:text]', '让当前群订阅指定任务的推送', { authority: config.subscribeAuthority })
+  ctx.command(config.subscribeKeyword + ' [taskName:text]', '让当前群订阅指定任务的推送')
     .action(async ({ session }, taskName) => {
+      if (!(await checkSubscribePerm(session))) return permDeniedHint()
       return await subscribeCurrentGroup(session, taskName)
     })
 
-  ctx.command('lls.sub [taskName:text]', '订阅推送（备用入口）', { authority: config.subscribeAuthority })
+  ctx.command('lls.sub [taskName:text]', '订阅推送（备用入口）')
     .action(async ({ session }, taskName) => {
+      if (!(await checkSubscribePerm(session))) return permDeniedHint()
       return await subscribeCurrentGroup(session, taskName)
     })
 
-  ctx.command(config.unsubscribeKeyword + ' [taskName:text]', '让当前群取消订阅指定任务的推送', { authority: config.subscribeAuthority })
+  ctx.command(config.unsubscribeKeyword + ' [taskName:text]', '让当前群取消订阅指定任务的推送')
     .action(async ({ session }, taskName) => {
+      if (!(await checkSubscribePerm(session))) return permDeniedHint()
       return await unsubscribeCurrentGroup(session, taskName)
     })
 
-  ctx.command('lls.unsub [taskName:text]', '取消订阅（备用入口）', { authority: config.subscribeAuthority })
+  ctx.command('lls.unsub [taskName:text]', '取消订阅（备用入口）')
     .action(async ({ session }, taskName) => {
+      if (!(await checkSubscribePerm(session))) return permDeniedHint()
       return await unsubscribeCurrentGroup(session, taskName)
     })
 
@@ -526,15 +832,18 @@ function apply(ctx, config) {
       return '📋 订阅列表：\n' + lines.join('\n')
     })
 
-  ctx.command('我的ID', '查看自己的账号信息（openid/群ID）')
+  ctx.command('我的ID', '查看自己的账号信息（openid/群ID/角色）')
     .action(({ session }) => {
       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}`,
       ]
       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')
     })
@@ -542,12 +851,15 @@ function apply(ctx, config) {
   ctx.command('lls.me', '查看自己的账号信息（备用入口）')
     .action(({ session }) => {
       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}`,
       ]
       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')
     })
@@ -581,7 +893,19 @@ 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 slots = Array.isArray(task.slots) && task.slots.length ? task.slots : null
+      let sendText, sendMarkdown
+      if (slots) {
+        const day = todayDay()
+        const hit = slots.find(sl => dayMatches(parseDays(sl.days), day))
+        sendText = hit ? (hit.text || '') : (task.text || '')
+        sendMarkdown = hit ? (hit.markdown !== undefined ? !!hit.markdown : !!task.markdown) : !!task.markdown
+      }
+      else {
+        sendText = task.text || ''
+        sendMarkdown = !!task.markdown
+      }
+      await sendTask(name, testTask, { text: sendText, markdown: sendMarkdown, onlyBotSid: session.bot?.sid })
       return `✅ 已发送任务 "${name}"`
     })
 

package/package.json

@@ -1,20 +1,20 @@
 {
   "name": "koishi-plugin-ll-schedule",
-  "version": "1.0.8",
-  "description": "Scheduled message sender with text/image support, works with official QQ bot",
+  "version": "1.1.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."
     }
   }
 }