Skip to content

Self-hosted workflows for coding-agent delivery. Orchestrate CodeBuddy, Codex and Claude Code with scripts and human approval gates. Includes Local workflows for coding assistants.

feat(assistant): lightweight GitHub tools for Main Bot without opening a workspace (#159)

newexploreorf25894409e9d
diff --git a/internal/httpapi/agent_tool_catalog.go b/internal/httpapi/agent_tool_catalog.go
index 79fe0a8b..209d4366 100644
--- a/internal/httpapi/agent_tool_catalog.go
+++ b/internal/httpapi/agent_tool_catalog.go
@@ -386,6 +386,7 @@ func (h *agentToolGateway) buildCatalog(ctx context.Context, session *AgentToolS
out = append(out, d)
}
out = append(out, mainBotBrowserTools(session)...)
+ out = append(out, mainBotGitHubTools(session)...)
out = append(out, terminalToolDescriptors(session.Mode, session.ExecMode)...)
session.mu.Lock()
session.catalog = append([]agentToolDescriptor{}, out...)
diff --git a/internal/httpapi/agent_tool_github.go b/internal/httpapi/agent_tool_github.go
new file mode 100644
index 00000000..b67eb35f
--- /dev/null
+++ b/internal/httpapi/agent_tool_github.go
@@ -0,0 +1,682 @@
+package httpapi
+
+import (
+ "context"
+ "encoding/json"
+ "errors"
+ "fmt"
+ "net/http"
+ "net/url"
+ "strconv"
+ "strings"
+ "time"
+
+ "agentflow/internal/domain"
+ "agentflow/internal/gitwork"
+)
+
+// Main Bot 的轻量 GitHub 工具:列 Issue/PR、查 PR 状态、加评论、加标签。
+//
+// 设计目标是不要求先 workbench_workspace_open 打开工作区(那条路径是为
+// "真的要改代码、推分支、开 PR" 准备的重路径),同时仍然复用
+// workbench_workspace_submit_mr 已验证的安全模型:服务端用请求人自己配置的
+// GitHub Git Token 直连 GitHub,token 只在服务端出现,不进模型上下文、不落库。
+//
+// 这组工具的 Kind 是 "github"(不是 "agentflow" 或 "workspace"),在
+// agentToolGateway.dispatch 里直接执行,不走平台写入工具的 drafts 确认流程,
+// 和 workbench_workspace_* 一致。同样和 workspace 工具一致的是:会话开启
+// 「帮我批准」(ExecMode.ReviewWrites)时,评论、加标签这两个写操作在调用
+// GitHub 之前先交给独立审查器逐项审查——它们对外公开可见,而列表工具会把
+// 不可信的 Issue/PR 标题带进上下文,正是最需要审查器把关的地方。
+// 操作范围限定在当前项目已绑定的 GitHub 仓库,写操作只开放评论和加标签,
+// 不提供关闭、合并、删除。
+const (
+ mainBotGitHubIssuesList = "workbench_github_issues_list"
+ mainBotGitHubPullsList = "workbench_github_pulls_list"
+ mainBotGitHubPRStatus = "workbench_github_pr_status"
+ mainBotGitHubCommentAdd = "workbench_github_comment_add"
+ mainBotGitHubLabelsAdd = "workbench_github_labels_add"
+)
+
+const (
+ // githubListPageSize 是 GitHub 列表接口单页上限。
+ githubListPageSize = 100
+ // githubIssuesMaxPages 限制 issues_list 为凑够 limit 最多翻的页数:
+ // /issues 端点混有 PR,PR 多的仓库要往后翻才能凑够纯 Issue。
+ githubIssuesMaxPages = 5
+)
+
+// mainBotGitHubTools 只在普通 Main Bot 会话(AgentToolAssistant)且已知项目时
+// 暴露:这组工具按项目绑定的仓库解析 repository 参数,脱离项目没有意义。
+func mainBotGitHubTools(s *AgentToolSession) []agentToolDescriptor {
+ if s == nil || s.Mode != AgentToolAssistant || strings.TrimSpace(s.ProjectID) == "" {
+ return nil
+ }
+ const repoProp = `"repository":{"type":"string","description":"项目里已绑定的仓库名(不是 owner/repo;参见 workbench_workspace_open 的仓库列表),必须是 GitHub 仓库"}`
+ const numberProp = `"number":{"type":"integer","minimum":1,"description":"Issue 或 PR 编号"}`
+ return []agentToolDescriptor{
+ {
+ Name: mainBotGitHubIssuesList,
+ Description: "列出项目绑定的 GitHub 仓库里的 Issue(不包含 PR)。只读,不需要打开工作区,用请求人自己的 Git Token 直连 GitHub。结果里 hasMore=true 表示还有符合条件但没列出的 Issue,不能把本次结果当成完整列表。",
+ InputSchema: json.RawMessage(`{"type":"object","properties":{` + repoProp + `,"state":{"type":"string","enum":["open","closed","all"],"description":"默认 open"},"labels":{"type":"string","description":"按标签过滤,逗号分隔的标签名"},"limit":{"type":"integer","minimum":1,"maximum":50,"description":"默认 20"}},"required":["repository"],"additionalProperties":false}`),
+ Kind: "github",
+ },
+ {
+ Name: mainBotGitHubPullsList,
+ Description: "列出项目绑定的 GitHub 仓库里的 Pull Request。只读,不需要打开工作区,用请求人自己的 Git Token 直连 GitHub。结果里 hasMore=true 表示还有没列出的 PR。",
+ InputSchema: json.RawMessage(`{"type":"object","properties":{` + repoProp + `,"state":{"type":"string","enum":["open","closed","all"],"description":"默认 open"},"limit":{"type":"integer","minimum":1,"maximum":50,"description":"默认 20"}},"required":["repository"],"additionalProperties":false}`),
+ Kind: "github",
+ },
+ {
+ Name: mainBotGitHubPRStatus,
+ Description: "查看一个 Pull Request 的详情(状态、是否可合并)和检查结果(CI checks / commit status)。只读,不需要打开工作区。checksState 为 unknown 时表示部分检查结果读取失败,原因见 checksWarnings。",
+ InputSchema: json.RawMessage(`{"type":"object","properties":{` + repoProp + `,` + numberProp + `},"required":["repository","number"],"additionalProperties":false}`),
+ Kind: "github",
+ },
+ {
+ Name: mainBotGitHubCommentAdd,
+ Description: "给一个 Issue 或 PR 加评论,对外公开可见。用请求人自己的 Git Token 直接提交,不经过草稿确认(「帮我批准」模式下会先经自动审批);调用前请把内容和目标 number 向用户确认清楚。",
+ InputSchema: json.RawMessage(`{"type":"object","properties":{` + repoProp + `,` + numberProp + `,"body":{"type":"string","minLength":1,"maxLength":10000}},"required":["repository","number","body"],"additionalProperties":false}`),
+ Kind: "github",
+ },
+ {
+ Name: mainBotGitHubLabelsAdd,
+ Description: "给一个 Issue 或 PR 加标签(标签必须在仓库里已存在,GitHub 不会自动创建)。用请求人自己的 Git Token 直接提交,不经过草稿确认(「帮我批准」模式下会先经自动审批)。",
+ InputSchema: json.RawMessage(`{"type":"object","properties":{` + repoProp + `,` + numberProp + `,"labels":{"type":"array","items":{"type":"string"},"minItems":1,"maxItems":20}},"required":["repository","number","labels"],"additionalProperties":false}`),
+ Kind: "github",
+ },
+ }
+}
+
+// callMainBotGitHub 是这组工具的统一入口:解析请求人的 Git Token 和项目里的
+// 目标仓库,再按工具名分发到具体操作。写操作先校验参数、再过审查、最后才
+// 调 GitHub。错误和结果都经过 redactAgentToolResult 过滤,避免 token 意外
+// 出现在模型可见的文本里。
+func (h *agentToolGateway) callMainBotGitHub(ctx context.Context, session *AgentToolSession, name string, args map[string]any) (string, error) {
+ if len(mainBotGitHubTools(session)) == 0 {
+ return "", errAgentToolForbidden
+ }
+ requester, ok := h.repo.User(session.User.ID)
+ if !ok {
+ return "", errAgentToolForbidden
+ }
+ token, err := h.githubUserToken(ctx, session.User.ID)
+ if err != nil {
+ return "", err
+ }
+ repository, _ := args["repository"].(string)
+ path, err := h.resolveProjectGitHubRepo(session.ProjectID, repository)
+ if err != nil {
+ return "", err
+ }
+ var result string
+ switch name {
+ case mainBotGitHubIssuesList:
+ result, err = githubIssuesList(ctx, token, path, args)
+ case mainBotGitHubPullsList:
+ result, err = githubPullsList(ctx, token, path, args)
+ case mainBotGitHubPRStatus:
+ result, err = githubPRStatus(ctx, token, path, args)
+ case mainBotGitHubCommentAdd:
+ number, body, verr := githubCommentArgs(args)
+ if verr != nil {
+ return "", verr
+ }
+ if rerr := reviewGitHubWrite(ctx, session, name, path, args); rerr != nil {
+ return "", rerr
+ }
+ result, err = githubIssueCommentAdd(ctx, token, path, number, body)
+ case mainBotGitHubLabelsAdd:
+ number, labels, verr := githubLabelsArgs(args)
+ if verr != nil {
+ return "", verr
+ }
+ if rerr := reviewGitHubWrite(ctx, session, name, path, args); rerr != nil {
+ return "", rerr
+ }
+ result, err = githubIssueLabelsAdd(ctx, token, path, number, labels)
+ default:
+ return "", errAgentToolUnknown
+ }
+ if err != nil {
+ return "", errors.New(redactAgentToolResult(err.Error(), requester))
+ }
+ return redactAgentToolResult(result, requester), nil
+}
+
+// reviewGitHubWrite 和 callMainBotWorkspace 对写操作的处理一致:会话开启
+// 「帮我批准」时,先把这一项具体操作交给独立审查器,未获批准不调用 GitHub。
+// 没有可用的审查器时 reviewAssistantAction 返回 unavailable,同样拒绝执行。
+func reviewGitHubWrite(ctx context.Context, s *AgentToolSession, name, path string, args map[string]any) error {
+ if !s.ExecMode.ReviewWrites {
+ return nil
+ }
+ ctx = withAssistantApprovalReviewer(ctx, s.approvalReviewer)
+ review := reviewAssistantAction(ctx, name, "用请求人自己的 Git Token 向项目绑定的 GitHub 仓库写入评论或标签,对外公开可见,执行后只能到 GitHub 上手动撤销", map[string]any{"projectId": s.ProjectID, "repository": path, "arguments": args})
+ if !review.allows() {
+ return assistantReviewRefusal(name, review)
+ }
+ return nil
+}
+
+// githubUserToken 复用 workbench_workspace_submit_mr 的令牌来源:请求人在
+// 「个人配置 → 个人凭证」里保存的 Git Token。未配置时给出同样的引导文案。
+func (h *agentToolGateway) githubUserToken(ctx context.Context, userID int64) (string, error) {
+ raw := strings.TrimSpace(h.repo.GitCredential(ctx, userID))
+ _, token := gitwork.SplitToken(raw)
+ if token == "" {
+ return "", fmt.Errorf("你还没有配置 GitHub Git Token,无法操作 GitHub。请到「个人配置 → 个人凭证」配置:打开 https://github.com/settings/tokens 新建令牌并授予目标仓库的权限,复制后粘贴并点校验")
+ }
+ return token, nil
+}
+
+// resolveProjectGitHubRepo 只允许操作当前项目已绑定、且是 GitHub 的仓库:
+// repository 填的是项目里的仓库名,不是裸 owner/repo,防止模型用这组工具
+// 操作项目以外、碰巧也在同一个 Git Token 权限范围内的仓库。
+func (h *agentToolGateway) resolveProjectGitHubRepo(projectID, repository string) (string, error) {
+ repository = strings.TrimSpace(repository)
+ if repository == "" {
+ return "", fmt.Errorf("repository is required:请填项目里已绑定的仓库名")
+ }
+ var names []string
+ for _, r := range h.repo.Repositories() {
+ if r.ProjectID != projectID {
+ continue
+ }
+ names = append(names, r.Name)
+ if !strings.EqualFold(r.Name, repository) && r.ID != repository {
+ continue
+ }
+ path := githubRepoPath(domain.RepositoryContext{CloneURL: r.CloneURL, WebURL: r.WebURL, GongfengProjectID: r.GongfengProjectID})
+ if path == "" {
+ return "", fmt.Errorf("仓库 %s 不是 GitHub 仓库,这组工具目前只支持 GitHub", r.Name)
+ }
+ return path, nil
+ }
+ if len(names) == 0 {
+ return "", fmt.Errorf("当前项目还没有绑定仓库")
+ }
+ return "", fmt.Errorf("找不到仓库 %q,当前项目已绑定:%s", repository, strings.Join(names, "、"))
+}
+
+func githubArgInt(args map[string]any, key string, def int) int {
+ v, ok := args[key]
+ if !ok || v == nil {
+ return def
+ }
+ switch t := v.(type) {
+ case json.Number:
+ if n, err := t.Int64(); err == nil {
+ return int(n)
+ }
+ case float64:
+ return int(t)
+ case int:
+ return t
+ case int64:
+ return int(t)
+ case string:
+ if n, err := strconv.Atoi(strings.TrimSpace(t)); err == nil {
+ return n
+ }
+ }
+ return def
+}
+
+func githubArgState(args map[string]any) (string, error) {
+ state := "open"
+ if raw, ok := args["state"].(string); ok && strings.TrimSpace(raw) != "" {
+ state = strings.ToLower(strings.TrimSpace(raw))
+ }
+ if state != "open" && state != "closed" && state != "all" {
+ return "", fmt.Errorf("state 只能是 open、closed 或 all")
+ }
+ return state, nil
+}
+
+func githubArgLimit(args map[string]any) int {
+ limit := githubArgInt(args, "limit", 20)
+ if limit <= 0 || limit > 50 {
+ limit = 20
+ }
+ return limit
+}
+
+func githubArgNumber(args map[string]any) (int, error) {
+ number := githubArgInt(args, "number", 0)
+ if number <= 0 {
+ return 0, fmt.Errorf("number is required and must be a positive integer")
+ }
+ return number, nil
+}
+
+func githubCommentArgs(args map[string]any) (int, string, error) {
+ number, err := githubArgNumber(args)
+ if err != nil {
+ return 0, "", err
+ }
+ body, _ := args["body"].(string)
+ body = strings.TrimSpace(body)
+ if body == "" {
+ return 0, "", fmt.Errorf("body is required")
+ }
+ if len([]rune(body)) > 10000 {
+ return 0, "", fmt.Errorf("body must be at most 10000 characters")
+ }
+ return number, body, nil
+}
+
+func githubLabelsArgs(args map[string]any) (int, []string, error) {
+ number, err := githubArgNumber(args)
+ if err != nil {
+ return 0, nil, err
+ }
+ raw, ok := args["labels"].([]any)
+ if !ok || len(raw) == 0 {
+ return 0, nil, fmt.Errorf("labels is required and must be a non-empty array of strings")
+ }
+ labels := make([]string, 0, len(raw))
+ for _, v := range raw {
+ s := strings.TrimSpace(fmt.Sprint(v))
+ if s != "" {
+ labels = append(labels, s)
+ }
+ }
+ if len(labels) == 0 {
+ return 0, nil, fmt.Errorf("labels is required and must be a non-empty array of strings")
+ }
+ return number, labels, nil
+}
+
+func githubHTTPClient() *http.Client {
+ return &http.Client{Timeout: 20 * time.Second}
+}
+
+// githubToolError 按具体操作给出报错。githubPRError 是为提交 PR 写的,403
+// 一律提示 Pull requests 权限;这组工具各自需要的权限不同,单独说明。
+func githubToolError(action, permission string, status int, raw []byte) error {
+ var body struct {
+ Message string `json:"message"`
+ Errors []struct {
+ Message string `json:"message"`
+ } `json:"errors"`
+ }
+ _ = json.Unmarshal(raw, &body)
+ detail := strings.TrimSpace(body.Message)
+ for _, e := range body.Errors {
+ if e.Message != "" {
+ detail = strings.TrimSpace(detail + " " + e.Message)
+ }
+ }
+ if detail == "" {
+ detail = strings.TrimSpace(truncateRunes(string(raw), 300))
+ }
+ switch status {
+ case http.StatusUnauthorized:
+ return fmt.Errorf("GitHub Git Token 无效或已过期(HTTP 401):请到「个人配置 → 个人凭证」重新配置")
+ case http.StatusForbidden:
+ return fmt.Errorf("GitHub 拒绝%s(HTTP 403):Git Token 需要目标仓库的 %s 权限。%s", action, permission, detail)
+ case http.StatusNotFound:
+ return fmt.Errorf("GitHub %s失败(HTTP 404):仓库或编号不存在,或 Git Token 无权访问该仓库(私有仓库对无权限的令牌也返回 404)。%s", action, detail)
+ }
+ return fmt.Errorf("GitHub %s失败(HTTP %d):%s", action, status, detail)
+}
+
+type githubIssueOut struct {
+ Number int64 `json:"number"`
+ Title string `json:"title"`
+ State string `json:"state"`
+ URL string `json:"url"`
+ Author string `json:"author"`
+ Labels []string `json:"labels,omitempty"`
+ Created string `json:"createdAt"`
+ Updated string `json:"updatedAt"`
+}
+
+type githubIssueItem struct {
+ Number int64 `json:"number"`
+ Title string `json:"title"`
+ State string `json:"state"`
+ HTMLURL string `json:"html_url"`
+ User struct {
+ Login string `json:"login"`
+ } `json:"user"`
+ Labels []struct {
+ Name string `json:"name"`
+ } `json:"labels"`
+ CreatedAt string `json:"created_at"`
+ UpdatedAt string `json:"updated_at"`
+ PullRequest json.RawMessage `json:"pull_request"`
+}
+
+// githubIssuesList 列 Issue。GitHub 的 /issues 端点也会混入 PR(PR 也是一种
+// Issue),按返回体里是否带 pull_request 字段过滤掉。因为过滤发生在取回之后,
+// 不能把 per_page 设成 limit:那样 PR 多的仓库会返回远少于 limit 的 Issue,
+// 看起来却像完整结果。这里按满页取、过滤后截到 limit,不够就翻页(最多
+// githubIssuesMaxPages 页),并用 hasMore 标明是否还有没列出的 Issue。
+func githubIssuesList(ctx context.Context, token, path string, args map[string]any) (string, error) {
+ state, err := githubArgState(args)
+ if err != nil {
+ return "", err
+ }
+ limit := githubArgLimit(args)
+ q := url.Values{"state": {state}, "per_page": {strconv.Itoa(githubListPageSize)}}
+ if labels, _ := args["labels"].(string); strings.TrimSpace(labels) != "" {
+ q.Set("labels", strings.TrimSpace(labels))
+ }
+ client := githubHTTPClient()
+ out := make([]githubIssueOut, 0, limit)
+ hasMore := false
+ for page := 1; page <= githubIssuesMaxPages; page++ {
+ q.Set("page", strconv.Itoa(page))
+ resp, raw, err := githubRequest(ctx, client, http.MethodGet, githubAPIBase+"/repos/"+path+"/issues?"+q.Encode(), token, nil)
+ if err != nil {
+ return "", fmt.Errorf("无法连接 GitHub:%v", err)
+ }
+ if resp.StatusCode != http.StatusOK {
+ return "", githubToolError("读取 Issue 列表", "Issues 读取", resp.StatusCode, raw)
+ }
+ var items []githubIssueItem
+ if json.Unmarshal(raw, &items) != nil {
+ return "", fmt.Errorf("GitHub 返回的 Issue 列表无法解析")
+ }
+ for _, it := range items {
+ if len(it.PullRequest) > 0 {
+ continue
+ }
+ if len(out) == limit {
+ hasMore = true
+ break
+ }
+ labels := make([]string, 0, len(it.Labels))
+ for _, l := range it.Labels {
+ labels = append(labels, l.Name)
+ }
+ out = append(out, githubIssueOut{Number: it.Number, Title: it.Title, State: it.State, URL: it.HTMLURL, Author: it.User.Login, Labels: labels, Created: it.CreatedAt, Updated: it.UpdatedAt})
+ }
+ if hasMore || len(items) < githubListPageSize {
+ break
+ }
+ if page == githubIssuesMaxPages {
+ // 翻页上限内没扫完,后面可能还有 Issue。
+ hasMore = true
+ }
+ }
+ body, _ := json.Marshal(map[string]any{"repository": path, "issues": out, "count": len(out), "hasMore": hasMore})
+ return string(body), nil
+}
+
+type githubPullOut struct {
+ Number int64 `json:"number"`
+ Title string `json:"title"`
+ State string `json:"state"`
+ Draft bool `json:"draft"`
+ URL string `json:"url"`
+ Author string `json:"author"`
+ Head string `json:"head"`
+ Base string `json:"base"`
+ Created string `json:"createdAt"`
+ Updated string `json:"updatedAt"`
+}
+
+// githubPullsList 列 PR。/pulls 不需要事后过滤,多取一条即可判断 hasMore。
+func githubPullsList(ctx context.Context, token, path string, args map[string]any) (string, error) {
+ state, err := githubArgState(args)
+ if err != nil {
+ return "", err
+ }
+ limit := githubArgLimit(args)
+ q := url.Values{"state": {state}, "per_page": {strconv.Itoa(limit + 1)}}
+ client := githubHTTPClient()
+ resp, raw, err := githubRequest(ctx, client, http.MethodGet, githubAPIBase+"/repos/"+path+"/pulls?"+q.Encode(), token, nil)
+ if err != nil {
+ return "", fmt.Errorf("无法连接 GitHub:%v", err)
+ }
+ if resp.StatusCode != http.StatusOK {
+ return "", githubToolError("读取 PR 列表", "Pull requests 读取", resp.StatusCode, raw)
+ }
+ var items []struct {
+ Number int64 `json:"number"`
+ Title string `json:"title"`
+ State string `json:"state"`
+ Draft bool `json:"draft"`
+ HTMLURL string `json:"html_url"`
+ User struct {
+ Login string `json:"login"`
+ } `json:"user"`
+ Head struct {
+ Ref string `json:"ref"`
+ } `json:"head"`
+ Base struct {
+ Ref string `json:"ref"`
+ } `json:"base"`
+ CreatedAt string `json:"created_at"`
+ UpdatedAt string `json:"updated_at"`
+ }
+ if json.Unmarshal(raw, &items) != nil {
+ return "", fmt.Errorf("GitHub 返回的 PR 列表无法解析")
+ }
+ hasMore := len(items) > limit
+ if hasMore {
+ items = items[:limit]
+ }
+ out := make([]githubPullOut, 0, len(items))
+ for _, it := range items {
+ out = append(out, githubPullOut{Number: it.Number, Title: it.Title, State: it.State, Draft: it.Draft, URL: it.HTMLURL, Author: it.User.Login, Head: it.Head.Ref, Base: it.Base.Ref, Created: it.CreatedAt, Updated: it.UpdatedAt})
+ }
+ body, _ := json.Marshal(map[string]any{"repository": path, "pulls": out, "count": len(out), "hasMore": hasMore})
+ return string(body), nil
+}
+
+type githubCheckSummary struct {
+ Name string `json:"name"`
+ State string `json:"state"`
+ URL string `json:"url,omitempty"`
+}
+
+// githubCheckOutcome 把 commit status 的 state 和 check run 的
+// status/conclusion 归到 success / pending / failure 三类。只有明确通过的才算
+// success:action_required、startup_failure、stale 以及未知取值都需要人处理,
+// 归为 failure,不能让 PR 看起来"全绿"。
+func githubCheckOutcome(state string) string {
+ switch strings.ToLower(strings.TrimSpace(state)) {
+ case "success", "neutral", "skipped":
+ return "success"
+ case "pending", "queued", "in_progress", "waiting", "requested", "expected", "":
+ return "pending"
+ }
+ return "failure"
+}
+
+func githubChecksWarning(source, permission string, status int) string {
+ switch status {
+ case http.StatusForbidden, http.StatusNotFound:
+ return fmt.Sprintf("%s 读取失败(HTTP %d):Git Token 可能缺少 %s 读取权限,这部分检查结果未计入", source, status, permission)
+ }
+ return fmt.Sprintf("%s 读取失败(HTTP %d),这部分检查结果未计入", source, status)
+}
+
+// githubCombinedChecks 合并两套 GitHub 检查来源:旧的 commit status API(很多
+// 第三方 CI 还在用)和新的 check-runs API(GitHub Actions)。任一项失败就
+// 整体标 failure;没有失败但有未完成的标 pending;都成功才是 success。
+// 任一来源读取失败(比如令牌没有 Checks 权限返回 403)时写进 warnings,
+// 并且不再给出 none/success 这种"看起来没问题"的结论,而是 unknown。
+func githubCombinedChecks(ctx context.Context, client *http.Client, token, path, sha string) ([]githubCheckSummary, string, []string) {
+ if strings.TrimSpace(sha) == "" {
+ return nil, "none", nil
+ }
+ var out []githubCheckSummary
+ var warnings []string
+ resp, raw, err := githubRequest(ctx, client, http.MethodGet, fmt.Sprintf("%s/repos/%s/commits/%s/status?per_page=%d", githubAPIBase, path, sha, githubListPageSize), token, nil)
+ switch {
+ case err != nil:
+ warnings = append(warnings, fmt.Sprintf("commit status 读取失败:%v", err))
+ case resp.StatusCode != http.StatusOK:
+ warnings = append(warnings, githubChecksWarning("commit status", "Commit statuses", resp.StatusCode))
+ default:
+ var combined struct {
+ TotalCount int `json:"total_count"`
+ Statuses []struct {
+ Context string `json:"context"`
+ State string `json:"state"`
+ TargetURL string `json:"target_url"`
+ } `json:"statuses"`
+ }
+ if json.Unmarshal(raw, &combined) != nil {
+ warnings = append(warnings, "commit status 返回无法解析,这部分检查结果未计入")
+ break
+ }
+ for _, s := range combined.Statuses {
+ out = append(out, githubCheckSummary{Name: s.Context, State: s.State, URL: s.TargetURL})
+ }
+ if combined.TotalCount > len(combined.Statuses) {
+ warnings = append(warnings, fmt.Sprintf("commit status 共 %d 项,只统计了前 %d 项", combined.TotalCount, len(combined.Statuses)))
+ }
+ }
+ resp, raw, err = githubRequest(ctx, client, http.MethodGet, fmt.Sprintf("%s/repos/%s/commits/%s/check-runs?per_page=%d", githubAPIBase, path, sha, githubListPageSize), token, nil)
+ switch {
+ case err != nil:
+ warnings = append(warnings, fmt.Sprintf("check runs 读取失败:%v", err))
+ case resp.StatusCode != http.StatusOK:
+ warnings = append(warnings, githubChecksWarning("check runs", "Checks", resp.StatusCode))
+ default:
+ var runs struct {
+ TotalCount int `json:"total_count"`
+ CheckRuns []struct {
+ Name string `json:"name"`
+ Status string `json:"status"`
+ Conclusion string `json:"conclusion"`
+ HTMLURL string `json:"html_url"`
+ } `json:"check_runs"`
+ }
+ if json.Unmarshal(raw, &runs) != nil {
+ warnings = append(warnings, "check runs 返回无法解析,这部分检查结果未计入")
+ break
+ }
+ for _, r := range runs.CheckRuns {
+ state := r.Status
+ if strings.TrimSpace(r.Conclusion) != "" {
+ state = r.Conclusion
+ }
+ out = append(out, githubCheckSummary{Name: r.Name, State: state, URL: r.HTMLURL})
+ }
+ if runs.TotalCount > len(runs.CheckRuns) {
+ warnings = append(warnings, fmt.Sprintf("check runs 共 %d 项,只统计了前 %d 项", runs.TotalCount, len(runs.CheckRuns)))
+ }
+ }
+ overall := "none"
+ if len(out) > 0 {
+ overall = "success"
+ for _, c := range out {
+ switch githubCheckOutcome(c.State) {
+ case "failure":
+ overall = "failure"
+ case "pending":
+ if overall != "failure" {
+ overall = "pending"
+ }
+ }
+ }
+ }
+ if len(warnings) > 0 && (overall == "none" || overall == "success") {
+ overall = "unknown"
+ }
+ return out, overall, warnings
+}
+
+func githubPRStatus(ctx context.Context, token, path string, args map[string]any) (string, error) {
+ number, err := githubArgNumber(args)
+ if err != nil {
+ return "", err
+ }
+ client := githubHTTPClient()
+ resp, raw, err := githubRequest(ctx, client, http.MethodGet, fmt.Sprintf("%s/repos/%s/pulls/%d", githubAPIBase, path, number), token, nil)
+ if err != nil {
+ return "", fmt.Errorf("无法连接 GitHub:%v", err)
+ }
+ if resp.StatusCode != http.StatusOK {
+ return "", githubToolError("读取 PR 详情", "Pull requests 读取", resp.StatusCode, raw)
+ }
+ var pr struct {
+ Number int64 `json:"number"`
+ Title string `json:"title"`
+ State string `json:"state"`
+ Draft bool `json:"draft"`
+ Merged bool `json:"merged"`
+ MergeableState string `json:"mergeable_state"`
+ HTMLURL string `json:"html_url"`
+ Head struct {
+ SHA string `json:"sha"`
+ Ref string `json:"ref"`
+ } `json:"head"`
+ Base struct {
+ Ref string `json:"ref"`
+ } `json:"base"`
+ }
+ if json.Unmarshal(raw, &pr) != nil || pr.Number == 0 {
+ return "", fmt.Errorf("GitHub 返回的 PR 信息无法解析")
+ }
+ checks, checksState, warnings := githubCombinedChecks(ctx, client, token, path, pr.Head.SHA)
+ result := map[string]any{
+ "repository": path,
+ "number": pr.Number,
+ "title": pr.Title,
+ "state": pr.State,
+ "draft": pr.Draft,
+ "merged": pr.Merged,
+ "mergeableState": pr.MergeableState,
+ "url": pr.HTMLURL,
+ "head": pr.Head.Ref,
+ "base": pr.Base.Ref,
+ "checksState": checksState,
+ "checks": checks,
+ }
+ if len(warnings) > 0 {
+ result["checksWarnings"] = warnings
+ }
+ out, _ := json.Marshal(result)
+ return string(out), nil
+}
+
+const githubIssueWritePermission = "Issues 读写(在 PR 上操作时也可以是 Pull requests 读写)"
+
+func githubIssueCommentAdd(ctx context.Context, token, path string, number int, body string) (string, error) {
+ client := githubHTTPClient()
+ payload, _ := json.Marshal(map[string]string{"body": body})
+ resp, raw, err := githubRequest(ctx, client, http.MethodPost, fmt.Sprintf("%s/repos/%s/issues/%d/comments", githubAPIBase, path, number), token, payload)
+ if err != nil {
+ return "", fmt.Errorf("无法连接 GitHub:%v", err)
+ }
+ if resp.StatusCode != http.StatusCreated {
+ return "", githubToolError("添加评论", githubIssueWritePermission, resp.StatusCode, raw)
+ }
+ var comment struct {
+ ID int64 `json:"id"`
+ HTMLURL string `json:"html_url"`
+ }
+ _ = json.Unmarshal(raw, &comment)
+ out, _ := json.Marshal(map[string]any{"repository": path, "number": number, "commentId": comment.ID, "url": comment.HTMLURL})
+ return string(out), nil
+}
+
+func githubIssueLabelsAdd(ctx context.Context, token, path string, number int, labels []string) (string, error) {
+ client := githubHTTPClient()
+ payload, _ := json.Marshal(map[string][]string{"labels": labels})
+ resp, body, err := githubRequest(ctx, client, http.MethodPost, fmt.Sprintf("%s/repos/%s/issues/%d/labels", githubAPIBase, path, number), token, payload)
+ if err != nil {
+ return "", fmt.Errorf("无法连接 GitHub:%v", err)
+ }
+ if resp.StatusCode != http.StatusOK {
+ return "", githubToolError("添加标签", githubIssueWritePermission, resp.StatusCode, body)
+ }
+ var result []struct {
+ Name string `json:"name"`
+ }
+ _ = json.Unmarshal(body, &result)
+ names := make([]string, 0, len(result))
+ for _, l := range result {
+ names = append(names, l.Name)
+ }
+ out, _ := json.Marshal(map[string]any{"repository": path, "number": number, "labels": names})
+ return string(out), nil
+}
diff --git a/internal/httpapi/agent_tool_github_test.go b/internal/httpapi/agent_tool_github_test.go
new file mode 100644
index 00000000..7ee0d11b
--- /dev/null
+++ b/internal/httpapi/agent_tool_github_test.go
@@ -0,0 +1,544 @@
+package httpapi
+
+import (
+ "context"
+ "encoding/json"
+ "fmt"
+ "io"
+ "net/http"
+ "net/http/httptest"
+ "strconv"
+ "strings"
+ "sync"
+ "testing"
+
+ "agentflow/internal/domain"
+ "agentflow/internal/repo"
+)
+
+const githubToolTestToken = "ghp_github_tool_secret"
+
+func TestMainBotGitHubToolsOnlyForAssistantWithProject(t *testing.T) {
+ for _, s := range []*AgentToolSession{
+ nil,
+ {Mode: AgentToolAssistant},
+ {Mode: AgentToolAssistant, ProjectID: " "},
+ {Mode: AgentToolClarify, ProjectID: "p"},
+ {Mode: AgentToolReport, ProjectID: "p"},
+ } {
+ if tools := mainBotGitHubTools(s); len(tools) != 0 {
+ t.Fatalf("session %+v exposes github tools: %v", s, tools)
+ }
+ }
+ tools := mainBotGitHubTools(&AgentToolSession{Mode: AgentToolAssistant, ProjectID: "p"})
+ want := map[string]bool{mainBotGitHubIssuesList: true, mainBotGitHubPullsList: true, mainBotGitHubPRStatus: true, mainBotGitHubCommentAdd: true, mainBotGitHubLabelsAdd: true}
+ if len(tools) != len(want) {
+ t.Fatalf("tools = %v", tools)
+ }
+ for _, tool := range tools {
+ if !want[tool.Name] || tool.Kind != "github" {
+ t.Fatalf("unexpected tool %+v", tool)
+ }
+ var schema map[string]any
+ if err := json.Unmarshal(tool.InputSchema, &schema); err != nil {
+ t.Fatalf("%s has invalid schema: %v", tool.Name, err)
+ }
+ }
+}
+
+type githubToolFixture struct {
+ gateway *agentToolGateway
+ session *AgentToolSession
+ user domain.User
+ set func(token string)
+}
+
+func newGitHubToolFixture(t *testing.T) githubToolFixture {
+ t.Helper()
+ h, user := workbenchFixture(t)
+ if err := h.repo.PutProject(domain.Project{ID: "other-project", Name: "Other", OwnerID: user.ID}); err != nil {
+ t.Fatal(err)
+ }
+ for _, r := range []domain.Repository{
+ {ID: "gh-app", Name: "app", ProjectID: "workbench", CloneURL: "https://github.com/octo/app.git", DefaultBranch: "main"},
+ {ID: "gl-internal", Name: "internal", ProjectID: "workbench", CloneURL: "https://gitlab.example.com/team/internal.git", DefaultBranch: "main"},
+ {ID: "gh-foreign", Name: "foreign", ProjectID: "other-project", CloneURL: "https://github.com/octo/foreign.git", DefaultBranch: "main"},
+ } {
+ if err := h.repo.PutRepository(r); err != nil {
+ t.Fatal(err)
+ }
+ }
+ f := githubToolFixture{
+ gateway: &agentToolGateway{deps: h.deps},
+ session: &AgentToolSession{Mode: AgentToolAssistant, ProjectID: "workbench", UserID: user.ID, User: user},
+ user: user,
+ }
+ f.set = func(token string) {
+ t.Helper()
+ updated, err := h.repo.UpdateUserCredentials(user.ID, repo.UserCredentialUpdate{GitToken: token})
+ if err != nil {
+ t.Fatal(err)
+ }
+ f.session.User = updated
+ }
+ return f
+}
+
+func TestResolveProjectGitHubRepoStaysInsideProject(t *testing.T) {
+ f := newGitHubToolFixture(t)
+ for _, name := range []string{"app", "APP", " app ", "gh-app"} {
+ if path, err := f.gateway.resolveProjectGitHubRepo("workbench", name); err != nil || path != "octo/app" {
+ t.Fatalf("%q: path=%q err=%v", name, path, err)
+ }
+ }
+ for name, want := range map[string]string{
+ "": "repository is required",
+ "internal": "不是 GitHub 仓库",
+ "foreign": "找不到仓库",
+ "gh-foreign": "找不到仓库",
+ "octo/app": "找不到仓库",
+ "octo/secret": "当前项目已绑定",
+ } {
+ path, err := f.gateway.resolveProjectGitHubRepo("workbench", name)
+ if err == nil || !strings.Contains(err.Error(), want) {
+ t.Fatalf("%q: path=%q err=%v, want %q", name, path, err, want)
+ }
+ }
+ if _, err := f.gateway.resolveProjectGitHubRepo("empty-project", "app"); err == nil || !strings.Contains(err.Error(), "还没有绑定仓库") {
+ t.Fatalf("empty project err = %v", err)
+ }
+}
+
+type fakeGitHubAPI struct {
+ mu sync.Mutex
+ requests []string
+ tokens []string
+ bodies []string
+ routes map[string]func(w http.ResponseWriter, r *http.Request)
+}
+
+func (f *fakeGitHubAPI) serve(t *testing.T) {
+ t.Helper()
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ raw, _ := io.ReadAll(r.Body)
+ f.mu.Lock()
+ f.requests = append(f.requests, r.Method+" "+r.URL.Path)
+ f.tokens = append(f.tokens, r.Header.Get("authorization"))
+ f.bodies = append(f.bodies, string(raw))
+ route := f.routes[r.Method+" "+r.URL.Path]
+ f.mu.Unlock()
+ if route == nil {
+ http.NotFound(w, r)
+ return
+ }
+ w.Header().Set("Content-Type", "application/json")
+ route(w, r)
+ }))
+ t.Cleanup(server.Close)
+ previous := githubAPIBase
+ githubAPIBase = server.URL
+ t.Cleanup(func() { githubAPIBase = previous })
+}
+
+func githubJSON(status int, body string) func(http.ResponseWriter, *http.Request) {
+ return func(w http.ResponseWriter, _ *http.Request) {
+ w.WriteHeader(status)
+ _, _ = io.WriteString(w, body)
+ }
+}
+
+func callGitHubTool(t *testing.T, f githubToolFixture, name string, args string) (string, bool) {
+ t.Helper()
+ raw := json.RawMessage(`{"name":"` + name + `","arguments":` + args + `}`)
+ result, err := f.gateway.callTool(context.Background(), f.session, raw)
+ if err != nil {
+ t.Fatalf("%s: callTool error %v", name, err)
+ }
+ content, _ := result["content"].([]map[string]any)
+ if len(content) == 0 {
+ t.Fatalf("%s: empty result %v", name, result)
+ }
+ text, _ := content[0]["text"].(string)
+ isError, _ := result["isError"].(bool)
+ return text, isError
+}
+
+func TestGitHubToolsRunWithoutWorkspaceInConfirmMode(t *testing.T) {
+ f := newGitHubToolFixture(t)
+ f.set(githubToolTestToken)
+ if f.session.ExecMode.AutoWrite || f.session.ExecMode.ReviewWrites || f.session.RunID != "" {
+ t.Fatalf("fixture must be a confirm-mode chat without a workspace: %+v", f.session)
+ }
+ var labelQuery string
+ api := &fakeGitHubAPI{routes: map[string]func(http.ResponseWriter, *http.Request){
+ "GET /repos/octo/app/issues": func(w http.ResponseWriter, r *http.Request) {
+ labelQuery = r.URL.RawQuery
+ _, _ = io.WriteString(w, `[
+ {"number":1,"title":"Real issue","state":"open","html_url":"https://github.com/octo/app/issues/1","user":{"login":"alice"},"labels":[{"name":"bug"}]},
+ {"number":2,"title":"A PR","state":"open","html_url":"https://github.com/octo/app/pull/2","user":{"login":"bob"},"pull_request":{"url":"x"}}
+ ]`)
+ },
+ "GET /repos/octo/app/pulls": githubJSON(http.StatusOK, `[{"number":7,"title":"Feature","state":"open","draft":true,"html_url":"https://github.com/octo/app/pull/7","user":{"login":"bob"},"head":{"ref":"topic"},"base":{"ref":"main"}}]`),
+ "GET /repos/octo/app/pulls/7": githubJSON(http.StatusOK, `{"number":7,"title":"Feature","state":"open","merged":false,"mergeable_state":"blocked","html_url":"https://github.com/octo/app/pull/7","head":{"sha":"abc123","ref":"topic"},"base":{"ref":"main"}}`),
+ "GET /repos/octo/app/commits/abc123/status": githubJSON(http.StatusOK, `{"statuses":[{"context":"ci/legacy","state":"success","target_url":"https://ci.example.com/1"}]}`),
+ "GET /repos/octo/app/commits/abc123/check-runs": githubJSON(http.StatusOK, `{"check_runs":[{"name":"unit","status":"in_progress","conclusion":null}]}`),
+ "POST /repos/octo/app/issues/7/comments": githubJSON(http.StatusCreated, `{"id":99,"html_url":"https://github.com/octo/app/pull/7#issuecomment-99"}`),
+ "POST /repos/octo/app/issues/7/labels": githubJSON(http.StatusOK, `[{"name":"bug"},{"name":"triage"}]`),
+ }}
+ api.serve(t)
+
+ text, isErr := callGitHubTool(t, f, mainBotGitHubIssuesList, `{"repository":"app","labels":"bug"}`)
+ if isErr || !strings.Contains(text, `"Real issue"`) || strings.Contains(text, `"A PR"`) || !strings.Contains(text, `"count":1`) || !strings.Contains(text, `"hasMore":false`) {
+ t.Fatalf("issues list = %s (error=%t)", text, isErr)
+ }
+ if !strings.Contains(labelQuery, "labels=bug") || !strings.Contains(labelQuery, "state=open") || !strings.Contains(labelQuery, "per_page=100") {
+ t.Fatalf("issues query = %q", labelQuery)
+ }
+
+ text, isErr = callGitHubTool(t, f, mainBotGitHubPullsList, `{"repository":"app"}`)
+ if isErr || !strings.Contains(text, `"head":"topic"`) || !strings.Contains(text, `"draft":true`) || !strings.Contains(text, `"hasMore":false`) {
+ t.Fatalf("pulls list = %s (error=%t)", text, isErr)
+ }
+
+ text, isErr = callGitHubTool(t, f, mainBotGitHubPRStatus, `{"repository":"app","number":7}`)
+ if isErr || !strings.Contains(text, `"checksState":"pending"`) || !strings.Contains(text, `"mergeableState":"blocked"`) || !strings.Contains(text, `"ci/legacy"`) || strings.Contains(text, "checksWarnings") {
+ t.Fatalf("pr status = %s (error=%t)", text, isErr)
+ }
+
+ text, isErr = callGitHubTool(t, f, mainBotGitHubCommentAdd, `{"repository":"app","number":7,"body":"LGTM"}`)
+ if isErr || !strings.Contains(text, `"commentId":99`) {
+ t.Fatalf("comment = %s (error=%t)", text, isErr)
+ }
+
+ text, isErr = callGitHubTool(t, f, mainBotGitHubLabelsAdd, `{"repository":"app","number":7,"labels":["bug"," triage "]}`)
+ if isErr || !strings.Contains(text, `"labels":["bug","triage"]`) {
+ t.Fatalf("labels = %s (error=%t)", text, isErr)
+ }
+
+ api.mu.Lock()
+ defer api.mu.Unlock()
+ for i, token := range api.tokens {
+ if token != "Bearer "+githubToolTestToken {
+ t.Fatalf("request %s used token %q", api.requests[i], token)
+ }
+ }
+ bodies := strings.Join(api.bodies, "\n")
+ if !strings.Contains(bodies, `{"body":"LGTM"}`) || !strings.Contains(bodies, `{"labels":["bug","triage"]}`) {
+ t.Fatalf("write payloads = %s", bodies)
+ }
+}
+
+func TestGitHubWriteToolsReviewedInAssistedMode(t *testing.T) {
+ f := newGitHubToolFixture(t)
+ f.set(githubToolTestToken)
+ f.session.ExecMode = assistantExecModeForApproval(AssistantApprovalAssisted)
+ if !f.session.ExecMode.ReviewWrites {
+ t.Fatalf("assisted mode must review writes: %+v", f.session.ExecMode)
+ }
+ allow := false
+ var reviewed []string
+ f.session.approvalReviewer = func(_ context.Context, tool, description string, args map[string]any) assistantApprovalReview {
+ reviewed = append(reviewed, tool)
+ if args["repository"] != "octo/app" || args["projectId"] != "workbench" || args["arguments"] == nil || !strings.Contains(description, "GitHub") {
+ t.Fatalf("review lost scope: %s %v", description, args)
+ }
+ outcome := "deny"
+ if allow {
+ outcome = "allow"
+ }
+ return assistantApprovalReview{Outcome: outcome, RiskLevel: "low", UserAuthorization: "high", Rationale: "核对本次 GitHub 写操作"}
+ }
+ api := &fakeGitHubAPI{routes: map[string]func(http.ResponseWriter, *http.Request){
+ "GET /repos/octo/app/issues": githubJSON(http.StatusOK, `[]`),
+ "POST /repos/octo/app/issues/7/comments": githubJSON(http.StatusCreated, `{"id":99}`),
+ "POST /repos/octo/app/issues/7/labels": githubJSON(http.StatusOK, `[{"name":"bug"}]`),
+ }}
+ api.serve(t)
+
+ // 只读工具不过审查。
+ if text, isErr := callGitHubTool(t, f, mainBotGitHubIssuesList, `{"repository":"app"}`); isErr {
+ t.Fatalf("read tool failed: %s", text)
+ }
+ // 参数不合法时先报错,不浪费一次审查。
+ if _, isErr := callGitHubTool(t, f, mainBotGitHubCommentAdd, `{"repository":"app","number":7,"body":" "}`); !isErr {
+ t.Fatal("invalid comment accepted")
+ }
+ if len(reviewed) != 0 {
+ t.Fatalf("unexpected reviews: %v", reviewed)
+ }
+
+ for _, tc := range []struct{ name, args string }{
+ {mainBotGitHubCommentAdd, `{"repository":"app","number":7,"body":"LGTM"}`},
+ {mainBotGitHubLabelsAdd, `{"repository":"app","number":7,"labels":["bug"]}`},
+ } {
+ text, isErr := callGitHubTool(t, f, tc.name, tc.args)
+ if !isErr || !strings.Contains(text, "帮我批准未执行") {
+ t.Fatalf("%s denied review = %s (error=%t)", tc.name, text, isErr)
+ }
+ }
+ api.mu.Lock()
+ for _, req := range api.requests {
+ if strings.HasPrefix(req, "POST ") {
+ api.mu.Unlock()
+ t.Fatalf("GitHub write executed without approval: %v", api.requests)
+ }
+ }
+ api.mu.Unlock()
+ if strings.Join(reviewed, ",") != mainBotGitHubCommentAdd+","+mainBotGitHubLabelsAdd {
+ t.Fatalf("reviewed = %v", reviewed)
+ }
+
+ allow = true
+ if text, isErr := callGitHubTool(t, f, mainBotGitHubCommentAdd, `{"repository":"app","number":7,"body":"LGTM"}`); isErr || !strings.Contains(text, `"commentId":99`) {
+ t.Fatalf("approved comment = %s (error=%t)", text, isErr)
+ }
+ if text, isErr := callGitHubTool(t, f, mainBotGitHubLabelsAdd, `{"repository":"app","number":7,"labels":["bug"]}`); isErr || !strings.Contains(text, `"labels":["bug"]`) {
+ t.Fatalf("approved labels = %s (error=%t)", text, isErr)
+ }
+
+ // 没有可用审查器时按拒绝处理,不静默放行。
+ f.session.approvalReviewer = nil
+ if text, isErr := callGitHubTool(t, f, mainBotGitHubCommentAdd, `{"repository":"app","number":7,"body":"again"}`); !isErr || !strings.Contains(text, "帮我批准未执行") {
+ t.Fatalf("comment without reviewer = %s (error=%t)", text, isErr)
+ }
+}
+
+func githubIssuePage(from, count int, pulls bool) string {
+ items := make([]string, 0, count)
+ for i := 0; i < count; i++ {
+ n := from + i
+ pr := ""
+ if pulls {
+ pr = `,"pull_request":{"url":"x"}`
+ }
+ items = append(items, fmt.Sprintf(`{"number":%d,"title":"item %d","state":"open"%s}`, n, n, pr))
+ }
+ return "[" + strings.Join(items, ",") + "]"
+}
+
+func TestGitHubIssuesListPagesPastPullRequests(t *testing.T) {
+ f := newGitHubToolFixture(t)
+ f.set(githubToolTestToken)
+ var queries []string
+ api := &fakeGitHubAPI{routes: map[string]func(http.ResponseWriter, *http.Request){
+ // 第 1 页全是 PR,第 2 页有 2 个 Issue 且不满页。
+ "GET /repos/octo/app/issues": func(w http.ResponseWriter, r *http.Request) {
+ queries = append(queries, r.URL.RawQuery)
+ switch r.URL.Query().Get("page") {
+ case "1":
+ _, _ = io.WriteString(w, githubIssuePage(1000, githubListPageSize, true))
+ case "2":
+ _, _ = io.WriteString(w, githubIssuePage(1, 2, false))
+ default:
+ _, _ = io.WriteString(w, `[]`)
+ }
+ },
+ }}
+ api.serve(t)
+
+ text, isErr := callGitHubTool(t, f, mainBotGitHubIssuesList, `{"repository":"app","limit":3}`)
+ if isErr || !strings.Contains(text, `"count":2`) || !strings.Contains(text, `"hasMore":false`) || !strings.Contains(text, `"item 1"`) || !strings.Contains(text, `"item 2"`) {
+ t.Fatalf("issues = %s (error=%t)", text, isErr)
+ }
+ if len(queries) != 2 || !strings.Contains(queries[0], "per_page=100") || !strings.Contains(queries[1], "page=2") {
+ t.Fatalf("queries = %v", queries)
+ }
+
+ text, isErr = callGitHubTool(t, f, mainBotGitHubIssuesList, `{"repository":"app","limit":1}`)
+ if isErr || !strings.Contains(text, `"count":1`) || !strings.Contains(text, `"hasMore":true`) || strings.Contains(text, `"item 2"`) {
+ t.Fatalf("truncated issues = %s (error=%t)", text, isErr)
+ }
+}
+
+func TestGitHubIssuesListStopsAtPageCap(t *testing.T) {
+ f := newGitHubToolFixture(t)
+ f.set(githubToolTestToken)
+ pages := 0
+ api := &fakeGitHubAPI{routes: map[string]func(http.ResponseWriter, *http.Request){
+ "GET /repos/octo/app/issues": func(w http.ResponseWriter, r *http.Request) {
+ pages++
+ page, _ := strconv.Atoi(r.URL.Query().Get("page"))
+ _, _ = io.WriteString(w, githubIssuePage(page*1000, githubListPageSize, true))
+ },
+ }}
+ api.serve(t)
+ text, isErr := callGitHubTool(t, f, mainBotGitHubIssuesList, `{"repository":"app"}`)
+ if isErr || !strings.Contains(text, `"count":0`) || !strings.Contains(text, `"hasMore":true`) || pages != githubIssuesMaxPages {
+ t.Fatalf("issues = %s (error=%t) pages=%d", text, isErr, pages)
+ }
+}
+
+func TestGitHubPullsListReportsHasMore(t *testing.T) {
+ f := newGitHubToolFixture(t)
+ f.set(githubToolTestToken)
+ var query string
+ api := &fakeGitHubAPI{routes: map[string]func(http.ResponseWriter, *http.Request){
+ "GET /repos/octo/app/pulls": func(w http.ResponseWriter, r *http.Request) {
+ query = r.URL.RawQuery
+ _, _ = io.WriteString(w, `[{"number":9,"title":"first"},{"number":8,"title":"second"}]`)
+ },
+ }}
+ api.serve(t)
+ text, isErr := callGitHubTool(t, f, mainBotGitHubPullsList, `{"repository":"app","limit":1}`)
+ if isErr || !strings.Contains(text, `"count":1`) || !strings.Contains(text, `"hasMore":true`) || strings.Contains(text, `"second"`) {
+ t.Fatalf("pulls = %s (error=%t)", text, isErr)
+ }
+ if !strings.Contains(query, "per_page=2") {
+ t.Fatalf("pulls query = %q", query)
+ }
+ text, _ = callGitHubTool(t, f, mainBotGitHubPullsList, `{"repository":"app","limit":2}`)
+ if !strings.Contains(text, `"count":2`) || !strings.Contains(text, `"hasMore":false`) {
+ t.Fatalf("pulls = %s", text)
+ }
+}
+
+func TestGitHubToolsRequirePersonalToken(t *testing.T) {
+ f := newGitHubToolFixture(t)
+ api := &fakeGitHubAPI{routes: map[string]func(http.ResponseWriter, *http.Request){}}
+ api.serve(t)
+ text, isErr := callGitHubTool(t, f, mainBotGitHubIssuesList, `{"repository":"app"}`)
+ if !isErr || !strings.Contains(text, "个人凭证") || !strings.Contains(text, "github.com/settings/tokens") {
+ t.Fatalf("missing token result = %s (error=%t)", text, isErr)
+ }
+ if len(api.requests) != 0 {
+ t.Fatalf("GitHub called without a token: %v", api.requests)
+ }
+}
+
+func TestGitHubToolsRejectForeignRepositoryWithoutCallingGitHub(t *testing.T) {
+ f := newGitHubToolFixture(t)
+ f.set(githubToolTestToken)
+ api := &fakeGitHubAPI{routes: map[string]func(http.ResponseWriter, *http.Request){}}
+ api.serve(t)
+ for _, args := range []string{
+ `{"repository":"foreign","number":1,"body":"x"}`,
+ `{"repository":"octo/foreign","number":1,"body":"x"}`,
+ `{"repository":"internal","number":1,"body":"x"}`,
+ } {
+ if text, isErr := callGitHubTool(t, f, mainBotGitHubCommentAdd, args); !isErr {
+ t.Fatalf("%s accepted: %s", args, text)
+ }
+ }
+ if len(api.requests) != 0 {
+ t.Fatalf("GitHub called for a repository outside the project: %v", api.requests)
+ }
+}
+
+func TestGitHubToolsValidateArgumentsBeforeCallingGitHub(t *testing.T) {
+ f := newGitHubToolFixture(t)
+ f.set(githubToolTestToken)
+ api := &fakeGitHubAPI{routes: map[string]func(http.ResponseWriter, *http.Request){}}
+ api.serve(t)
+ for _, tc := range []struct {
+ name, args, want string
+ }{
+ {mainBotGitHubIssuesList, `{"repository":"app","state":"merged"}`, "state"},
+ {mainBotGitHubPRStatus, `{"repository":"app"}`, "number"},
+ {mainBotGitHubCommentAdd, `{"repository":"app","number":1,"body":" "}`, "body"},
+ {mainBotGitHubCommentAdd, `{"repository":"app","number":0,"body":"x"}`, "number"},
+ {mainBotGitHubLabelsAdd, `{"repository":"app","number":1,"labels":[]}`, "labels"},
+ {mainBotGitHubLabelsAdd, `{"repository":"app","number":1,"labels":[" "]}`, "labels"},
+ } {
+ text, isErr := callGitHubTool(t, f, tc.name, tc.args)
+ if !isErr || !strings.Contains(text, tc.want) {
+ t.Fatalf("%s %s = %s (error=%t), want error mentioning %q", tc.name, tc.args, text, isErr, tc.want)
+ }
+ }
+ if len(api.requests) != 0 {
+ t.Fatalf("GitHub called with invalid arguments: %v", api.requests)
+ }
+}
+
+func TestGitHubToolErrorsDoNotLeakToken(t *testing.T) {
+ f := newGitHubToolFixture(t)
+ f.set(githubToolTestToken)
+ api := &fakeGitHubAPI{routes: map[string]func(http.ResponseWriter, *http.Request){
+ "POST /repos/octo/app/issues/3/comments": githubJSON(http.StatusForbidden, `{"message":"token `+githubToolTestToken+` lacks Issues write"}`),
+ }}
+ api.serve(t)
+ text, isErr := callGitHubTool(t, f, mainBotGitHubCommentAdd, `{"repository":"app","number":3,"body":"hi"}`)
+ if !isErr || !strings.Contains(text, "HTTP 403") || strings.Contains(text, githubToolTestToken) {
+ t.Fatalf("error result = %s (error=%t)", text, isErr)
+ }
+ // 报错按操作说明所需权限,不再沿用"发起 PR"的文案。
+ if !strings.Contains(text, "添加评论") || !strings.Contains(text, "Issues 读写") || strings.Contains(text, "发起 PR") {
+ t.Fatalf("error text = %s", text)
+ }
+}
+
+func TestGitHubCombinedChecksState(t *testing.T) {
+ for _, tc := range []struct {
+ name, status, runs, want string
+ }{
+ {"none", `{"statuses":[]}`, `{"check_runs":[]}`, "none"},
+ {"all success", `{"statuses":[{"context":"a","state":"success"}]}`, `{"check_runs":[{"name":"b","status":"completed","conclusion":"success"}]}`, "success"},
+ {"neutral and skipped pass", `{"statuses":[]}`, `{"check_runs":[{"name":"b","status":"completed","conclusion":"neutral"},{"name":"c","status":"completed","conclusion":"skipped"}]}`, "success"},
+ {"pending", `{"statuses":[{"context":"a","state":"pending"}]}`, `{"check_runs":[]}`, "pending"},
+ {"queued run", `{"statuses":[]}`, `{"check_runs":[{"name":"b","status":"queued","conclusion":null}]}`, "pending"},
+ {"failure wins", `{"statuses":[{"context":"a","state":"pending"}]}`, `{"check_runs":[{"name":"b","status":"completed","conclusion":"failure"}]}`, "failure"},
+ {"action_required", `{"statuses":[]}`, `{"check_runs":[{"name":"b","status":"completed","conclusion":"action_required"}]}`, "failure"},
+ {"startup_failure", `{"statuses":[]}`, `{"check_runs":[{"name":"b","status":"completed","conclusion":"startup_failure"}]}`, "failure"},
+ {"stale", `{"statuses":[]}`, `{"check_runs":[{"name":"b","status":"completed","conclusion":"stale"}]}`, "failure"},
+ } {
+ api := &fakeGitHubAPI{routes: map[string]func(http.ResponseWriter, *http.Request){
+ "GET /repos/octo/app/commits/sha/status": githubJSON(http.StatusOK, tc.status),
+ "GET /repos/octo/app/commits/sha/check-runs": githubJSON(http.StatusOK, tc.runs),
+ }}
+ api.serve(t)
+ if _, got, warnings := githubCombinedChecks(context.Background(), githubHTTPClient(), "tok", "octo/app", "sha"); got != tc.want || len(warnings) != 0 {
+ t.Errorf("%s: state = %q warnings = %v, want %q", tc.name, got, warnings, tc.want)
+ }
+ }
+ if _, got, _ := githubCombinedChecks(context.Background(), githubHTTPClient(), "tok", "octo/app", " "); got != "none" {
+ t.Fatalf("empty sha state = %q", got)
+ }
+}
+
+func TestGitHubCombinedChecksReportsUnreadableSources(t *testing.T) {
+ var runsQuery, statusQuery string
+ api := &fakeGitHubAPI{routes: map[string]func(http.ResponseWriter, *http.Request){
+ "GET /repos/octo/app/commits/sha/status": func(w http.ResponseWriter, r *http.Request) {
+ statusQuery = r.URL.RawQuery
+ _, _ = io.WriteString(w, `{"total_count":1,"statuses":[{"context":"a","state":"success"}]}`)
+ },
+ "GET /repos/octo/app/commits/sha/check-runs": func(w http.ResponseWriter, r *http.Request) {
+ runsQuery = r.URL.RawQuery
+ w.WriteHeader(http.StatusForbidden)
+ _, _ = io.WriteString(w, `{"message":"Resource not accessible by personal access token"}`)
+ },
+ }}
+ api.serve(t)
+ checks, state, warnings := githubCombinedChecks(context.Background(), githubHTTPClient(), "tok", "octo/app", "sha")
+ if state != "unknown" || len(checks) != 1 || len(warnings) != 1 || !strings.Contains(warnings[0], "HTTP 403") || !strings.Contains(warnings[0], "Checks") {
+ t.Fatalf("403 on check-runs: state=%q checks=%v warnings=%v", state, checks, warnings)
+ }
+ if !strings.Contains(runsQuery, "per_page=100") || !strings.Contains(statusQuery, "per_page=100") {
+ t.Fatalf("queries: status=%q runs=%q", statusQuery, runsQuery)
+ }
+
+ // 读到的部分已经失败时,另一个来源读不到(这里 status 返回 404)也不影响
+ // failure 的结论;只统计了前 N 项时要提示。
+ api = &fakeGitHubAPI{routes: map[string]func(http.ResponseWriter, *http.Request){
+ "GET /repos/octo/app/commits/sha/check-runs": githubJSON(http.StatusOK, `{"total_count":150,"check_runs":[{"name":"b","status":"completed","conclusion":"failure"}]}`),
+ }}
+ api.serve(t)
+ _, state, warnings = githubCombinedChecks(context.Background(), githubHTTPClient(), "tok", "octo/app", "sha")
+ if state != "failure" || len(warnings) != 2 || !strings.Contains(strings.Join(warnings, "\n"), "共 150 项") {
+ t.Fatalf("partial failure: state=%q warnings=%v", state, warnings)
+ }
+}
+
+func TestGitHubPRStatusSurfacesCheckWarnings(t *testing.T) {
+ f := newGitHubToolFixture(t)
+ f.set(githubToolTestToken)
+ api := &fakeGitHubAPI{routes: map[string]func(http.ResponseWriter, *http.Request){
+ "GET /repos/octo/app/pulls/7": githubJSON(http.StatusOK, `{"number":7,"state":"open","head":{"sha":"abc","ref":"topic"},"base":{"ref":"main"}}`),
+ "GET /repos/octo/app/commits/abc/status": githubJSON(http.StatusForbidden, `{"message":"no"}`),
+ "GET /repos/octo/app/commits/abc/check-runs": githubJSON(http.StatusForbidden, `{"message":"no"}`),
+ }}
+ api.serve(t)
+ text, isErr := callGitHubTool(t, f, mainBotGitHubPRStatus, `{"repository":"app","number":7}`)
+ if isErr || !strings.Contains(text, `"checksState":"unknown"`) || !strings.Contains(text, "checksWarnings") || !strings.Contains(text, "Commit statuses") {
+ t.Fatalf("pr status = %s (error=%t)", text, isErr)
+ }
+}
diff --git a/internal/httpapi/agent_tool_mcp.go b/internal/httpapi/agent_tool_mcp.go
index 8479a107..28f4b4a2 100644
--- a/internal/httpapi/agent_tool_mcp.go
+++ b/internal/httpapi/agent_tool_mcp.go
@@ -269,6 +269,12 @@ func (h *agentToolGateway) dispatch(ctx context.Context, session *AgentToolSessi
if tool.Kind == "workspace" {
return h.callMainBotWorkspace(ctx, session, tool.Name, args)
}
+ // 轻量 GitHub 工具(agent_tool_github.go):用请求人自己的 Git Token 直连
+ // GitHub,范围限定在当前项目已绑定的仓库。与 workspace 工具一样不走 drafts,
+ // 「帮我批准」时写操作在 callMainBotGitHub 里逐项过审查。
+ if tool.Kind == "github" {
+ return h.callMainBotGitHub(ctx, session, tool.Name, args)
+ }
if tool.Kind == "agentflow" {
if session.Mode == AgentToolClarify && !agentToolNameAllowed(AgentToolClarify, "agentflow", tool.UpstreamName) {
return "", errAgentToolForbidden