koishi-plugin-command-interceptor
Version:
Intercept commands according to the rules
225 lines (221 loc) • 9.32 kB
JavaScript
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
var __export = (target, all) => {
for (var name2 in all)
__defProp(target, name2, { get: all[name2], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
// src/index.ts
var src_exports = {};
__export(src_exports, {
Config: () => Config,
apply: () => apply,
name: () => name
});
module.exports = __toCommonJS(src_exports);
// src/Config.ts
var import_koishi = require("koishi");
var CommonSchema = {
AndOr: /* @__PURE__ */ __name(() => import_koishi.Schema.union([
import_koishi.Schema.const("and").description("and"),
import_koishi.Schema.const("or").description("or")
]).role("radio"), "AndOr")
};
var Config = import_koishi.Schema.intersect([
import_koishi.Schema.object({
rules: import_koishi.Schema.array(
import_koishi.Schema.intersect([
import_koishi.Schema.object({
type: import_koishi.Schema.union([
import_koishi.Schema.const("whitelist").description("whitelist"),
import_koishi.Schema.const("blacklist").description("blacklist")
]).role("radio").default("whitelist"),
priority: import_koishi.Schema.number().default(100),
command: import_koishi.Schema.array(import_koishi.Schema.string().required()).role("table"),
notCommandMessage: import_koishi.Schema.boolean().default(false)
}),
import_koishi.Schema.object({
conditionGroups: import_koishi.Schema.array(
import_koishi.Schema.object({
externalLogic: CommonSchema.AndOr().default("or"),
internalLogic: CommonSchema.AndOr().default("and"),
conditions: import_koishi.Schema.array(
import_koishi.Schema.object({
key: import_koishi.Schema.union([
import_koishi.Schema.const("private").description("private"),
import_koishi.Schema.const("userId").description("userId"),
import_koishi.Schema.const("groupId").description("groupId"),
import_koishi.Schema.const("channelId").description("channelId"),
import_koishi.Schema.const("botId").description("botId"),
import_koishi.Schema.const("platform").description("platform"),
import_koishi.Schema.const("content").description("content")
]).default("private"),
logic: import_koishi.Schema.union([
import_koishi.Schema.const("equalTo").description("equalTo"),
import_koishi.Schema.const("notEqualTo").description("notEqualTo"),
import_koishi.Schema.const("include").description("include"),
import_koishi.Schema.const("notInclude").description("notInclude"),
import_koishi.Schema.const("like").description("like"),
import_koishi.Schema.const("notLike").description("notLike")
]).default("equalTo"),
value: import_koishi.Schema.union([
import_koishi.Schema.string().description("string"),
import_koishi.Schema.const(true).description("true"),
import_koishi.Schema.const(false).description("false"),
import_koishi.Schema.object({
value: import_koishi.Schema.array(import_koishi.Schema.string()).role("table")
}).description("array")
]).required()
})
).default([{}])
})
).default([{}])
})
])
).default([{}])
})
]);
// src/index.ts
var name = "command-interceptor";
var IsCmd = Symbol("command-interceptor-is-cmd");
var SourceCmd = Symbol("command-interceptor-source-cmd");
function apply(ctx, config) {
const rules = [...config.rules || []].sort(
(a, b) => a.priority - b.priority
);
ctx.on(
"command/before-execute",
(argv) => {
if (!argv.session) {
return;
}
argv.session[IsCmd] = true;
let cmd = [argv.command.name];
if (cmd.includes("help")) {
if (Array.isArray(argv.args)) {
const sourceCmd = argv.session[SourceCmd];
if (sourceCmd?.includes(argv.args?.[0])) {
cmd = sourceCmd;
}
}
} else if (argv.command._aliases) {
cmd.push(...Object.keys(argv.command._aliases));
argv.session[SourceCmd] = [...cmd];
}
const { whitelist, blacklist } = getRuleCommandList(argv.session, rules);
if (blacklist.some((c) => cmd.includes(c))) {
return "";
}
if (whitelist.length > 0 && whitelist.every((c) => !cmd.includes(c))) {
return "";
}
},
true
);
ctx.on(
"before-send",
(_session, options) => {
if (!options?.session || options.session[IsCmd]) {
return;
}
const { allowNotCommandMessage } = getRuleCommandList(
options.session,
rules
);
if (allowNotCommandMessage) {
return;
}
return true;
},
true
);
}
__name(apply, "apply");
var getConditionVal = {
private: /* @__PURE__ */ __name((session) => session.isDirect, "private"),
userId: /* @__PURE__ */ __name((session) => session.userId, "userId"),
groupId: /* @__PURE__ */ __name((session) => session.guildId, "groupId"),
channelId: /* @__PURE__ */ __name((session) => session.channelId, "channelId"),
botId: /* @__PURE__ */ __name((session) => session.bot.selfId, "botId"),
platform: /* @__PURE__ */ __name((session) => session.platform, "platform"),
content: /* @__PURE__ */ __name((session) => session.content, "content")
};
var verifyConditionLogic = {
equalTo: /* @__PURE__ */ __name((val, conditionValue) => {
const type = typeof conditionValue;
return type === "boolean" ? conditionValue === !!val : type === "string" ? conditionValue === val + "" : false;
}, "equalTo"),
notEqualTo: /* @__PURE__ */ __name((val, conditionValue) => !verifyConditionLogic["equalTo"](val, conditionValue), "notEqualTo"),
include: /* @__PURE__ */ __name((val, conditionValue) => typeof conditionValue === "object" ? conditionValue.value.includes(val + "") : verifyConditionLogic["equalTo"](val, conditionValue), "include"),
notInclude: /* @__PURE__ */ __name((val, conditionValue) => !verifyConditionLogic["include"](val, conditionValue), "notInclude"),
like: /* @__PURE__ */ __name((val, conditionValue) => {
const sVal = val + "";
return typeof conditionValue === "object" ? conditionValue.value.some((v) => sVal.includes(v)) : sVal.includes(conditionValue + "");
}, "like"),
notLike: /* @__PURE__ */ __name((val, conditionValue) => !verifyConditionLogic["like"](val, conditionValue), "notLike")
};
function verifyCondition(session, condition) {
return verifyConditionLogic[condition.logic](
getConditionVal[condition.key](session),
condition.value
);
}
__name(verifyCondition, "verifyCondition");
function verifyConditionGroup(session, conditionGroup) {
const _verifyCondition = /* @__PURE__ */ __name((condition) => verifyCondition(session, condition), "_verifyCondition");
return conditionGroup.internalLogic === "and" ? conditionGroup.conditions.every(_verifyCondition) : conditionGroup.conditions.some(_verifyCondition);
}
__name(verifyConditionGroup, "verifyConditionGroup");
function verifyConditionGroups(session, conditionGroups) {
const logics = [[]];
for (let i = conditionGroups.length - 1; i >= 0; i--) {
const item = conditionGroups[i];
logics[0].unshift(item);
if (item.externalLogic === "or" && i !== 0) {
logics.unshift([]);
}
}
return logics.some(
(groups) => groups.every((group) => verifyConditionGroup(session, group))
);
}
__name(verifyConditionGroups, "verifyConditionGroups");
function getRuleCommandList(session, rules) {
const whitelist = [];
const blacklist = [];
let allowNotCommandMessage = true;
for (let rule of rules) {
const res = verifyConditionGroups(session, rule.conditionGroups);
if (!res) {
continue;
}
const isWhite = rule.type === "whitelist";
if (isWhite) {
whitelist.push(...rule.command || []);
} else {
blacklist.push(...rule.command || []);
}
if (allowNotCommandMessage) {
allowNotCommandMessage = isWhite ? rule.notCommandMessage : !rule.notCommandMessage;
}
}
return { whitelist, blacklist, allowNotCommandMessage };
}
__name(getRuleCommandList, "getRuleCommandList");
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
Config,
apply,
name
});