koishi-plugin-subscription 0.0.1 → 0.0.2

package/lib/index.d.ts

@@ -0,0 +1,68 @@
+import { Context, Dict, Schema, Service, Fragment } from 'koishi';
+interface SubscriptionItem {
+    id: number;
+    app: string;
+    account: string;
+    groupId: string;
+    createdAt: Date;
+}
+interface AppConfig {
+    alias: string[];
+    allowedAccounts: {
+        id: string;
+        name: string;
+        alias: string;
+    }[];
+}
+export interface Config {
+    apps: Dict<AppConfig>;
+    minAuthority: number;
+    mode: "noAdmin" | "and" | "or";
+}
+export declare const Config: Schema<Config>;
+export declare const name = "subscription";
+export declare const inject: {
+    required: string[];
+    optional: string[];
+};
+declare module 'koishi' {
+    interface Context {
+        subscription: SubscriptionService;
+    }
+    interface Tables {
+        subscription_service: SubscriptionItem;
+    }
+}
+declare class SubscriptionService extends Service {
+    readonly tableName = "subscription_service";
+    subsConfig: Config;
+    appMap: Map<string, string>;
+    accountMap: Map<string, string>;
+    constructor(ctx: Context, config: Config);
+    initMap(): void;
+    private getApp;
+    private getAccount;
+    getAvailableAccounts(app: string): string[];
+    getSubscribedGroups(app: string, account: string): Promise<string[]>;
+    broadcast(app: string, account: string, content: Fragment): Promise<void>;
+    private getSelfIds;
+    private getAssignedChannels;
+    broadcastForward(app: string, account: string, content: Fragment): Promise<any[]>;
+    addSubscription(app: string, account: string, groupId: string): Promise<{
+        status: boolean;
+        msg: string;
+    }>;
+    removeSubscription(app: string, account: string, groupId: string): Promise<boolean>;
+    getGroupSubscriptions(groupId: string): Promise<SubscriptionItem[]>;
+    getAllSubscriptions(): Promise<SubscriptionItem[]>;
+    getSubscriptionStats(): Promise<{
+        app: string;
+        account: string;
+        count: number;
+    }[]>;
+    private authCheck;
+    private getChannelId;
+    private registerCommands;
+}
+export declare function apply(ctx: Context, config: Config): void;
+export {};

package/lib/index.js

@@ -0,0 +1,395 @@
+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.tsx
+var src_exports = {};
+__export(src_exports, {
+  Config: () => Config,
+  apply: () => apply,
+  inject: () => inject,
+  name: () => name
+});
+module.exports = __toCommonJS(src_exports);
+var import_koishi = require("koishi");
+var import_jsx_runtime = require("@satorijs/element/jsx-runtime");
+var Config = import_koishi.Schema.intersect([
+  import_koishi.Schema.object({
+    apps: import_koishi.Schema.dict(
+      import_koishi.Schema.object({
+        alias: import_koishi.Schema.array(import_koishi.Schema.string()).role("table").description("应用别名，如果重复，后面会覆盖前面的"),
+        allowedAccounts: import_koishi.Schema.array(
+          import_koishi.Schema.object({
+            id: import_koishi.Schema.string().required().description("账号id"),
+            name: import_koishi.Schema.string().required().description("账号名称，用于订阅列表显示"),
+            alias: import_koishi.Schema.string().description("账号别名，使用英文逗号分隔")
+          })
+        ).role("table").description("允许订阅的账号列表，别名如果重复，后面会覆盖前面的").required()
+      })
+    ).description("应用配置列表").required()
+  }).description("订阅配置"),
+  import_koishi.Schema.object({
+    minAuthority: import_koishi.Schema.number().default(3).description("需要的最低用户权限"),
+    mode: import_koishi.Schema.union([
+      import_koishi.Schema.const("noAdmin").description("不考虑群组管理员权限"),
+      import_koishi.Schema.const("and").description("同时需要群组管理员权限和用户权限"),
+      import_koishi.Schema.const("or").description("群组管理员权限和用户权限只需满足一个")
+    ]).default("or").role("radio").description("权限模式")
+  }).description("权限配置")
+]);
+var name = "subscription";
+var inject = {
+  required: ["database"],
+  optional: ["puppeteer"]
+};
+var SubscriptionService = class extends import_koishi.Service {
+  static {
+    __name(this, "SubscriptionService");
+  }
+  // 数据表名称
+  tableName = "subscription_service";
+  subsConfig;
+  appMap;
+  accountMap;
+  constructor(ctx, config) {
+    super(ctx, "subscription");
+    this.subsConfig = config;
+    this.initMap();
+    ctx.model.extend(this.tableName, {
+      id: "unsigned",
+      app: "string",
+      account: "string",
+      groupId: "string",
+      createdAt: "timestamp"
+    }, {
+      primary: "id",
+      autoInc: true
+    });
+    this.registerCommands(ctx, config);
+  }
+  initMap() {
+    this.appMap = /* @__PURE__ */ new Map();
+    this.accountMap = /* @__PURE__ */ new Map();
+    for (const app in this.subsConfig.apps) {
+      if (this.subsConfig.apps[app].alias?.length > 0)
+        for (const appAlias of this.subsConfig.apps[app].alias) {
+          this.appMap.set(appAlias.toLowerCase(), app);
+        }
+      for (const item of this.subsConfig.apps[app].allowedAccounts) {
+        if (item.alias?.length > 0)
+          for (const accountAlias of item.alias.split(","))
+            this.accountMap.set((app + accountAlias).toLowerCase(), item.id);
+      }
+    }
+    for (const app in this.subsConfig.apps) {
+      this.appMap.set(app.toLowerCase(), app);
+      for (const item of this.subsConfig.apps[app].allowedAccounts) {
+        this.accountMap.set((app + item.id).toLowerCase(), item.id);
+      }
+      for (const item of this.subsConfig.apps[app].allowedAccounts) {
+        this.accountMap.set((app + item.name).toLowerCase(), item.id);
+      }
+    }
+  }
+  getApp(app) {
+    return this.appMap.get(app.toLowerCase());
+  }
+  getAccount(app, account) {
+    return this.accountMap.get((app + account).toLowerCase());
+  }
+  // 获取对应应用可以订阅的账号
+  getAvailableAccounts(app) {
+    app = this.getApp(app);
+    const appConfig = this.subsConfig.apps[app];
+    return appConfig ? appConfig.allowedAccounts.map((item) => item.id) : [];
+  }
+  // 根据应用和账号获取订阅了这个账号的所有群组
+  async getSubscribedGroups(app, account) {
+    app = this.getApp(app), account = this.getAccount(app, account);
+    const subscriptions = await this.ctx.database.get(this.tableName, {
+      app,
+      account
+    });
+    return subscriptions.map((sub) => sub.groupId);
+  }
+  async broadcast(app, account, content) {
+    app = this.getApp(app), account = this.getAccount(app, account);
+    const channelArr = await this.getSubscribedGroups(app, account);
+    this.ctx.broadcast(channelArr, content);
+  }
+  getSelfIds(platforms) {
+    const selfIdMap = /* @__PURE__ */ Object.create(null);
+    for (const bot of this.ctx.bots) {
+      if (platforms && !platforms.includes(bot.platform)) continue;
+      (selfIdMap[bot.platform] ||= []).push(bot.selfId);
+    }
+    return selfIdMap;
+  }
+  async getAssignedChannels(fields, selfIdMap) {
+    return this.ctx.database.get("channel", {
+      $or: Object.entries(selfIdMap).map(([platform, assignee]) => ({ platform, assignee }))
+    }, fields);
+  }
+  async broadcastForward(app, account, content) {
+    app = this.getApp(app), account = this.getAccount(app, account);
+    const channels = await this.getSubscribedGroups(app, account);
+    const platforms = channels.map((c) => c.split(":")[0]);
+    const selfIdMap = this.getSelfIds(platforms);
+    const data = await this.getAssignedChannels(["id", "assignee", "flag", "platform", "guildId", "locales"], selfIdMap);
+    const assignMap = {};
+    for (const channel of data) {
+      const { platform, id, assignee, flag } = channel;
+      if (channels) {
+        const index = channels?.indexOf(`${platform}:${id}`);
+        if (index < 0) continue;
+        channels.splice(index, 1);
+      }
+      ((assignMap[platform] ||= {})[assignee] ||= []).push(channel);
+    }
+    if (channels?.length) {
+      this.ctx.logger("app").warn("broadcastForward", "channel not found: ", channels.join(", "));
+    }
+    return (await Promise.all(this.ctx.bots.map(async (bot) => {
+      const targets = assignMap[bot.platform]?.[bot.selfId];
+      if (!targets) return Promise.resolve([]);
+      const messageIds = await bot.sendPrivateMessage(bot.selfId, content);
+      const forwardContent = /* @__PURE__ */ (0, import_jsx_runtime.jsx)("message", { forward: true, children: messageIds.map((id) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)("message", { id: `${id}` })) });
+      const sessions = targets.map(({ id, guildId, locales }) => {
+        const session = bot.session({
+          type: "message",
+          channel: { id, type: import_koishi.Universal.Channel.Type.TEXT },
+          guild: { id: guildId }
+        });
+        session.locales = locales;
+        return session;
+      });
+      return bot.broadcast(sessions, forwardContent);
+    }))).flat(1);
+  }
+  // 添加订阅
+  async addSubscription(app, account, groupId) {
+    app = this.getApp(app), account = this.getAccount(app, account);
+    const appConfig = this.getAvailableAccounts(app);
+    if (!appConfig) {
+      return { status: false, msg: "应用不存在" };
+    }
+    if (!appConfig.includes(account)) {
+      return { status: false, msg: "账号不在白名单中" };
+    }
+    const existing = await this.ctx.database.get(this.tableName, {
+      app,
+      account,
+      groupId
+    });
+    if (existing.length > 0) {
+      return { status: false, msg: "已订阅该账号" };
+    }
+    await this.ctx.database.create(this.tableName, {
+      app,
+      account,
+      groupId,
+      createdAt: /* @__PURE__ */ new Date()
+    });
+    return { status: true, msg: "订阅成功" };
+  }
+  // 删除订阅
+  async removeSubscription(app, account, groupId) {
+    app = this.appMap.get(app), account = this.accountMap.get(app + account);
+    const result = await this.ctx.database.remove(this.tableName, {
+      app,
+      account,
+      groupId
+    });
+    return result.removed > 0;
+  }
+  // 获取群组的所有订阅
+  async getGroupSubscriptions(groupId) {
+    return await this.ctx.database.get(this.tableName, { groupId });
+  }
+  // 获取所有订阅（用于管理）
+  async getAllSubscriptions() {
+    return await this.ctx.database.get(this.tableName, {});
+  }
+  // 按应用获取订阅统计
+  async getSubscriptionStats() {
+    const subscriptions = await this.getAllSubscriptions();
+    const stats = {};
+    subscriptions.forEach((sub) => {
+      const key = `${sub.app}-${sub.account}`;
+      stats[key] = (stats[key] || 0) + 1;
+    });
+    return Object.entries(stats).map(([key, count]) => {
+      const [app, account] = key.split("-");
+      return { app, account, count };
+    });
+  }
+  async authCheck(session, config) {
+    const userAuthority = session.user?.authority || 0;
+    if (config.mode == "noAdmin") {
+      return userAuthority >= config.minAuthority;
+    }
+    if (config.mode == "or" && userAuthority >= config.minAuthority)
+      return true;
+    if (config.mode == "and" && userAuthority < config.minAuthority)
+      return false;
+    let isGroupAdmin = false;
+    const memberInfo = await session.bot.getGuildMember?.(session.guildId, session.userId);
+    isGroupAdmin = memberInfo?.roles?.includes("admin") || memberInfo?.roles?.includes("owner");
+    return isGroupAdmin;
+  }
+  getChannelId(channel) {
+    if (!channel) return;
+    return `${channel.platform}:${channel.id}`;
+  }
+  registerCommands(ctx, config) {
+    const sub = ctx.command("subscription.add <app:string> [...accounts]", "添加订阅").alias("订阅").alias("添加订阅").userFields(["authority"]).action(async ({ session, options }, app, ...accounts) => {
+      if (!await this.authCheck(session, config)) {
+        return "权限不足";
+      }
+      if (!app || !accounts || accounts.length == 0) {
+        return "请指定应用名和账号，格式：订阅 <应用名> <账号> [...更多账号]";
+      }
+      const groupId = this.getChannelId(session.channel);
+      if (!groupId) {
+        return "请在群聊中使用当前指令";
+      }
+      let result = "";
+      for (const account of accounts) {
+        const { status, msg } = await this.addSubscription(app, account, groupId);
+        if (status) {
+          result += `成功为群组 ${groupId} 添加订阅：${app} - ${account}
+`;
+        } else {
+          result += `添加订阅 ${app} - ${account} 失败，${msg}
+`;
+        }
+      }
+      return result;
+    });
+    const unsub = ctx.command("subscription.remove <app:string> <account:string>", "删除订阅").alias("删除订阅").alias("取消订阅").userFields(["authority"]).action(async ({ session, options }, app, account) => {
+      if (!await this.authCheck(session, config)) {
+        return "权限不足";
+      }
+      if (!app || !account) {
+        return "请指定应用名和账号，格式：取消订阅 <应用名> <账号>";
+      }
+      const groupId = this.getChannelId(session.channel);
+      if (!groupId) {
+        return "请在群聊中使用当前指令";
+      }
+      const success = await this.removeSubscription(app, account, groupId);
+      if (success) {
+        return `成功为群组 ${groupId} 删除订阅：${app} - ${account}`;
+      } else {
+        return `删除订阅失败，可能的原因：订阅不存在`;
+      }
+    });
+    for (const app in config.apps) {
+      sub.alias(`${app}订阅`, { args: [app] });
+      unsub.alias(`取消${app}订阅`, { args: [app] });
+      for (const appAlias of config.apps[app].alias) {
+        sub.alias(`${appAlias}订阅`, { args: [app] });
+        unsub.alias(`取消${appAlias}订阅`, { args: [app] });
+      }
+    }
+    ctx.command("subscription.list", "查看当前群组的订阅").alias("订阅列表").userFields(["authority"]).action(async ({ session, options }) => {
+      if (!await this.authCheck(session, config)) {
+        return "权限不足";
+      }
+      const groupId = this.getChannelId(session.channel);
+      if (!groupId) {
+        return "请在群聊中使用当前指令";
+      }
+      const subscriptions = await this.getGroupSubscriptions(groupId);
+      const subscribedByApp = {};
+      subscriptions.forEach((sub2) => {
+        if (!subscribedByApp[sub2.app]) {
+          subscribedByApp[sub2.app] = /* @__PURE__ */ new Set();
+        }
+        subscribedByApp[sub2.app].add(sub2.account);
+      });
+      const availableAccounts = {};
+      const appConfig = this.subsConfig.apps;
+      for (const app in appConfig) {
+        availableAccounts[app] = appConfig[app].allowedAccounts.map((account) => ({
+          id: account.id,
+          name: account.name,
+          alias: account.alias ? account.alias.split(",") : []
+        }));
+      }
+      let result = `群组 ${groupId} 的订阅状态：
+
+`;
+      for (const app in availableAccounts) {
+        result += `【${app}】
+`;
+        const subscribed = subscribedByApp[app] || /* @__PURE__ */ new Set();
+        availableAccounts[app].forEach((account) => {
+          const isSubscribed = subscribed.has(account.id);
+          const status = isSubscribed ? "✅ 已订阅" : "❌ 未订阅";
+          const aliases = account.alias.length > 0 ? ` (${account.alias.join(", ")})` : "";
+          result += `${status} ${account.name}  id:${account.id}
+	${aliases}
+`;
+        });
+        result += "\n";
+      }
+      return result;
+    });
+    ctx.command("subscription.clear", "删除群组的所有订阅").alias("清空订阅").userFields(["authority"]).action(async ({ session }) => {
+      if (!await this.authCheck(session, config)) {
+        return "权限不足";
+      }
+      const groupId = this.getChannelId(session.channel);
+      if (!groupId) {
+        return "请在群聊中使用当前指令";
+      }
+      const subscriptions = await this.getGroupSubscriptions(groupId);
+      if (subscriptions.length === 0) {
+        return `群组 ${groupId} 暂无订阅`;
+      }
+      await ctx.database.remove("subscription_service", { groupId });
+      return `已删除群组 ${groupId} 的所有订阅（共 ${subscriptions.length} 个）`;
+    });
+    ctx.command("subscription.stats", "查看订阅统计", {
+      permissions: [`authority:${config.minAuthority}`],
+      hidden: true
+    }).alias("订阅统计").userFields(["authority"]).action(async ({ session }) => {
+      const stats = await this.getSubscriptionStats();
+      if (stats.length === 0) {
+        return "暂无订阅数据";
+      }
+      const statsList = stats.map(
+        (stat) => `${stat.app} - ${stat.account}: ${stat.count} 个群组订阅`
+      ).join("\n");
+      return `订阅统计：
+${statsList}`;
+    });
+  }
+};
+function apply(ctx, config) {
+  ctx.plugin(SubscriptionService, config);
+}
+__name(apply, "apply");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Config,
+  apply,
+  inject,
+  name
+});

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "koishi-plugin-subscription",
   "description": "给多个应用提供订阅群组管理",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
   "files": [
@@ -16,14 +16,19 @@
   ],
   "koishi": {
     "service": {
-      "required": ["database"],
-      "optional": ["puppeteer"],
+      "required": [
+        "database"
+      ],
+      "optional": [
+        "puppeteer"
+      ],
       "implements": [
         "subscription"
       ]
     }
   },
   "peerDependencies": {
-    "koishi": "4.18.9"
+    "@satorijs/element": "^3.1.8",
+    "koishi": "^4.18.9"
   }
 }