@zhin.js/adapter-github 1.0.1 → 1.1.0

package/lib/gh-client.js

@@ -181,6 +181,7 @@ export class GhClient {
                     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} 仓库)` };
                 }
@@ -265,6 +266,95 @@ export class GhClient {
     async deletePRReviewComment(repo, commentId) {
         return this.del(`/repos/${repo}/pulls/comments/${commentId}`);
     }
+    // ── Contents / Pulls（Bot 写操作）──────────────────────────────────
+    async getFileContent(repo, path, ref) {
+        let apiPath = `/repos/${repo}/contents/${path.split('/').map(encodeURIComponent).join('/')}`;
+        if (ref)
+            apiPath += `?ref=${encodeURIComponent(ref)}`;
+        return this.get(apiPath);
+    }
+    async createOrUpdateFile(repo, path, content, message, options) {
+        const body = {
+            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(apiPath, body);
+    }
+    async getRef(repo, ref) {
+        return this.get(`/repos/${repo}/git/ref/${encodeURIComponent(ref)}`);
+    }
+    async createRef(repo, ref, sha) {
+        return this.post(`/repos/${repo}/git/refs`, { ref, sha });
+    }
+    async createPullRequest(repo, title, head, base, body) {
+        return this.post(`/repos/${repo}/pulls`, { title, head, base, body: body ?? '' });
+    }
+    getBotLogin() {
+        if (this._user)
+            return this._user;
+        if (this._appSlug)
+            return `${this._appSlug}[bot]`;
+        return null;
+    }
+    getCommitAuthor() {
+        const identity = this.getBotIdentitySync();
+        if (!identity)
+            return null;
+        return { name: identity.login, email: identity.email, date: new Date().toISOString() };
+    }
+    getBotIdentitySync() {
+        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() {
+        if (!this._appAuth)
+            return null;
+        if (this._botUserId == null)
+            await this.resolveBotUserId();
+        return this.getBotIdentitySync();
+    }
+    buildCloneUrl(repo, token) {
+        const host = this.host || 'github.com';
+        return `https://x-access-token:${encodeURIComponent(token)}@${host}/${repo}.git`;
+    }
+    async resolveBotUserId() {
+        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());
+            if (typeof data.id === 'number') {
+                this._botUserId = data.id;
+                return data.id;
+            }
+        }
+        catch {
+            return null;
+        }
+        return null;
+    }
     // ── Star ─────────────────────────────────────────────────────────
     async starRepo(repo) {
         return this.put(`/user/starred/${repo}`);
@@ -384,6 +474,15 @@ export class GhClient {
     get appSlug() { return this._appSlug; }
     /** App 的 client_id（verifyAuth 后从 /app 获取，用于 Device Flow） */
     _clientId = null;
+    /** Bot 机器用户 numeric id（/users/{slug}[bot]） */
+    _botUserId = null;
+    /** 确保 App 认证的 Installation Token 对指定 repo 有效，并返回 token */
+    async ensureInstallationTokenForRepo(repo) {
+        if (!this._appAuth)
+            return this.token;
+        await this.ensureTokenForRepo(repo);
+        return this.token;
+    }
     get clientId() { return this._clientId; }
     // ── 事件轮询 ─────────────────────────────────────────────────────
     /**
@@ -495,4 +594,3 @@ export class GhClient {
         return null;
     }
 }
-//# sourceMappingURL=gh-client.js.map

package/lib/github-bot-handlers.d.ts

@@ -0,0 +1,27 @@
+/**
+ * GitHub App Bot workflow handlers (Installation Token identity).
+ */
+import type { Message } from 'zhin.js';
+import type { GithubClient } from './client.js';
+export declare function executeGithubPrepareWorkspace(args: {
+    repo?: string;
+}, client: GithubClient, commMessage?: Message): Promise<string>;
+export declare function executeGithubPatchFile(args: {
+    repo?: string;
+    path: string;
+    content: string;
+    message: string;
+    branch?: string;
+}, client: GithubClient, commMessage?: Message): Promise<string>;
+export declare function executeGithubPushBranch(args: {
+    repo?: string;
+    branch?: string;
+    message: string;
+}, client: GithubClient, commMessage?: Message): Promise<string>;
+export declare function executeGithubCreatePr(args: {
+    repo?: string;
+    title: string;
+    body?: string;
+    head?: string;
+    base?: string;
+}, client: GithubClient, commMessage?: Message): Promise<string>;

package/lib/github-bot-handlers.js

@@ -0,0 +1,76 @@
+import { getCurrentCommMessage } from '@zhin.js/agent/security';
+import { parseMessageChannel, resolveWorkspaceBranch, formatChannelContext, } from './github-channel-context.js';
+function requireBotGh(client) {
+    const gh = client.api;
+    if (!gh?.isAppAuth) {
+        throw new Error('需要 GitHub App 认证（app_id + private_key），Bot 写操作不可用');
+    }
+    return gh;
+}
+function resolveCommMessage(commMessage) {
+    const msg = commMessage ?? getCurrentCommMessage();
+    if (!msg)
+        throw new Error('无 IM 上下文，请在 Issue/PR 评论线程内调用');
+    return msg;
+}
+function resolveChannel(msg, repo) {
+    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, client, commMessage) {
+    const msg = resolveCommMessage(commMessage);
+    const ctx = resolveChannel(msg, args.repo);
+    const gh = requireBotGh(client);
+    const wm = client.workspaceManager;
+    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, client, commMessage) {
+    const msg = resolveCommMessage(commMessage);
+    const ctx = resolveChannel(msg, args.repo);
+    const gh = requireBotGh(client);
+    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, client, commMessage) {
+    const msg = resolveCommMessage(commMessage);
+    const ctx = resolveChannel(msg, args.repo);
+    const gh = requireBotGh(client);
+    const wm = client.workspaceManager;
+    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, client, commMessage) {
+    const msg = resolveCommMessage(commMessage);
+    const ctx = resolveChannel(msg, args.repo);
+    const gh = requireBotGh(client);
+    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/lib/github-channel-context.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Parse GitHub Issue/PR channel context from IM messages.
+ */
+import type { Message } from 'zhin.js';
+import { type ParsedChannel } from './types.js';
+import type { GhClient } from './gh-client.js';
+export interface GitHubChannelContext extends ParsedChannel {
+    channelId: string;
+}
+export declare function parseMessageChannel(message: Message): GitHubChannelContext | null;
+export declare function issueBranchName(number: number): string;
+export declare function resolveWorkspaceBranch(gh: GhClient, ctx: GitHubChannelContext): Promise<{
+    branch: string;
+    base: string;
+}>;
+export declare function formatChannelContext(ctx: GitHubChannelContext): string;

package/lib/github-channel-context.js

@@ -0,0 +1,31 @@
+import { buildChannelId, parseChannelId } from './types.js';
+export function parseMessageChannel(message) {
+    const channelId = message.$channel?.id;
+    if (!channelId)
+        return null;
+    const parsed = parseChannelId(channelId);
+    if (!parsed)
+        return null;
+    return { ...parsed, channelId };
+}
+export function issueBranchName(number) {
+    return `zhin/bot/issue-${number}`;
+}
+export async function resolveWorkspaceBranch(gh, ctx) {
+    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) {
+    return buildChannelId(ctx.repo, ctx.type, ctx.number);
+}

package/lib/github-endpoint-commands.d.ts

@@ -0,0 +1 @@
+export declare const githubEndpointCommands: import("@zhin.js/adapter").EndpointCommands<Readonly<import("@zhin.js/command").CommandDefinition<unknown, unknown, import("@zhin.js/command").CommandMessage, string | undefined>>>;

package/lib/github-endpoint-commands.js

@@ -0,0 +1,22 @@
+/**
+ * `github.endpoint` 命令族：由 @zhin.js/adapter 的 createEndpointCommands 套件生成。
+ * commands/endpoint/ 下的 list / add / remove 直接默认导出这三项。
+ *
+ * 字段说明：private_key 内容长且含换行，不适合 kv 直传——运行时（gh-client
+ * resolvePrivateKey）本就支持 PEM 内容或文件路径，故 add 采用**内联路径**形式：
+ * `github.endpoint add mybot app_id=123456 private_key=./data/mybot.pem`。
+ */
+import { createEndpointCommands } from 'zhin.js/adapter';
+import { defineCommand } from 'zhin.js/command';
+import { githubRuntimeStateToken } from './github-runtime-state.js';
+export const githubEndpointCommands = createEndpointCommands({
+    adapterKey: 'github',
+    adapterDisplayName: 'GitHub',
+    fields: [
+        { key: 'app_id', required: true, env: true, description: 'GitHub App ID' },
+        { key: 'private_key', required: true, description: 'PEM 文件路径（推荐，如 ./data/xxx.pem）或 PEM 内容' },
+        { key: 'webhook_secret', env: true, description: 'webhook 签名密钥（不配则 API-only）' },
+    ],
+    running: (use) => use(githubRuntimeStateToken).endpoints.values(),
+    describeEntry: (entry) => `app_id: ${String(entry.app_id ?? entry.appId)}`,
+}, defineCommand);

package/lib/github-runtime-state.d.ts

@@ -0,0 +1 @@
+export declare const githubRuntimeStateToken: import("zhin.js").Token<import("@zhin.js/adapter").EndpointRuntimeState>;

package/lib/github-runtime-state.js

@@ -0,0 +1,6 @@
+/**
+ * GitHub 插件实例的运行时状态：adapter create() 注册的 endpoint 列表。
+ * 由 plugin.ts setup() provide，adapter create 与 `github.endpoint` 命令共享（同一 owner generation）。
+ */
+import { defineEndpointRuntimeStateToken } from 'zhin.js/adapter';
+export const githubRuntimeStateToken = defineEndpointRuntimeStateToken('github');

package/lib/github-tool-handlers.d.ts

@@ -0,0 +1,18 @@
+import type { Message } from 'zhin.js';
+import type { GithubClient } from './client.js';
+export declare function executeGithubStar(args: {
+    action: 'star' | 'unstar' | 'check';
+    repo: string;
+}, client: GithubClient, commMessage?: Message): Promise<string>;
+export declare function executeGithubBind(_args: Record<string, never>, client: GithubClient, commMessage?: Message): Promise<string>;
+export declare function executeGithubUnbind(_args: Record<string, never>, client: GithubClient, commMessage?: Message): Promise<string>;
+export declare function executeGithubWhoami(_args: Record<string, never>, client: GithubClient, commMessage?: Message): Promise<string>;
+export declare function executeGithubInstall(client: GithubClient): Promise<string>;
+export declare function executeGithubSubscribe(args: {
+    repo: string;
+    events?: string;
+}, client: GithubClient, commMessage?: Message): Promise<string>;
+export declare function executeGithubUnsubscribe(args: {
+    repo: string;
+}, client: GithubClient, commMessage?: Message): Promise<string>;
+export declare function executeGithubSubscriptions(_args: Record<string, never>, client: GithubClient, commMessage?: Message): Promise<string>;

package/lib/github-tool-handlers.js

@@ -0,0 +1,214 @@
+import { formatCompact } from '@zhin.js/logger';
+import { getCurrentCommMessage } from '@zhin.js/agent/security';
+import { GhClient } from './gh-client.js';
+function oauthModel(client) {
+    const db = client.database;
+    return db?.models?.get('github_oauth_users');
+}
+function subscriptionsModel(client) {
+    const db = client.database;
+    return db?.models?.get('github_subscriptions');
+}
+function depsLogger() {
+    return {
+        debug: (...args) => console.debug(...args),
+        warn: (...args) => console.warn(...args),
+        error: (...args) => console.error(...args),
+    };
+}
+export async function executeGithubStar(args, client, commMessage) {
+    const msg = commMessage ?? getCurrentCommMessage();
+    const gh = await client.getUserOrDefaultApi(msg?.$adapter, msg?.$sender.id);
+    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, client, commMessage) {
+    const log = depsLogger();
+    const msg = commMessage ?? getCurrentCommMessage();
+    if (!msg?.$adapter || !msg?.$sender?.id)
+        return '❌ 无法获取当前用户信息';
+    const clientId = client.clientId;
+    if (!clientId)
+        return '❌ Endpoint 未配置 GitHub App 或 App 无 client_id，无法进行账号绑定';
+    const model = oauthModel(client);
+    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 = client.host;
+        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) {
+        return `❌ Device Flow 启动失败: ${e instanceof Error ? e.message : String(e)}`;
+    }
+}
+export async function executeGithubUnbind(_args, client, commMessage) {
+    const msg = commMessage ?? getCurrentCommMessage();
+    if (!msg?.$adapter || !msg?.$sender?.id)
+        return '❌ 无法获取当前用户信息';
+    const model = oauthModel(client);
+    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, client, commMessage) {
+    const msg = commMessage ?? getCurrentCommMessage();
+    if (!msg?.$adapter || !msg?.$sender?.id)
+        return '❌ 无法获取当前用户信息';
+    const model = oauthModel(client);
+    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: client.host, 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(client) {
+    const slug = client.appSlug;
+    if (!slug)
+        return '❌ Endpoint 未配置 GitHub App';
+    const host = client.host || 'github.com';
+    const installations = client.installations;
+    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, client, commMessage) {
+    const msg = commMessage ?? getCurrentCommMessage();
+    if (!msg?.$adapter || !msg?.$sender.id || !msg?.$channel?.id || !msg?.$endpoint) {
+        return '❌ 无法获取当前聊天通道信息';
+    }
+    const model = subscriptionsModel(client);
+    if (!model)
+        return '❌ 数据库未就绪';
+    const validEvents = ['push', 'issue', 'star', 'fork', 'unstar', 'pull_request'];
+    const events = args.events
+        ? args.events.split(',').map((s) => s.trim()).filter((e) => validEvents.includes(e))
+        : 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, client, commMessage) {
+    const msg = commMessage ?? getCurrentCommMessage();
+    if (!msg?.$adapter || !msg?.$channel?.id || !msg?.$endpoint) {
+        return '❌ 无法获取当前聊天通道信息';
+    }
+    const model = subscriptionsModel(client);
+    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, client, commMessage) {
+    const msg = commMessage ?? getCurrentCommMessage();
+    if (!msg?.$adapter || !msg?.$channel?.id || !msg?.$endpoint) {
+        return '❌ 无法获取当前聊天通道信息';
+    }
+    const model = subscriptionsModel(client);
+    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) => {
+            const events = Array.isArray(s.events) ? s.events : [];
+            return `  📦 ${s.repo}\n     📡 ${events.join(', ') || '(无事件)'}`;
+        }).join('\n\n');
+}

package/lib/index.d.ts

@@ -1,34 +1,9 @@
-import { GitHubAdapter } from './adapter.js';
-declare module 'zhin.js' {
-    interface Adapters {
-        github: GitHubAdapter;
-    }
-    namespace Plugin {
-        interface Contexts {
-            router: import('@zhin.js/host-router').Router;
-        }
-    }
-    interface Models {
-        github_subscriptions: {
-            id: number;
-            repo: string;
-            events: import('./types.js').EventType[];
-            target_id: string;
-            target_type: 'private' | 'group' | 'channel';
-            adapter: string;
-            endpoint: string;
-        };
-        github_events: {
-            id: number;
-            repo: string;
-            event_type: string;
-            payload: any;
-        };
-        github_oauth_users: import('./types.js').GitHubOAuthUser;
-    }
-}
+export { buildChannelId, enrichInboundContent, formatInboundContent, formatNotification, formatOutboundBody, normalizeWebhookPath, parseChannelId, parseIssueCommentInbound, parsePrReviewCommentInbound, parsePrReviewInbound, resolveGithubConfig, shouldAutoReplyRepo, verifyWebhookSignature, type GithubAdapterConfig, type GithubInboundComment, type GithubWireSegment, type ResolvedGithubConfig, } from './protocol.js';
 export * from './types.js';
-export { GitHubEndpoint, parseMarkdown, toMarkdown } from './endpoint.js';
-export { GitHubAdapter } from './adapter.js';
 export { GhClient } from './gh-client.js';
-//# sourceMappingURL=index.d.ts.map
+export { GithubClient, githubClient, type GithubClientEventMap } from './client.js';
+export { WorkspaceManager } from './workspace-manager.js';
+export { parseMessageChannel, issueBranchName, resolveWorkspaceBranch, formatChannelContext, } from './github-channel-context.js';
+export { GithubEndpoint, defaultCreateClient, type GithubEndpointOptions, } from './endpoint.js';
+export { GITHUB_OAUTH_USERS_TABLE, GITHUB_OAUTH_USERS_SCHEMA, defineGithubOauthUsersTable, lookupGithubOauthAccessToken, } from './oauth-users.js';
+export { registerGithubWebhookRoutes, handleGithubWebhookRequest, dispatchGithubWebhookPayload, type GithubWebhookHandler, } from './webhook.js';