koishi-plugin-github-webhook-pusher 0.0.1

package/lib/index.js

@@ -0,0 +1,1012 @@
+"use strict";
+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,
+  inject: () => inject,
+  name: () => name
+});
+module.exports = __toCommonJS(src_exports);
+var import_koishi5 = require("koishi");
+
+// src/config.ts
+var import_koishi = require("koishi");
+
+// src/types.ts
+var EVENT_DISPLAY_MAP = {
+  issues: { name: "Issue", emoji: "📌" },
+  release: { name: "Release", emoji: "🚀" },
+  push: { name: "Commit", emoji: "⬆️" },
+  pull_request: { name: "PR", emoji: "🔀" },
+  star: { name: "Star", emoji: "⭐" }
+};
+function getDisplayType(type) {
+  return EVENT_DISPLAY_MAP[type].name;
+}
+__name(getDisplayType, "getDisplayType");
+function getEventEmoji(type) {
+  return EVENT_DISPLAY_MAP[type].emoji;
+}
+__name(getEventEmoji, "getEventEmoji");
+
+// src/config.ts
+var EVENT_TYPES = ["issues", "release", "push", "pull_request", "star"];
+var Config = import_koishi.Schema.object({
+  path: import_koishi.Schema.string().default("/github/webhook").description("Webhook 接收路径"),
+  secret: import_koishi.Schema.string().required().description("GitHub Webhook Secret"),
+  baseUrl: import_koishi.Schema.string().description("显示用基础 URL"),
+  defaultEvents: import_koishi.Schema.array(import_koishi.Schema.union(EVENT_TYPES.map((e) => import_koishi.Schema.const(e)))).default(["issues", "release", "push"]).description("默认订阅事件"),
+  debug: import_koishi.Schema.boolean().default(false).description("调试模式"),
+  allowUntrusted: import_koishi.Schema.boolean().default(false).description("允许非信任仓库"),
+  concurrency: import_koishi.Schema.number().default(5).description("推送并发数")
+});
+
+// src/database.ts
+function extendDatabase(ctx) {
+  ctx.model.extend("github_trusted_repos", {
+    id: "unsigned",
+    repo: "string",
+    enabled: "boolean",
+    createdAt: "timestamp",
+    updatedAt: "timestamp"
+  }, {
+    primary: "id",
+    unique: ["repo"]
+  });
+  ctx.model.extend("github_subscriptions", {
+    id: "unsigned",
+    platform: "string",
+    channelId: "string",
+    guildId: "string",
+    userId: "string",
+    repo: "string",
+    events: "json",
+    enabled: "boolean",
+    createdAt: "timestamp",
+    updatedAt: "timestamp"
+  }, {
+    primary: "id"
+  });
+  ctx.model.extend("github_deliveries", {
+    deliveryId: "string",
+    repo: "string",
+    event: "string",
+    receivedAt: "timestamp"
+  }, {
+    primary: "deliveryId"
+  });
+}
+__name(extendDatabase, "extendDatabase");
+
+// src/webhook.ts
+var import_koishi4 = require("koishi");
+
+// src/signature.ts
+var import_crypto = require("crypto");
+function createSignature(payload, secret) {
+  const hmac = (0, import_crypto.createHmac)("sha256", secret);
+  hmac.update(payload, "utf8");
+  return `sha256=${hmac.digest("hex")}`;
+}
+__name(createSignature, "createSignature");
+function verifySignature(payload, signature, secret) {
+  if (!signature || !signature.startsWith("sha256=")) {
+    return false;
+  }
+  const expected = createSignature(payload, secret);
+  const sigBuffer = Buffer.from(signature);
+  const expectedBuffer = Buffer.from(expected);
+  if (sigBuffer.length !== expectedBuffer.length) {
+    return false;
+  }
+  return (0, import_crypto.timingSafeEqual)(sigBuffer, expectedBuffer);
+}
+__name(verifySignature, "verifySignature");
+
+// src/parser.ts
+var MAX_COMMITS = 3;
+function parseIssuesEvent(payload) {
+  const { action, issue, repository, sender } = payload;
+  if (!["opened", "closed", "reopened", "edited"].includes(action)) {
+    return null;
+  }
+  return {
+    type: "issues",
+    displayType: getDisplayType("issues"),
+    repo: repository.full_name,
+    actor: sender.login,
+    action,
+    title: issue.title,
+    number: issue.number,
+    url: issue.html_url,
+    body: issue.body
+  };
+}
+__name(parseIssuesEvent, "parseIssuesEvent");
+function parseReleaseEvent(payload) {
+  const { action, release, repository, sender } = payload;
+  if (!["published", "created"].includes(action)) {
+    return null;
+  }
+  return {
+    type: "release",
+    displayType: getDisplayType("release"),
+    repo: repository.full_name,
+    actor: sender.login,
+    action,
+    title: release.name || release.tag_name,
+    tagName: release.tag_name,
+    url: release.html_url,
+    body: release.body
+  };
+}
+__name(parseReleaseEvent, "parseReleaseEvent");
+function parsePushEvent(payload) {
+  const { ref, commits, repository, sender, compare } = payload;
+  const branch = ref?.replace("refs/heads/", "") || "";
+  const allCommits = (commits || []).map((commit) => ({
+    sha: commit.id?.substring(0, 7) || "",
+    message: commit.message?.split("\n")[0] || "",
+    // 只取第一行
+    author: commit.author?.name || commit.author?.username || "",
+    url: commit.url || ""
+  }));
+  const displayCommits = allCommits.slice(0, MAX_COMMITS);
+  return {
+    type: "push",
+    displayType: getDisplayType("push"),
+    // 显示为 "Commit"
+    repo: repository.full_name,
+    actor: sender.login,
+    ref: branch,
+    commits: displayCommits,
+    totalCommits: allCommits.length,
+    url: compare || `https://github.com/${repository.full_name}`
+  };
+}
+__name(parsePushEvent, "parsePushEvent");
+function parsePullRequestEvent(payload) {
+  const { action, pull_request, repository, sender } = payload;
+  const validActions = ["opened", "closed", "reopened", "edited"];
+  if (!validActions.includes(action)) {
+    return null;
+  }
+  const actualAction = action === "closed" && pull_request.merged ? "merged" : action;
+  return {
+    type: "pull_request",
+    displayType: getDisplayType("pull_request"),
+    repo: repository.full_name,
+    actor: sender.login,
+    action: actualAction,
+    title: pull_request.title,
+    number: pull_request.number,
+    url: pull_request.html_url,
+    body: pull_request.body
+  };
+}
+__name(parsePullRequestEvent, "parsePullRequestEvent");
+function parseStarEvent(payload) {
+  const { action, repository, sender } = payload;
+  if (!["created", "deleted"].includes(action)) {
+    return null;
+  }
+  return {
+    type: "star",
+    displayType: getDisplayType("star"),
+    repo: repository.full_name,
+    actor: sender.login,
+    action,
+    starCount: repository.stargazers_count,
+    url: repository.html_url
+  };
+}
+__name(parseStarEvent, "parseStarEvent");
+function parseEvent(eventName, payload) {
+  switch (eventName) {
+    case "issues":
+      return parseIssuesEvent(payload);
+    case "release":
+      return parseReleaseEvent(payload);
+    case "push":
+      return parsePushEvent(payload);
+    case "pull_request":
+      return parsePullRequestEvent(payload);
+    case "star":
+      return parseStarEvent(payload);
+    default:
+      return null;
+  }
+}
+__name(parseEvent, "parseEvent");
+
+// src/pusher.ts
+var import_koishi3 = require("koishi");
+
+// src/repository/subscription.ts
+async function createSubscription(ctx, session, repo, defaultEvents) {
+  const now = /* @__PURE__ */ new Date();
+  const existing = await ctx.database.get("github_subscriptions", {
+    platform: session.platform,
+    channelId: session.channelId,
+    repo
+  });
+  if (existing.length > 0) {
+    return existing[0];
+  }
+  await ctx.database.create("github_subscriptions", {
+    platform: session.platform,
+    channelId: session.channelId,
+    guildId: session.guildId || "",
+    userId: session.userId || "",
+    repo,
+    events: defaultEvents,
+    enabled: true,
+    createdAt: now,
+    updatedAt: now
+  });
+  const [created] = await ctx.database.get("github_subscriptions", {
+    platform: session.platform,
+    channelId: session.channelId,
+    repo
+  });
+  return created;
+}
+__name(createSubscription, "createSubscription");
+async function removeSubscription(ctx, session, repo) {
+  const result = await ctx.database.remove("github_subscriptions", {
+    platform: session.platform,
+    channelId: session.channelId,
+    repo
+  });
+  return (result.removed ?? 0) > 0;
+}
+__name(removeSubscription, "removeSubscription");
+async function listSubscriptions(ctx, session) {
+  return ctx.database.get("github_subscriptions", {
+    platform: session.platform,
+    channelId: session.channelId
+  });
+}
+__name(listSubscriptions, "listSubscriptions");
+async function getSubscription(ctx, session, repo) {
+  const subs = await ctx.database.get("github_subscriptions", {
+    platform: session.platform,
+    channelId: session.channelId,
+    repo
+  });
+  return subs.length > 0 ? subs[0] : null;
+}
+__name(getSubscription, "getSubscription");
+async function updateEvents(ctx, session, repo, events) {
+  const result = await ctx.database.set("github_subscriptions", {
+    platform: session.platform,
+    channelId: session.channelId,
+    repo
+  }, {
+    events,
+    updatedAt: /* @__PURE__ */ new Date()
+  });
+  return (result.modified ?? 0) > 0;
+}
+__name(updateEvents, "updateEvents");
+async function queryTargets(ctx, repo, eventType) {
+  const subscriptions = await ctx.database.get("github_subscriptions", {
+    repo,
+    enabled: true
+  });
+  return subscriptions.filter((sub) => sub.events.includes(eventType)).map((sub) => ({
+    platform: sub.platform,
+    channelId: sub.channelId,
+    guildId: sub.guildId || void 0,
+    userId: sub.userId || void 0
+  }));
+}
+__name(queryTargets, "queryTargets");
+
+// src/message.ts
+var import_koishi2 = require("koishi");
+function buildMessage(event) {
+  switch (event.type) {
+    case "issues":
+      return buildIssuesMessage(event);
+    case "release":
+      return buildReleaseMessage(event);
+    case "push":
+      return buildPushMessage(event);
+    case "pull_request":
+      return buildPullRequestMessage(event);
+    case "star":
+      return buildStarMessage(event);
+    default:
+      return buildGenericMessage(event);
+  }
+}
+__name(buildMessage, "buildMessage");
+function buildIssuesMessage(event) {
+  const emoji = getEventEmoji(event.type);
+  const actionText = getActionText(event.action);
+  const lines = [
+    `${emoji} [${event.repo}] ${event.displayType}`,
+    `${event.actor} ${actionText} #${event.number}: ${event.title}`,
+    event.url
+  ];
+  return [(0, import_koishi2.h)("text", { content: lines.join("\n") })];
+}
+__name(buildIssuesMessage, "buildIssuesMessage");
+function buildReleaseMessage(event) {
+  const emoji = getEventEmoji(event.type);
+  const actionText = getActionText(event.action);
+  const lines = [
+    `${emoji} [${event.repo}] ${event.displayType}`,
+    `${event.actor} ${actionText} ${event.tagName || event.title}`,
+    event.url
+  ];
+  return [(0, import_koishi2.h)("text", { content: lines.join("\n") })];
+}
+__name(buildReleaseMessage, "buildReleaseMessage");
+function buildPushMessage(event) {
+  const emoji = getEventEmoji(event.type);
+  const commits = event.commits || [];
+  const totalCommits = event.totalCommits || commits.length;
+  const lines = [
+    `${emoji} [${event.repo}] ${event.displayType}`,
+    `${event.actor} 推送了 ${totalCommits} 个提交到 ${event.ref}`,
+    ""
+  ];
+  for (const commit of commits) {
+    lines.push(`• ${commit.sha} - ${commit.message}`);
+  }
+  if (totalCommits > commits.length) {
+    lines.push("");
+    lines.push(`还有 ${totalCommits - commits.length} 条提交...`);
+  }
+  lines.push(event.url);
+  return [(0, import_koishi2.h)("text", { content: lines.join("\n") })];
+}
+__name(buildPushMessage, "buildPushMessage");
+function buildPullRequestMessage(event) {
+  const emoji = getEventEmoji(event.type);
+  const actionText = getActionText(event.action);
+  const lines = [
+    `${emoji} [${event.repo}] ${event.displayType}`,
+    `${event.actor} ${actionText} #${event.number}: ${event.title}`,
+    event.url
+  ];
+  return [(0, import_koishi2.h)("text", { content: lines.join("\n") })];
+}
+__name(buildPullRequestMessage, "buildPullRequestMessage");
+function buildStarMessage(event) {
+  const emoji = getEventEmoji(event.type);
+  const actionText = event.action === "created" ? "starred" : "unstarred";
+  const lines = [
+    `${emoji} [${event.repo}] ${event.displayType}`,
+    `${event.actor} ${actionText} (⭐ ${event.starCount})`,
+    event.url
+  ];
+  return [(0, import_koishi2.h)("text", { content: lines.join("\n") })];
+}
+__name(buildStarMessage, "buildStarMessage");
+function buildGenericMessage(event) {
+  const emoji = getEventEmoji(event.type);
+  const lines = [
+    `${emoji} [${event.repo}] ${event.displayType}`,
+    `${event.actor} ${event.action || "triggered"}`,
+    event.url
+  ];
+  return [(0, import_koishi2.h)("text", { content: lines.join("\n") })];
+}
+__name(buildGenericMessage, "buildGenericMessage");
+function getActionText(action) {
+  const actionMap = {
+    opened: "opened",
+    closed: "closed",
+    reopened: "reopened",
+    edited: "edited",
+    merged: "merged",
+    published: "published",
+    created: "created",
+    deleted: "deleted"
+  };
+  return actionMap[action || ""] || action || "";
+}
+__name(getActionText, "getActionText");
+
+// src/pusher.ts
+var logger = new import_koishi3.Logger("github-webhook-pusher");
+async function queryTargets2(ctx, repo, eventType) {
+  return queryTargets(ctx, repo, eventType);
+}
+__name(queryTargets2, "queryTargets");
+async function sendMessage(ctx, target, message) {
+  try {
+    const bot = ctx.bots.find((b) => b.platform === target.platform);
+    if (!bot) {
+      throw new Error(`未找到平台 ${target.platform} 的 bot`);
+    }
+    await bot.sendMessage(target.channelId, message, target.guildId);
+    return { target, success: true };
+  } catch (error) {
+    return {
+      target,
+      success: false,
+      error: error instanceof Error ? error : new Error(String(error))
+    };
+  }
+}
+__name(sendMessage, "sendMessage");
+async function pushWithConcurrency(ctx, targets, message, concurrency) {
+  if (targets.length === 0) {
+    return [];
+  }
+  const results = [];
+  const queue = [...targets];
+  const workers = Array(Math.min(concurrency, queue.length)).fill(null).map(async () => {
+    while (queue.length > 0) {
+      const target = queue.shift();
+      if (!target) break;
+      const result = await sendMessage(ctx, target, message);
+      results.push(result);
+      if (!result.success && result.error) {
+        logger.error(
+          `推送失败 [${target.platform}:${target.channelId}]: ${result.error.message}`
+        );
+      }
+    }
+  });
+  await Promise.all(workers);
+  return results;
+}
+__name(pushWithConcurrency, "pushWithConcurrency");
+async function pushMessage(ctx, event, concurrency = 5) {
+  const targets = await queryTargets2(ctx, event.repo, event.type);
+  if (targets.length === 0) {
+    logger.debug(`仓库 ${event.repo} 的 ${event.type} 事件没有订阅目标`);
+    return [];
+  }
+  logger.info(`准备推送 ${event.type} 事件到 ${targets.length} 个目标`);
+  const message = buildMessage(event);
+  const results = await pushWithConcurrency(ctx, targets, message, concurrency);
+  const successCount = results.filter((r) => r.success).length;
+  const failCount = results.filter((r) => !r.success).length;
+  logger.info(`推送完成: 成功 ${successCount}, 失败 ${failCount}`);
+  return results;
+}
+__name(pushMessage, "pushMessage");
+async function pushEvent(ctx, event, concurrency = 5) {
+  const results = await pushMessage(ctx, event, concurrency);
+  return {
+    pushed: results.filter((r) => r.success).length,
+    failed: results.filter((r) => !r.success).length,
+    results
+  };
+}
+__name(pushEvent, "pushEvent");
+
+// src/repository/trust.ts
+var REPO_NAME_REGEX = /^[a-zA-Z0-9_.-]+\/[a-zA-Z0-9_.-]+$/;
+function isValidRepoFormat(repo) {
+  if (!repo || typeof repo !== "string") {
+    return false;
+  }
+  return REPO_NAME_REGEX.test(repo);
+}
+__name(isValidRepoFormat, "isValidRepoFormat");
+async function addTrustedRepo(ctx, repo) {
+  if (!isValidRepoFormat(repo)) {
+    return null;
+  }
+  const now = /* @__PURE__ */ new Date();
+  const existing = await ctx.database.get("github_trusted_repos", { repo });
+  if (existing.length > 0) {
+    return existing[0];
+  }
+  await ctx.database.create("github_trusted_repos", {
+    repo,
+    enabled: true,
+    createdAt: now,
+    updatedAt: now
+  });
+  const [created] = await ctx.database.get("github_trusted_repos", { repo });
+  return created;
+}
+__name(addTrustedRepo, "addTrustedRepo");
+async function removeTrustedRepo(ctx, repo) {
+  const result = await ctx.database.remove("github_trusted_repos", { repo });
+  return (result.removed ?? 0) > 0;
+}
+__name(removeTrustedRepo, "removeTrustedRepo");
+async function listTrustedRepos(ctx) {
+  return ctx.database.get("github_trusted_repos", {});
+}
+__name(listTrustedRepos, "listTrustedRepos");
+async function isTrusted(ctx, repo) {
+  const repos = await ctx.database.get("github_trusted_repos", { repo, enabled: true });
+  return repos.length > 0;
+}
+__name(isTrusted, "isTrusted");
+async function isInTrustList(ctx, repo) {
+  const repos = await ctx.database.get("github_trusted_repos", { repo });
+  return repos.length > 0;
+}
+__name(isInTrustList, "isInTrustList");
+async function enableRepo(ctx, repo) {
+  const result = await ctx.database.set("github_trusted_repos", { repo }, {
+    enabled: true,
+    updatedAt: /* @__PURE__ */ new Date()
+  });
+  return (result.modified ?? 0) > 0;
+}
+__name(enableRepo, "enableRepo");
+async function disableRepo(ctx, repo) {
+  const result = await ctx.database.set("github_trusted_repos", { repo }, {
+    enabled: false,
+    updatedAt: /* @__PURE__ */ new Date()
+  });
+  return (result.modified ?? 0) > 0;
+}
+__name(disableRepo, "disableRepo");
+
+// src/repository/delivery.ts
+async function recordDelivery(ctx, deliveryId, repo, event) {
+  const now = /* @__PURE__ */ new Date();
+  await ctx.database.create("github_deliveries", {
+    deliveryId,
+    repo,
+    event,
+    receivedAt: now
+  });
+  const [created] = await ctx.database.get("github_deliveries", { deliveryId });
+  return created;
+}
+__name(recordDelivery, "recordDelivery");
+async function isDelivered(ctx, deliveryId) {
+  const deliveries = await ctx.database.get("github_deliveries", { deliveryId });
+  return deliveries.length > 0;
+}
+__name(isDelivered, "isDelivered");
+
+// src/webhook.ts
+var logger2 = new import_koishi4.Logger("github-webhook");
+function registerWebhook(ctx, config) {
+  const path = config.path || "/github/webhook";
+  logger2.info(`注册 Webhook 处理器: ${path}`);
+  ctx.server.post(path, async (koaCtx) => {
+    const startTime = Date.now();
+    try {
+      const signature = koaCtx.get("X-Hub-Signature-256");
+      const eventName = koaCtx.get("X-GitHub-Event");
+      const deliveryId = koaCtx.get("X-GitHub-Delivery");
+      const rawBody = await getRawBody(koaCtx);
+      if (config.debug) {
+        logger2.debug(`收到 Webhook 请求: event=${eventName}, delivery=${deliveryId}`);
+      }
+      if (config.secret) {
+        if (!signature) {
+          logger2.warn("请求缺少 X-Hub-Signature-256 头");
+          koaCtx.status = 401;
+          koaCtx.body = { error: "Missing signature" };
+          return;
+        }
+        if (!verifySignature(rawBody, signature, config.secret)) {
+          logger2.warn("签名验证失败");
+          koaCtx.status = 401;
+          koaCtx.body = { error: "Invalid signature" };
+          return;
+        }
+      }
+      let payload;
+      try {
+        payload = JSON.parse(rawBody);
+      } catch (e) {
+        logger2.warn("无法解析 JSON 负载");
+        koaCtx.status = 400;
+        koaCtx.body = { error: "Invalid JSON payload" };
+        return;
+      }
+      const repo = payload.repository?.full_name;
+      if (!repo) {
+        logger2.warn("负载中缺少仓库信息");
+        koaCtx.status = 400;
+        koaCtx.body = { error: "Missing repository information" };
+        return;
+      }
+      logger2.info(`收到 Webhook: [${repo}] ${eventName} (${deliveryId})`);
+      if (deliveryId) {
+        const isDuplicate = await isDelivered(ctx, deliveryId);
+        if (isDuplicate) {
+          logger2.info(`跳过重复请求: ${deliveryId}`);
+          koaCtx.status = 200;
+          koaCtx.body = { status: "duplicate" };
+          return;
+        }
+      }
+      if (!config.allowUntrusted) {
+        const trusted = await isTrusted(ctx, repo);
+        if (!trusted) {
+          logger2.info(`忽略非信任仓库事件: ${repo}`);
+          koaCtx.status = 200;
+          koaCtx.body = { status: "ignored", reason: "untrusted" };
+          return;
+        }
+      }
+      const event = parseEvent(eventName, payload);
+      if (!event) {
+        logger2.info(`不支持的事件类型: ${eventName}`);
+        koaCtx.status = 200;
+        koaCtx.body = { status: "ignored", reason: "unsupported" };
+        return;
+      }
+      if (deliveryId) {
+        await recordDelivery(ctx, deliveryId, repo, eventName);
+      }
+      const result = await pushEvent(ctx, event, config.concurrency);
+      const elapsed = Date.now() - startTime;
+      logger2.info(`处理完成: 推送 ${result.pushed} 成功, ${result.failed} 失败 (${elapsed}ms)`);
+      koaCtx.status = 200;
+      koaCtx.body = { status: "ok", pushed: result.pushed };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      logger2.error(`处理 Webhook 时发生错误: ${errorMessage}`);
+      if (config.debug && error instanceof Error) {
+        logger2.error(error.stack || "");
+      }
+      koaCtx.status = 500;
+      koaCtx.body = { status: "error", error: "Internal server error" };
+    }
+  });
+}
+__name(registerWebhook, "registerWebhook");
+async function getRawBody(koaCtx) {
+  if (koaCtx.request.body) {
+    return JSON.stringify(koaCtx.request.body);
+  }
+  return new Promise((resolve, reject) => {
+    let data = "";
+    koaCtx.req.on("data", (chunk) => {
+      data += chunk.toString();
+    });
+    koaCtx.req.on("end", () => {
+      resolve(data);
+    });
+    koaCtx.req.on("error", reject);
+  });
+}
+__name(getRawBody, "getRawBody");
+
+// src/commands/trust.ts
+var ADMIN_AUTHORITY = 3;
+function registerTrustCommands(ctx) {
+  const trust = ctx.command("gh.trust", "管理信任的 GitHub 仓库").usage("gh.trust <add|remove|list|enable|disable> [repo]");
+  trust.subcommand(".add <repo:string>", "添加信任仓库").usage("gh.trust.add owner/repo").example("gh.trust.add koishijs/koishi").action(async ({ session }, repo) => {
+    const user = session?.user;
+    if ((user?.authority ?? 0) < ADMIN_AUTHORITY) {
+      return "❌ 权限不足，需要管理员权限";
+    }
+    if (!repo) {
+      return "❌ 请指定仓库名，格式: owner/repo";
+    }
+    if (!isValidRepoFormat(repo)) {
+      return "❌ 仓库格式错误，请使用 owner/repo 格式";
+    }
+    const result = await addTrustedRepo(ctx, repo);
+    if (result) {
+      return `✅ 已添加信任仓库: ${repo}`;
+    }
+    return "❌ 添加失败";
+  });
+  trust.subcommand(".remove <repo:string>", "移除信任仓库").usage("gh.trust.remove owner/repo").example("gh.trust.remove koishijs/koishi").action(async ({ session }, repo) => {
+    const user = session?.user;
+    if ((user?.authority ?? 0) < ADMIN_AUTHORITY) {
+      return "❌ 权限不足，需要管理员权限";
+    }
+    if (!repo) {
+      return "❌ 请指定仓库名";
+    }
+    const success = await removeTrustedRepo(ctx, repo);
+    if (success) {
+      return `✅ 已移除信任仓库: ${repo}`;
+    }
+    return `❌ 仓库 ${repo} 不在信任列表中`;
+  });
+  trust.subcommand(".list", "列出所有信任仓库").usage("gh.trust.list").action(async ({ session }) => {
+    const user = session?.user;
+    if ((user?.authority ?? 0) < ADMIN_AUTHORITY) {
+      return "❌ 权限不足，需要管理员权限";
+    }
+    const repos = await listTrustedRepos(ctx);
+    if (repos.length === 0) {
+      return "📋 信任仓库列表为空";
+    }
+    const lines = ["📋 信任仓库列表:"];
+    for (const repo of repos) {
+      const status = repo.enabled ? "✅" : "⏸️";
+      lines.push(`${status} ${repo.repo}`);
+    }
+    return lines.join("\n");
+  });
+  trust.subcommand(".enable <repo:string>", "启用信任仓库").usage("gh.trust.enable owner/repo").example("gh.trust.enable koishijs/koishi").action(async ({ session }, repo) => {
+    const user = session?.user;
+    if ((user?.authority ?? 0) < ADMIN_AUTHORITY) {
+      return "❌ 权限不足，需要管理员权限";
+    }
+    if (!repo) {
+      return "❌ 请指定仓库名";
+    }
+    const success = await enableRepo(ctx, repo);
+    if (success) {
+      return `✅ 已启用仓库: ${repo}`;
+    }
+    return `❌ 仓库 ${repo} 不在信任列表中`;
+  });
+  trust.subcommand(".disable <repo:string>", "禁用信任仓库").usage("gh.trust.disable owner/repo").example("gh.trust.disable koishijs/koishi").action(async ({ session }, repo) => {
+    const user = session?.user;
+    if ((user?.authority ?? 0) < ADMIN_AUTHORITY) {
+      return "❌ 权限不足，需要管理员权限";
+    }
+    if (!repo) {
+      return "❌ 请指定仓库名";
+    }
+    const success = await disableRepo(ctx, repo);
+    if (success) {
+      return `⏸️ 已禁用仓库: ${repo}`;
+    }
+    return `❌ 仓库 ${repo} 不在信任列表中`;
+  });
+}
+__name(registerTrustCommands, "registerTrustCommands");
+
+// src/commands/subscription.ts
+var ALL_EVENT_TYPES = ["issues", "release", "push", "pull_request", "star"];
+function getSessionIdentifier(session) {
+  return {
+    platform: session.platform,
+    channelId: session.channelId,
+    guildId: session.guildId,
+    userId: session.userId
+  };
+}
+__name(getSessionIdentifier, "getSessionIdentifier");
+function parseEventChanges(changes, currentEvents) {
+  const events = new Set(currentEvents);
+  for (const change of changes) {
+    if (!change) continue;
+    const prefix = change[0];
+    const eventName = change.slice(1);
+    if (!ALL_EVENT_TYPES.includes(eventName)) {
+      continue;
+    }
+    if (prefix === "+") {
+      events.add(eventName);
+    } else if (prefix === "-") {
+      events.delete(eventName);
+    }
+  }
+  return Array.from(events);
+}
+__name(parseEventChanges, "parseEventChanges");
+function registerSubscriptionCommands(ctx, config) {
+  ctx.command("gh.sub <repo:string>", "订阅 GitHub 仓库事件").usage("gh.sub owner/repo").example("gh.sub koishijs/koishi").action(async ({ session }, repo) => {
+    if (!session) return "❌ 无法获取会话信息";
+    if (!repo) {
+      return "❌ 请指定仓库名，格式: owner/repo";
+    }
+    const trusted = await isInTrustList(ctx, repo);
+    if (!trusted) {
+      return "❌ 该仓库不在信任列表中";
+    }
+    const sessionId = getSessionIdentifier(session);
+    const subscription = await createSubscription(ctx, sessionId, repo, config.defaultEvents);
+    if (subscription) {
+      const eventList = subscription.events.join(", ");
+      return `✅ 已订阅仓库: ${repo}
+📋 订阅事件: ${eventList}`;
+    }
+    return "❌ 订阅失败";
+  });
+  ctx.command("gh.unsub <repo:string>", "取消订阅 GitHub 仓库").usage("gh.unsub owner/repo").example("gh.unsub koishijs/koishi").action(async ({ session }, repo) => {
+    if (!session) return "❌ 无法获取会话信息";
+    if (!repo) {
+      return "❌ 请指定仓库名";
+    }
+    const sessionId = getSessionIdentifier(session);
+    const success = await removeSubscription(ctx, sessionId, repo);
+    if (success) {
+      return `✅ 已取消订阅: ${repo}`;
+    }
+    return `❌ 未找到仓库 ${repo} 的订阅`;
+  });
+  ctx.command("gh.list", "列出当前会话的所有订阅").usage("gh.list").action(async ({ session }) => {
+    if (!session) return "❌ 无法获取会话信息";
+    const sessionId = getSessionIdentifier(session);
+    const subscriptions = await listSubscriptions(ctx, sessionId);
+    if (subscriptions.length === 0) {
+      return "📋 当前会话没有订阅任何仓库";
+    }
+    const lines = ["📋 订阅列表:"];
+    for (const sub of subscriptions) {
+      const status = sub.enabled ? "✅" : "⏸️";
+      const events = sub.events.join(", ");
+      lines.push(`${status} ${sub.repo}`);
+      lines.push(`   事件: ${events}`);
+    }
+    return lines.join("\n");
+  });
+  ctx.command("gh.events <repo:string> [...changes:string]", "查看或修改订阅的事件类型").usage("gh.events owner/repo [+event] [-event]").example("gh.events koishijs/koishi").example("gh.events koishijs/koishi +issues -star +release").action(async ({ session }, repo, ...changes) => {
+    if (!session) return "❌ 无法获取会话信息";
+    if (!repo) {
+      const lines = ["📋 可用事件类型:"];
+      for (const [type, info] of Object.entries(EVENT_DISPLAY_MAP)) {
+        lines.push(`${info.emoji} ${type} - ${info.name}`);
+      }
+      return lines.join("\n");
+    }
+    const sessionId = getSessionIdentifier(session);
+    const subscription = await getSubscription(ctx, sessionId, repo);
+    if (!subscription) {
+      return `❌ 未找到仓库 ${repo} 的订阅`;
+    }
+    if (!changes || changes.length === 0) {
+      const events = subscription.events.join(", ");
+      return `📋 ${repo} 订阅的事件:
+${events}`;
+    }
+    const newEvents = parseEventChanges(changes, subscription.events);
+    const success = await updateEvents(ctx, sessionId, repo, newEvents);
+    if (success) {
+      const eventList = newEvents.join(", ");
+      return `✅ 已更新 ${repo} 的订阅事件:
+${eventList}`;
+    }
+    return "❌ 更新失败";
+  });
+}
+__name(registerSubscriptionCommands, "registerSubscriptionCommands");
+
+// src/commands/utils.ts
+var PLUGIN_NAME = "github-webhook-pusher";
+var ADMIN_AUTHORITY2 = 3;
+var ALL_EVENT_TYPES2 = ["issues", "release", "push", "pull_request", "star"];
+function generateTestEvent(repo, eventType) {
+  const baseEvent = {
+    type: eventType,
+    displayType: getDisplayType(eventType),
+    repo,
+    actor: "test-user",
+    url: `https://github.com/${repo}`
+  };
+  switch (eventType) {
+    case "issues":
+      return {
+        ...baseEvent,
+        action: "opened",
+        title: "测试 Issue 标题",
+        number: 123
+      };
+    case "release":
+      return {
+        ...baseEvent,
+        action: "published",
+        title: "v1.0.0",
+        tagName: "v1.0.0"
+      };
+    case "push":
+      return {
+        ...baseEvent,
+        ref: "main",
+        commits: [
+          { sha: "abc1234", message: "测试提交 1", author: "test-user", url: "" },
+          { sha: "def5678", message: "测试提交 2", author: "test-user", url: "" }
+        ],
+        totalCommits: 2
+      };
+    case "pull_request":
+      return {
+        ...baseEvent,
+        action: "opened",
+        title: "测试 PR 标题",
+        number: 456
+      };
+    case "star":
+      return {
+        ...baseEvent,
+        action: "created",
+        starCount: 1234
+      };
+    default:
+      return baseEvent;
+  }
+}
+__name(generateTestEvent, "generateTestEvent");
+function registerUtilCommands(ctx, config) {
+  ctx.command("gh.ping", "查看插件状态").usage("gh.ping").action(async () => {
+    const repos = await listTrustedRepos(ctx);
+    const enabledCount = repos.filter((r) => r.enabled).length;
+    const lines = [
+      "🏓 GitHub Webhook 推送插件",
+      `📦 插件名称: ${PLUGIN_NAME}`,
+      `🔗 Webhook 路径: ${config.path}`,
+      `📋 信任仓库: ${repos.length} 个 (${enabledCount} 个已启用)`,
+      `🔧 调试模式: ${config.debug ? "开启" : "关闭"}`
+    ];
+    return lines.join("\n");
+  });
+  ctx.command("gh.test <repo:string> <event:string>", "生成测试消息").usage("gh.test owner/repo event").example("gh.test koishijs/koishi issues").example("gh.test koishijs/koishi push").action(async ({ session }, repo, event) => {
+    const user = session?.user;
+    if ((user?.authority ?? 0) < ADMIN_AUTHORITY2) {
+      return "❌ 权限不足，需要管理员权限";
+    }
+    if (!repo) {
+      return "❌ 请指定仓库名，格式: owner/repo";
+    }
+    if (!event) {
+      const eventList = ALL_EVENT_TYPES2.map((e) => {
+        const info = EVENT_DISPLAY_MAP[e];
+        return `${info.emoji} ${e}`;
+      }).join(", ");
+      return `❌ 请指定事件类型
+可用类型: ${eventList}`;
+    }
+    if (!ALL_EVENT_TYPES2.includes(event)) {
+      const eventList = ALL_EVENT_TYPES2.join(", ");
+      return `❌ 不支持的事件类型: ${event}
+可用类型: ${eventList}`;
+    }
+    const testEvent = generateTestEvent(repo, event);
+    const message = buildMessage(testEvent);
+    await session?.send(message);
+    return;
+  });
+}
+__name(registerUtilCommands, "registerUtilCommands");
+
+// src/index.ts
+var name = "github-webhook-pusher";
+var inject = ["server", "database"];
+var logger3 = new import_koishi5.Logger("github-webhook-pusher");
+function apply(ctx, config) {
+  logger3.info(`正在加载 GitHub Webhook 插件...`);
+  extendDatabase(ctx);
+  logger3.debug("数据库模型已注册");
+  registerWebhook(ctx, config);
+  logger3.debug(`Webhook 处理器已注册: ${config.path}`);
+  registerTrustCommands(ctx);
+  logger3.debug("信任仓库管理命令已注册");
+  registerSubscriptionCommands(ctx, config);
+  logger3.debug("订阅管理命令已注册");
+  registerUtilCommands(ctx, config);
+  logger3.debug("工具命令已注册");
+  logger3.info(`GitHub Webhook 插件已加载`);
+  logger3.info(`Webhook 路径: ${config.path}`);
+  logger3.info(`默认订阅事件: ${config.defaultEvents.join(", ")}`);
+  if (config.debug) {
+    logger3.info("调试模式已启用");
+  }
+}
+__name(apply, "apply");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Config,
+  apply,
+  inject,
+  name
+});