@zhin.js/adapter-github 3.0.1 → 3.0.3

package/lib/endpoint.d.ts

@@ -1,26 +1,48 @@
-/**
- * GitHub Endpoint 实现（基于 gh CLI）
- */
-import { Endpoint, Message, SendContent, SendOptions, type MessageSegment } from 'zhin.js';
-import type { GitHubEndpointConfig, IssueCommentPayload, PRReviewCommentPayload, PRReviewPayload } from './types.js';
-import type { GitHubAdapter } from './adapter.js';
+import type { EndpointInstance } from '@zhin.js/adapter';
+import type { MessageGateway } from '@zhin.js/core/runtime';
+import type { HttpHost } from '@zhin.js/host-http';
+import type { CapabilityId, DatabaseHost } from '@zhin.js/plugin-runtime';
 import { GhClient } from './gh-client.js';
-export declare function parseMarkdown(md: string): MessageSegment[];
-export declare function toMarkdown(content: SendContent): string;
-export declare class GitHubEndpoint implements Endpoint<GitHubEndpointConfig, IssueCommentPayload> {
-    adapter: GitHubAdapter;
-    $config: GitHubEndpointConfig;
-    $connected: boolean;
-    gh: GhClient;
-    get $id(): string;
-    get logger(): import("zhin.js").Logger;
-    constructor(adapter: GitHubAdapter, $config: GitHubEndpointConfig);
-    $connect(): Promise<void>;
-    $disconnect(): Promise<void>;
-    $formatMessage(payload: IssueCommentPayload): Message<IssueCommentPayload>;
-    formatPRReviewComment(payload: PRReviewCommentPayload): Message<PRReviewCommentPayload>;
-    formatPRReview(payload: PRReviewPayload): Message<PRReviewPayload> | null;
-    $sendMessage(options: SendOptions): Promise<string>;
-    $recallMessage(id: string): Promise<void>;
+import { type GithubInboundComment, type ResolvedGithubConfig } from './protocol.js';
+import { WorkspaceManager } from './workspace-manager.js';
+export interface GithubEndpointOptions {
+    readonly id: CapabilityId;
+    readonly gateway: MessageGateway;
+    readonly http?: HttpHost;
+    readonly database?: DatabaseHost;
+    readonly config: ResolvedGithubConfig;
+    readonly createClient?: (config: ResolvedGithubConfig) => GhClient;
 }
-//# sourceMappingURL=endpoint.d.ts.map
+export declare class GithubEndpoint implements EndpointInstance {
+    #private;
+    readonly gh: GhClient;
+    readonly config: ResolvedGithubConfig;
+    readonly name: string;
+    constructor(options: GithubEndpointOptions);
+    getAPI(): GhClient;
+    getUserOrDefaultAPI(platform?: string, platformUid?: string): Promise<GhClient | null>;
+    getClientId(): string | null;
+    getHost(): string | undefined;
+    getAppSlug(): string | null;
+    getInstallations(): {
+        id: number;
+        account: {
+            login: string;
+            type: string;
+        };
+        target_type: string;
+    }[];
+    getWorkspaceManager(): WorkspaceManager;
+    getDatabase(): DatabaseHost | undefined;
+    start(): Promise<void>;
+    open(): void;
+    close(): void;
+    stop(): Promise<void>;
+    send({ target, payload }: {
+        readonly target: string;
+        readonly payload: unknown;
+    }): Promise<string>;
+    /** Test / internal: admit a parsed comment when open. */
+    admit(comment: GithubInboundComment): void;
+}
+export declare function defaultCreateClient(config: ResolvedGithubConfig): GhClient;

package/lib/endpoint.js

@@ -1,165 +1,165 @@
 /**
- * GitHub Endpoint 实现（基于 gh CLI）
+ * GithubEndpoint — lifecycle, outbound send, inbound admit.
  */
-import { formatCompact, Message, coerceQrcodeSegmentsToText, expandInteractiveSegmentsInContent, } from 'zhin.js';
-import { buildChannelId, parseChannelId } from './types.js';
+import path from 'node:path';
+import { formatCompact, getLogger } from '@zhin.js/logger';
 import { GhClient } from './gh-client.js';
-import { fromCanonicalSegments, toCanonicalSegments } from './segment-mapper.js';
-export function parseMarkdown(md) {
-    const segments = [];
-    const mentionRe = /@(\w[-\w]*)/g;
-    let lastIdx = 0;
-    let match;
-    while ((match = mentionRe.exec(md)) !== null) {
-        if (match.index > lastIdx)
-            segments.push({ type: 'text', data: { text: md.slice(lastIdx, match.index) } });
-        segments.push({ type: 'at', data: { id: match[1], name: match[1], text: match[0] } });
-        lastIdx = match.index + match[0].length;
+import { registerGithubAgentEndpoint } from './github-agent-deps.js';
+import { lookupGithubOauthAccessToken } from './oauth-users.js';
+import { enrichInboundContent, formatInboundContent, formatOutboundBody, parseChannelId, } from './protocol.js';
+import { registerGithubWebhookRoutes } from './webhook.js';
+import { WorkspaceManager } from './workspace-manager.js';
+const logger = getLogger('github');
+export class GithubEndpoint {
+    #options;
+    gh;
+    config;
+    name;
+    #workspaceManager = null;
+    #routeReleases = [];
+    #open = false;
+    #started = false;
+    #unregisterAgent;
+    constructor(options) {
+        this.#options = options;
+        this.config = options.config;
+        this.name = options.config.name;
+        this.gh = options.createClient?.(options.config) ?? defaultCreateClient(options.config);
     }
-    if (lastIdx < md.length)
-        segments.push({ type: 'text', data: { text: md.slice(lastIdx) } });
-    return segments.length ? segments : [{ type: 'text', data: { text: md } }];
-}
-export function toMarkdown(content) {
-    if (!Array.isArray(content))
-        content = [content];
-    return content.map(seg => {
-        if (typeof seg === 'string')
-            return seg;
-        switch (seg.type) {
-            case 'text': return seg.data.text || '';
-            case 'mention': return `@${seg.data.name || seg.data.target}`;
-            case 'at': return `@${seg.data.name || seg.data.id}`;
-            case 'image': return seg.data.url ? `![image](${seg.data.url})` : '[image]';
-            case 'link': return `[${seg.data.text || seg.data.url}](${seg.data.url})`;
-            default: return seg.data?.text || `[${seg.type}]`;
+    getAPI() {
+        return this.gh;
+    }
+    async getUserOrDefaultAPI(platform, platformUid) {
+        if (platform && platformUid) {
+            const token = await lookupGithubOauthAccessToken(this.#options.database, platform, platformUid);
+            if (token)
+                return this.gh.withToken(token);
         }
-    }).join('');
-}
-export class GitHubEndpoint {
-    adapter;
-    $config;
-    $connected = false;
-    gh;
-    get $id() { return this.$config.name; }
-    get logger() {
-        return this.adapter.plugin.logger;
+        return this.gh;
     }
-    constructor(adapter, $config) {
-        this.adapter = adapter;
-        this.$config = $config;
-        const { host, app_id, private_key } = $config;
-        const appAuth = app_id && private_key
-            ? { appId: app_id, privateKey: private_key }
-            : undefined;
-        this.gh = new GhClient({ host, appAuth });
+    getClientId() {
+        return this.gh.clientId || null;
     }
-    async $connect() {
-        const result = await this.gh.verifyAuth();
-        if (!result.ok)
-            throw new Error(`GitHub 认证失败: ${result.message}`);
-        this.$connected = true;
-        this.logger.info(formatCompact({ endpoint: this.$id }));
+    getHost() {
+        return this.config.host;
     }
-    async $disconnect() {
-        this.$connected = false;
-        this.logger.debug(formatCompact({ endpoint: this.$id, disconnect: true }));
+    getAppSlug() {
+        return this.gh.appSlug || null;
     }
-    $formatMessage(payload) {
-        const repo = payload.repository.full_name;
-        const number = payload.issue.number;
-        const isPR = 'pull_request' in payload.issue;
-        const channelId = buildChannelId(repo, isPR ? 'pr' : 'issue', number);
-        const gh = this.gh;
-        const result = Message.from(payload, {
-            $id: payload.comment.id.toString(),
-            $adapter: 'github',
-            $endpoint: this.$config.name,
-            $sender: { id: payload.sender.login, name: payload.sender.login },
-            $channel: { id: channelId, type: 'group' },
-            $content: toCanonicalSegments(parseMarkdown(payload.comment.body)),
-            $raw: payload.comment.body,
-            $timestamp: new Date(payload.comment.created_at).getTime(),
-            $recall: async () => { await gh.deleteIssueComment(repo, payload.comment.id); },
-            $reply: async (content, quote) => {
-                const text = toMarkdown(content);
-                const finalBody = quote ? `> ${payload.comment.body.split('\n')[0]}\n\n${text}` : text;
-                const r = await gh.createIssueComment(repo, number, finalBody);
-                return r.ok ? r.data.id.toString() : '';
-            },
-        });
-        return result;
+    getInstallations() {
+        return this.gh.installations || [];
     }
-    formatPRReviewComment(payload) {
-        const repo = payload.repository.full_name;
-        const number = payload.pull_request.number;
-        const channelId = buildChannelId(repo, 'pr', number);
-        const gh = this.gh;
-        const body = payload.comment.path
-            ? `**${payload.comment.path}**\n${payload.comment.diff_hunk ? '```diff\n' + payload.comment.diff_hunk + '\n```\n' : ''}${payload.comment.body}`
-            : payload.comment.body;
-        return Message.from(payload, {
-            $id: payload.comment.id.toString(),
-            $adapter: 'github',
-            $endpoint: this.$config.name,
-            $sender: { id: payload.sender.login, name: payload.sender.login },
-            $channel: { id: channelId, type: 'group' },
-            $content: toCanonicalSegments(parseMarkdown(body)),
-            $raw: body,
-            $timestamp: new Date(payload.comment.created_at).getTime(),
-            $recall: async () => { await gh.deletePRReviewComment(repo, payload.comment.id); },
-            $reply: async (content) => {
-                const r = await gh.createPRComment(repo, number, toMarkdown(content));
-                return r.ok ? r.data.id.toString() : '';
-            },
-        });
+    getWorkspaceManager() {
+        if (this.#workspaceManager)
+            return this.#workspaceManager;
+        const workspaceRoot = this.config.workspaceRoot
+            ?? path.join(process.cwd(), 'data', 'github-workspaces');
+        this.#workspaceManager = new WorkspaceManager(this.gh, workspaceRoot);
+        return this.#workspaceManager;
     }
-    formatPRReview(payload) {
-        if (!payload.review.body)
-            return null;
-        const repo = payload.repository.full_name;
-        const number = payload.pull_request.number;
-        const channelId = buildChannelId(repo, 'pr', number);
-        const gh = this.gh;
-        const stateLabel = {
-            approved: '✅ APPROVED', changes_requested: '🔄 CHANGES REQUESTED',
-            commented: '💬 COMMENTED', dismissed: '❌ DISMISSED',
-        };
-        const body = `**[${stateLabel[payload.review.state] || payload.review.state}]**\n${payload.review.body}`;
-        return Message.from(payload, {
-            $id: payload.review.id.toString(),
-            $adapter: 'github',
-            $endpoint: this.$config.name,
-            $sender: { id: payload.sender.login, name: payload.sender.login },
-            $channel: { id: channelId, type: 'group' },
-            $content: toCanonicalSegments(parseMarkdown(body)),
-            $raw: body,
-            $timestamp: new Date(payload.review.submitted_at).getTime(),
-            $recall: async () => { },
-            $reply: async (content) => {
-                const r = await gh.createPRComment(repo, number, toMarkdown(content));
-                return r.ok ? r.data.id.toString() : '';
-            },
-        });
+    getDatabase() {
+        return this.#options.database;
     }
-    async $sendMessage(options) {
-        const parsed = parseChannelId(options.id);
+    async start() {
+        if (this.#started)
+            return;
+        this.#started = true;
+        try {
+            const result = await this.gh.verifyAuth();
+            if (!result.ok)
+                throw new Error(`GitHub 认证失败: ${result.message}`);
+            this.#unregisterAgent = registerGithubAgentEndpoint(this.name, this);
+            if (this.config.webhookSecret) {
+                if (!this.#options.http) {
+                    throw new TypeError('GitHub webhook_secret requires httpHostToken');
+                }
+                this.#routeReleases.push(...registerGithubWebhookRoutes(this.#options.http, this));
+                logger.debug(formatCompact({
+                    endpoint: this.name,
+                    op: 'webhook',
+                    path: this.config.webhookPath,
+                }));
+            }
+            else {
+                logger.debug(formatCompact({
+                    endpoint: this.name,
+                    op: 'connect',
+                    mode: 'api-only',
+                    bot: this.gh.authenticatedUser,
+                }));
+            }
+        }
+        catch (error) {
+            await this.stop();
+            logger.error('Failed to connect GitHub endpoint:', error);
+            throw error;
+        }
+    }
+    open() {
+        this.#open = true;
+    }
+    close() {
+        this.#open = false;
+    }
+    async stop() {
+        this.#open = false;
+        for (const release of this.#routeReleases.splice(0))
+            release();
+        this.#unregisterAgent?.();
+        this.#unregisterAgent = undefined;
+        this.#started = false;
+        logger.debug(formatCompact({ op: 'disconnect', endpoint: this.name }));
+    }
+    async send({ target, payload }) {
+        const parsed = parseChannelId(target);
         if (!parsed)
-            throw new Error(`无效的 GitHub channel ID: ${options.id}`);
-        const expanded = expandInteractiveSegmentsInContent(coerceQrcodeSegmentsToText(options.content ?? ''));
-        const arr = Array.isArray(expanded) ? expanded : [expanded];
-        const canonical = arr.map((s) => (typeof s === 'string' ? { type: 'text', data: { text: s } } : s));
-        const text = toMarkdown(fromCanonicalSegments(canonical));
+            throw new Error(`无效的 GitHub channel ID: ${target}`);
+        const text = formatOutboundBody(payload);
         const r = parsed.type === 'issue'
             ? await this.gh.createIssueComment(parsed.repo, parsed.number, text)
             : await this.gh.createPRComment(parsed.repo, parsed.number, text);
         if (!r.ok)
             throw new Error(`发送失败: ${JSON.stringify(r.data)}`);
-        this.logger.debug(`${this.$id} send → ${options.id}: ${text.slice(0, 80)}...`);
-        return r.data.id.toString();
+        logger.debug(formatCompact({
+            op: 'github_send',
+            endpoint: this.name,
+            target,
+            messageId: r.data.id,
+        }));
+        return String(r.data.id);
     }
-    async $recallMessage(id) {
-        this.logger.warn(formatCompact({ op: 'recall', ok: false, error: 'use message.$recall()' }));
+    /** Test / internal: admit a parsed comment when open. */
+    admit(comment) {
+        if (!this.#open)
+            return;
+        const botUser = this.config.botLogin || this.gh.getBotLogin() || this.gh.authenticatedUser;
+        if (botUser && comment.sender === botUser)
+            return;
+        const content = enrichInboundContent(formatInboundContent(comment.content), this.config, botUser ?? undefined, comment.repo);
+        void this.#options.gateway.receive({
+            adapter: this.#options.id,
+            target: comment.channelId,
+            content,
+            sender: comment.sender,
+            id: comment.id,
+            metadata: Object.freeze({
+                endpoint: this.name,
+                repo: comment.repo,
+                kind: comment.kind,
+                createdAt: comment.createdAt,
+            }),
+        }).catch((err) => {
+            logger.warn(formatCompact({
+                op: 'github_gateway_receive_failed',
+                target: comment.channelId,
+                error: err instanceof Error ? err.message : String(err),
+            }));
+        });
     }
 }
-//# sourceMappingURL=endpoint.js.map
+export function defaultCreateClient(config) {
+    const appAuth = config.appId && config.privateKey
+        ? { appId: config.appId, privateKey: config.privateKey }
+        : undefined;
+    return new GhClient({ host: config.host, appAuth });
+}

package/lib/gh-client.d.ts

@@ -13,6 +13,17 @@ export interface AppAuth {
     /** PEM 格式私钥内容，或私钥文件路径 */
     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;
@@ -153,6 +164,64 @@ export declare class GhClient {
         status: number;
         data: any;
     }>;
+    getFileContent(repo: string, path: string, ref?: string): Promise<{
+        ok: boolean;
+        status: number;
+        data: {
+            content: string;
+            sha: string;
+            encoding: string;
+        };
+    }>;
+    createOrUpdateFile(repo: string, path: string, content: string, message: string, options?: {
+        branch?: string;
+        sha?: string;
+    }): Promise<{
+        ok: boolean;
+        status: number;
+        data: {
+            commit: {
+                sha: string;
+                html_url?: string;
+            };
+            content: {
+                html_url?: string;
+            };
+        };
+    }>;
+    getRef(repo: string, ref: string): Promise<{
+        ok: boolean;
+        status: number;
+        data: {
+            ref: string;
+            object: {
+                sha: string;
+                type: string;
+            };
+        };
+    }>;
+    createRef(repo: string, ref: string, sha: string): Promise<{
+        ok: boolean;
+        status: number;
+        data: any;
+    }>;
+    createPullRequest(repo: string, title: string, head: string, base: string, body?: string): Promise<{
+        ok: boolean;
+        status: number;
+        data: {
+            number: number;
+            html_url: string;
+            head: {
+                ref: string;
+            };
+        };
+    }>;
+    getBotLogin(): string | null;
+    getCommitAuthor(): GitHubCommitAuthor | null;
+    getBotIdentitySync(): GitHubBotIdentity | null;
+    getBotIdentity(): Promise<GitHubBotIdentity | null>;
+    buildCloneUrl(repo: string, token: string): string;
+    resolveBotUserId(): Promise<number | null>;
     starRepo(repo: string): Promise<{
         ok: boolean;
         status: number;
@@ -193,6 +262,10 @@ export declare class GhClient {
     get appSlug(): string | null;
     /** App 的 client_id（verifyAuth 后从 /app 获取，用于 Device Flow） */
     private _clientId;
+    /** Bot 机器用户 numeric id（/users/{slug}[bot]） */
+    private _botUserId;
+    /** 确保 App 认证的 Installation Token 对指定 repo 有效，并返回 token */
+    ensureInstallationTokenForRepo(repo: string): Promise<string | undefined>;
     get clientId(): string | null;
     /**
      * 获取仓库事件（支持 ETag 条件请求）
@@ -225,4 +298,3 @@ export declare class GhClient {
         scope: string;
     } | null>;
 }
-//# sourceMappingURL=gh-client.d.ts.map

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-agent-deps.d.ts

@@ -0,0 +1,47 @@
+/**
+ * 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;
+    };
+}
+export declare function registerGithubAgentEndpoint(endpointId: string, endpoint: GithubAgentEndpoint): () => void;
+/** Optional override used by tests / transitional callers. Pass `null` to clear. */
+export declare function setGithubAgentDeps(deps: GithubAgentDeps | null): void;
+export declare function getGithubAgentDeps(): GithubAgentDeps;
+export declare function getAdapter(): GithubAgentEndpoint;