@zhin.js/adapter-github 3.0.1 → 3.0.3

package/src/gh-client.ts

@@ -21,6 +21,19 @@ export interface AppAuth {
   privateKey: string;
 }
 
+export interface GitHubBotIdentity {
+  login: string;
+  email: string;
+  slug: string;
+  userId: number;
+}
+
+export interface GitHubCommitAuthor {
+  name: string;
+  email: string;
+  date?: string;
+}
+
 export interface GhClientOptions {
   /** GitHub Enterprise 主机名（默认 github.com） */
   host?: string;
@@ -201,6 +214,7 @@ export class GhClient {
           this._user = name;
           this._appSlug = appData.slug || null;
           if (appData.client_id) this._clientId = appData.client_id;
+          await this.resolveBotUserId();
           const repos = this._repoToInstallation.size;
           return { ok: true, user: name, message: `GitHub App: ${name} (${this._allInstallations.length} 安装, ${repos} 仓库)` };
         }
@@ -313,6 +327,114 @@ export class GhClient {
     return this.del(`/repos/${repo}/pulls/comments/${commentId}`);
   }
 
+  // ── Contents / Pulls（Bot 写操作）──────────────────────────────────
+
+  async getFileContent(repo: string, path: string, ref?: string) {
+    let apiPath = `/repos/${repo}/contents/${path.split('/').map(encodeURIComponent).join('/')}`;
+    if (ref) apiPath += `?ref=${encodeURIComponent(ref)}`;
+    return this.get<{ content: string; sha: string; encoding: string }>(apiPath);
+  }
+
+  async createOrUpdateFile(
+    repo: string,
+    path: string,
+    content: string,
+    message: string,
+    options?: { branch?: string; sha?: string },
+  ) {
+    const body: Record<string, unknown> = {
+      message,
+      content: Buffer.from(content, 'utf-8').toString('base64'),
+    };
+    if (options?.branch) body.branch = options.branch;
+    if (options?.sha) body.sha = options.sha;
+    const apiPath = `/repos/${repo}/contents/${path.split('/').map(encodeURIComponent).join('/')}`;
+    return this.put<{ commit: { sha: string; html_url?: string }; content: { html_url?: string } }>(
+      apiPath,
+      body,
+    );
+  }
+
+  async getRef(repo: string, ref: string) {
+    return this.get<{ ref: string; object: { sha: string; type: string } }>(
+      `/repos/${repo}/git/ref/${encodeURIComponent(ref)}`,
+    );
+  }
+
+  async createRef(repo: string, ref: string, sha: string) {
+    return this.post(`/repos/${repo}/git/refs`, { ref, sha });
+  }
+
+  async createPullRequest(
+    repo: string,
+    title: string,
+    head: string,
+    base: string,
+    body?: string,
+  ) {
+    return this.post<{ number: number; html_url: string; head: { ref: string } }>(
+      `/repos/${repo}/pulls`,
+      { title, head, base, body: body ?? '' },
+    );
+  }
+
+  getBotLogin(): string | null {
+    if (this._user) return this._user;
+    if (this._appSlug) return `${this._appSlug}[bot]`;
+    return null;
+  }
+
+  getCommitAuthor(): GitHubCommitAuthor | null {
+    const identity = this.getBotIdentitySync();
+    if (!identity) return null;
+    return { name: identity.login, email: identity.email, date: new Date().toISOString() };
+  }
+
+  getBotIdentitySync(): GitHubBotIdentity | null {
+    const slug = this._appSlug;
+    const login = this.getBotLogin();
+    if (!slug || !login || this._botUserId == null) return null;
+    return {
+      login,
+      slug,
+      userId: this._botUserId,
+      email: `${this._botUserId}+${login}@users.noreply.github.com`,
+    };
+  }
+
+  async getBotIdentity(): Promise<GitHubBotIdentity | null> {
+    if (!this._appAuth) return null;
+    if (this._botUserId == null) await this.resolveBotUserId();
+    return this.getBotIdentitySync();
+  }
+
+  buildCloneUrl(repo: string, token: string): string {
+    const host = this.host || 'github.com';
+    return `https://x-access-token:${encodeURIComponent(token)}@${host}/${repo}.git`;
+  }
+
+  async resolveBotUserId(): Promise<number | null> {
+    if (this._botUserId != null) return this._botUserId;
+    const slug = this._appSlug;
+    if (!slug) return null;
+    const login = `${slug}[bot]`;
+    const baseUrl = this.host ? `https://${this.host}/api/v3` : 'https://api.github.com';
+    try {
+      const res = await fetch(`${baseUrl}/users/${encodeURIComponent(login)}`, {
+        headers: { Accept: 'application/vnd.github+json' },
+      });
+      if (!res.ok) return null;
+      const data = (await res.json()) as { id?: number };
+      if (typeof data.id === 'number') {
+        this._botUserId = data.id;
+        return data.id;
+      }
+    } catch {
+      return null;
+    }
+    return null;
+  }
+
   // ── Star ─────────────────────────────────────────────────────────
 
   async starRepo(repo: string) {
@@ -445,6 +567,15 @@ export class GhClient {
 
   /** App 的 client_id（verifyAuth 后从 /app 获取，用于 Device Flow） */
   private _clientId: string | null = null;
+  /** Bot 机器用户 numeric id（/users/{slug}[bot]） */
+  private _botUserId: number | null = null;
+
+  /** 确保 App 认证的 Installation Token 对指定 repo 有效，并返回 token */
+  async ensureInstallationTokenForRepo(repo: string): Promise<string | undefined> {
+    if (!this._appAuth) return this.token;
+    await this.ensureTokenForRepo(repo);
+    return this.token;
+  }
   get clientId(): string | null { return this._clientId; }
 
   // ── 事件轮询 ─────────────────────────────────────────────────────

package/src/github-agent-deps.ts

@@ -0,0 +1,82 @@
+/**
+ * Agent tool deps for github.
+ * Endpoints register themselves on start; tools look up by config name / endpoint id.
+ */
+
+import type { GhClient } from './gh-client.js';
+import type { ResolvedGithubConfig } from './protocol.js';
+import type { WorkspaceManager } from './workspace-manager.js';
+
+export interface GithubAgentEndpoint {
+  readonly name: string;
+  readonly gh: GhClient;
+  readonly config: ResolvedGithubConfig;
+  getAPI(): GhClient;
+  getUserOrDefaultAPI(platform?: string, platformUid?: string): Promise<GhClient | null>;
+  getClientId(): string | null;
+  getHost(): string | undefined;
+  getAppSlug(): string | null;
+  getInstallations(): Array<{ id: number; account: { login: string; type: string }; target_type: string }>;
+  getWorkspaceManager(): WorkspaceManager;
+  /** DatabaseHost wired at endpoint creation (optional). */
+  getDatabase?(): unknown;
+}
+
+export interface GithubAgentDeps {
+  getEndpoint: (endpointId?: string) => GithubAgentEndpoint;
+  /** Alias kept for existing agent handlers that call getAdapter(). */
+  getAdapter: () => GithubAgentEndpoint;
+  getWorkspaceManager: () => WorkspaceManager;
+  getDatabase?: () => { models?: Map<string, unknown> } | null | undefined;
+  logger?: {
+    debug: (...args: unknown[]) => void;
+    warn: (...args: unknown[]) => void;
+    error: (...args: unknown[]) => void;
+  };
+}
+
+const endpoints = new Map<string, GithubAgentEndpoint>();
+let override: GithubAgentDeps | null = null;
+
+export function registerGithubAgentEndpoint(
+  endpointId: string,
+  endpoint: GithubAgentEndpoint,
+): () => void {
+  endpoints.set(endpointId, endpoint);
+  return () => {
+    if (endpoints.get(endpointId) === endpoint) {
+      endpoints.delete(endpointId);
+    }
+  };
+}
+
+/** Optional override used by tests / transitional callers. Pass `null` to clear. */
+export function setGithubAgentDeps(deps: GithubAgentDeps | null): void {
+  override = deps;
+}
+
+function lookup(endpointId?: string): GithubAgentEndpoint {
+  if (endpointId) {
+    const registered = endpoints.get(endpointId);
+    if (!registered) throw new Error(`Endpoint ${endpointId} 不存在`);
+    return registered;
+  }
+  const first = endpoints.values().next().value;
+  if (!first) throw new Error('github agent deps not initialized');
+  return first;
+}
+
+export function getGithubAgentDeps(): GithubAgentDeps {
+  if (override) return override;
+  return {
+    getEndpoint: lookup,
+    getAdapter: () => lookup(),
+    getWorkspaceManager: () => lookup().getWorkspaceManager(),
+    getDatabase: () => lookup().getDatabase?.() as
+      { models?: Map<string, unknown> } | null | undefined,
+  };
+}
+
+export function getAdapter(): GithubAgentEndpoint {
+  return getGithubAgentDeps().getAdapter();
+}

package/src/github-bot-handlers.ts

@@ -0,0 +1,109 @@
+/**
+ * GitHub App Bot workflow handlers (Installation Token identity).
+ */
+import type { Message } from 'zhin.js';
+import { getCurrentCommMessage } from '@zhin.js/agent/security';
+import { getAdapter, getGithubAgentDeps } from './github-agent-deps.js';
+import {
+  parseMessageChannel,
+  resolveWorkspaceBranch,
+  formatChannelContext,
+} from './github-channel-context.js';
+
+function requireBotGh() {
+  const gh = getAdapter().getAPI();
+  if (!gh?.isAppAuth) {
+    throw new Error('需要 GitHub App 认证（app_id + private_key），Bot 写操作不可用');
+  }
+  return gh;
+}
+
+function resolveCommMessage(commMessage?: Message): Message {
+  const msg = commMessage ?? getCurrentCommMessage();
+  if (!msg) throw new Error('无 IM 上下文，请在 Issue/PR 评论线程内调用');
+  return msg;
+}
+
+function resolveChannel(msg: Message, repo?: string) {
+  const ctx = parseMessageChannel(msg);
+  if (ctx) return ctx;
+  if (repo) {
+    throw new Error(`请从 GitHub Issue/PR 频道调用，或提供完整 channel（当前仅 repo=${repo}）`);
+  }
+  throw new Error('无法解析 GitHub 频道（需要 Issue/PR 评论上下文）');
+}
+
+export async function executeGithubPrepareWorkspace(
+  args: { repo?: string },
+  commMessage?: Message,
+) {
+  const msg = resolveCommMessage(commMessage);
+  const ctx = resolveChannel(msg, args.repo);
+  const gh = requireBotGh();
+  const wm = getGithubAgentDeps().getWorkspaceManager();
+  const { branch, base } = await resolveWorkspaceBranch(gh, ctx);
+  const repoPath = await wm.checkoutBranch(ctx.repo, branch, base);
+  return [
+    `✅ 工作区就绪`,
+    `📁 ${repoPath}`,
+    `🌿 分支 \`${branch}\`（base: \`${base}\`）`,
+    `📍 ${formatChannelContext(ctx)}`,
+  ].join('\n');
+}
+
+export async function executeGithubPatchFile(
+  args: { repo?: string; path: string; content: string; message: string; branch?: string },
+  commMessage?: Message,
+) {
+  const msg = resolveCommMessage(commMessage);
+  const ctx = resolveChannel(msg, args.repo);
+  const gh = requireBotGh();
+  const { branch } = args.branch
+    ? { branch: args.branch }
+    : await resolveWorkspaceBranch(gh, ctx);
+
+  const existing = await gh.getFileContent(ctx.repo, args.path, branch);
+  const sha = existing.ok ? existing.data.sha : undefined;
+  const r = await gh.createOrUpdateFile(
+    ctx.repo,
+    args.path,
+    args.content,
+    args.message,
+    { branch, sha },
+  );
+  if (!r.ok) {
+    return `❌ 更新文件失败: ${JSON.stringify(r.data)}`;
+  }
+  const url = r.data.content?.html_url ?? r.data.commit?.html_url ?? '';
+  return `✅ 已更新 \`${args.path}\` @ \`${branch}\`${url ? `\n🔗 ${url}` : ''}`;
+}
+
+export async function executeGithubPushBranch(
+  args: { repo?: string; branch?: string; message: string },
+  commMessage?: Message,
+) {
+  const msg = resolveCommMessage(commMessage);
+  const ctx = resolveChannel(msg, args.repo);
+  const gh = requireBotGh();
+  const wm = getGithubAgentDeps().getWorkspaceManager();
+  const branch = args.branch ?? (await resolveWorkspaceBranch(gh, ctx)).branch;
+  const result = await wm.commitAndPush(ctx.repo, branch, args.message);
+  return `✅ ${result}\n📍 ${ctx.repo} @ \`${branch}\``;
+}
+
+export async function executeGithubCreatePr(
+  args: { repo?: string; title: string; body?: string; head?: string; base?: string },
+  commMessage?: Message,
+) {
+  const msg = resolveCommMessage(commMessage);
+  const ctx = resolveChannel(msg, args.repo);
+  const gh = requireBotGh();
+  const resolved = await resolveWorkspaceBranch(gh, ctx);
+  const head = args.head ?? resolved.branch;
+  const base = args.base ?? resolved.base;
+  const r = await gh.createPullRequest(ctx.repo, args.title, head, base, args.body);
+  if (!r.ok) {
+    return `❌ 创建 PR 失败: ${JSON.stringify(r.data)}`;
+  }
+  return `✅ PR #${r.data.number} 已创建\n🔗 ${r.data.html_url}`;
+}

package/src/github-channel-context.ts

@@ -0,0 +1,46 @@
+/**
+ * Parse GitHub Issue/PR channel context from IM messages.
+ */
+import type { Message } from 'zhin.js';
+import { buildChannelId, parseChannelId, type ParsedChannel } from './types.js';
+import type { GhClient } from './gh-client.js';
+
+export interface GitHubChannelContext extends ParsedChannel {
+  channelId: string;
+}
+
+export function parseMessageChannel(message: Message): GitHubChannelContext | null {
+  const channelId = message.$channel?.id;
+  if (!channelId) return null;
+  const parsed = parseChannelId(channelId);
+  if (!parsed) return null;
+  return { ...parsed, channelId };
+}
+
+export function issueBranchName(number: number): string {
+  return `zhin/bot/issue-${number}`;
+}
+
+export async function resolveWorkspaceBranch(
+  gh: GhClient,
+  ctx: GitHubChannelContext,
+): Promise<{ branch: string; base: string }> {
+  if (ctx.type === 'pr') {
+    const pr = await gh.getPR(ctx.repo, ctx.number);
+    if (pr.ok && pr.data?.head?.ref) {
+      const base = pr.data.base?.ref ?? 'main';
+      return { branch: pr.data.head.ref, base };
+    }
+    throw new Error(`无法读取 PR #${ctx.number} 的 head 分支`);
+  }
+
+  const repoInfo = await gh.getRepo(ctx.repo);
+  const base = repoInfo.ok && repoInfo.data?.default_branch
+    ? String(repoInfo.data.default_branch)
+    : 'main';
+  return { branch: issueBranchName(ctx.number), base };
+}
+
+export function formatChannelContext(ctx: GitHubChannelContext): string {
+  return buildChannelId(ctx.repo, ctx.type, ctx.number);
+}

package/src/github-tool-handlers.ts

@@ -0,0 +1,257 @@
+import { formatCompact } from '@zhin.js/logger';
+import type { Message } from 'zhin.js';
+import { getCurrentCommMessage } from '@zhin.js/agent/security';
+import { GhClient } from './gh-client.js';
+import type { EventType } from './types.js';
+import { getAdapter, getGithubAgentDeps } from './github-agent-deps.js';
+
+function oauthModel() {
+  const db = getGithubAgentDeps().getDatabase?.() as {
+    models?: Map<string, unknown>;
+  } | null | undefined;
+  return db?.models?.get('github_oauth_users') as {
+    select: () => { where: (q: object) => Promise<any[]> };
+    insert: (row: object) => Promise<void>;
+    delete: () => { where: (q: object) => Promise<void> };
+  } | undefined;
+}
+
+function subscriptionsModel() {
+  const db = getGithubAgentDeps().getDatabase?.() as {
+    models?: Map<string, unknown>;
+  } | null | undefined;
+  return db?.models?.get('github_subscriptions') as {
+    select: () => { where: (q: object) => Promise<any[]> };
+    insert: (row: object) => Promise<void>;
+    update: (row: object) => { where: (q: object) => Promise<void> };
+    delete: () => { where: (q: object) => Promise<void> };
+  } | undefined;
+}
+
+function depsLogger() {
+  return getGithubAgentDeps().logger ?? {
+    debug: (...args: unknown[]) => console.debug(...args),
+    warn: (...args: unknown[]) => console.warn(...args),
+    error: (...args: unknown[]) => console.error(...args),
+  };
+}
+
+export async function executeGithubStar(args: { action: 'star' | 'unstar' | 'check'; repo: string }, commMessage?: Message) {
+  const adapter = getAdapter();
+  const msg = commMessage ?? getCurrentCommMessage();
+  const gh = await adapter.getUserOrDefaultAPI(msg?.$adapter, msg?.$sender.id);
+  if (!gh) return '❌ 没有可用的 GitHub bot';
+  switch (args.action) {
+    case 'star': {
+      const r = await gh.starRepo(args.repo);
+      return r.ok ? `⭐ 已 Star ${args.repo}` : `❌ ${r.data?.message || JSON.stringify(r.data)}`;
+    }
+    case 'unstar': {
+      const r = await gh.unstarRepo(args.repo);
+      return r.ok ? `💔 已取消 Star ${args.repo}` : `❌ ${r.data?.message || JSON.stringify(r.data)}`;
+    }
+    case 'check': {
+      const starred = await gh.isStarred(args.repo);
+      return starred ? `⭐ 已 Star ${args.repo}` : `☆ 尚未 Star ${args.repo}`;
+    }
+    default:
+      return `❌ 未知操作: ${args.action}`;
+  }
+}
+
+export async function executeGithubBind(_args: Record<string, never>, commMessage?: Message) {
+  const adapter = getAdapter();
+  const log = depsLogger();
+  const msg = commMessage ?? getCurrentCommMessage();
+  if (!msg?.$adapter || !msg?.$sender?.id) return '❌ 无法获取当前用户信息';
+
+  const clientId = adapter.getClientId();
+  if (!clientId) return '❌ Endpoint 未配置 GitHub App 或 App 无 client_id，无法进行账号绑定';
+
+  const model = oauthModel();
+  if (!model) return '❌ 数据库未就绪';
+
+  const [existing] = await model.select().where({ platform: msg.$adapter, platform_uid: msg.$sender.id });
+  if (existing) {
+    return `⚠️ 你已绑定 GitHub 账号: ${existing.github_login}\n如需重新绑定，请先执行 github_unbind`;
+  }
+
+  try {
+    const host = adapter.getHost();
+    const codeResp = await GhClient.deviceFlowRequestCode(clientId, host);
+    const tokenPromise = GhClient.deviceFlowPollToken(
+      clientId, codeResp.device_code, codeResp.interval, codeResp.expires_in, host,
+    );
+
+    const replyMsg = [
+      '🔗 请在浏览器中打开以下链接进行授权：',
+      `   ${codeResp.verification_uri}`,
+      '',
+      `📋 输入验证码: **${codeResp.user_code}**`,
+      '',
+      `⏳ 等待授权中…（${Math.floor(codeResp.expires_in / 60)} 分钟内有效）`,
+    ].join('\n');
+
+    tokenPromise.then(async (tokenData) => {
+      if (!tokenData) {
+        log.warn(formatCompact({ op: 'device_flow', ok: false, platform: msg.$adapter, sender: msg.$sender.id }));
+        return;
+      }
+
+      const userGh = new GhClient({ host, token: tokenData.access_token });
+      const authResult = await userGh.verifyAuth();
+      const login = authResult.ok ? authResult.user : 'unknown';
+
+      await model.insert({
+        id: Date.now(),
+        platform: msg.$adapter,
+        platform_uid: msg.$sender.id,
+        github_login: login,
+        access_token: tokenData.access_token,
+        created_at: Date.now(),
+      });
+      log.debug(formatCompact({ op: 'bind', platform: msg.$adapter, sender: msg.$sender.id, login }));
+
+      if (msg?.$reply) {
+        await msg.$reply(`✅ GitHub 账号绑定成功！\n👤 ${login}`);
+      }
+    }).catch((err) => {
+      log.error('GitHub Device Flow 错误:', err);
+    });
+
+    return replyMsg;
+  } catch (e: unknown) {
+    return `❌ Device Flow 启动失败: ${e instanceof Error ? e.message : String(e)}`;
+  }
+}
+
+export async function executeGithubUnbind(_args: Record<string, never>, commMessage?: Message) {
+  const msg = commMessage ?? getCurrentCommMessage();
+  if (!msg?.$adapter || !msg?.$sender?.id) return '❌ 无法获取当前用户信息';
+
+  const model = oauthModel();
+  if (!model) return '❌ 数据库未就绪';
+
+  const [existing] = await model.select().where({ platform: msg.$adapter, platform_uid: msg.$sender.id });
+  if (!existing) return '📭 你尚未绑定 GitHub 账号';
+
+  await model.delete().where({ id: existing.id });
+  return `✅ 已解除 GitHub 账号绑定: ${existing.github_login}`;
+}
+
+export async function executeGithubWhoami(_args: Record<string, never>, commMessage?: Message) {
+  const adapter = getAdapter();
+  const msg = commMessage ?? getCurrentCommMessage();
+  if (!msg?.$adapter || !msg?.$sender?.id) return '❌ 无法获取当前用户信息';
+
+  const model = oauthModel();
+  if (!model) return '❌ 数据库未就绪';
+
+  const [existing] = await model.select().where({ platform: msg.$adapter, platform_uid: msg.$sender.id });
+  if (!existing) return '📭 你尚未绑定 GitHub 账号\n🔗 使用 github_bind 绑定你的账号';
+
+  const userGh = new GhClient({ host: adapter.getHost(), token: existing.access_token });
+  const auth = await userGh.verifyAuth();
+  if (auth.ok) {
+    return `👤 已绑定 GitHub 账号: ${auth.user}\n📅 绑定时间: ${new Date(existing.created_at).toLocaleString('zh-CN')}`;
+  }
+  return `⚠️ 已绑定账号 ${existing.github_login}，但 Token 已失效\n🔗 请执行 github_unbind 后重新 github_bind`;
+}
+
+export async function executeGithubInstall() {
+  const adapter = getAdapter();
+  const slug = adapter.getAppSlug();
+  if (!slug) return '❌ Endpoint 未配置 GitHub App';
+  const host = adapter.getHost() || 'github.com';
+  const installations = adapter.getInstallations();
+  let msg = `🔗 请点击以下链接安装 GitHub App 到你的仓库：\n   https://${host}/apps/${slug}/installations/new`;
+  if (installations.length) {
+    msg += `\n\n📋 当前已安装 (${installations.length}):`;
+    for (const inst of installations) {
+      msg += `\n  • ${inst.account.login} (${inst.account.type})`;
+    }
+  }
+  return msg;
+}
+
+export async function executeGithubSubscribe(args: { repo: string; events?: string }, commMessage?: Message) {
+  const msg = commMessage ?? getCurrentCommMessage();
+  if (!msg?.$adapter || !msg?.$sender.id || !msg?.$channel?.id || !msg?.$endpoint) {
+    return '❌ 无法获取当前聊天通道信息';
+  }
+
+  const model = subscriptionsModel();
+  if (!model) return '❌ 数据库未就绪';
+
+  const validEvents: EventType[] = ['push', 'issue', 'star', 'fork', 'unstar', 'pull_request'];
+  const events: EventType[] = args.events
+    ? args.events.split(',').map((s) => s.trim()).filter((e): e is EventType => validEvents.includes(e as EventType))
+    : validEvents;
+  if (!events.length) return `❌ 无效的事件类型，可选: ${validEvents.join(', ')}`;
+
+  const [existing] = await model.select().where({
+    repo: args.repo,
+    target_id: msg.$channel?.id,
+    adapter: msg.$adapter,
+    endpoint: msg.$endpoint,
+  });
+  if (existing) {
+    await model.update({ events, target_type: msg.$channel?.type || 'private' }).where({ id: existing.id });
+    return `✅ 已更新订阅 ${args.repo}\n📡 事件: ${events.join(', ')}`;
+  }
+
+  await model.insert({
+    id: Date.now(),
+    repo: args.repo,
+    events,
+    target_id: msg.$channel?.id,
+    target_type: msg.$channel?.type || 'private',
+    adapter: msg.$adapter,
+    endpoint: msg.$endpoint,
+  });
+  return `✅ 已订阅 ${args.repo}\n📡 事件: ${events.join(', ')}\n📌 通知将推送到当前通道`;
+}
+
+export async function executeGithubUnsubscribe(args: { repo: string }, commMessage?: Message) {
+  const msg = commMessage ?? getCurrentCommMessage();
+  if (!msg?.$adapter || !msg?.$channel?.id || !msg?.$endpoint) {
+    return '❌ 无法获取当前聊天通道信息';
+  }
+
+  const model = subscriptionsModel();
+  if (!model) return '❌ 数据库未就绪';
+
+  const [existing] = await model.select().where({
+    repo: args.repo,
+    target_id: msg.$channel?.id,
+    adapter: msg.$adapter,
+    endpoint: msg.$endpoint,
+  });
+  if (!existing) return `📭 当前通道未订阅 ${args.repo}`;
+
+  await model.delete().where({ id: existing.id });
+  return `✅ 已取消订阅 ${args.repo}`;
+}
+
+export async function executeGithubSubscriptions(_args: Record<string, never>, commMessage?: Message) {
+  const msg = commMessage ?? getCurrentCommMessage();
+  if (!msg?.$adapter || !msg?.$channel?.id || !msg?.$endpoint) {
+    return '❌ 无法获取当前聊天通道信息';
+  }
+
+  const model = subscriptionsModel();
+  if (!model) return '❌ 数据库未就绪';
+
+  const subs = await model.select().where({
+    target_id: msg.$channel?.id,
+    adapter: msg.$adapter,
+    endpoint: msg.$endpoint,
+  });
+  if (!subs?.length) return '📭 当前通道没有任何 GitHub 订阅';
+
+  return `📋 当前通道订阅 (${subs.length}):\n\n` +
+    subs.map((s: any) => {
+      const events = Array.isArray(s.events) ? s.events : [];
+      return `  📦 ${s.repo}\n     📡 ${events.join(', ') || '(无事件)'}`;
+    }).join('\n\n');
+}