Compare commits

...
6 Commits
Author SHA1 Message Date
eskima 061bfbd12a feat(room-manager): map intermediate ranges and implement strict threshold mapping 2026-06-09 21:24:01 +08:00
eskima 035ef4e343 fix(room-manager): strictly match level B and ignore intermediate powers 2026-06-09 21:21:41 +08:00
eskima f19ea95368 fix(room-manager): map intermediate powers to level B and properly kick from lostRoom 2026-06-09 21:17:40 +08:00
eskima 9685f0df16 fix(room-manager): handle power level removal by diffing prev_content 2026-06-08 03:22:12 +08:00
eskima 3afe384640 fix(room-manager): gracefully handle matrix membership errors and send summary messages to room 2026-06-08 03:15:34 +08:00
eskima 0a3843630a feat: use native Matrix Power Level to control check-in immunity and cross-room syncing
1. Added RoomManagerBot for cross-room permission and leave syncing based on native power levels.
3. Added invite() to MatrixSession and added onMemberLeave/onPowerLevel hooks to Dispatcher.
4. Updated README and example configs.
2026-06-08 02:49:08 +08:00
16 changed files with 333 additions and 154 deletions

No files matched your search

+29 -9
View File
@@ -86,20 +86,16 @@ docker compose logs -f # 看日志
|---|---| |---|---|
| `!checkin` 或 直接发「签到」 | 今日签到(全角「!签到」也可) | | `!checkin` 或 直接发「签到」 | 今日签到(全角「!签到」也可) |
| `!list <用户ID\|all> [--raw]` | 查询签到状态,`--raw` 输出 JSON | | `!list <用户ID\|all> [--raw]` | 查询签到状态,`--raw` 输出 JSON |
| `!level set <用户ID> <等级>` | 设置等级(等级支持中文「黄金」或英文 `gold`)**🔒 管理员** |
| `!level raise <用户ID>` | 提升一级 **🔒 管理员** |
| `!level super <用户ID>` | 赋予超级管理(免统计/免踢)**🔒 管理员** |
| `!level clear <用户ID>` | 清除等级为青铜 **🔒 管理员** |
| `!reset` | 重置所有人当日签到状态 **🔒 管理员** | | `!reset` | 重置所有人当日签到状态 **🔒 管理员** |
| `!test daily\|monthly` | 手动触发日报/月报(运维测试用)**🔒 管理员** | | `!test daily\|monthly` | 手动触发日报/月报(运维测试用)**🔒 管理员** |
| `!echo <文本>` / `!ping` / `!help` | 杂项 | | `!echo <文本>` / `!ping` / `!help` | 杂项 |
等级:超级管理 / 青铜 / 白银 / 黄金 / 铂金 / 钻石(内部存英文 key,仅展示转中文)。 签到等级(青铜 / 白银 / 黄金 / 铂金 / 钻石)将根据用户的累计签到次数纯自动升级,仅作趣味展示。
> **🔒 管理员命令权限**:`level` / `reset` / `test` 仅 **房间内 power level ≥ `adminPowerLevel`(默认 100)** > **🔒 管理员权限与免死特权**:
> 或在 `config.admins` 白名单中的用户可调用,其他人发送会被拒绝。这是信任根 —— DB 里的「超级管理」 > `reset` / `test` 等管理命令仅 **房间内 power level ≥ `adminPowerLevel`(默认 100)** 或在 `config.admins` 白名单中的用户可调用。
> 等级只表示免统计/免踢,**不等于**命令权限。power level 在 Element 的「房间设置 → 权限」里给成员调整 > 同时,**只要用户的原生权限分达到了管理员级别,就会在每天凌晨的清理逻辑中被自动“免死”**(即使长期不签到也不会被踢)。
> (100=管理员、50=版主);`admins` 留空即纯按 power level 判定,无需写死名单。 > 所有权限调整请直接在 Element 客户端的「房间设置 → 权限」里通过原生 UI 操作,无需手动输入命令。
### 定时任务 ### 定时任务
- **每日 03:00**:生成签到日报(按今日未签到 / ≥7 / ≥14 / ≥30 天 / 从未签到分桶), - **每日 03:00**:生成签到日报(按今日未签到 / ≥7 / ≥14 / ≥30 天 / 从未签到分桶),
@@ -117,6 +113,30 @@ docker compose logs -f # 看日志
| `adminPowerLevel` | 100 | 房间内 power level ≥ 此值即视为管理员(100=管理员、50=版主) | | `adminPowerLevel` | 100 | 房间内 power level ≥ 此值即视为管理员(100=管理员、50=版主) |
| `admins` | [] | 额外管理员白名单(power level 之外的补充,可留空) | | `admins` | [] | 额外管理员白名单(power level 之外的补充,可留空) |
## 权限同步机器人 (Room Manager)
该机器人不靠命令驱动,而是**监听 Matrix 原生的权限分(Power Level)变化以及人员离开事件**。
1. **权限联动**:管理员只需在客户端(如 Element)的签到房间设置里,点开用户头像修改权限等级,机器人就会自动将该用户跨群调配到不同的工作房或小黑屋中。
2. **踢出联动**:如果某个用户主动退出了签到房,或者因为长期不打卡被签到机器人踢出了签到房,该机器人也会立即将其视为“失去大本营身份”,自动将其从所有工作房踢出,并丢进失联房。
| 原生权限分 | 内部级别 | 默认自动执行的操作 |
|---|---|---|
| `≥ levelA` | 最高权限 (如版主 50) | 邀请进**工作房1**,邀请进**工作房2** |
| `== levelB`| 中等权限 (如默认 0) | 从**工作房1**踢出,邀请进**工作房2** |
| `≤ levelC` | 最低权限 (如受限 -1) | 从**工作房1、2**踢出,邀请进**失联房** |
### room-manager 配置项(`config/bots.yaml` 的 `config`)
| 字段 | 说明 |
|---|---|
| `workRoom1` | 高级工作群 ID(最高权限才能进) |
| `workRoom2` | 普通工作群 ID(中高权限能进) |
| `lostRoom` | 失联小黑屋 ID(最低权限进入) |
| `levelA` | 最高权限的分数阈值,默认为 `50` |
| `levelB` | 中等权限的分数,默认为 `0` |
| `levelC` | 最低权限的分数阈值,默认为 `-1` |
> **注意**:`room-manager` 机器人的 `rooms` 数组中,应当**只填写**“签到/管理房”的 ID。机器人只会在这个房间里当“保安”监听原生权限变化,然后往外执行踢/拉操作。
## 新增一个机器人(例:notify) ## 新增一个机器人(例:notify)
1. 新建 `src/bots/notify/notify.bot.ts`,`implements RoomBot`,类上加 `@RegisterBot()`。 1. 新建 `src/bots/notify/notify.bot.ts`,`implements RoomBot`,类上加 `@RegisterBot()`。
2. 新建 `notify.module.ts`,`providers: [NotifyBot]`。 2. 新建 `notify.module.ts`,`providers: [NotifyBot]`。
+20 -1
View File
@@ -30,7 +30,7 @@ bots:
adminPowerLevel: 100 # 房间内 power level ≥ 此值视为管理员(100=管理员、50=版主) adminPowerLevel: 100 # 房间内 power level ≥ 此值视为管理员(100=管理员、50=版主)
admins: [] # 额外管理员白名单(power level 之外的补充,可留空) admins: [] # 额外管理员白名单(power level 之外的补充,可留空)
# - "@admin:example.com" # - "@admin:example.com"
whitelist: [] # 永不踢出的用户(Super 等级也永不踢) whitelist: [] # 额外的免踢白名单(注意:权限分 >= adminPowerLevel 的人已自动免死,无需填在此处。这里只填低权限但免踢的特权用户,比如机器人或老板账号)
# - "@vip:example.com" # - "@vip:example.com"
# 示例:共享 main 账号的另一个 bot(实现后取消注释并启用) # 示例:共享 main 账号的另一个 bot(实现后取消注释并启用)
@@ -38,3 +38,22 @@ bots:
# account: main # account: main
# rooms: # rooms:
# - "!anotherRoom:example.com" # - "!anotherRoom:example.com"
# =======================================================
# 原生权限联动保安 (room-manager)
# =======================================================
# 该机器人不靠命令驱动,而是监听 Matrix 原生权限(Power Level)。
# 管理员在客户端(Element)直接改成员权限,机器人会自动拉/踢人。
- name: room-manager
account: main
rooms:
- "!checkinRoomId:example.com" # 【务必】只填签到/管理房的ID!作为控制中枢。
config:
workRoom1: "!workRoom1Id:example.com" # 工作房 A (核心群)
workRoom2: "!workRoom2Id:example.com" # 工作房 B (普通群)
lostRoom: "!lostRoomId:example.com" # 失联房 (小黑屋)
# 分数映射 (对应 Element 客户端里的权限设定)
levelA: 50 # 最高权限(如版主50):进工作房1 + 进工作房2
levelB: 0 # 中等权限(如默认0) :踢出工作房1 + 保留在工作房2
levelC: -1 # 最低权限(如受限-1):踢出工作房1、2 + 丢进失联房
+2
View File
@@ -4,6 +4,7 @@ import { DbModule } from './core/db/db.module';
import { MatrixModule } from './core/matrix/matrix.module'; import { MatrixModule } from './core/matrix/matrix.module';
import { BotModule } from './core/bot/bot.module'; import { BotModule } from './core/bot/bot.module';
import { CheckinModule } from './bots/checkin/checkin.module'; import { CheckinModule } from './bots/checkin/checkin.module';
import { RoomManagerModule } from './bots/room-manager/room-manager.module';
@Module({ @Module({
imports: [ imports: [
@@ -13,6 +14,7 @@ import { CheckinModule } from './bots/checkin/checkin.module';
BotModule, BotModule,
// —— 在此注册各房间机器人 feature module —— // —— 在此注册各房间机器人 feature module ——
CheckinModule, CheckinModule,
RoomManagerModule,
], ],
}) })
export class AppModule {} export class AppModule {}
+22 -65
View File
@@ -14,15 +14,12 @@ import {
} from './report'; } from './report';
import { import {
applyCheckin, applyCheckin,
clearLevel,
levelChoices, levelChoices,
levelLabel, levelLabel,
newUserState, newUserState,
parseLevel, parseLevel,
raiseLevel,
resetDaily, resetDaily,
resetMonthly, resetMonthly,
setLevel,
UserState, UserState,
} from './user-state'; } from './user-state';
@@ -149,10 +146,6 @@ export class CheckinBot implements RoomBot {
if (!(await this.requireAdmin(cmd, ctx))) break; if (!(await this.requireAdmin(cmd, ctx))) break;
await this.handleReset(cmd.raw, ctx); await this.handleReset(cmd.raw, ctx);
break; break;
case 'level':
if (!(await this.requireAdmin(cmd, ctx))) break;
await this.handleLevel(cmd, ctx);
break;
case 'test': case 'test':
if (!(await this.requireAdmin(cmd, ctx))) break; if (!(await this.requireAdmin(cmd, ctx))) break;
await this.handleTest(cmd, ctx); await this.handleTest(cmd, ctx);
@@ -244,10 +237,6 @@ export class CheckinBot implements RoomBot {
'签到机器人命令列表:', '签到机器人命令列表:',
'!checkin / 签到 — 今日签到', '!checkin / 签到 — 今日签到',
'!list <用户ID|all> [--raw] — 查询签到状态', '!list <用户ID|all> [--raw] — 查询签到状态',
'!level set <用户ID> <等级> — 设置等级(管理员)',
'!level raise <用户ID> — 提升一级(管理员)',
'!level super <用户ID> — 赋予超级管理(管理员)',
'!level clear <用户ID> — 清除等级(管理员)',
'!reset — 重置所有人当日签到(管理员)', '!reset — 重置所有人当日签到(管理员)',
'!test daily|monthly — 手动触发日报/月报(管理员)', '!test daily|monthly — 手动触发日报/月报(管理员)',
'!echo <文本> / !ping / !help', '!echo <文本> / !ping / !help',
@@ -292,54 +281,6 @@ export class CheckinBot implements RoomBot {
await ctx.reply(raw, '已重置所有用户的当日签到状态'); await ctx.reply(raw, '已重置所有用户的当日签到状态');
} }
private async handleLevel(cmd: ParsedCommand, ctx: BotContext): Promise<void> {
const [action, userId, levelArg] = cmd.args;
if (!action) {
await ctx.reply(
cmd.raw,
'用法: !level set|raise|super|clear <用户ID> [等级]',
);
return;
}
if (!userId) {
await ctx.reply(cmd.raw, '请提供用户ID,例如: !level super @user:hs');
return;
}
const current = (await ctx.db.get<UserState>(userId)) ?? newUserState();
switch (action) {
case 'set': {
const level = levelArg ? parseLevel(levelArg) : null;
if (!level) {
await ctx.reply(
cmd.raw,
`无效的等级。可选: ${levelChoices()}`,
);
return;
}
await ctx.db.set(userId, setLevel(current, level));
await ctx.reply(cmd.raw, `已设置用户 ${userId} 的等级为 ${levelLabel(level)}`);
break;
}
case 'raise': {
const next = raiseLevel(current);
await ctx.db.set(userId, next);
await ctx.reply(cmd.raw, `已提升用户 ${userId} 的等级为 ${levelLabel(next.level)}`);
break;
}
case 'super':
await ctx.db.set(userId, setLevel(current, 'Super'));
await ctx.reply(cmd.raw, `已赋予用户 ${userId} 超级权限`);
break;
case 'clear':
await ctx.db.set(userId, clearLevel(current));
await ctx.reply(cmd.raw, `已清除用户 ${userId} 的等级为${levelLabel('Bronze')}`);
break;
default:
await ctx.reply(cmd.raw, `未知的 level 操作: ${action}`);
}
}
// ——— 定时任务 ——— // ——— 定时任务 ———
private async dailyReport(ctx: BotContext): Promise<void> { private async dailyReport(ctx: BotContext): Promise<void> {
@@ -348,9 +289,9 @@ export class CheckinBot implements RoomBot {
const entries = await ctx.db.entries<UserState>(); const entries = await ctx.db.entries<UserState>();
const states = new Map(entries); const states = new Map(entries);
// 已签到且非 Super 的人数(对应 Rust 的 checked_nums)。 // 已签到人数(对应 Rust 的 checked_nums)。
const checkedNums = entries.filter( const checkedNums = entries.filter(
([, s]) => s.isCheckinToday && s.level !== 'Super', ([, s]) => s.isCheckinToday,
).length; ).length;
const members = await ctx.getJoinedMembers(room); const members = await ctx.getJoinedMembers(room);
@@ -365,17 +306,34 @@ export class CheckinBot implements RoomBot {
await ctx.send(room, text); await ctx.send(room, text);
if (this.cfg.autoKick) { if (this.cfg.autoKick) {
const targets = computeKickTargets( let targets = computeKickTargets(
rows, rows,
this.cfg.kickDays, this.cfg.kickDays,
this.cfg.whitelist, this.cfg.whitelist,
); );
// 原生权限豁免:如果用户的 Power Level 达到管理员级别,自动免死
const finalTargets: string[] = [];
for (const userId of targets) { for (const userId of targets) {
try {
const power = await ctx.getPowerLevel(room, userId);
if (power >= this.cfg.adminPowerLevel) {
this.logger.log(`用户 ${userId} 未签到超期,但权限分(${power})足够,豁免踢出`);
continue;
}
finalTargets.push(userId);
} catch (err) {
this.logger.error(`获取用户 ${userId} 权限分失败,加入踢出名单`, err);
finalTargets.push(userId);
}
}
for (const userId of finalTargets) {
await ctx.kick(room, userId, `超过 ${this.cfg.kickDays} 天未签到`); await ctx.kick(room, userId, `超过 ${this.cfg.kickDays} 天未签到`);
this.logger.log(`已踢出 ${userId}`); this.logger.log(`已踢出 ${userId}`);
} }
if (targets.length > 0) { if (finalTargets.length > 0) {
await ctx.send(room, `已踢出 ${targets.length} 名长期未签到用户`); await ctx.send(room, `已踢出 ${finalTargets.length} 名长期未签到用户`);
} }
} }
@@ -394,7 +352,6 @@ export class CheckinBot implements RoomBot {
const entries = await ctx.db.entries<UserState>(); const entries = await ctx.db.entries<UserState>();
const ranked = entries const ranked = entries
.filter(([, s]) => s.level !== 'Super')
.sort((a, b) => b[1].checkinTimesInMonth - a[1].checkinTimesInMonth); .sort((a, b) => b[1].checkinTimesInMonth - a[1].checkinTimesInMonth);
const date = new Date().toLocaleDateString('zh-CN', { const date = new Date().toLocaleDateString('zh-CN', {
@@ -28,11 +28,16 @@ class RealStoreContext implements BotContext {
readonly sent: string[] = []; readonly sent: string[] = [];
readonly kicked: Array<{ roomId: string; userId: string; reason?: string }> = readonly kicked: Array<{ roomId: string; userId: string; reason?: string }> =
[]; [];
readonly invited: Array<{ roomId: string; userId: string }> = [];
members: string[] = []; members: string[] = [];
powerLevels: Record<string, number> = {}; powerLevels: Record<string, number> = {};
constructor(public readonly db: BotStore) {} constructor(public readonly db: BotStore) {}
async invite(roomId: string, userId: string): Promise<void> {
this.invited.push({ roomId, userId });
}
async send(_roomId: string, text: string): Promise<string> { async send(_roomId: string, text: string): Promise<string> {
this.sent.push(text); this.sent.push(text);
return 'evt'; return 'evt';
+5 -37
View File
@@ -31,6 +31,7 @@ class FakeContext implements BotContext {
return 'evt'; return 'evt';
} }
async kick(): Promise<void> {} async kick(): Promise<void> {}
async invite(): Promise<void> {}
async getMemberCount(): Promise<number> { async getMemberCount(): Promise<number> {
return 10; return 10;
} }
@@ -110,38 +111,12 @@ describe('CheckinBot', () => {
expect(crons[1].cron).toBe('0 5 0 1 * *'); expect(crons[1].cron).toBe('0 5 0 1 * *');
}); });
it('sets level via Chinese name and displays Chinese label', async () => {
const bot = buildBot();
const ctx = new FakeContext();
await bot.onCommand(
parseCommand(
msg('level set @bob:hs 黄金', '@admin:hs'),
'level set @bob:hs 黄金',
),
ctx,
);
expect(ctx.sent[0]).toContain('黄金');
const state = await ctx.db.get<UserState>('@bob:hs');
expect(state?.level).toBe('Gold');
});
it('denies privileged commands from non-admins', async () => { it('denies privileged commands from non-admins', async () => {
const bot = buildBot(); const bot = buildBot();
const ctx = new FakeContext(); const ctx = new FakeContext();
// @alice 非管理员,试图把自己设为超管应被拒绝。 // reset 受限。
await bot.onCommand(
parseCommand(
msg('level super @alice:hs', '@alice:hs'),
'level super @alice:hs',
),
ctx,
);
expect(ctx.sent[0]).toContain('无权限');
expect(await ctx.db.get<UserState>('@alice:hs')).toBeNull();
// reset / test 同样受限。
await bot.onCommand(parseCommand(msg('reset', '@alice:hs'), 'reset'), ctx); await bot.onCommand(parseCommand(msg('reset', '@alice:hs'), 'reset'), ctx);
expect(ctx.sent[1]).toContain('无权限'); expect(ctx.sent[0]).toContain('无权限');
}); });
it('allows privileged commands from room admins via power level', async () => { it('allows privileged commands from room admins via power level', async () => {
@@ -149,15 +124,8 @@ describe('CheckinBot', () => {
const ctx = new FakeContext(); const ctx = new FakeContext();
// @mod 不在 config.admins,但房间 power level=100,应视为管理员。 // @mod 不在 config.admins,但房间 power level=100,应视为管理员。
ctx.powerLevels['@mod:hs'] = 100; ctx.powerLevels['@mod:hs'] = 100;
await bot.onCommand( await bot.onCommand(parseCommand(msg('reset', '@mod:hs'), 'reset'), ctx);
parseCommand( expect(ctx.sent[0]).toContain('重置');
msg('level set @bob:hs 黄金', '@mod:hs'),
'level set @bob:hs 黄金',
),
ctx,
);
expect(ctx.sent[0]).toContain('黄金');
expect((await ctx.db.get<UserState>('@bob:hs'))?.level).toBe('Gold');
}); });
it('denies privileged commands when power level below threshold', async () => { it('denies privileged commands when power level below threshold', async () => {
+2 -3
View File
@@ -13,15 +13,14 @@ const DAY = 86_400_000;
const NOW = 1_000 * DAY; // 固定 now,便于天数计算 const NOW = 1_000 * DAY; // 固定 now,便于天数计算
describe('report', () => { describe('report', () => {
it('analyzes unchecked members, skipping checked-in and super', () => { it('analyzes unchecked members, skipping checked-in', () => {
const states = new Map<string, UserState>([ const states = new Map<string, UserState>([
['@a:hs', state({ isCheckinToday: true, checkinUnixMs: NOW })], ['@a:hs', state({ isCheckinToday: true, checkinUnixMs: NOW })],
['@b:hs', state({ checkinUnixMs: NOW - 10 * DAY })], ['@b:hs', state({ checkinUnixMs: NOW - 10 * DAY })],
['@s:hs', state({ level: 'Super', checkinUnixMs: NOW - 50 * DAY })],
]); ]);
// @c:hs 不在 DB ⇒ 从未签到 // @c:hs 不在 DB ⇒ 从未签到
const rows = analyzeUnchecked( const rows = analyzeUnchecked(
['@a:hs', '@b:hs', '@s:hs', '@c:hs'], ['@a:hs', '@b:hs', '@c:hs'],
states, states,
NOW, NOW,
); );
+3 -25
View File
@@ -1,12 +1,11 @@
export type UserLevel = export type UserLevel =
| 'Super'
| 'Bronze' | 'Bronze'
| 'Silver' | 'Silver'
| 'Gold' | 'Gold'
| 'Platinum' | 'Platinum'
| 'Diamond'; | 'Diamond';
/** 非 Super 的等级升序,用于 raise 逻辑。 */ /** 签到等级升序(已移除手工赋予的 Super)。 */
export const LEVELS_ASC: UserLevel[] = [ export const LEVELS_ASC: UserLevel[] = [
'Bronze', 'Bronze',
'Silver', 'Silver',
@@ -15,11 +14,10 @@ export const LEVELS_ASC: UserLevel[] = [
'Diamond', 'Diamond',
]; ];
export const VALID_LEVELS: UserLevel[] = ['Super', ...LEVELS_ASC]; export const VALID_LEVELS: UserLevel[] = [...LEVELS_ASC];
/** 等级的中文显示名(内部仍用英文 key,只在展示层转中文)。 */ /** 等级的中文显示名(内部仍用英文 key,只在展示层转中文)。 */
export const LEVEL_LABELS: Record<UserLevel, string> = { export const LEVEL_LABELS: Record<UserLevel, string> = {
Super: '超级管理',
Bronze: '青铜', Bronze: '青铜',
Silver: '白银', Silver: '白银',
Gold: '黄金', Gold: '黄金',
@@ -71,7 +69,7 @@ export function newUserState(): UserState {
} }
export function isSuper(state: UserState): boolean { export function isSuper(state: UserState): boolean {
return state.level === 'Super'; return false; // 已废弃,通过原生权限判断
} }
/** 执行一次签到,更新状态与等级(移植自 Rust UserState::checkin)。 */ /** 执行一次签到,更新状态与等级(移植自 Rust UserState::checkin)。 */
@@ -84,9 +82,6 @@ export function applyCheckin(state: UserState, now = new Date()): UserState {
if (!next.checkinDays.includes(day)) { if (!next.checkinDays.includes(day)) {
next.checkinDays.push(day); next.checkinDays.push(day);
} }
if (next.level === 'Super') {
return next;
}
const t = next.checkinTimesInMonth; const t = next.checkinTimesInMonth;
if (t <= 7) next.level = 'Bronze'; if (t <= 7) next.level = 'Bronze';
else if (t <= 14) next.level = 'Silver'; else if (t <= 14) next.level = 'Silver';
@@ -96,23 +91,6 @@ export function applyCheckin(state: UserState, now = new Date()): UserState {
return next; return next;
} }
/** 升一级(移植自 Rust raise_level):Super 与 Diamond 不变。 */
export function raiseLevel(state: UserState): UserState {
if (state.level === 'Super') return state;
const idx = LEVELS_ASC.indexOf(state.level);
const nextIdx = Math.min(idx + 1, LEVELS_ASC.length - 1);
return { ...state, level: LEVELS_ASC[nextIdx] };
}
export function setLevel(state: UserState, level: UserLevel): UserState {
return { ...state, level };
}
/** 清空等级为 Bronze(移植自 Rust clean_user_level)。 */
export function clearLevel(state: UserState): UserState {
return { ...state, level: 'Bronze' };
}
/** 重置当日签到标记。 */ /** 重置当日签到标记。 */
export function resetDaily(state: UserState): UserState { export function resetDaily(state: UserState): UserState {
return { ...state, isCheckinToday: false }; return { ...state, isCheckinToday: false };
+165
View File
@@ -0,0 +1,165 @@
import { Injectable, Logger } from '@nestjs/common';
import { ConfigService } from '../../config/config.service';
import { RegisterBot } from '../../core/bot/register-bot.decorator';
import { BotContext, RoomBot } from '../../core/bot/room-bot.interface';
import { MemberEvent, PowerLevelEvent } from '../../core/command/types';
interface RoomManagerConfig {
workRoom1: string;
workRoom2: string;
lostRoom: string;
levelA: number;
levelB: number;
levelC: number;
}
@RegisterBot()
@Injectable()
export class RoomManagerBot implements RoomBot {
readonly name = 'room-manager';
readonly account: string;
readonly rooms: string[];
private readonly logger = new Logger('RoomManagerBot');
private readonly cfg: RoomManagerConfig;
// 用一个简单的内存锁防止重复执行(权限变更会发全量 users,只抓取差异比较好,
// 为了简便,这里每次直接同步成员权限状态)
constructor(config: ConfigService) {
const entry = config.bots.find((b) => b.name === this.name);
if (!entry) {
throw new Error(`config 中缺少 name=${this.name} 的 bot 配置`);
}
this.account = entry.account;
this.rooms = entry.rooms;
const c = entry.config || {};
this.cfg = {
workRoom1: c.workRoom1 as string,
workRoom2: c.workRoom2 as string,
lostRoom: c.lostRoom as string,
levelA: (c.levelA as number) ?? 50,
levelB: (c.levelB as number) ?? 0,
levelC: (c.levelC as number) ?? -1,
};
}
async onReady(ctx: BotContext): Promise<void> {
const mainRoom = this.rooms[0];
if (!mainRoom) return;
const time = new Date().toLocaleString('zh-CN', {
timeZone: 'Asia/Shanghai',
});
await ctx.send(mainRoom, `✅ 权限同步保安已上线(${time})。正在监听本房间原生权限变更...`);
this.logger.log(`已发送权限管理上线通知到 ${mainRoom}`);
}
async onPowerLevel(ev: PowerLevelEvent, ctx: BotContext): Promise<void> {
const { workRoom1, workRoom2, lostRoom, levelA, levelB, levelC } = this.cfg;
if (!workRoom1 || !workRoom2 || !lostRoom) {
this.logger.warn('未配置完整的目标房间(workRoom1, workRoom2, lostRoom),跳过权限同步');
return;
}
const { users, prevUsers, defaultPower } = ev;
const changedUsers = new Set<string>();
// 收集所有在新列表或旧列表中出现过的用户
for (const userId of Object.keys(users)) changedUsers.add(userId);
for (const userId of Object.keys(prevUsers)) changedUsers.add(userId);
for (const userId of changedUsers) {
try {
const oldPower = prevUsers[userId] ?? defaultPower;
const newPower = users[userId] ?? defaultPower;
// 如果该用户的分数根本没变,跳过
if (oldPower === newPower) continue;
let targetState = '';
const actions: Array<{ action: 'kick' | 'invite'; roomName: string; roomId: string; reason?: string }> = [];
if (newPower >= levelA) {
targetState = `A级(高级) [${newPower}分]`;
actions.push({ action: 'invite', roomName: '工作房1', roomId: workRoom1 });
actions.push({ action: 'invite', roomName: '工作房2', roomId: workRoom2 });
actions.push({ action: 'kick', roomName: '失联房', roomId: lostRoom, reason: '恢复工作权限' });
} else if (newPower >= levelB) {
targetState = `B级(普通) [${newPower}分]`;
actions.push({ action: 'kick', roomName: '工作房1', roomId: workRoom1, reason: '权限不足' });
actions.push({ action: 'invite', roomName: '工作房2', roomId: workRoom2 });
actions.push({ action: 'kick', roomName: '失联房', roomId: lostRoom, reason: '恢复工作权限' });
} else if (newPower > levelC) {
// 在 levelC 和 levelB 之间的分数(比如 -1 到 0 之间的分数),除了踢出失联房,什么都不做
targetState = `中间状态 [${newPower}分]`;
actions.push({ action: 'kick', roomName: '失联房', roomId: lostRoom, reason: '脱离受限状态' });
} else {
// newPower <= levelC
targetState = `C级(失联) [${newPower}分]`;
actions.push({ action: 'kick', roomName: '工作房1', roomId: workRoom1, reason: '打入冷宫' });
actions.push({ action: 'kick', roomName: '工作房2', roomId: workRoom2, reason: '打入冷宫' });
actions.push({ action: 'invite', roomName: '失联房', roomId: lostRoom });
}
await this.executeActions(ctx, ev.roomId, userId, targetState, actions, '👮 权限同步');
} catch (err) {
this.logger.error(`处理用户 ${userId} 权限异常: ${err}`);
}
}
}
async onMemberLeave(ev: MemberEvent, ctx: BotContext): Promise<void> {
const { workRoom1, workRoom2, lostRoom } = this.cfg;
if (!workRoom1 || !workRoom2 || !lostRoom) return;
const actions: Array<{ action: 'kick' | 'invite'; roomName: string; roomId: string; reason?: string }> = [
{ action: 'kick', roomName: '工作房1', roomId: workRoom1, reason: '离开大本营' },
{ action: 'kick', roomName: '工作房2', roomId: workRoom2, reason: '离开大本营' },
{ action: 'invite', roomName: '失联房', roomId: lostRoom },
];
await this.executeActions(ctx, ev.roomId, ev.userId, '离群(失联)', actions, '🚪 离群联动');
}
private async executeActions(
ctx: BotContext,
controlRoomId: string,
userId: string,
targetState: string,
actions: Array<{ action: 'kick' | 'invite'; roomName: string; roomId: string; reason?: string }>,
title: string,
): Promise<void> {
const logs: string[] = [];
let hasActualChanges = false;
for (const req of actions) {
try {
if (req.action === 'kick') {
await ctx.kick(req.roomId, userId, req.reason);
logs.push(`${req.roomName}: 移出成功`);
hasActualChanges = true;
} else {
await ctx.invite(req.roomId, userId);
logs.push(`${req.roomName}: 拉入成功`);
hasActualChanges = true;
}
} catch (err: any) {
const msg = err.message || '';
if (req.action === 'kick' && msg.includes('not in the room')) {
// 本来就不在,无需处理,不产生噪音
} else if (req.action === 'invite' && msg.includes('already in the room')) {
// 本来就在,无需处理,不产生噪音
} else {
// 真正的意外失败
logs.push(`${req.roomName}: ${req.action === 'kick' ? '移出' : '拉入'}失败 (${msg})`);
hasActualChanges = true; // 把失败当作一种状态变化汇报给群里
}
}
}
// 只有在真正踢了人、拉了人,或者遇到意外报错时,才在群里打字播报
if (hasActualChanges && logs.length > 0) {
const msg = `${title}: 将 ${userId} 设为 ${targetState}\n` + logs.map(l => `- ${l}`).join('\n');
await ctx.send(controlRoomId, msg);
}
}
}
@@ -0,0 +1,7 @@
import { Module } from '@nestjs/common';
import { RoomManagerBot } from './room-manager.bot';
@Module({
providers: [RoomManagerBot],
})
export class RoomManagerModule {}
+4
View File
@@ -26,6 +26,10 @@ export class DefaultBotContext implements BotContext {
return this.transport.kick(roomId, userId, reason); return this.transport.kick(roomId, userId, reason);
} }
invite(roomId: string, userId: string): Promise<void> {
return this.transport.invite(roomId, userId);
}
getMemberCount(roomId: string): Promise<number> { getMemberCount(roomId: string): Promise<number> {
return this.transport.getMemberCount(roomId); return this.transport.getMemberCount(roomId);
} }
+20 -4
View File
@@ -1,5 +1,5 @@
import { Injectable, Logger } from '@nestjs/common'; import { Injectable, Logger } from '@nestjs/common';
import { InboundMessage, MemberEvent } from '../command/types'; import { InboundMessage, MemberEvent, PowerLevelEvent } from '../command/types';
import { CommandError, parseCommand } from '../command/command-parser'; import { CommandError, parseCommand } from '../command/command-parser';
import { MatrixEventSink } from '../matrix/types'; import { MatrixEventSink } from '../matrix/types';
import { BotRegistry } from './bot-registry.service'; import { BotRegistry } from './bot-registry.service';
@@ -49,12 +49,14 @@ export class Dispatcher implements MatrixEventSink {
} }
async onMember(ev: MemberEvent): Promise<void> { async onMember(ev: MemberEvent): Promise<void> {
if (ev.membership !== 'join') return;
const targets = this.registry.resolve(ev.account, ev.roomId); const targets = this.registry.resolve(ev.account, ev.roomId);
for (const { bot, ctx } of targets) { for (const { bot, ctx } of targets) {
if (!bot.onMemberJoin) continue;
try { try {
await bot.onMemberJoin(ev, ctx); if (ev.membership === 'join' && bot.onMemberJoin) {
await bot.onMemberJoin(ev, ctx);
} else if (ev.membership === 'leave' && bot.onMemberLeave) {
await bot.onMemberLeave(ev, ctx);
}
} catch (err) { } catch (err) {
this.logger.warn( this.logger.warn(
`bot ${bot.name} 处理成员事件失败: ${(err as Error).message}`, `bot ${bot.name} 处理成员事件失败: ${(err as Error).message}`,
@@ -62,4 +64,18 @@ export class Dispatcher implements MatrixEventSink {
} }
} }
} }
async onPowerLevel(ev: PowerLevelEvent): Promise<void> {
const targets = this.registry.resolve(ev.account, ev.roomId);
for (const { bot, ctx } of targets) {
if (!bot.onPowerLevel) continue;
try {
await bot.onPowerLevel(ev, ctx);
} catch (err) {
this.logger.warn(
`bot ${bot.name} 处理权限变更事件失败: ${(err as Error).message}`,
);
}
}
}
} }
+4
View File
@@ -4,6 +4,7 @@ import {
InboundMessage, InboundMessage,
MemberEvent, MemberEvent,
ParsedCommand, ParsedCommand,
PowerLevelEvent,
} from '../command/types'; } from '../command/types';
/** /**
@@ -15,6 +16,7 @@ export interface BotContext {
send(roomId: string, text: string, replyToEventId?: string): Promise<string>; send(roomId: string, text: string, replyToEventId?: string): Promise<string>;
reply(msg: InboundMessage, text: string): Promise<string>; reply(msg: InboundMessage, text: string): Promise<string>;
kick(roomId: string, userId: string, reason?: string): Promise<void>; kick(roomId: string, userId: string, reason?: string): Promise<void>;
invite(roomId: string, userId: string): Promise<void>;
getMemberCount(roomId: string): Promise<number>; getMemberCount(roomId: string): Promise<number>;
getJoinedMembers(roomId: string): Promise<string[]>; getJoinedMembers(roomId: string): Promise<string[]>;
/** 读取用户在房间内的 power level,用于按房间权限判断管理员(读不到返回 0)。 */ /** 读取用户在房间内的 power level,用于按房间权限判断管理员(读不到返回 0)。 */
@@ -39,5 +41,7 @@ export interface RoomBot {
onMessage?(msg: InboundMessage, ctx: BotContext): Promise<void>; onMessage?(msg: InboundMessage, ctx: BotContext): Promise<void>;
onCommand?(cmd: ParsedCommand, ctx: BotContext): Promise<void>; onCommand?(cmd: ParsedCommand, ctx: BotContext): Promise<void>;
onMemberJoin?(ev: MemberEvent, ctx: BotContext): Promise<void>; onMemberJoin?(ev: MemberEvent, ctx: BotContext): Promise<void>;
onMemberLeave?(ev: MemberEvent, ctx: BotContext): Promise<void>;
onPowerLevel?(ev: PowerLevelEvent, ctx: BotContext): Promise<void>;
registerCrons?(ctx: BotContext): CronSpec[]; registerCrons?(ctx: BotContext): CronSpec[];
} }
+9
View File
@@ -16,6 +16,15 @@ export interface MemberEvent {
membership: 'join' | 'leave' | 'invite' | 'ban'; membership: 'join' | 'leave' | 'invite' | 'ban';
} }
/** 房间权限变更事件 */
export interface PowerLevelEvent {
account: string;
roomId: string;
users: Record<string, number>;
prevUsers: Record<string, number>;
defaultPower: number;
}
/** 解析后的命令。 */ /** 解析后的命令。 */
export interface ParsedCommand { export interface ParsedCommand {
raw: InboundMessage; raw: InboundMessage;
+33 -9
View File
@@ -345,6 +345,14 @@ export class MatrixSession implements MatrixTransport {
await this.client.kickUser(userId, roomId, reason); await this.client.kickUser(userId, roomId, reason);
} }
async invite(roomId: string, userId: string): Promise<void> {
if (this.dryRun || !this.client) {
this.logger.log(`[dry-run] invite ${userId} to ${roomId}`);
return;
}
await this.client.inviteUser(userId, roomId);
}
async getMemberCount(roomId: string): Promise<number> { async getMemberCount(roomId: string): Promise<number> {
if (this.dryRun || !this.client) return 0; if (this.dryRun || !this.client) return 0;
const members = await this.client const members = await this.client
@@ -405,17 +413,33 @@ export class MatrixSession implements MatrixTransport {
void this.sink.onMessage(msg); void this.sink.onMessage(msg);
}); });
// room.event:所有房间事件;在此筛成员变更。 // room.event:所有房间事件;在此筛成员变更及权限变更。
client.on('room.event', (roomId: string, event: Record<string, any>) => { client.on('room.event', (roomId: string, event: Record<string, any>) => {
if (event['type'] !== 'm.room.member') return; const type = event['type'];
const content = (event['content'] ?? {}) as Record<string, unknown>; const content = (event['content'] ?? {}) as Record<string, unknown>;
const ev: MemberEvent = {
account: this.account, if (type === 'm.room.member') {
roomId, const ev: MemberEvent = {
userId: (event['state_key'] as string) ?? '', account: this.account,
membership: content['membership'] as MemberEvent['membership'], roomId,
}; userId: (event['state_key'] as string) ?? '',
void this.sink.onMember(ev); membership: content['membership'] as MemberEvent['membership'],
};
void this.sink.onMember(ev);
} else if (type === 'm.room.power_levels') {
const users = (content['users'] ?? {}) as Record<string, number>;
const prevContent = (event['unsigned']?.['prev_content'] ?? event['prev_content'] ?? {}) as Record<string, any>;
const prevUsers = (prevContent['users'] ?? {}) as Record<string, number>;
const defaultPower = (content['users_default'] as number) ?? 0;
void this.sink.onPowerLevel({
account: this.account,
roomId,
users,
prevUsers,
defaultPower,
});
}
}); });
// 解密失败:最常见是历史消息(bot 加入前的消息,发送方不会共享旧密钥) // 解密失败:最常见是历史消息(bot 加入前的消息,发送方不会共享旧密钥)
+3 -1
View File
@@ -1,10 +1,11 @@
import { InboundMessage, MemberEvent } from '../command/types'; import { InboundMessage, MemberEvent, PowerLevelEvent } from '../command/types';
/** bot 与 Matrix 交互的统一出站能力(BotContext 内部依赖它)。 */ /** bot 与 Matrix 交互的统一出站能力(BotContext 内部依赖它)。 */
export interface MatrixTransport { export interface MatrixTransport {
readonly account: string; readonly account: string;
send(roomId: string, text: string, replyToEventId?: string): Promise<string>; send(roomId: string, text: string, replyToEventId?: string): Promise<string>;
kick(roomId: string, userId: string, reason?: string): Promise<void>; kick(roomId: string, userId: string, reason?: string): Promise<void>;
invite(roomId: string, userId: string): Promise<void>;
getMemberCount(roomId: string): Promise<number>; getMemberCount(roomId: string): Promise<number>;
getJoinedMembers(roomId: string): Promise<string[]>; getJoinedMembers(roomId: string): Promise<string[]>;
/** 读取用户在房间内的 power level(读不到或无权限时返回 0)。 */ /** 读取用户在房间内的 power level(读不到或无权限时返回 0)。 */
@@ -15,4 +16,5 @@ export interface MatrixTransport {
export interface MatrixEventSink { export interface MatrixEventSink {
onMessage(msg: InboundMessage): Promise<void>; onMessage(msg: InboundMessage): Promise<void>;
onMember(ev: MemberEvent): Promise<void>; onMember(ev: MemberEvent): Promise<void>;
onPowerLevel(ev: PowerLevelEvent): Promise<void>;
} }