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.
JavaScript agent-orchestrationagentic-workflowai-agentsai-codingclaude-codecode-reviewcodebuddycodexcoding-agentscursordeveloper-toolshuman-on-the-loopllmmcpmulti-agentsdlcself-hostedsopworkflow-automationworkflow-engine
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.goindex 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 *AgentToolSout = 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.gonew file mode 100644index 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.gonew file mode 100644index 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.goindex 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 *AgentToolSessiif 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