diff --git a/README.md b/README.md index e26510c..b41b8f1 100644 --- a/README.md +++ b/README.md @@ -1,12 +1,13 @@ # teai -teai 是 Gitea 的命令列（CLI）輔助工具，補足官方 `tea` CLI 缺少的功能。 +teai 是 Gitea 的命令列（CLI）工具，以更完整、更可靠的方式操作 Gitea。 名稱取「**te**a + **AI**」：這套工具主要為了讓 AI agent 能以更完整、更可靠的 方式操作 Gitea（查詢、回覆、審核、自動化……）。 - **語言：** Go（與 Gitea 本體一致），僅用標準庫，離線可建置 - **目標站點：** `https://gitea.alterminal.com` -- **狀態：** 基礎建設（#5：internal/gitea）與工作流命令（#6：whoami/orgs/members/mine/pulls/next）已實作；stalled/xrefs（#7）與日常操作命令（#8）進行中 +- **狀態：** 基礎建設（#5：internal/gitea）、工作流命令（#6：whoami/orgs/members/mine/pulls/next）與日常操作命令（#8：issues/pulls/labels/milestones/releases/repos/api）已實作；stalled/xrefs（#7）進行中 +- **範圍（#3）：** 不避開 tea 已有的功能；單一工具涵蓋完整操作 ## 安裝與建置 @@ -23,12 +24,43 @@ go build -o teai ./cmd/teai ### 設計原則 -1. **與 tea 互補，不重複**：`tea` 已有的功能（clone、issues、pulls、labels、milestones、release、api……）一律用 `tea`。teai 只做 tea 做不到的事：跨倉庫／跨組織聚合、工作流判定（跟進／審核／停滯）、機器可讀輸出。 +1. **功能自主完整（#3）**：teai 自行實作完整的功能集，**不**以「tea 已有」為由略過（tea 本身存在諸多問題，見 #3）。除了 gitea.py 工作流（跨倉庫／跨組織聚合、工作流判定、機器可讀輸出），也涵蓋日常操作（issues／pulls／labels／milestones／release……），tea 只是相容參考與對照組。由單一二進位檔提供一致介面，避免多工具拼接。 2. **規則單一來源**：「最後一則留言不是自己」等工作流判定規則以 `AGENTS.md` 為準，teai 只實作、不改義。規則要變更，先改 AGENTS.md，teai 跟著改。 3. **機器可讀優先**：預設輸出 JSON；`--output table` 僅供人工抽查。 4. **可直接替換原型**：`gitea.py` 的每個子命令在 teai 都有語義相同的對應命令，可交叉驗證、平滑遷移。 5. **認證沿用 tea**：讀 `tea` 的登入組態（`TEA_CONFIG` 或 `~/.config/tea/config.yml`），不另建認證體系。 -6. **安全預設**：本期全部是查詢類（唯讀）；寫入類（留言、指派、審核者）不在本期範圍，未來加入時須明確 `--yes`。 +6. **安全預設**：查詢類唯讀；寫入類命令（#8 起）一律要求明確 `--yes`，未確認時不發出任何請求、不產生任何遠端變更。 + +### 日常操作（tea 對等指令；#3 不避開 tea 已有功能；#8 已實作） + +issues／pulls／labels／milestones／releases／repos／api 的日常操作，自行實作、輸出一致 JSON、共用同一套認證與全域選項。介面語義以 `tea`／Gitea API 為相容參考。已實作： + +```sh +# issues +teai issues list --repo / [--state open|closed|all] +teai issues view --repo / [--comments] +teai issues create --repo / --title … [--body …] [--assignees a,b] --yes +teai issues close --repo / --yes +teai issues comment --repo / --body … --yes +# pulls（無子命令仍是工作流清單：--mine／--reviewer／--repo） +teai pulls list --repo / [--state open|closed|all] +teai pulls view --repo / [--comments] +teai pulls create --repo / --head [--base main] --title … [--body …] --yes +teai pulls merge --repo / [--style merge|rebase|rebase-merge|squash] --yes +teai pulls comment --repo / --body … --yes +# labels／milestones／releases／repos +teai labels list --repo / +teai labels create --repo / --name … [--color #RRGGBB] [--description …] --yes +teai milestones list --repo / [--state open|closed|all] +teai milestones create --repo / --title … [--description …] [--due RFC3339] --yes +teai releases list --repo / +teai repos list [--org ] +# 任意 API 呼叫（逃生口） +teai api [--method GET|POST|PATCH|DELETE] [--data ''] [--yes] +``` + +> `--yes` 閘門：所有寫入類命令（create／close／comment／merge／labels create／milestones create／api 非 GET 動詞）未帶 `--yes` 時回 exit 2（用法錯誤），且不發出任何 HTTP 請求。 +> `teai api` 的 path 內含查詢字串（如 `/repos/a/b/issues?state=closed`）時會正確傳遞。 ### 全域介面 @@ -48,6 +80,7 @@ teai [全域選項] <命令> [參數] | 命令 | 對應 gitea.py | 說明 | | --- | --- | --- | +| `teai login list\|add\|default\|remove` | — | 管理 tea 相容登入組態（見下） | | `teai whoami` | `get_current_username` | 目前帳號 | | `teai orgs` | `for_all_organizations` | 我所屬的組織 | | `teai members [--has-work]` | `members [--has-work]` | Agents 團隊成員；`--has-work` 只列有未完成工作者 | @@ -86,6 +119,25 @@ teai next --output table # 人類可讀 } ``` +### `teai login` — 管理登入 + +teai 與 tea 共用同一份組態檔（`--config`／`TEA_CONFIG`，預設 `~/.config/tea/config.yml`）。 +寫入採行級編輯：只動目標項目的行，未知欄位（`ssh_*` 等）與 `preferences` 區段逐字保留， +不改壞 tea 也在使用的檔案；檔案權限 `0600`、暫存檔原子替換。 + +```sh +teai login list # 列出登入（一律不含 token） +teai login add [--url ] [--name <名稱>] [--default=false] [--token ] + # 先以 token 呼叫 GET /user 驗證，成功才寫入（並記下帳號） +teai login default <名稱> # 設定預設登入 +teai login remove <名稱> [--yes] # 移除登入；移除預設者時其餘第一筆自動遞補 +``` + +- `login add` 未給 `--token` 時自 stdin 讀一行，避免 token 進 shell 歷史；token 驗證失敗（401） + 不寫入，結束碼 3。 +- 未給 `--name` 時：同站（URL 主機相同）已有登入 → 就地更新該項目；否則以 URL 主機為名稱。 +- 輸出 JSON（`--output table` 供人工查看），欄位 `name`／`url`／`user`／`default`，**永不輸出 token**。 + ### `teai stalled [--hours N]` — 管理者巡邏 ```sh diff --git a/internal/cli/cli.go b/internal/cli/cli.go index 5acc872..054ebb4 100644 --- a/internal/cli/cli.go +++ b/internal/cli/cli.go @@ -12,6 +12,7 @@ package cli import ( "errors" + "flag" "fmt" "io" "sort" @@ -88,6 +89,11 @@ type Env struct { // commands 是已註冊的子命令表。新增功能時在這裡註冊即可。 var commands = map[string]*command{ + "login": { + name: "login", + usage: "管理登入（list/add/default/remove）", + run: runLogin, + }, "version": { name: "version", usage: "顯示版本資訊", @@ -97,9 +103,8 @@ var commands = map[string]*command{ // Run 剖析引數並分派到對應子命令，回傳行程結束碼。 // -// 引數結構：teai [全域選項] <命令> [命令參數]。全域選項可出現在命令 -// 之前或之後（README 範例：teai next --output table）；無引數或要求說明 -// （-h/--help）時印出用法；未知命令或無效選項回 ExitUsage。 +// 引數結構：teai [全域選項] <命令> [命令參數]。全域選項須在命令之前； +// 無引數或要求說明（-h/--help）時印出用法；未知命令或無效選項回 ExitUsage。 func Run(stdout, stderr io.Writer, args []string) int { env := &Env{Out: stdout, Err: stderr, Globals: defaultGlobals()} @@ -108,7 +113,7 @@ func Run(stdout, stderr io.Writer, args []string) int { return int(ExitOK) } - rest, err := extractGlobals(&env.Globals, args) + rest, err := parseGlobals(&env.Globals, args) if err != nil { fmt.Fprintf(stderr, "teai: %v\n\n", err) printUsage(stderr) @@ -127,11 +132,6 @@ func Run(stdout, stderr io.Writer, args []string) int { return dispatch(env, "version", rest[1:]) default: name := rest[0] - if strings.HasPrefix(name, "-") { - fmt.Fprintf(stderr, "teai: unknown global option %q\n\n", name) - printUsage(stderr) - return int(ExitUsage) - } if _, ok := commands[name]; !ok { fmt.Fprintf(stderr, "teai: unknown command %q\n\n", name) printUsage(stderr) @@ -141,7 +141,7 @@ func Run(stdout, stderr io.Writer, args []string) int { } } -// globalFlags 列出全域選項的長名稱（目前全部都需要值）。 +// globalFlags 列出全域選項的長名稱與是否需要值。 var globalFlags = map[string]bool{ "--url": true, "--token": true, @@ -150,24 +150,40 @@ var globalFlags = map[string]bool{ "--timeout": true, } -// extractGlobals 從 args 中抽出全域選項（可出現在命令之前或之後）， -// 回傳其餘引數（命令與其參數，順序保留）。 -// -// 採「抽取式」剖析：只取走已知的全域選項；任何其他引數——位置參數或 -// 子命令自己的旗標（如 members 的 --has-work、pulls 的 --mine／--reviewer／ -// --repo）——原樣依序交回，由子命令的 flagset 解析。因此 -// -// teai members --has-work --output table -// teai pulls --mine --repo alterminal/teai -// teai next --output table -// -// 都能正確分派（全域與命令旗標可交錯出現）。 -// -// 停止條件：遇到 --（剝除它，其後全部交回，不再抽取）或 -// -h/--help/-v/--version（不是全域選項，交回 Run 的分派處理）。 -// 全域選項缺少值或值無效時回 ErrUsage。 +// extractGlobals 從 args 中「抽取」全域選項（可出現在命令之後、與命令 +// 旗標交錯），其餘引數依原順序保留給子命令剖析。未知的選項一律留給 +// 子命令處理（可能是命令旗標，如 --has-work），不在這裡報錯。 func extractGlobals(g *Globals, args []string) ([]string, error) { rest := make([]string, 0, len(args)) + applyGlobal := func(name, value string) error { + switch name { + case "--url": + if strings.TrimSpace(value) == "" { + return &ErrUsage{Msg: "--url must not be empty"} + } + g.URL = value + case "--token": + g.Token = value + case "--config": + if strings.TrimSpace(value) == "" { + return &ErrUsage{Msg: "--config must not be empty"} + } + g.ConfigPath = value + case "--output": + f, err := gitea.ParseFormat(value) + if err != nil { + return &ErrUsage{Msg: err.Error()} + } + g.Output = f + case "--timeout": + d, err := time.ParseDuration(value) + if err != nil || d <= 0 { + return &ErrUsage{Msg: fmt.Sprintf("invalid --timeout %q (want e.g. 30s)", value)} + } + g.Timeout = d + } + return nil + } i := 0 for i < len(args) { arg := args[i] @@ -175,19 +191,15 @@ func extractGlobals(g *Globals, args []string) ([]string, error) { rest = append(rest, args[i+1:]...) return rest, nil } - if arg == "-" || !strings.HasPrefix(arg, "-") { + if !strings.HasPrefix(arg, "--") { rest = append(rest, arg) i++ continue } name, inline, hasInline := strings.Cut(arg, "=") - switch name { - case "-h", "--help", "-v", "--version": - rest = append(rest, args[i:]...) - return rest, nil - } - if _, ok := globalFlags[name]; !ok { - // 非全域選項：屬於子命令，原樣交回（順序保留）。 + _, ok := globalFlags[name] + if !ok { + // 不是全域選項：留給子命令（可能是 --has-work 這類命令旗標）。 rest = append(rest, arg) i++ continue @@ -202,7 +214,7 @@ func extractGlobals(g *Globals, args []string) ([]string, error) { i++ value = args[i] } - if err := applyGlobal(g, name, value); err != nil { + if err := applyGlobal(name, value); err != nil { return nil, err } i++ @@ -210,50 +222,111 @@ func extractGlobals(g *Globals, args []string) ([]string, error) { return rest, nil } -// applyGlobal 套用單一全域選項的值；值無效時回 ErrUsage。 -func applyGlobal(g *Globals, name, value string) error { - switch name { - case "--url": - if strings.TrimSpace(value) == "" { - return &ErrUsage{Msg: "--url must not be empty"} +// parseGlobals 從 args 前端取走全域選項，回傳剩餘引數（命令與其參數）。 +// 遇到第一個非選項引數即停；不認得的選項或缺少值都回 ErrUsage。 +func parseGlobals(g *Globals, args []string) ([]string, error) { + i := 0 + for i < len(args) { + arg := args[i] + if arg == "--" { + return args[i+1:], nil } - g.URL = value - case "--token": - g.Token = value - case "--config": - if strings.TrimSpace(value) == "" { - return &ErrUsage{Msg: "--config must not be empty"} + if !strings.HasPrefix(arg, "-") || arg == "-" { + return args[i:], nil } - g.ConfigPath = value - case "--output": - f, err := gitea.ParseFormat(value) - if err != nil { - return &ErrUsage{Msg: err.Error()} + name, inline, hasInline := strings.Cut(arg, "=") + // -h/--help/-v/--version 不是全域選項；交回 Run 的分派處理。 + switch name { + case "-h", "--help", "-v", "--version": + return args[i:], nil } - g.Output = f - case "--timeout": - d, err := time.ParseDuration(value) - if err != nil || d <= 0 { - return &ErrUsage{Msg: fmt.Sprintf("invalid --timeout %q (want e.g. 30s)", value)} + need, ok := globalFlags[name] + if !ok { + return nil, &ErrUsage{Msg: fmt.Sprintf("unknown global option %q", name)} } - g.Timeout = d + var value string + if hasInline { + value = inline + } else { + if !need { + // 目前所有全域選項都需要值；保留機制給未來的布林選項。 + value = "" + } + if i+1 >= len(args) { + return nil, &ErrUsage{Msg: fmt.Sprintf("global option %q requires a value", name)} + } + i++ + value = args[i] + } + switch name { + case "--url": + if strings.TrimSpace(value) == "" { + return nil, &ErrUsage{Msg: "--url must not be empty"} + } + g.URL = value + case "--token": + g.Token = value + case "--config": + if strings.TrimSpace(value) == "" { + return nil, &ErrUsage{Msg: "--config must not be empty"} + } + g.ConfigPath = value + case "--output": + f, err := gitea.ParseFormat(value) + if err != nil { + return nil, &ErrUsage{Msg: err.Error()} + } + g.Output = f + case "--timeout": + d, err := time.ParseDuration(value) + if err != nil || d <= 0 { + return nil, &ErrUsage{Msg: fmt.Sprintf("invalid --timeout %q (want e.g. 30s)", value)} + } + g.Timeout = d + } + i++ } - return nil + return nil, nil } // dispatch 執行已註冊的子命令，把錯誤轉成結束碼並輸出。 -// 全域選項已在 Run 的 extractGlobals 抽取完畢（允許出現在命令之後， -// README 範例：teai next --output table）；這裡把剩餘引數直接交給 -// 命令的 flagset 解析。 +// 旗標剖析交由各命令自行處理（不同命令有不同旗標，如 pulls --mine）； +// 全域選項允許出現在命令之後（README 範例：teai next --output table）， +// dispatch 先從 args 剝離全域選項併入 Globals，其餘（含命令自己的旗標， +// 如 --has-work）原樣交給命令，不會誤判為未知全域選項。 func dispatch(env *Env, name string, args []string) int { cmd := commands[name] - if err := cmd.run(env, args); err != nil { + g := env.Globals + rest, err := extractGlobals(&g, args) + if err != nil { + fmt.Fprintf(env.Err, "teai: %v\n\n", err) + printUsage(env.Err) + return int(ExitUsage) + } + env.Globals = g + if err := cmd.run(env, rest); err != nil { fmt.Fprintf(env.Err, "teai %s: %v\n", name, err) return int(exitCodeFor(err)) } return int(ExitOK) } +// errHelp 表示使用者要求該命令的說明（-h/--help）；FlagSet 已自行印出 +// 用法，靜默成功結束即可。 +var errHelp = errors.New("help requested") + +// parseFlags 剖析命令旗標：-h/--help 回 errHelp（由 exitCodeFor 視為成功）， +// 其他剖析錯誤回 ErrUsage。 +func parseFlags(fs *flag.FlagSet, args []string) error { + if err := fs.Parse(args); err != nil { + if errors.Is(err, flag.ErrHelp) { + return errHelp + } + return &ErrUsage{Msg: err.Error()} + } + return nil +} + // exitCodeFor 把命令錯誤映射到結束碼：用法錯誤 → 2，API 錯誤 → 3， // 其他（內部）→ 1。 func exitCodeFor(err error) ExitCode { @@ -271,9 +344,9 @@ func exitCodeFor(err error) ExitCode { return ExitInternal } -// runVersion 輸出版本資訊。 +// runVersion 輸出版本資訊；不接受任何參數。 func runVersion(env *Env, args []string) error { - if len(args) != 0 { + if len(args) > 0 { return &ErrUsage{Msg: "version 不接受參數"} } fmt.Fprintf(env.Out, "teai version %s\n", Version) diff --git a/internal/cli/dailyops_commands.go b/internal/cli/dailyops_commands.go new file mode 100644 index 0000000..58e6dab --- /dev/null +++ b/internal/cli/dailyops_commands.go @@ -0,0 +1,866 @@ +// dailyops_commands.go — 日常操作命令的 CLI 接線（#8）：issues、pulls、 +// labels、milestones、releases、repos、api（tea 對等指令）。 +// +// 規則： +// - 寫入類命令（create／close／comment／merge…）一律要求 --yes， +// 未帶 --yes 時不產生任何遠端變更（exit 2，用法錯誤）。 +// - `teai pulls` 相容 #6 的工作流用法（無子命令＝工作流清單 --mine/--reviewer）； +// 有子命令（list/create/view/merge/comment）時走日常操作。 +// - 輸出走 internal/gitea 的 Printer（--output json|table）。 +package cli + +import ( + "context" + "encoding/json" + "flag" + "fmt" + "strconv" + "strings" + + "gitea.alterminal.com/alterminal/teai/internal/dailyops" + "gitea.alterminal.com/alterminal/teai/internal/gitea" +) + +func init() { + register := func(c *command) { commands[c.name] = c } + register(&command{name: "issues", usage: "issues 管理（list/view/create/close/comment）", run: runIssues}) + register(&command{name: "pulls", usage: "PR 管理（list/view/create/merge/comment；無子命令＝工作流清單）", run: runPullsDaily}) + register(&command{name: "labels", usage: "標籤管理（list/create）", run: runLabels}) + register(&command{name: "milestones", usage: "里程碑管理（list/create）", run: runMilestones}) + register(&command{name: "releases", usage: "發佈清單（list）", run: runReleases}) + register(&command{name: "repos", usage: "倉庫查詢（list）", run: runRepos}) + register(&command{name: "api", usage: "任意 API 呼叫（--method/--data；寫入動詞需 --yes）", run: runAPIDirect}) +} + +// requireYes 檢查寫入閘門：未帶 --yes 回 ErrUsage（exit 2），不觸發任何請求。 +func requireYes(yes bool, what string) error { + if !yes { + return &ErrUsage{Msg: what + " 是寫入操作，需 --yes 明確確認（未確認，未產生任何遠端變更）"} + } + return nil +} + +// splitRepoFlag 把 --repo owner/repo 拆成兩段；空值回 ("", "", nil)。 +func splitRepoFlag(v string) (string, string, error) { + if v == "" { + return "", "", nil + } + parts := strings.SplitN(v, "/", 2) + if len(parts) != 2 || parts[0] == "" || parts[1] == "" { + return "", "", &ErrUsage{Msg: errNoRepoFlag.Error()} + } + return parts[0], parts[1], nil +} + +// newOpsClient 依全域選項建立 dailyops 用戶端。 +func newOpsClient(env *Env) (*dailyops.Ops, error) { + token, _, err := gitea.ResolveToken(gitea.AuthOptions{ + FlagToken: env.Globals.Token, + SiteURL: env.Globals.URL, + ConfigPath: env.Globals.ConfigPath, + }) + if err != nil { + return nil, err + } + client, err := gitea.New(env.Globals.URL, token, env.Globals.Timeout) + if err != nil { + return nil, err + } + return &dailyops.Ops{Client: client}, nil +} + +// parseNumber 把位置參數解析為 issue／PR 編號。 +func parseNumber(s string) (int64, error) { + n, err := strconv.ParseInt(s, 10, 64) + if err != nil || n <= 0 { + return 0, &ErrUsage{Msg: fmt.Sprintf("無效的編號 %q", s)} + } + return n, nil +} + +// joinOrEmpty 把清單型欄位格式化為逗號分隔（table 用）。 +func joinOrEmpty(v any) string { + switch x := v.(type) { + case string: + return x + case []string: + return strings.Join(x, ",") + default: + return fmt.Sprint(x) + } +} + +// issueRowsFields 是 issues 清單的欄位定義（與值順序對應）。 +func issueListFields() []gitea.Field { + return []gitea.Field{ + {Name: "number"}, {Name: "title"}, {Name: "state"}, + {Name: "author"}, {Name: "assignees", ValueFmt: joinOrEmpty}, {Name: "updated_at"}, + } +} + +// ---- issues ---- + +// runIssues：teai issues [list|view|create|close|comment] … +func runIssues(env *Env, args []string) error { + if len(args) == 0 { + return &ErrUsage{Msg: "issues 需要子命令：list | view | create | close | comment"} + } + sub, rest := args[0], args[1:] + switch sub { + case "list": + return runIssuesList(env, rest) + case "view": + return runIssuesView(env, rest) + case "create": + return runIssuesCreate(env, rest) + case "close": + return runIssuesClose(env, rest) + case "comment": + return runComment(env, rest, false) + default: + return &ErrUsage{Msg: fmt.Sprintf("issues 未知子命令 %q（可用：list | view | create | close | comment）", sub)} + } +} + +// runIssuesList：teai issues list --repo owner/repo [--state open|closed|all] +func runIssuesList(env *Env, args []string) error { + fs := flag.NewFlagSet("teai issues list", flag.ContinueOnError) + fs.SetOutput(env.Err) + repo := fs.String("repo", "", "倉庫（owner/repo，必填）") + state := fs.String("state", "open", "狀態：open|closed|all") + if err := parseFlags(fs, args); err != nil { + return err + } + if fs.NArg() != 0 { + return &ErrUsage{Msg: "issues list 不接受位置參數"} + } + owner, name, err := splitRepoFlag(*repo) + if err != nil { + return err + } + if owner == "" { + return &ErrUsage{Msg: "issues list 需要 --repo owner/repo"} + } + ops, err := newOpsClient(env) + if err != nil { + return err + } + issues, err := ops.ListIssues(context.Background(), owner, name, *state) + if err != nil { + return err + } + p := printer(env) + rows := make([]gitea.Values, 0, len(issues)) + for i := range issues { + it := &issues[i] + rows = append(rows, gitea.Values{ + it.Number, it.Title, it.State, it.Author(), + it.AssigneeNames(), it.UpdatedAt, + }) + } + return p.PrintList(issueListFields(), rows) +} + +// runIssuesView：teai issues view --repo owner/repo [--comments] +func runIssuesView(env *Env, args []string) error { + fs := flag.NewFlagSet("teai issues view", flag.ContinueOnError) + fs.SetOutput(env.Err) + repo := fs.String("repo", "", "倉庫（owner/repo，必填）") + withComments := fs.Bool("comments", false, "連留言一起輸出") + if err := parseFlags(fs, args); err != nil { + return err + } + owner, name, err := splitRepoFlag(*repo) + if err != nil { + return err + } + if owner == "" { + return &ErrUsage{Msg: "issues view 需要 --repo owner/repo"} + } + if fs.NArg() != 1 { + return &ErrUsage{Msg: "issues view 需要恰好一個編號"} + } + num, err := parseNumber(fs.Arg(0)) + if err != nil { + return err + } + ops, err := newOpsClient(env) + if err != nil { + return err + } + it, err := ops.GetIssue(context.Background(), owner, name, num) + if err != nil { + return err + } + p := printer(env) + fields := []gitea.Field{ + {Name: "number"}, {Name: "title"}, {Name: "state"}, + {Name: "author"}, {Name: "assignees", ValueFmt: joinOrEmpty}, + {Name: "labels", ValueFmt: joinOrEmpty}, {Name: "body"}, + {Name: "url"}, {Name: "updated_at"}, + } + row := gitea.Values{ + it.Number, it.Title, it.State, it.Author(), + it.AssigneeNames(), it.LabelNames(), it.Body, + it.HTMLURL, it.UpdatedAt, + } + if err := p.PrintOne(fields, row); err != nil { + return err + } + if !*withComments { + return nil + } + return printComments(env, ops, owner, name, num) +} + +// printComments 輸出 issue／PR 的留言清單（view --comments 共用）。 +func printComments(env *Env, ops *dailyops.Ops, owner, repo string, number int64) error { + comments, err := ops.ListComments(context.Background(), owner, repo, number) + if err != nil { + return err + } + p := printer(env) + rows := make([]gitea.Values, 0, len(comments)) + for i := range comments { + c := &comments[i] + rows = append(rows, gitea.Values{c.Author(), c.CreatedAt, c.Body}) + } + return p.PrintList([]gitea.Field{ + {Name: "author"}, {Name: "created_at"}, {Name: "body"}, + }, rows) +} + +// runIssuesCreate：teai issues create --repo owner/repo --title … [--body …] [--assignees a,b] --yes +func runIssuesCreate(env *Env, args []string) error { + fs := flag.NewFlagSet("teai issues create", flag.ContinueOnError) + fs.SetOutput(env.Err) + repo := fs.String("repo", "", "倉庫（owner/repo，必填）") + title := fs.String("title", "", "標題（必填）") + body := fs.String("body", "", "內文") + assignees := fs.String("assignees", "", "assignees（逗號分隔，可選）") + yes := fs.Bool("yes", false, "確認寫入") + if err := parseFlags(fs, args); err != nil { + return err + } + owner, name, err := splitRepoFlag(*repo) + if err != nil { + return err + } + if owner == "" { + return &ErrUsage{Msg: "issues create 需要 --repo owner/repo"} + } + if strings.TrimSpace(*title) == "" { + return &ErrUsage{Msg: "issues create 需要 --title"} + } + if err := requireYes(*yes, "issues create"); err != nil { + return err + } + var assigneeList []string + if strings.TrimSpace(*assignees) != "" { + for _, a := range strings.Split(*assignees, ",") { + if a = strings.TrimSpace(a); a != "" { + assigneeList = append(assigneeList, a) + } + } + } + ops, err := newOpsClient(env) + if err != nil { + return err + } + issue, err := ops.CreateIssue(context.Background(), owner, name, *title, *body, assigneeList) + if err != nil { + return err + } + return printer(env).PrintOne([]gitea.Field{ + {Name: "number"}, {Name: "title"}, {Name: "url"}, + }, gitea.Values{issue.Number, issue.Title, issue.HTMLURL}) +} + +// runIssuesClose：teai issues close --repo owner/repo --yes +func runIssuesClose(env *Env, args []string) error { + fs := flag.NewFlagSet("teai issues close", flag.ContinueOnError) + fs.SetOutput(env.Err) + repo := fs.String("repo", "", "倉庫（owner/repo，必填）") + yes := fs.Bool("yes", false, "確認寫入") + if err := parseFlags(fs, args); err != nil { + return err + } + owner, name, err := splitRepoFlag(*repo) + if err != nil { + return err + } + if owner == "" { + return &ErrUsage{Msg: "issues close 需要 --repo owner/repo"} + } + if fs.NArg() != 1 { + return &ErrUsage{Msg: "issues close 需要恰好一個編號"} + } + num, err := parseNumber(fs.Arg(0)) + if err != nil { + return err + } + if err := requireYes(*yes, "issues close"); err != nil { + return err + } + ops, err := newOpsClient(env) + if err != nil { + return err + } + issue, err := ops.SetIssueState(context.Background(), owner, name, num, "closed") + if err != nil { + return err + } + return printer(env).PrintOne([]gitea.Field{ + {Name: "number"}, {Name: "title"}, {Name: "state"}, {Name: "url"}, + }, gitea.Values{issue.Number, issue.Title, issue.State, issue.HTMLURL}) +} + +// runComment：teai issues comment / teai pulls comment 共用。 +func runComment(env *Env, args []string, isPR bool) error { + name := "issues comment" + if isPR { + name = "pulls comment" + } + fs := flag.NewFlagSet("teai "+name, flag.ContinueOnError) + fs.SetOutput(env.Err) + repo := fs.String("repo", "", "倉庫（owner/repo，必填）") + body := fs.String("body", "", "留言內容（必填）") + yes := fs.Bool("yes", false, "確認寫入") + if err := parseFlags(fs, args); err != nil { + return err + } + owner, rname, err := splitRepoFlag(*repo) + if err != nil { + return err + } + if owner == "" { + return &ErrUsage{Msg: name + " 需要 --repo owner/repo"} + } + if strings.TrimSpace(*body) == "" { + return &ErrUsage{Msg: name + " 需要 --body"} + } + if fs.NArg() != 1 { + return &ErrUsage{Msg: name + " 需要恰好一個編號"} + } + num, err := parseNumber(fs.Arg(0)) + if err != nil { + return err + } + if err := requireYes(*yes, name); err != nil { + return err + } + ops, err := newOpsClient(env) + if err != nil { + return err + } + comment, err := ops.AddComment(context.Background(), owner, rname, num, *body) + if err != nil { + return err + } + return printer(env).PrintOne([]gitea.Field{ + {Name: "author"}, {Name: "created_at"}, {Name: "body"}, + }, gitea.Values{comment.Author(), comment.CreatedAt, comment.Body}) +} + +// ---- pulls ---- + +// runPullsDaily：teai pulls [list|view|create|merge|comment] …； +// 無子命令時沿用 #6 的工作流清單（teai pulls [--mine|--reviewer] [--repo]）。 +func runPullsDaily(env *Env, args []string) error { + if len(args) == 0 || strings.HasPrefix(args[0], "-") { + // 相容 #6：teai pulls / teai pulls --mine …（工作流清單）。 + return runPulls(env, args) + } + sub, rest := args[0], args[1:] + switch sub { + case "list": + return runPullsList(env, rest) + case "view": + return runPullsView(env, rest) + case "create": + return runPullsCreate(env, rest) + case "merge": + return runPullsMerge(env, rest) + case "comment": + return runComment(env, rest, true) + default: + return &ErrUsage{Msg: fmt.Sprintf("pulls 未知子命令 %q（可用：list | view | create | merge | comment；或無子命令＝工作流清單）", sub)} + } +} + +// runPullsList：teai pulls list --repo owner/repo [--state open|closed|all] +func runPullsList(env *Env, args []string) error { + fs := flag.NewFlagSet("teai pulls list", flag.ContinueOnError) + fs.SetOutput(env.Err) + repo := fs.String("repo", "", "倉庫（owner/repo，必填）") + state := fs.String("state", "open", "狀態：open|closed|all") + if err := parseFlags(fs, args); err != nil { + return err + } + owner, name, err := splitRepoFlag(*repo) + if err != nil { + return err + } + if owner == "" { + return &ErrUsage{Msg: "pulls list 需要 --repo owner/repo"} + } + ops, err := newOpsClient(env) + if err != nil { + return err + } + pulls, err := ops.ListPulls(context.Background(), owner, name, *state) + if err != nil { + return err + } + p := printer(env) + rows := make([]gitea.Values, 0, len(pulls)) + for i := range pulls { + pr := &pulls[i] + rows = append(rows, gitea.Values{ + pr.Number, pr.Title, pr.State, pr.Author(), + pr.HeadRef(), pr.BaseRef(), pr.UpdatedAt, + }) + } + return p.PrintList([]gitea.Field{ + {Name: "number"}, {Name: "title"}, {Name: "state"}, + {Name: "author"}, {Name: "head"}, {Name: "base"}, {Name: "updated_at"}, + }, rows) +} + +// runPullsView：teai pulls view --repo owner/repo [--comments] +func runPullsView(env *Env, args []string) error { + fs := flag.NewFlagSet("teai pulls view", flag.ContinueOnError) + fs.SetOutput(env.Err) + repo := fs.String("repo", "", "倉庫（owner/repo，必填）") + withComments := fs.Bool("comments", false, "連留言一起輸出") + if err := parseFlags(fs, args); err != nil { + return err + } + owner, name, err := splitRepoFlag(*repo) + if err != nil { + return err + } + if owner == "" { + return &ErrUsage{Msg: "pulls view 需要 --repo owner/repo"} + } + if fs.NArg() != 1 { + return &ErrUsage{Msg: "pulls view 需要恰好一個編號"} + } + num, err := parseNumber(fs.Arg(0)) + if err != nil { + return err + } + ops, err := newOpsClient(env) + if err != nil { + return err + } + pr, err := ops.GetPull(context.Background(), owner, name, num) + if err != nil { + return err + } + p := printer(env) + fields := []gitea.Field{ + {Name: "number"}, {Name: "title"}, {Name: "state"}, + {Name: "author"}, {Name: "head"}, {Name: "base"}, {Name: "body"}, + {Name: "url"}, {Name: "updated_at"}, + } + row := gitea.Values{ + pr.Number, pr.Title, pr.State, pr.Author(), + pr.HeadRef(), pr.BaseRef(), pr.Body, pr.HTMLURL, pr.UpdatedAt, + } + if err := p.PrintOne(fields, row); err != nil { + return err + } + if !*withComments { + return nil + } + return printComments(env, ops, owner, name, num) +} + +// runPullsCreate：teai pulls create --repo owner/repo --head --base --title … [--body …] --yes +func runPullsCreate(env *Env, args []string) error { + fs := flag.NewFlagSet("teai pulls create", flag.ContinueOnError) + fs.SetOutput(env.Err) + repo := fs.String("repo", "", "倉庫（owner/repo，必填）") + head := fs.String("head", "", "來源分支（必填）") + base := fs.String("base", "main", "目標分支（預設 main）") + title := fs.String("title", "", "標題（必填）") + body := fs.String("body", "", "說明") + yes := fs.Bool("yes", false, "確認寫入") + if err := parseFlags(fs, args); err != nil { + return err + } + owner, name, err := splitRepoFlag(*repo) + if err != nil { + return err + } + if owner == "" { + return &ErrUsage{Msg: "pulls create 需要 --repo owner/repo"} + } + if *head == "" || *title == "" { + return &ErrUsage{Msg: "pulls create 需要 --head 與 --title"} + } + if err := requireYes(*yes, "pulls create"); err != nil { + return err + } + ops, err := newOpsClient(env) + if err != nil { + return err + } + pr, err := ops.CreatePull(context.Background(), owner, name, *title, *body, *head, *base) + if err != nil { + return err + } + return printer(env).PrintOne([]gitea.Field{ + {Name: "number"}, {Name: "title"}, {Name: "url"}, + }, gitea.Values{pr.Number, pr.Title, pr.HTMLURL}) +} + +// runPullsMerge：teai pulls merge --repo owner/repo [--style merge|rebase|squash] --yes +func runPullsMerge(env *Env, args []string) error { + fs := flag.NewFlagSet("teai pulls merge", flag.ContinueOnError) + fs.SetOutput(env.Err) + repo := fs.String("repo", "", "倉庫（owner/repo，必填）") + style := fs.String("style", "merge", "合併方式：merge|rebase|rebase-merge|squash") + yes := fs.Bool("yes", false, "確認寫入") + if err := parseFlags(fs, args); err != nil { + return err + } + owner, name, err := splitRepoFlag(*repo) + if err != nil { + return err + } + if owner == "" { + return &ErrUsage{Msg: "pulls merge 需要 --repo owner/repo"} + } + if fs.NArg() != 1 { + return &ErrUsage{Msg: "pulls merge 需要恰好一個編號"} + } + num, err := parseNumber(fs.Arg(0)) + if err != nil { + return err + } + switch *style { + case "merge", "rebase", "rebase-merge", "squash": + default: + return &ErrUsage{Msg: "pulls merge 的 --style 需為 merge|rebase|rebase-merge|squash"} + } + if err := requireYes(*yes, "pulls merge"); err != nil { + return err + } + ops, err := newOpsClient(env) + if err != nil { + return err + } + if err := ops.MergePull(context.Background(), owner, name, num, *style); err != nil { + return err + } + return printer(env).PrintOne([]gitea.Field{ + {Name: "number"}, {Name: "state"}, + }, gitea.Values{num, "merged"}) +} + +// ---- labels ---- + +// runLabels：teai labels list --repo owner/repo｜teai labels create … --yes +func runLabels(env *Env, args []string) error { + if len(args) == 0 { + return &ErrUsage{Msg: "labels 需要子命令：list | create"} + } + sub, rest := args[0], args[1:] + switch sub { + case "list": + return runLabelsList(env, rest) + case "create": + return runLabelsCreate(env, rest) + default: + return &ErrUsage{Msg: fmt.Sprintf("labels 未知子命令 %q（可用：list | create）", sub)} + } +} + +// runLabelsList：teai labels list --repo owner/repo +func runLabelsList(env *Env, args []string) error { + fs := flag.NewFlagSet("teai labels list", flag.ContinueOnError) + fs.SetOutput(env.Err) + repo := fs.String("repo", "", "倉庫（owner/repo，必填）") + if err := parseFlags(fs, args); err != nil { + return err + } + owner, name, err := splitRepoFlag(*repo) + if err != nil { + return err + } + if owner == "" { + return &ErrUsage{Msg: "labels list 需要 --repo owner/repo"} + } + ops, err := newOpsClient(env) + if err != nil { + return err + } + labels, err := ops.ListLabels(context.Background(), owner, name) + if err != nil { + return err + } + rows := make([]gitea.Values, 0, len(labels)) + for _, l := range labels { + rows = append(rows, gitea.Values{l.Name, l.Color, l.Description}) + } + return printer(env).PrintList([]gitea.Field{ + {Name: "name"}, {Name: "color"}, {Name: "description"}, + }, rows) +} + +// runLabelsCreate：teai labels create --repo owner/repo --name … [--color …] [--description …] --yes +func runLabelsCreate(env *Env, args []string) error { + fs := flag.NewFlagSet("teai labels create", flag.ContinueOnError) + fs.SetOutput(env.Err) + repo := fs.String("repo", "", "倉庫（owner/repo，必填）") + labelName := fs.String("name", "", "標籤名（必填）") + color := fs.String("color", "#ffffff", "顏色（#RRGGBB，預設 #ffffff）") + desc := fs.String("description", "", "說明") + yes := fs.Bool("yes", false, "確認寫入") + if err := parseFlags(fs, args); err != nil { + return err + } + owner, name, err := splitRepoFlag(*repo) + if err != nil { + return err + } + if owner == "" { + return &ErrUsage{Msg: "labels create 需要 --repo owner/repo"} + } + if *labelName == "" { + return &ErrUsage{Msg: "labels create 需要 --name"} + } + if err := requireYes(*yes, "labels create"); err != nil { + return err + } + ops, err := newOpsClient(env) + if err != nil { + return err + } + label, err := ops.CreateLabel(context.Background(), owner, name, *labelName, *color, *desc) + if err != nil { + return err + } + return printer(env).PrintOne([]gitea.Field{ + {Name: "name"}, {Name: "color"}, {Name: "description"}, + }, gitea.Values{label.Name, label.Color, label.Description}) +} + +// ---- milestones ---- + +// runMilestones：teai milestones list｜create … +func runMilestones(env *Env, args []string) error { + if len(args) == 0 { + return &ErrUsage{Msg: "milestones 需要子命令：list | create"} + } + sub, rest := args[0], args[1:] + switch sub { + case "list": + return runMilestonesList(env, rest) + case "create": + return runMilestonesCreate(env, rest) + default: + return &ErrUsage{Msg: fmt.Sprintf("milestones 未知子命令 %q（可用：list | create）", sub)} + } +} + +// runMilestonesList：teai milestones list --repo owner/repo [--state open|closed|all] +func runMilestonesList(env *Env, args []string) error { + fs := flag.NewFlagSet("teai milestones list", flag.ContinueOnError) + fs.SetOutput(env.Err) + repo := fs.String("repo", "", "倉庫（owner/repo，必填）") + state := fs.String("state", "open", "狀態：open|closed|all") + if err := parseFlags(fs, args); err != nil { + return err + } + owner, name, err := splitRepoFlag(*repo) + if err != nil { + return err + } + if owner == "" { + return &ErrUsage{Msg: "milestones list 需要 --repo owner/repo"} + } + ops, err := newOpsClient(env) + if err != nil { + return err + } + ms, err := ops.ListMilestones(context.Background(), owner, name, *state) + if err != nil { + return err + } + rows := make([]gitea.Values, 0, len(ms)) + for _, m := range ms { + rows = append(rows, gitea.Values{m.Title, m.State, m.Description, m.DueOn}) + } + return printer(env).PrintList([]gitea.Field{ + {Name: "title"}, {Name: "state"}, {Name: "description"}, {Name: "due_on"}, + }, rows) +} + +// runMilestonesCreate：teai milestones create --repo owner/repo --title … [--description …] [--due …] --yes +func runMilestonesCreate(env *Env, args []string) error { + fs := flag.NewFlagSet("teai milestones create", flag.ContinueOnError) + fs.SetOutput(env.Err) + repo := fs.String("repo", "", "倉庫（owner/repo，必填）") + title := fs.String("title", "", "標題（必填）") + desc := fs.String("description", "", "說明") + due := fs.String("due", "", "截止日（RFC3339，可選）") + yes := fs.Bool("yes", false, "確認寫入") + if err := parseFlags(fs, args); err != nil { + return err + } + owner, name, err := splitRepoFlag(*repo) + if err != nil { + return err + } + if owner == "" { + return &ErrUsage{Msg: "milestones create 需要 --repo owner/repo"} + } + if *title == "" { + return &ErrUsage{Msg: "milestones create 需要 --title"} + } + if err := requireYes(*yes, "milestones create"); err != nil { + return err + } + ops, err := newOpsClient(env) + if err != nil { + return err + } + m, err := ops.CreateMilestone(context.Background(), owner, name, *title, *desc, *due) + if err != nil { + return err + } + return printer(env).PrintOne([]gitea.Field{ + {Name: "id"}, {Name: "title"}, {Name: "state"}, {Name: "due_on"}, + }, gitea.Values{m.ID, m.Title, m.State, m.DueOn}) +} + +// ---- releases / repos / api ---- + +// runReleases：teai releases list --repo owner/repo +func runReleases(env *Env, args []string) error { + if len(args) == 0 || args[0] != "list" { + return &ErrUsage{Msg: "releases 目前支援子命令：list"} + } + fs := flag.NewFlagSet("teai releases list", flag.ContinueOnError) + fs.SetOutput(env.Err) + repo := fs.String("repo", "", "倉庫（owner/repo，必填）") + if err := parseFlags(fs, args[1:]); err != nil { + return err + } + owner, name, err := splitRepoFlag(*repo) + if err != nil { + return err + } + if owner == "" { + return &ErrUsage{Msg: "releases list 需要 --repo owner/repo"} + } + ops, err := newOpsClient(env) + if err != nil { + return err + } + releases, err := ops.ListReleases(context.Background(), owner, name) + if err != nil { + return err + } + rows := make([]gitea.Values, 0, len(releases)) + for _, r := range releases { + rows = append(rows, gitea.Values{r.TagName, r.Name, r.Draft, r.Prerelease, r.PublishedAt}) + } + return printer(env).PrintList([]gitea.Field{ + {Name: "tag_name"}, {Name: "name"}, {Name: "draft"}, {Name: "prerelease"}, {Name: "published_at"}, + }, rows) +} + +// runRepos：teai repos list [--org ]（未指定 --org 則列自己可存的倉庫） +func runRepos(env *Env, args []string) error { + if len(args) == 0 || args[0] != "list" { + return &ErrUsage{Msg: "repos 目前支援子命令：list"} + } + fs := flag.NewFlagSet("teai repos list", flag.ContinueOnError) + fs.SetOutput(env.Err) + org := fs.String("org", "", "組織（未指定則列自己可存取的倉庫）") + if err := parseFlags(fs, args[1:]); err != nil { + return err + } + ops, err := newOpsClient(env) + if err != nil { + return err + } + var repos []dailyops.Repo + if *org != "" { + repos, err = ops.ListOrgRepos(context.Background(), *org) + } else { + repos, err = ops.ListMyRepos(context.Background()) + } + if err != nil { + return err + } + rows := make([]gitea.Values, 0, len(repos)) + for _, r := range repos { + rows = append(rows, gitea.Values{r.FullName, r.Private, r.Empty, r.UpdatedAt, r.HTMLURL}) + } + return printer(env).PrintList([]gitea.Field{ + {Name: "full_name"}, {Name: "private"}, {Name: "empty"}, {Name: "updated_at"}, {Name: "url"}, + }, rows) +} + +// runAPIDirect：teai api [--method GET|POST|…] [--data ] [--yes] +func runAPIDirect(env *Env, args []string) error { + fs := flag.NewFlagSet("teai api", flag.ContinueOnError) + fs.SetOutput(env.Err) + method := fs.String("method", "GET", "HTTP 動詞（GET 預設；非 GET 需 --yes）") + data := fs.String("data", "", "請求 body（JSON 字串，可選）") + yes := fs.Bool("yes", false, "確認寫入") + if err := parseFlags(fs, args); err != nil { + return err + } + if fs.NArg() != 1 { + return &ErrUsage{Msg: "api 需要恰好一個 path（相對 api/v1，以 / 開頭）"} + } + path := fs.Arg(0) + // path 內含查詢字串（如 /repos/x?state=closed）時剝離到 rawQuery， + // 不可併進 URL path（會 404）。 + rawQuery := "" + if q := strings.IndexByte(path, '?'); q >= 0 { + rawQuery = path[q+1:] + path = path[:q] + } + if path == "" || path[0] != '/' { + return &ErrUsage{Msg: "api path 必須以 / 開頭（相對 api/v1）"} + } + upper := strings.ToUpper(strings.TrimSpace(*method)) + if upper == "" { + upper = "GET" + } + switch upper { + case "GET", "HEAD", "OPTIONS": + default: + if err := requireYes(*yes, "api "+upper); err != nil { + return err + } + } + var payload []byte + if strings.TrimSpace(*data) != "" { + if !json.Valid([]byte(*data)) { + return &ErrUsage{Msg: "--data 必須是合法 JSON"} + } + payload = []byte(*data) + } + ops, err := newOpsClient(env) + if err != nil { + return err + } + resp, err := ops.CallAPIDirect(context.Background(), upper, path, rawQuery, payload) + if err != nil { + return err + } + // 原樣輸出（teai api 是逃生口，不做欄位挑選）。 + _, err = env.Out.Write(resp) + if len(resp) > 0 && resp[len(resp)-1] != '\n' { + fmt.Fprintln(env.Out) + } + return err +} diff --git a/internal/cli/dailyops_commands_test.go b/internal/cli/dailyops_commands_test.go new file mode 100644 index 0000000..b59e175 --- /dev/null +++ b/internal/cli/dailyops_commands_test.go @@ -0,0 +1,289 @@ +// dailyops_commands_test.go — #8 的驗收測試：以 httptest 假伺服器驗證 +// issues/pulls/labels/milestones/releases/repos/api 的讀取行為，與 +// 寫入命令的 --yes 閘門（未帶 --yes 不得發出任何請求）。 +package cli + +import ( + "fmt" + "net/http" + "net/http/httptest" + "strings" + "testing" +) + +// opsTestServer 建立假 Gitea API 伺服器與對應的執行輔助。 +func opsTestServer(t *testing.T, handler http.HandlerFunc) func(args ...string) (string, string, int) { + t.Helper() + srv := httptest.NewServer(handler) + t.Cleanup(srv.Close) + return func(args ...string) (string, string, int) { + full := append([]string{"--url", srv.URL}, args...) + return runCLI(full...) // 套件級輔助（見下） + } +} + +// runCLI 是 cli_test.go `run` 的別名，避免與各測試內的區域變數 run 混淆。 +func runCLI(args ...string) (string, string, int) { + return run(args...) +} + +// TestIssuesListReadsOpenIssuesOnly 驗證 issues list 帶 state=open 與 +// type=issues（排除 PR），輸出 JSON 陣列。 +func TestIssuesListReadsOpenIssuesOnly(t *testing.T) { + var gotQuery string + run := opsTestServer(t, func(w http.ResponseWriter, r *http.Request) { + gotQuery = r.URL.RawQuery + fmt.Fprint(w, `[{"number":8,"title":"日常操作","state":"open","user":{"login":"ceo"},"assignees":[{"login":"alex"}],"updated_at":"2026-09-10T08:13:00Z"}]`) + }) + stdout, _, code := run("issues", "list", "--repo", "alterminal/teai") + if code != 0 { + t.Fatalf("issues list 應回 0，得到 %d", code) + } + if !strings.Contains(gotQuery, "state=open") || !strings.Contains(gotQuery, "type=issues") { + t.Errorf("查詢參數應含 state=open 與 type=issues，得到 %q", gotQuery) + } + if !strings.Contains(stdout, `"number":8`) || !strings.Contains(stdout, `"author":"ceo"`) { + t.Errorf("輸出應含 number 與 author 欄位，得到：%s", stdout) + } +} + +// TestIssuesListRequiresRepo 驗證 --repo 必填。 +func TestIssuesListRequiresRepo(t *testing.T) { + run := opsTestServer(t, func(w http.ResponseWriter, r *http.Request) { + t.Errorf("不應發出任何請求") + }) + _, stderr, code := run("issues", "list") + if code != int(ExitUsage) { + t.Errorf("缺 --repo 應回 ExitUsage，得到 %d", code) + } + if !strings.Contains(stderr, "--repo") { + t.Errorf("錯誤訊息應提及 --repo，得到：%s", stderr) + } +} + +// TestIssuesViewWithComments 驗證 view --comments 連留言輸出。 +func TestIssuesViewWithComments(t *testing.T) { + var paths []string + run := opsTestServer(t, func(w http.ResponseWriter, r *http.Request) { + paths = append(paths, r.URL.Path) + switch { + case strings.HasSuffix(r.URL.Path, "/issues/8"): + fmt.Fprint(w, `{"number":8,"title":"日常操作","state":"open","user":{"login":"ceo"},"body":"內文","html_url":"https://x/8","labels":[],"updated_at":"t"}`) + case strings.HasSuffix(r.URL.Path, "/comments"): + fmt.Fprint(w, `[{"body":"開始處理","created_at":"t1","user":{"login":"alex"}}]`) + default: + fmt.Fprint(w, `[]`) + } + }) + stdout, _, code := run("issues", "view", "--repo", "alterminal/teai", "--comments", "8") + if code != 0 { + t.Fatalf("view --comments 應回 0，得到 %d", code) + } + if len(paths) != 2 || !strings.HasSuffix(paths[1], "/issues/8/comments") { + t.Errorf("應依序呼叫 issue 與 comments 端點，得到 %v", paths) + } + if !strings.Contains(stdout, `"body":"開始處理"`) { + t.Errorf("輸出應含留言內容，得到：%s", stdout) + } +} + +// TestWriteCommandsRequireYes 驗證所有寫入命令未帶 --yes 時： +// 回 ExitUsage 且不發出任何 HTTP 請求（issue 驗收條件）。 +func TestWriteCommandsRequireYes(t *testing.T) { + cases := []struct { + name string + args []string + }{ + {"issues create", []string{"issues", "create", "--repo", "a/b", "--title", "t"}}, + {"issues close", []string{"issues", "close", "--repo", "a/b", "1"}}, + {"issues comment", []string{"issues", "comment", "--repo", "a/b", "--body", "x", "1"}}, + {"pulls create", []string{"pulls", "create", "--repo", "a/b", "--head", "h", "--title", "t"}}, + {"pulls merge", []string{"pulls", "merge", "--repo", "a/b", "1"}}, + {"pulls comment", []string{"pulls", "comment", "--repo", "a/b", "--body", "x", "1"}}, + {"labels create", []string{"labels", "create", "--repo", "a/b", "--name", "n"}}, + {"milestones create", []string{"milestones", "create", "--repo", "a/b", "--title", "t"}}, + {"api POST", []string{"api", "--method", "POST", "/repos/a/b/issues"}}, + } + for _, tc := range cases { + t.Run(tc.name, func(t *testing.T) { + run := opsTestServer(t, func(w http.ResponseWriter, r *http.Request) { + t.Errorf("%s：未帶 --yes 不得發出請求（%s %s）", tc.name, r.Method, r.URL.Path) + }) + _, stderr, code := run(tc.args...) + if code != int(ExitUsage) { + t.Errorf("%s 未帶 --yes 應回 ExitUsage(2)，得到 %d", tc.name, code) + } + if !strings.Contains(stderr, "--yes") { + t.Errorf("%s 錯誤訊息應提及 --yes，得到：%s", tc.name, stderr) + } + }) + } +} + +// TestIssuesCreateWithYes 驗證帶 --yes 時 POST 正確 payload。 +func TestIssuesCreateWithYes(t *testing.T) { + var gotMethod, gotPath, gotBody string + run := opsTestServer(t, func(w http.ResponseWriter, r *http.Request) { + gotMethod, gotPath = r.Method, r.URL.Path + buf := make([]byte, 512) + n, _ := r.Body.Read(buf) + gotBody = string(buf[:n]) + fmt.Fprint(w, `{"number":15,"title":"新 issue","html_url":"https://x/15"}`) + }) + stdout, _, code := run("issues", "create", "--repo", "alterminal/teai", "--title", "新 issue", "--body", "說明", "--assignees", "alex,ceo", "--yes") + if code != 0 { + t.Fatalf("create --yes 應回 0，得到 %d", code) + } + if gotMethod != "POST" || !strings.HasSuffix(gotPath, "/repos/alterminal/teai/issues") { + t.Errorf("應 POST /repos/alterminal/teai/issues，得到 %s %s", gotMethod, gotPath) + } + if !strings.Contains(gotBody, `"assignees":["alex","ceo"]`) { + t.Errorf("body 應含 assignees，得到：%s", gotBody) + } + if !strings.Contains(stdout, `"number":15`) { + t.Errorf("輸出應含新 issue 編號，得到：%s", stdout) + } +} + +// TestPullsListAndSubcommands 驗證 pulls list 與 pulls（無子命令）可並存。 +func TestPullsListAndSubcommands(t *testing.T) { + var gotPath string + run := opsTestServer(t, func(w http.ResponseWriter, r *http.Request) { + gotPath = r.URL.Path + fmt.Fprint(w, `[{"number":13,"title":"PR","state":"open","user":{"login":"alex"},"head":{"ref":"feat"},"base":{"ref":"main"},"updated_at":"t"}]`) + }) + stdout, _, code := run("pulls", "list", "--repo", "alterminal/teai") + if code != 0 { + t.Fatalf("pulls list 應回 0，得到 %d", code) + } + if !strings.HasSuffix(gotPath, "/repos/alterminal/teai/pulls") { + t.Errorf("應呼叫 /repos/alterminal/teai/pulls，得到 %s", gotPath) + } + if !strings.Contains(stdout, `"head":"feat"`) || !strings.Contains(stdout, `"base":"main"`) { + t.Errorf("輸出應含 head/base 欄位，得到：%s", stdout) + } +} + +// TestLabelsMilestonesReleasesList 驗證三個清單命令打對端點並輸出。 +func TestLabelsMilestonesReleasesList(t *testing.T) { + cases := []struct { + args []string + path string + resp string + wantOut string + }{ + { + args: []string{"labels", "list", "--repo", "a/b"}, + path: "/api/v1/repos/a/b/labels", + resp: `[{"name":"enhancement","color":"#84b6eb","description":""}]`, + wantOut: `"name":"enhancement"`, + }, + { + args: []string{"milestones", "list", "--repo", "a/b"}, + path: "/api/v1/repos/a/b/milestones", + resp: `[{"title":"v1","state":"open","description":"","due_on":""}]`, + wantOut: `"title":"v1"`, + }, + { + args: []string{"releases", "list", "--repo", "a/b"}, + path: "/api/v1/repos/a/b/releases", + resp: `[{"tag_name":"v1.0.0","name":"首個發佈","draft":false,"prerelease":false,"published_at":"t"}]`, + wantOut: `"tag_name":"v1.0.0"`, + }, + { + args: []string{"repos", "list", "--org", "alterminal"}, + path: "/api/v1/orgs/alterminal/repos", + resp: `[{"full_name":"alterminal/teai","private":false,"empty":false,"updated_at":"t","html_url":"u"}]`, + wantOut: `"full_name":"alterminal/teai"`, + }, + } + for _, tc := range cases { + t.Run(strings.Join(tc.args, " "), func(t *testing.T) { + var gotPath string + run := opsTestServer(t, func(w http.ResponseWriter, r *http.Request) { + gotPath = r.URL.Path + fmt.Fprint(w, tc.resp) + }) + stdout, _, code := run(tc.args...) + if code != 0 { + t.Fatalf("%v 應回 0，得到 %d", tc.args, code) + } + if gotPath != tc.path { + t.Errorf("應呼叫 %s，得到 %s", tc.path, gotPath) + } + if !strings.Contains(stdout, tc.wantOut) { + t.Errorf("輸出應含 %s，得到：%s", tc.wantOut, stdout) + } + }) + } +} + +// TestAPIDirectPassthrough 驗證 teai api 原樣輸出、GET 免 --yes、 +// POST 未帶 --yes 被擋。 +func TestAPIDirectPassthrough(t *testing.T) { + var gotMethod string + run := opsTestServer(t, func(w http.ResponseWriter, r *http.Request) { + gotMethod = r.Method + fmt.Fprint(w, `{"version":"1.27.0"}`) + }) + stdout, _, code := run("api", "/version") + if code != 0 || gotMethod != "GET" { + t.Fatalf("GET /version 應回 0，得到 %d (%s)", code, gotMethod) + } + if strings.TrimSpace(stdout) != `{"version":"1.27.0"}` { + t.Errorf("api 應原樣輸出，得到：%s", stdout) + } + + _, stderr, code := run("api", "--method", "POST", "/version") + if code != int(ExitUsage) || !strings.Contains(stderr, "--yes") { + t.Errorf("POST 未帶 --yes 應回 2 並提及 --yes，得到 %d：%s", code, stderr) + } +} + +// TestAPIDirectQueryInPath 驗證 path 內含 ?query 時查詢字串正確傳遞。 +func TestAPIDirectQueryInPath(t *testing.T) { + var gotQuery, gotPath string + run := opsTestServer(t, func(w http.ResponseWriter, r *http.Request) { + gotPath, gotQuery = r.URL.Path, r.URL.RawQuery + fmt.Fprint(w, `[]`) + }) + _, _, code := run("api", "/repos/a/b/issues?state=closed&limit=10") + if code != 0 { + t.Fatalf("api 帶查詢字串應回 0，得到 %d", code) + } + if gotPath != "/api/v1/repos/a/b/issues" || gotQuery != "state=closed&limit=10" { + t.Errorf("應剝離查詢字串，得到 path=%s query=%s", gotPath, gotQuery) + } +} + +// TestIssuesCommentPostsBody 驗證 comment --yes 送出 body。 +func TestIssuesCommentPostsBody(t *testing.T) { + var gotPath, gotBody string + run := opsTestServer(t, func(w http.ResponseWriter, r *http.Request) { + buf := make([]byte, 512) + n, _ := r.Body.Read(buf) + gotPath, gotBody = r.URL.Path, string(buf[:n]) + fmt.Fprint(w, `{"body":"留言","created_at":"t","user":{"login":"alex"}}`) + }) + _, _, code := run("issues", "comment", "--repo", "alterminal/teai", "--body", "留言", "--yes", "8") + if code != 0 { + t.Fatalf("comment --yes 應回 0，得到 %d", code) + } + if !strings.HasSuffix(gotPath, "/issues/8/comments") || !strings.Contains(gotBody, `"body":"留言"`) { + t.Errorf("應 POST comments 端點帶 body，得到 %s %s", gotPath, gotBody) + } +} + +// TestExtractGlobalsAllowsCommandFlags 驗證命令旗標與全域選項可交錯。 +func TestExtractGlobalsAllowsCommandFlags(t *testing.T) { + run := opsTestServer(t, func(w http.ResponseWriter, r *http.Request) { + fmt.Fprint(w, `{"login":"alex"}`) + }) + stdout, _, code := run("whoami", "--output", "table") + if code != 0 { + t.Fatalf("whoami --output table 應回 0，得到 %d", code) + } + if !strings.Contains(stdout, "alex") { + t.Errorf("table 輸出應含 alex，得到：%s", stdout) + } +} diff --git a/internal/cli/login.go b/internal/cli/login.go new file mode 100644 index 0000000..e861702 --- /dev/null +++ b/internal/cli/login.go @@ -0,0 +1,365 @@ +// login.go — teai login 指令：管理 tea 相容的登入組態。 +// +// teai 與 tea 共用同一份組態檔（README 設計原則 5），login 的職責是： +// 以 token 向站點驗證（GET /user），成功後才寫入組態並記下帳號。 +// token 只走記憶體與組態檔，不進輸出、日誌或錯誤訊息。 +// +// 子命令：list／add／default／remove。 +package cli + +import ( + "bufio" + "context" + "errors" + "flag" + "fmt" + "io" + "net/url" + "os" + "path/filepath" + "strings" + + "gitea.alterminal.com/alterminal/teai/internal/gitea" +) + +// loginStdin 是讀 token 與確認的輸入（測試可替換）。 +var loginStdin io.Reader = os.Stdin + +// loginConfigPath 回傳組態檔路徑：--config／TEA_CONFIG 優先，其次 +// ~/.config/tea/config.yml。找不到可用路徑回空字串。 +func loginConfigPath(g Globals) string { + if p := strings.TrimSpace(g.ConfigPath); p != "" { + return expandHome(p) + } + if p := os.Getenv("TEA_CONFIG"); strings.TrimSpace(p) != "" { + return expandHome(strings.TrimSpace(p)) + } + home, err := os.UserHomeDir() + if err != nil || home == "" { + return "" + } + return filepath.Join(home, ".config", "tea", "config.yml") +} + +// expandHome 展開路徑開頭的 ~。 +func expandHome(p string) string { + if p == "~" || strings.HasPrefix(p, "~/") { + if home, err := os.UserHomeDir(); err == nil { + return filepath.Join(home, strings.TrimPrefix(p, "~")) + } + } + return p +} + +// runLogin 是 teai login 的進入點：分派子命令。 +func runLogin(env *Env, args []string) error { + if len(args) == 0 { + return &ErrUsage{Msg: "login requires a subcommand: list, add, default, remove"} + } + sub, rest := args[0], args[1:] + switch sub { + case "list": + return runLoginList(env, rest) + case "add": + return runLoginAdd(env, rest) + case "default": + return runLoginDefault(env, rest) + case "remove": + return runLoginRemove(env, rest) + default: + return &ErrUsage{Msg: fmt.Sprintf("unknown login subcommand %q (want list, add, default, remove)", sub)} + } +} + +// loginFields 是輸出欄位（不含 token）。 +var loginFields = []gitea.Field{ + {Name: "name"}, + {Name: "url"}, + {Name: "user"}, + {Name: "default"}, +} + +// printLoginList 依格式輸出登入清單。 +func printLoginList(env *Env, logins []gitea.LoginEntry) error { + p := gitea.Printer{Format: env.Globals.Output, Out: env.Out} + rows := make([]gitea.Values, 0, len(logins)) + for _, l := range logins { + rows = append(rows, gitea.Values{l.Name, l.URL, l.User, l.Default}) + } + return p.PrintList(loginFields, rows) +} + +// runLoginList 列出組態中的登入（一律不含 token）。 +func runLoginList(env *Env, args []string) error { + fs := flag.NewFlagSet("teai login list", flag.ContinueOnError) + fs.SetOutput(env.Err) + if err := fs.Parse(args); err != nil { + return &ErrUsage{Msg: err.Error()} + } + if fs.NArg() > 0 { + return &ErrUsage{Msg: fmt.Sprintf("unexpected argument %q", fs.Arg(0))} + } + path := loginConfigPath(env.Globals) + if path == "" { + return fmt.Errorf("cannot determine config path") + } + logins, err := gitea.ListLoginsFile(path) + if err != nil { + return fmt.Errorf("read config %s: %w", path, err) + } + return printLoginList(env, logins) +} + +// runLoginAdd 新增或更新登入：先驗證 token（GET /user），成功才寫入。 +// +// token 來源：--token 旗標，或 stdin（預設未給旗標時讀一行， +// 避免 token 進 shell 歷史）。 +func runLoginAdd(env *Env, args []string) error { + fs := flag.NewFlagSet("teai login add", flag.ContinueOnError) + fs.SetOutput(env.Err) + urlFlag := fs.String("url", env.Globals.URL, "Gitea 站點網址") + nameFlag := fs.String("name", "", "登入名稱（省略時取 URL 主機）") + tokenFlag := fs.String("token", "", "API token（省略時自 stdin 讀一行）") + defaultFlag := fs.Bool("default", true, "設為預設登入") + if err := fs.Parse(args); err != nil { + return &ErrUsage{Msg: err.Error()} + } + if fs.NArg() > 0 { + return &ErrUsage{Msg: fmt.Sprintf("unexpected argument %q", fs.Arg(0))} + } + siteURL := strings.TrimSuffix(strings.TrimSpace(*urlFlag), "/") + if siteURL == "" { + return &ErrUsage{Msg: "--url must not be empty"} + } + + token := strings.TrimSpace(*tokenFlag) + if token == "" { + t, err := readLineFrom(loginStdin) + if err != nil { + return fmt.Errorf("read token from stdin: %w", err) + } + token = t + } + if token == "" { + return &ErrUsage{Msg: "token must not be empty"} + } + + path := loginConfigPath(env.Globals) + if path == "" { + return fmt.Errorf("cannot determine config path") + } + data, err := os.ReadFile(path) + if err != nil && !os.IsNotExist(err) { + return fmt.Errorf("read config %s: %w", path, err) + } + + name := strings.TrimSpace(*nameFlag) + if name == "" { + // 未指定名稱：同站（主機相同）已有登入就就地更新，避免重複項目。 + if existing, ok := findLoginByHost(data, siteURL); ok { + name = existing.Name + } else { + name = defaultLoginName(siteURL) + } + } + + // 先驗證再寫入：token 無效時不動組態檔。 + user, err := verifyToken(env, siteURL, token) + if err != nil { + return err + } + out, final, err := gitea.UpsertLogin(data, gitea.LoginEntry{ + Name: name, + URL: siteURL, + Token: token, + Default: *defaultFlag, + User: user, + }, *defaultFlag) + if err != nil { + return err + } + if err := gitea.SaveTeaConfigFile(path, out); err != nil { + return err + } + p := gitea.Printer{Format: env.Globals.Output, Out: env.Out} + return p.PrintOne(loginFields, gitea.Values{final.Name, final.URL, final.User, final.Default}) +} + +// readLineFrom 讀一行並去除頭尾空白；EOF 且無內容回空字串。 +func readLineFrom(r io.Reader) (string, error) { + line, err := bufio.NewReader(r).ReadString('\n') + if err != nil && err != io.EOF { + return "", err + } + return strings.TrimSpace(line), nil +} + +// verifyToken 以 token 呼叫 GET /user，回傳帳號名稱。 +// 401 特別標明是 token 遭拒，其餘依 *gitea.ErrAPI 對應結束碼 3。 +func verifyToken(env *Env, siteURL, token string) (string, error) { + c, err := gitea.New(siteURL, token, env.Globals.Timeout) + if err != nil { + return "", &ErrUsage{Msg: err.Error()} + } + ctx, cancel := context.WithTimeout(context.Background(), env.Globals.Timeout) + defer cancel() + var out struct { + Login string `json:"login"` + } + if err := c.GetJSON(ctx, "/user", &out); err != nil { + var api *gitea.ErrAPI + if errors.As(err, &api) && api.StatusCode == 401 { + // 包 %w 保留 *ErrAPI：結束碼對應 3（API 錯誤）。 + return "", fmt.Errorf("token rejected by %s: %w", siteURL, api) + } + return "", err + } + if out.Login == "" { + return "", fmt.Errorf("empty account name returned by %s", siteURL) + } + return out.Login, nil +} + +// runLoginDefault 設定預設登入。 +func runLoginDefault(env *Env, args []string) error { + fs := flag.NewFlagSet("teai login default", flag.ContinueOnError) + fs.SetOutput(env.Err) + if err := fs.Parse(args); err != nil { + return &ErrUsage{Msg: err.Error()} + } + if fs.NArg() != 1 { + return &ErrUsage{Msg: "login default requires exactly one login name"} + } + name := fs.Arg(0) + data, err := readLoginConfig(env, "login default") + if err != nil { + return err + } + entry, found := findLogin(data, name) + if !found { + return fmt.Errorf("gitea: login %q not found", name) + } + out, err := gitea.SetDefaultLogin(data, name) + if err != nil { + return err + } + if err := saveLoginConfig(env, out); err != nil { + return err + } + p := gitea.Printer{Format: env.Globals.Output, Out: env.Out} + return p.PrintOne(loginFields, gitea.Values{entry.Name, entry.URL, entry.User, true}) +} + +// runLoginRemove 移除登入；未加 --yes 時先確認。 +func runLoginRemove(env *Env, args []string) error { + fs := flag.NewFlagSet("teai login remove", flag.ContinueOnError) + fs.SetOutput(env.Err) + yesFlag := fs.Bool("yes", false, "跳過確認") + if err := fs.Parse(args); err != nil { + return &ErrUsage{Msg: err.Error()} + } + if fs.NArg() != 1 { + return &ErrUsage{Msg: "login remove requires exactly one login name"} + } + name := fs.Arg(0) + data, err := readLoginConfig(env, "login remove") + if err != nil { + return err + } + entry, found := findLogin(data, name) + if !found { + return fmt.Errorf("gitea: login %q not found", name) + } + if !*yesFlag { + confirmed, err := confirmRemove(env, entry) + if err != nil { + return err + } + if !confirmed { + fmt.Fprintln(env.Out, "cancelled") + return nil + } + } + out, promoted, err := gitea.RemoveLogin(data, name) + if err != nil { + return err + } + if err := saveLoginConfig(env, out); err != nil { + return err + } + if promoted != "" { + fmt.Fprintf(env.Err, "default login is now %q\n", promoted) + } + p := gitea.Printer{Format: env.Globals.Output, Out: env.Out} + return p.PrintOne(loginFields, gitea.Values{entry.Name, entry.URL, entry.User, false}) +} + +// confirmRemove 印出待移除項目（不含 token）並讀 y/yes 確認； +// 其他輸入（含 EOF）一律視為取消。 +func confirmRemove(env *Env, entry gitea.LoginEntry) (bool, error) { + fmt.Fprintf(env.Err, "remove login %q (url %s, user %s)? [y/N] ", entry.Name, entry.URL, entry.User) + line, err := readLineFrom(loginStdin) + if err != nil { + return false, fmt.Errorf("read confirmation: %w", err) + } + switch strings.ToLower(line) { + case "y", "yes": + return true, nil + default: + return false, nil + } +} + +// readLoginConfig 讀組態檔內容；路徑無法判定或讀取失敗時回錯。 +func readLoginConfig(env *Env, op string) ([]byte, error) { + path := loginConfigPath(env.Globals) + if path == "" { + return nil, fmt.Errorf("cannot determine config path") + } + data, err := os.ReadFile(path) + if err != nil { + return nil, fmt.Errorf("%s: read config %s: %w", op, path, err) + } + return data, nil +} + +// saveLoginConfig 原子寫回組態檔。 +func saveLoginConfig(env *Env, data []byte) error { + path := loginConfigPath(env.Globals) + if path == "" { + return fmt.Errorf("cannot determine config path") + } + return gitea.SaveTeaConfigFile(path, data) +} + +// findLoginByHost 在組態內容中找 URL 主機與 siteURL 相同的登入。 +func findLoginByHost(data []byte, siteURL string) (gitea.LoginEntry, bool) { + for _, l := range gitea.ListLogins(data) { + if gitea.HostOf(l.URL) == gitea.HostOf(siteURL) { + return l, true + } + } + return gitea.LoginEntry{}, false +} + +// findLogin 在組態內容中找指定名稱的登入。 +func findLogin(data []byte, name string) (gitea.LoginEntry, bool) { + for _, l := range gitea.ListLogins(data) { + if l.Name == name { + return l, true + } + } + return gitea.LoginEntry{}, false +} + +// defaultLoginName 以 URL 主機作為登入名稱（同 tea 的習慣）。 +func defaultLoginName(rawURL string) string { + s := rawURL + if !strings.Contains(s, "://") { + s = "https://" + s + } + if u, err := url.Parse(s); err == nil && u.Host != "" { + return u.Host + } + return rawURL +} diff --git a/internal/cli/login_test.go b/internal/cli/login_test.go new file mode 100644 index 0000000..aea20d9 --- /dev/null +++ b/internal/cli/login_test.go @@ -0,0 +1,288 @@ +// login_test.go 驗證 login 指令：list/add/default/remove 的輸出、 +// 驗證流程（先 GET /user 再寫入）、401 不寫檔、token 不外洩。 +package cli + +import ( + "fmt" + "net/http" + "net/http/httptest" + "os" + "path/filepath" + "strings" + "sync/atomic" + "testing" + + "gitea.alterminal.com/alterminal/teai/internal/gitea" +) + +// loginTestEnv 建立測試環境：臨時組態檔路徑 + 可替換的 stdin。 +func loginTestEnv(t *testing.T, configContent string) (args []string, configPath string) { + t.Helper() + dir := t.TempDir() + configPath = filepath.Join(dir, "config.yml") + if configContent != "" { + if err := os.WriteFile(configPath, []byte(configContent), 0o600); err != nil { + t.Fatal(err) + } + } + t.Setenv("TEA_CONFIG", configPath) + return []string{"--config", configPath}, configPath +} + +// newAPIServer 建立假的 Gitea API：/user 檢查 Authorization。 +func newAPIServer(t *testing.T, wantToken string, status int) (*httptest.Server, *atomic.Value) { + t.Helper() + var gotAuth atomic.Value + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + gotAuth.Store(r.Header.Get("Authorization")) + if r.URL.Path != "/api/v1/user" { + w.WriteHeader(http.StatusNotFound) + return + } + if status != 0 { + w.WriteHeader(status) + return + } + fmt.Fprint(w, `{"login":"ceo"}`) + })) + t.Cleanup(srv.Close) + return srv, &gotAuth +} + +func TestLoginListJSONNoToken(t *testing.T) { + prefix, _ := loginTestEnv(t, `logins: + - name: alterminal + url: https://gitea.alterminal.com + token: super-secret + default: true + user: ceo +`) + stdout, _, code := run(append(prefix, "login", "list")...) + if code != 0 { + t.Fatalf("code = %d", code) + } + if !strings.Contains(stdout, `"name":"alterminal"`) || !strings.Contains(stdout, `"user":"ceo"`) { + t.Fatalf("unexpected output: %s", stdout) + } + if strings.Contains(stdout, "super-secret") || strings.Contains(stdout, "token") { + t.Fatalf("token leaked: %s", stdout) + } +} + +func TestLoginListEmpty(t *testing.T) { + prefix, path := loginTestEnv(t, "") + if _, err := os.Stat(path); err == nil { + t.Fatal("precondition: config should not exist") + } + stdout, _, code := run(append(prefix, "login", "list")...) + if code != 0 { + t.Fatalf("code = %d", code) + } + if strings.TrimSpace(stdout) != "[]" { + t.Fatalf("want [], got %q", stdout) + } +} + +func TestLoginAddVerifiesThenWrites(t *testing.T) { + srv, gotAuth := newAPIServer(t, "tok-xyz", 0) + prefix, configPath := loginTestEnv(t, "") + stdout, _, code := run(append(prefix, + "--url", srv.URL, "login", "add", "--name", "test-site", "--token", "tok-xyz")...) + if code != 0 { + t.Fatalf("code = %d, stdout = %s", code, stdout) + } + if got := gotAuth.Load(); got != "token tok-xyz" { + t.Fatalf("server saw Authorization %v", got) + } + if !strings.Contains(stdout, `"name":"test-site"`) || !strings.Contains(stdout, `"user":"ceo"`) { + t.Fatalf("unexpected output: %s", stdout) + } + if strings.Contains(stdout, "tok-xyz") { + t.Fatalf("token leaked: %s", stdout) + } + // 寫入的組態可被解析，且欄位齊全。 + data, err := os.ReadFile(configPath) + if err != nil { + t.Fatal(err) + } + logins := gitea.ListLogins(data) + if len(logins) != 1 { + t.Fatalf("want 1 login, got %d:\n%s", len(logins), data) + } + l := logins[0] + if l.Name != "test-site" || l.URL != srv.URL || l.Token != "tok-xyz" || !l.Default || l.User != "ceo" { + t.Fatalf("entry mismatch: %+v", l) + } + info, _ := os.Stat(configPath) + if info.Mode().Perm() != 0o600 { + t.Fatalf("perm = %v", info.Mode().Perm()) + } +} + +func TestLoginAddTokenFromStdin(t *testing.T) { + srv, _ := newAPIServer(t, "stdin-tok", 0) + prefix, configPath := loginTestEnv(t, "") + old := loginStdin + loginStdin = strings.NewReader("stdin-tok\n") + defer func() { loginStdin = old }() + stdout, _, code := run(append(prefix, "--url", srv.URL, "login", "add")...) + if code != 0 { + t.Fatalf("code = %d, stdout = %s", code, stdout) + } + data, _ := os.ReadFile(configPath) + if l := gitea.ListLogins(data); len(l) != 1 || l[0].Token != "stdin-tok" { + t.Fatalf("stdin token not saved:\n%s", data) + } +} + +func TestLoginAddRejected401NoWrite(t *testing.T) { + srv, _ := newAPIServer(t, "", http.StatusUnauthorized) + prefix, configPath := loginTestEnv(t, `logins: + - name: keep + url: https://keep.example.com + token: keep-tok + default: true +`) + _, stderr, code := run(append(prefix, + "--url", srv.URL, "login", "add", "--token", "bad-tok")...) + if code != int(ExitAPI) { + t.Fatalf("401 should exit 3, got %d (stderr %s)", code, stderr) + } + if !strings.Contains(stderr, "401") { + t.Fatalf("stderr should mention 401: %s", stderr) + } + // 組態不受影響。 + data, _ := os.ReadFile(configPath) + if l := gitea.ListLogins(data); len(l) != 1 || l[0].Token != "keep-tok" { + t.Fatalf("config must be untouched:\n%s", data) + } +} + +func TestLoginAddUpdatesExistingInPlace(t *testing.T) { + srv, _ := newAPIServer(t, "new-tok", 0) + prefix, configPath := loginTestEnv(t, `logins: + - name: alterminal + url: `+srv.URL+` + token: old-tok + default: true + user: someone-else + ssh_key: "keep-me" +preferences: + editor: false +`) + stdout, _, code := run(append(prefix, "--url", srv.URL, "login", "add", "--token", "new-tok")...) + if code != 0 { + t.Fatalf("code = %d, out = %s", code, stdout) + } + data, _ := os.ReadFile(configPath) + s := string(data) + // 未給 --name：同站既有項目（name: alterminal）就地更新，不新增重複項目。 + if strings.Contains(stdout, `"name":"127.0.0.1:`) { + t.Fatalf("should reuse existing entry name, got %s", stdout) + } + if !strings.Contains(s, "- name: alterminal") { + t.Fatalf("existing entry name lost:\n%s", s) + } + if strings.Contains(s, "old-tok") || !strings.Contains(s, "token: new-tok") { + t.Fatalf("token not replaced:\n%s", s) + } + if !strings.Contains(s, `ssh_key: "keep-me"`) || !strings.Contains(s, "editor: false") { + t.Fatalf("unrelated content lost:\n%s", s) + } + if !strings.Contains(s, "user: ceo") { + t.Fatalf("user not refreshed:\n%s", s) + } +} + +func TestLoginDefaultAndRemove(t *testing.T) { + cfg := `logins: + - name: a + url: https://a.example.com + token: ta + default: true + - name: b + url: https://b.example.com + token: tb + default: false +` + prefix, configPath := loginTestEnv(t, cfg) + stdout, _, code := run(append(prefix, "login", "default", "b")...) + if code != 0 || !strings.Contains(stdout, `"name":"b"`) { + t.Fatalf("default failed: code=%d out=%s", code, stdout) + } + data, _ := os.ReadFile(configPath) + if l := gitea.ListLogins(data); !l[1].Default || l[0].Default { + t.Fatalf("default not switched:\n%s", data) + } + + // remove --yes：移除預設者 b，a 遞補。 + stdout, _, code = run(append(prefix, "login", "remove", "--yes", "b")...) + if code != 0 || !strings.Contains(stdout, `"name":"b"`) { + t.Fatalf("remove failed: code=%d out=%s", code, stdout) + } + data, _ = os.ReadFile(configPath) + if l := gitea.ListLogins(data); len(l) != 1 || l[0].Name != "a" || !l[0].Default { + t.Fatalf("promote failed:\n%s", data) + } +} + +func TestLoginRemoveAsksConfirmation(t *testing.T) { + prefix, _ := loginTestEnv(t, `logins: + - name: a + url: https://a.example.com + token: ta + default: true +`) + old := loginStdin + loginStdin = strings.NewReader("n\n") + defer func() { loginStdin = old }() + _, _, code := run(append(prefix, "login", "remove", "a")...) + if code != 0 { + t.Fatalf("cancel should still exit 0, got %d", code) + } + // 取消：檔案不變（token 仍在）。 + data, _ := os.ReadFile(filepath.Dir(prefix[1]) + "/config.yml") + if !strings.Contains(string(data), "token: ta") { + t.Fatalf("cancelled remove must not write:\n%s", data) + } +} + +func TestLoginUnknownSubcommandUsage(t *testing.T) { + prefix, _ := loginTestEnv(t, "") + _, stderr, code := run(append(prefix, "login", "bogus")...) + if code != int(ExitUsage) { + t.Fatalf("want exit 2, got %d", code) + } + if !strings.Contains(stderr, "unknown login subcommand") { + t.Fatalf("stderr: %s", stderr) + } +} + +func TestLoginNoSubcommandUsage(t *testing.T) { + prefix, _ := loginTestEnv(t, "") + _, stderr, code := run(append(prefix, "login")...) + if code != int(ExitUsage) { + t.Fatalf("want exit 2, got %d", code) + } + if !strings.Contains(stderr, "subcommand") { + t.Fatalf("stderr: %s", stderr) + } +} + +func TestLoginRemoveNotFound(t *testing.T) { + prefix, _ := loginTestEnv(t, "logins: []\n") + _, stderr, code := run(append(prefix, "login", "remove", "--yes", "ghost")...) + if code != int(ExitInternal) { + t.Fatalf("want exit 1, got %d", code) + } + if !strings.Contains(stderr, `login "ghost" not found`) { + t.Fatalf("stderr: %s", stderr) + } +} + +func TestLoginRegisteredInUsage(t *testing.T) { + stdout, _, code := run() + if code != 0 || !strings.Contains(stdout, "login") { + t.Fatalf("usage should list login: %s", stdout) + } +} diff --git a/internal/cli/workflow_commands.go b/internal/cli/workflow_commands.go index d393bb6..ba9dd65 100644 --- a/internal/cli/workflow_commands.go +++ b/internal/cli/workflow_commands.go @@ -23,7 +23,8 @@ func init() { register(&command{name: "orgs", usage: "我所屬的組織", run: runOrgs}) register(&command{name: "members", usage: "Agents 團隊成員；--has-work 只列有未完成工作者", run: runMembers}) register(&command{name: "mine", usage: "分派給我、待跟進的 issues", run: runMine}) - register(&command{name: "pulls", usage: "跨倉庫 PR 跟進清單（--mine／--reviewer／--repo）", run: runPulls}) + // pulls 由 dailyops_commands.go 註冊（#8）：無子命令時走本檔的 runPulls + // 工作流清單，有子命令（list/view/create/merge/comment）走日常操作。 register(&command{name: "next", usage: "下一件該做的事", run: runNext}) } diff --git a/internal/dailyops/dailyops.go b/internal/dailyops/dailyops.go new file mode 100644 index 0000000..ece6ceb --- /dev/null +++ b/internal/dailyops/dailyops.go @@ -0,0 +1,384 @@ +// Package dailyops 實作 tea 對等的日常操作（#8）：issues、pulls、labels、 +// milestones、releases、repos 的讀寫，直接以 Gitea API 為準。 +// +// 讀寫行為對照 Gitea 1.27 API（issues 端點帶 type=issues 排除 PR， +// 見 gitea.py 的注意事項）；寫入的「--yes 閘門」在 CLI 層（見 +// dailyops_commands.go），本套件只負責 API 呼叫。 +package dailyops + +import ( + "context" + "fmt" + "net/url" + "strconv" + + "gitea.alterminal.com/alterminal/teai/internal/gitea" +) + +// User 是 API 回應中的使用者精簡欄位。 +type User struct { + UserName string `json:"login"` +} + +// Name 回傳帳號名。 +func (u *User) Name() string { + if u == nil { + return "" + } + return u.UserName +} + +// Issue 是 Gitea issue／PR 共用端點的精簡欄位（PR 亦走 issues 端點）。 +type Issue struct { + Number int64 `json:"number"` + Title string `json:"title"` + State string `json:"state"` + Body string `json:"body"` + HTMLURL string `json:"html_url"` + UpdatedAt string `json:"updated_at"` + User *User `json:"user"` + Assignees []*User `json:"assignees"` + Labels []Label `json:"labels"` + Assignee []string `json:"-"` // 輸出用：帳號清單（由 Assignees 導出） +} + +// Author 回傳建立者帳號。 +func (i *Issue) Author() string { return i.User.Name() } + +// AssigneeNames 回傳 assignees 帳號清單（輸出用）。 +func (i *Issue) AssigneeNames() []string { + names := make([]string, 0, len(i.Assignees)) + for _, a := range i.Assignees { + if n := a.Name(); n != "" { + names = append(names, n) + } + } + return names +} + +// LabelNames 回傳標籤名稱清單（輸出用）。 +func (i *Issue) LabelNames() []string { + names := make([]string, 0, len(i.Labels)) + for _, l := range i.Labels { + names = append(names, l.Name) + } + return names +} + +// Label 是倉庫標籤。 +type Label struct { + ID int64 `json:"id"` + Name string `json:"name"` + Color string `json:"color"` + Description string `json:"description"` +} + +// Milestone 是倉庫里程碑。 +type Milestone struct { + ID int64 `json:"id"` + Title string `json:"title"` + Description string `json:"description"` + State string `json:"state"` + DueOn string `json:"due_on"` +} + +// Release 是倉庫發佈。 +type Release struct { + TagName string `json:"tag_name"` + Name string `json:"name"` + Draft bool `json:"draft"` + Prerelease bool `json:"prerelease"` + CreatedAt string `json:"created_at"` + PublishedAt string `json:"published_at"` + HTMLURL string `json:"html_url"` +} + +// Comment 是 issue／PR 留言。 +type Comment struct { + Body string `json:"body"` + CreatedAt string `json:"created_at"` + User *User `json:"user"` +} + +// Author 回串留言者帳號。 +func (c *Comment) Author() string { return c.User.Name() } + +// Pull 是 pull request 的精簡欄位。 +type Pull struct { + Number int64 `json:"number"` + Title string `json:"title"` + State string `json:"state"` + Body string `json:"body"` + HTMLURL string `json:"html_url"` + UpdatedAt string `json:"updated_at"` + User *User `json:"user"` + Head *pullRef `json:"head"` + Base *pullRef `json:"base"` +} + +// pullRef 是 PR 的 head／base 參照。 +type pullRef struct { + Ref string `json:"ref"` + Repo *struct { + FullName string `json:"full_name"` + } `json:"repo"` +} + +// HeadRef 回傳 head 分支名（輸出用）。 +func (p *Pull) HeadRef() string { + if p.Head == nil { + return "" + } + return p.Head.Ref +} + +// BaseRef 回傳 base 分支名（輸出用）。 +func (p *Pull) BaseRef() string { + if p.Base == nil { + return "" + } + return p.Base.Ref +} + +// Author 回傳 PR 作者帳號。 +func (p *Pull) Author() string { return p.User.Name() } + +// Repo 是倉庫的精簡欄位。 +type Repo struct { + FullName string `json:"full_name"` + Description string `json:"description"` + Private bool `json:"private"` + Empty bool `json:"empty"` + UpdatedAt string `json:"updated_at"` + HTMLURL string `json:"html_url"` +} + +// Ops 聚合日常操作的 API 呼叫。 +type Ops struct { + // Client 是 Gitea API 用戶端（internal/gitea）。 + Client *gitea.Client +} + +// repoPath 組出 /repos/{owner}/{repo} 前綴；owner／repo 皆做路徑跳脫。 +func repoPath(owner, repo string) string { + return "/repos/" + url.PathEscape(owner) + "/" + url.PathEscape(repo) +} + +// ListIssues 列出倉庫 issues。state：open｜closed｜all（預設 open）； +// type=issues 排除 PR（Gitea 的 issues 端點會連 PR 一起回）。 +func (o *Ops) ListIssues(ctx context.Context, owner, repo, state string) ([]Issue, error) { + if state == "" { + state = "open" + } + extra := url.Values{} + if state != "all" { + extra.Set("state", state) + } + // type=issues：排除 PR（PR 在此端點帶 pull_request 欄位）。 + extra.Set("type", "issues") + var issues []Issue + if err := o.Client.ListAll(ctx, repoPath(owner, repo)+"/issues", gitea.ListOptions{Extra: extra}, &issues); err != nil { + return nil, err + } + return issues, nil +} + +// CreateIssue 建立 issue；assignees 可為空。 +func (o *Ops) CreateIssue(ctx context.Context, owner, repo, title, body string, assignees []string) (*Issue, error) { + payload := map[string]any{ + "title": title, + "body": body, + } + if len(assignees) > 0 { + payload["assignees"] = assignees + } + var issue Issue + if err := o.Client.DoJSON(ctx, "POST", repoPath(owner, repo)+"/issues", "", payload, &issue); err != nil { + return nil, err + } + return &issue, nil +} + +// GetIssue 取得單一 issue（含 PR，但此處供 issues view 用）。 +func (o *Ops) GetIssue(ctx context.Context, owner, repo string, number int64) (*Issue, error) { + var issue Issue + path := repoPath(owner, repo) + "/issues/" + strconv.FormatInt(number, 10) + if err := o.Client.GetJSON(ctx, path, &issue); err != nil { + return nil, err + } + return &issue, nil +} + +// SetIssueState 變更 issue 狀態（open｜closed）。 +func (o *Ops) SetIssueState(ctx context.Context, owner, repo string, number int64, state string) (*Issue, error) { + payload := map[string]any{"state": state} + var issue Issue + path := repoPath(owner, repo) + "/issues/" + strconv.FormatInt(number, 10) + if err := o.Client.DoJSON(ctx, "PATCH", path, "", payload, &issue); err != nil { + return nil, err + } + return &issue, nil +} + +// ListComments 列出 issue／PR 的留言（PR 亦走 issues 端點）。 +func (o *Ops) ListComments(ctx context.Context, owner, repo string, number int64) ([]Comment, error) { + var comments []Comment + path := repoPath(owner, repo) + "/issues/" + strconv.FormatInt(number, 10) + "/comments" + if err := o.Client.ListAll(ctx, path, gitea.ListOptions{}, &comments); err != nil { + return nil, err + } + return comments, nil +} + +// AddComment 對 issue／PR 留言。 +func (o *Ops) AddComment(ctx context.Context, owner, repo string, number int64, body string) (*Comment, error) { + payload := map[string]any{"body": body} + var comment Comment + path := repoPath(owner, repo) + "/issues/" + strconv.FormatInt(number, 10) + "/comments" + if err := o.Client.DoJSON(ctx, "POST", path, "", payload, &comment); err != nil { + return nil, err + } + return &comment, nil +} + +// ListPulls 列出倉庫 PR；state 預設 open。 +func (o *Ops) ListPulls(ctx context.Context, owner, repo, state string) ([]Pull, error) { + if state == "" { + state = "open" + } + extra := url.Values{} + if state != "all" { + extra.Set("state", state) + } + var pulls []Pull + if err := o.Client.ListAll(ctx, repoPath(owner, repo)+"/pulls", gitea.ListOptions{Extra: extra}, &pulls); err != nil { + return nil, err + } + return pulls, nil +} + +// GetPull 取得單一 PR。 +func (o *Ops) GetPull(ctx context.Context, owner, repo string, number int64) (*Pull, error) { + var pull Pull + path := repoPath(owner, repo) + "/pulls/" + strconv.FormatInt(number, 10) + if err := o.Client.GetJSON(ctx, path, &pull); err != nil { + return nil, err + } + return &pull, nil +} + +// CreatePull 建立 PR。 +func (o *Ops) CreatePull(ctx context.Context, owner, repo, title, body, head, base string) (*Pull, error) { + payload := map[string]any{ + "title": title, + "body": body, + "head": head, + "base": base, + } + var pull Pull + if err := o.Client.DoJSON(ctx, "POST", repoPath(owner, repo)+"/pulls", "", payload, &pull); err != nil { + return nil, err + } + return &pull, nil +} + +// MergePull 合併 PR。style：merge｜rebase｜rebase-merge｜squash（預設 merge）。 +func (o *Ops) MergePull(ctx context.Context, owner, repo string, number int64, style string) error { + if style == "" { + style = "merge" + } + payload := map[string]any{"Do": style} + path := repoPath(owner, repo) + "/pulls/" + strconv.FormatInt(number, 10) + "/merge" + return o.Client.DoJSON(ctx, "POST", path, "", payload, nil) +} + +// ListLabels 列出倉庫標籤。 +func (o *Ops) ListLabels(ctx context.Context, owner, repo string) ([]Label, error) { + var labels []Label + if err := o.Client.ListAll(ctx, repoPath(owner, repo)+"/labels", gitea.ListOptions{}, &labels); err != nil { + return nil, err + } + return labels, nil +} + +// CreateLabel 建立標籤；color 格式如 #ffffff。 +func (o *Ops) CreateLabel(ctx context.Context, owner, repo, name, color, description string) (*Label, error) { + payload := map[string]any{ + "name": name, + "color": color, + "description": description, + } + var label Label + if err := o.Client.DoJSON(ctx, "POST", repoPath(owner, repo)+"/labels", "", payload, &label); err != nil { + return nil, err + } + return &label, nil +} + +// ListMilestones 列出倉庫里程碑；state 預設 open（可用 all）。 +func (o *Ops) ListMilestones(ctx context.Context, owner, repo, state string) ([]Milestone, error) { + if state == "" { + state = "open" + } + extra := url.Values{} + if state != "all" { + extra.Set("state", state) + } + var ms []Milestone + if err := o.Client.ListAll(ctx, repoPath(owner, repo)+"/milestones", gitea.ListOptions{Extra: extra}, &ms); err != nil { + return nil, err + } + return ms, nil +} + +// CreateMilestone 建立里程碑；dueOn 可空（RFC3339）。 +func (o *Ops) CreateMilestone(ctx context.Context, owner, repo, title, description, dueOn string) (*Milestone, error) { + payload := map[string]any{ + "title": title, + "description": description, + } + if dueOn != "" { + payload["due_on"] = dueOn + } + var m Milestone + if err := o.Client.DoJSON(ctx, "POST", repoPath(owner, repo)+"/milestones", "", payload, &m); err != nil { + return nil, err + } + return &m, nil +} + +// ListReleases 列出倉庫發佈。 +func (o *Ops) ListReleases(ctx context.Context, owner, repo string) ([]Release, error) { + var releases []Release + if err := o.Client.ListAll(ctx, repoPath(owner, repo)+"/releases", gitea.ListOptions{}, &releases); err != nil { + return nil, err + } + return releases, nil +} + +// ListMyRepos 列出自己可存取的倉庫。 +func (o *Ops) ListMyRepos(ctx context.Context) ([]Repo, error) { + var repos []Repo + if err := o.Client.ListAll(ctx, "/user/repos", gitea.ListOptions{}, &repos); err != nil { + return nil, err + } + return repos, nil +} + +// ListOrgRepos 列出組織倉庫。 +func (o *Ops) ListOrgRepos(ctx context.Context, org string) ([]Repo, error) { + var repos []Repo + if err := o.Client.ListAll(ctx, "/orgs/"+url.PathEscape(org)+"/repos", gitea.ListOptions{}, &repos); err != nil { + return nil, err + } + return repos, nil +} + +// CallAPIDirect 是 teai api 的原樣傳遞：以指定動詞呼叫 path（相對 /api/v1）， +// data 為原樣 JSON（可為 nil）。回傳原始回應位元組。 +func (o *Ops) CallAPIDirect(ctx context.Context, method, path, rawQuery string, data []byte) ([]byte, error) { + if path == "" || path[0] != '/' { + return nil, fmt.Errorf("api path 必須以 / 開頭（相對 api/v1）") + } + return o.Client.DoRaw(ctx, method, path, rawQuery, data) +} diff --git a/internal/gitea/client.go b/internal/gitea/client.go index 0f8af58..d5fd402 100644 --- a/internal/gitea/client.go +++ b/internal/gitea/client.go @@ -7,6 +7,7 @@ package gitea import ( + "bytes" "context" "encoding/json" "fmt" @@ -79,36 +80,80 @@ const MaxLimit = 50 // getJSON 對 path（相對 baseURL，以 / 開頭）發 GET，把 JSON 回應解到 out。 // 失敗時回傳 *ErrAPI。rawQuery 為組好的查詢字串（見 ListOptions.query）。 func (c *Client) getJSON(ctx context.Context, path, rawQuery string, out any) error { + _, err := c.do(ctx, http.MethodGet, path, rawQuery, "", nil, out) + return err +} + +// DoJSON 對 path 發 method 請求（POST/PATCH/PUT/DELETE…），body 為可 JSON +// 化的值（nil 表示不帶 body），2xx 時把回應解到 out（out 非 nil 且回應 +// 有內容時）。供寫入類操作（issues create、pulls merge…）使用。 +func (c *Client) DoJSON(ctx context.Context, method, path, rawQuery string, body any, out any) error { + var payload []byte + if body != nil { + b, err := json.Marshal(body) + if err != nil { + return fmt.Errorf("gitea: marshal request body: %w", err) + } + payload = b + } + _, err := c.do(ctx, method, path, rawQuery, "application/json", payload, out) + return err +} + +// DoRaw 以原樣 body 送出請求並回傳原始回應內容（teai api 用）。 +// 非 2xx 回 *ErrAPI。 +func (c *Client) DoRaw(ctx context.Context, method, path, rawQuery string, body []byte) ([]byte, error) { + contentType := "" + if body != nil { + contentType = "application/json" + } + return c.do(ctx, method, path, rawQuery, contentType, body, nil) +} + +// do 是所有請求的共同核心：組 URL、帶認證表頭、送出、檢查狀態碼、 +// 解析回應。2xx 時回傳原始回應位元組；out 非 nil 時另解到 out。 +// 錯誤訊息不含 token 或回應內容。 +func (c *Client) do(ctx context.Context, method, path, rawQuery, contentType string, payload []byte, out any) ([]byte, error) { u := *c.baseURL u.Path += path u.RawQuery = rawQuery - op := "GET " + u.Path + op := method + " " + u.Path - req, err := http.NewRequestWithContext(ctx, http.MethodGet, u.String(), nil) + var body io.Reader + if payload != nil { + body = bytes.NewReader(payload) + } + req, err := http.NewRequestWithContext(ctx, method, u.String(), body) if err != nil { - return &ErrAPI{Op: op, Err: err} + return nil, &ErrAPI{Op: op, Err: err} } req.Header.Set("Accept", "application/json") + if payload != nil && contentType != "" { + req.Header.Set("Content-Type", contentType) + } if c.token != "" { req.Header.Set("Authorization", "token "+c.token) } resp, err := c.hc.Do(req) if err != nil { - return &ErrAPI{Op: op, Err: err} + return nil, &ErrAPI{Op: op, Err: err} } defer resp.Body.Close() if resp.StatusCode < 200 || resp.StatusCode > 299 { // 把內容讀掉再丟棄，讓連線可重用；錯誤訊息不含回應內容。 _, _ = io.Copy(io.Discard, io.LimitReader(resp.Body, 4096)) - return &ErrAPI{Op: op, StatusCode: resp.StatusCode} + return nil, &ErrAPI{Op: op, StatusCode: resp.StatusCode} } - if out == nil { - return nil + data, err := io.ReadAll(resp.Body) + if err != nil { + return nil, &ErrAPI{Op: op, Err: err} } - if err := json.NewDecoder(resp.Body).Decode(out); err != nil { - return &ErrAPI{Op: op, Err: fmt.Errorf("decode response: %w", err)} + if out != nil && len(data) > 0 { + if err := json.Unmarshal(data, out); err != nil { + return nil, &ErrAPI{Op: op, Err: fmt.Errorf("decode response: %w", err)} + } } - return nil + return data, nil } // GetJSON 是 getJSON 的公開介面，供非清單端點（如 /user）使用。 diff --git a/internal/gitea/config.go b/internal/gitea/config.go new file mode 100644 index 0000000..1788984 --- /dev/null +++ b/internal/gitea/config.go @@ -0,0 +1,421 @@ +// config.go — tea 相容登入組態的讀取與行級編輯。 +// +// teai 與 tea 共用同一份組態檔（README 設計原則 5），因此寫入採「行級編輯」： +// 只修改目標登入項目的所屬行，其餘內容（未知欄位、註解、preferences 區段、 +// 空行與縮排）逐字保留，避免改壞 tea 也在使用的檔案。新增項目依 tea 實際 +// 寫出的欄位順序輸出，讓檔案外觀與 tea 一致。 +// +// token 值只會進出這個套件的資料結構與組態檔本身，永遠不出現在錯誤訊息。 +package gitea + +import ( + "fmt" + "os" + "path/filepath" + "regexp" + "slices" + "strconv" + "strings" +) + +// LoginEntry 是組態檔中的一筆登入資料（編輯用，含 tea 的 user 欄位）。 +type LoginEntry struct { + Name string + URL string + Token string + Default bool + User string +} + +// loginItemSpan 標記 logins 清單中一個項目在檔案中的行範圍 [start, end)。 +type loginItemSpan struct { + name string + start int + end int +} + +// configDoc 是解析後的組態檔：原始行與 logins 項目的位置資訊。 +type configDoc struct { + lines []string + items []loginItemSpan + loginsHeader int // 「logins:」所在行；-1 表示沒有 + itemIndent string // 項目行的縮排（取第一個項目）；預設四格空白 +} + +// parseConfigDoc 掃描組態內容，定位 logins 清單與各項目的行範圍。 +// 只認識 tea 實際寫出的格式：頂層 `logins:` 加縮排的 `- key: value` 項目； +// 其餘行原樣保留在 lines 中。 +func parseConfigDoc(data []byte) configDoc { + doc := configDoc{lines: splitLines(data), loginsHeader: -1, itemIndent: " "} + inLogins := false + cur := -1 + for i, raw := range doc.lines { + line := raw + trimmed := strings.TrimSpace(line) + if trimmed == "" || strings.HasPrefix(trimmed, "#") { + continue + } + indent := line[:len(line)-len(strings.TrimLeft(line, " "))] + if indent == "" { + if inLogins && doc.loginsHeader >= 0 { + // 離開 logins 區段；listEnd 由最後一個項目的 end 決定，這裡不用記。 + } + inLogins = strings.HasPrefix(trimmed, "logins:") + if inLogins && doc.loginsHeader < 0 { + doc.loginsHeader = i + } + cur = -1 + continue + } + if !inLogins { + continue + } + if strings.HasPrefix(trimmed, "- ") || trimmed == "-" { + if cur >= 0 { + doc.items[cur].end = i + } + doc.items = append(doc.items, loginItemSpan{start: i, end: i + 1}) + cur = len(doc.items) - 1 + if len(doc.items) == 1 { + doc.itemIndent = indent + } + if rest := strings.TrimSpace(strings.TrimPrefix(trimmed, "-")); rest != "" { + if key, value, ok := strings.Cut(rest, ":"); ok && strings.TrimSpace(key) == "name" { + doc.items[cur].name = unquoteYAML(strings.TrimSpace(value)) + } + } + continue + } + if cur >= 0 { + doc.items[cur].end = i + 1 + } + } + return doc +} + +// findItem 依名稱找項目；找不到回 -1。 +func (d configDoc) findItem(name string) int { + for i, it := range d.items { + if it.name == name { + return i + } + } + return -1 +} + +// fieldIndent 回傳項目內屬性行的縮排（項目縮排 + 兩格，tea 的格式）。 +func (d configDoc) fieldIndent() string { + return d.itemIndent + " " +} + +// entryAt 取某個項目的完整欄位值。 +func (d configDoc) entryAt(it loginItemSpan) LoginEntry { + var e LoginEntry + apply := func(kv string) { + key, value, ok := strings.Cut(kv, ":") + if !ok { + return + } + key = strings.TrimSpace(key) + value = unquoteYAML(strings.TrimSpace(value)) + switch key { + case "name": + e.Name = value + case "url": + e.URL = value + case "token": + e.Token = value + case "default": + e.Default = value == "true" + case "user": + e.User = value + } + } + first := strings.TrimSpace(d.lines[it.start]) + if rest := strings.TrimSpace(strings.TrimPrefix(first, "-")); rest != "" { + apply(rest) + } + for i := it.start + 1; i < it.end; i++ { + if kv := strings.TrimSpace(d.lines[i]); kv != "" && !strings.HasPrefix(kv, "#") { + apply(kv) + } + } + return e +} + +// ListLogins 回傳組態內容中的所有登入（依檔案順序）。 +func ListLogins(data []byte) []LoginEntry { + doc := parseConfigDoc(data) + out := make([]LoginEntry, 0, len(doc.items)) + for _, it := range doc.items { + out = append(out, doc.entryAt(it)) + } + return out +} + +// ListLoginsFile 讀取組態檔並列出登入；檔案不存在視為空清單（非錯誤）。 +func ListLoginsFile(path string) ([]LoginEntry, error) { + data, err := os.ReadFile(path) + if err != nil { + if os.IsNotExist(err) { + return nil, nil + } + return nil, err + } + return ListLogins(data), nil +} + +// UpsertLogin 新增或更新名為 e.Name 的登入。 +// +// 已存在則就地更新 url/token/user/default（保留其他欄位與行）；不存在則 +// 依 tea 的欄位順序插入新項目。makeDefault 為 true 時將其設為預設並取消 +// 其他登入的預設旗標；新增後若成為唯一登入也自動成為預設。 +// 回傳新內容與最終生效的項目值。 +func UpsertLogin(data []byte, e LoginEntry, makeDefault bool) ([]byte, LoginEntry, error) { + if strings.TrimSpace(e.Name) == "" { + return nil, LoginEntry{}, fmt.Errorf("gitea: login name must not be empty") + } + if strings.TrimSpace(e.URL) == "" { + return nil, LoginEntry{}, fmt.Errorf("gitea: login url must not be empty") + } + if e.Token == "" { + return nil, LoginEntry{}, fmt.Errorf("gitea: login token must not be empty") + } + doc := parseConfigDoc(data) + idx := doc.findItem(e.Name) + if idx >= 0 { + existing := doc.entryAt(doc.items[idx]) + wantDefault := existing.Default || makeDefault + it := doc.items[idx] + lines := doc.lines + // 就地替換各欄位；缺少的欄位補在項目結尾。 + for _, kv := range []struct{ key, value string }{ + {"name", yamlScalar(e.Name)}, + {"url", yamlScalar(e.URL)}, + {"token", yamlScalar(e.Token)}, + {"user", yamlScalar(e.User)}, + {"default", strconv.FormatBool(wantDefault)}, + } { + lines = setFieldInItem(lines, it, kv.key, kv.value, doc.fieldIndent()) + } + out := joinLines(lines) + if wantDefault { + var err error + out, err = SetDefaultLogin(out, e.Name) + if err != nil { + return nil, LoginEntry{}, err + } + } + final := existing + final.URL, final.Token, final.User = e.URL, e.Token, e.User + final.Default = wantDefault + return out, final, nil + } + + // 新增項目。 + wantDefault := makeDefault || len(doc.items) == 0 + block := newLoginBlock(doc.itemIndent, e.Name, e.URL, e.Token, wantDefault, e.User) + var lines []string + var insertAt int + if doc.loginsHeader < 0 { + if len(doc.lines) == 0 { + lines = []string{"logins:"} + } else { + lines = append(slices.Clone(doc.lines), "", "logins:") + } + insertAt = len(lines) + } else { + lines = slices.Clone(doc.lines) + // 「logins: []」是空清單的串流寫法，直接接項目會變無效 YAML；改回區段寫法。 + if len(doc.items) == 0 && strings.TrimSpace(lines[doc.loginsHeader]) == "logins: []" { + lines[doc.loginsHeader] = "logins:" + } + if len(doc.items) > 0 { + insertAt = doc.items[len(doc.items)-1].end + } else { + insertAt = doc.loginsHeader + 1 + } + } + out := append(slices.Clone(lines[:insertAt]), block...) + out = append(out, lines[insertAt:]...) + data2 := joinLines(out) + if wantDefault { + var err error + data2, err = SetDefaultLogin(data2, e.Name) + if err != nil { + return nil, LoginEntry{}, err + } + } + return data2, LoginEntry{ + Name: e.Name, + URL: e.URL, + Token: e.Token, + Default: wantDefault, + User: e.User, + }, nil +} + +// SetDefaultLogin 把名為 name 的登入設為預設，其餘一律取消預設。 +func SetDefaultLogin(data []byte, name string) ([]byte, error) { + doc := parseConfigDoc(data) + idx := doc.findItem(name) + if idx < 0 { + return nil, fmt.Errorf("gitea: login %q not found", name) + } + lines := doc.lines + // 反序處理：前面的插入不影響後面已算好的行範圍，這裡的反序則保證 + // 後方項目的插入/修改不會推移前方項目的範圍。 + for i := len(doc.items) - 1; i >= 0; i-- { + want := "false" + if i == idx { + want = "true" + } + lines = setFieldInItem(lines, doc.items[i], "default", want, doc.fieldIndent()) + } + return joinLines(lines), nil +} + +// RemoveLogin 移除名為 name 的登入。若被移除者是預設且還有其他登入， +// 剩下的第一筆自動遞補為預設。回傳新內容與遞補後的預設名稱（無則空字串）。 +func RemoveLogin(data []byte, name string) ([]byte, string, error) { + doc := parseConfigDoc(data) + idx := doc.findItem(name) + if idx < 0 { + return nil, "", fmt.Errorf("gitea: login %q not found", name) + } + removed := doc.entryAt(doc.items[idx]) + it := doc.items[idx] + lines := slices.Delete(slices.Clone(doc.lines), it.start, it.end) + out := joinLines(lines) + promoted := "" + if removed.Default { + rest := ListLogins(out) + if len(rest) > 0 { + promoted = rest[0].Name + var err error + out, err = SetDefaultLogin(out, promoted) + if err != nil { + return nil, "", err + } + } + } + return out, promoted, nil +} + +// setFieldInItem 把項目內 key 的值換成 value，保留該行的原始縮排； +// key 不存在時以 fieldIndent 插在項目結尾。回傳新的行切片。 +func setFieldInItem(lines []string, it loginItemSpan, key, value, fieldIndent string) []string { + first := lines[it.start] + trimmed := strings.TrimSpace(first) + if rest := strings.TrimSpace(strings.TrimPrefix(trimmed, "-")); rest != "" { + if k, _, ok := strings.Cut(rest, ":"); ok && strings.TrimSpace(k) == key { + prefix := first[:strings.Index(first, "-")] + "- " + lines[it.start] = prefix + key + ": " + value + return lines + } + } + for i := it.start + 1; i < it.end; i++ { + t := strings.TrimSpace(lines[i]) + if k, _, ok := strings.Cut(t, ":"); ok && strings.TrimSpace(k) == key { + indent := lines[i][:len(lines[i])-len(strings.TrimLeft(lines[i], " "))] + lines[i] = indent + key + ": " + value + return lines + } + } + out := append(slices.Clone(lines[:it.end]), fieldIndent+key+": "+value) + return append(out, lines[it.end:]...) +} + +// newLoginBlock 產生 tea 格式的新登入項目（欄位順序與 tea 實際寫出的一致）。 +func newLoginBlock(itemIndent, name, url, token string, isDefault bool, user string) []string { + f := itemIndent + " " + return []string{ + itemIndent + "- name: " + yamlScalar(name), + f + "url: " + yamlScalar(url), + f + "token: " + yamlScalar(token), + f + "default: " + strconv.FormatBool(isDefault), + f + `ssh_host: ""`, + f + `ssh_key: ""`, + f + "insecure: false", + f + `ssh_certificate_principal: ""`, + f + "ssh_agent: false", + f + `ssh_key_agent_pub: ""`, + f + "version_check: false", + f + "user: " + yamlScalar(user), + f + "created: 0", + } +} + +// plainScalar 是可以不加引號直接寫出的 YAML 純量。 +var plainScalar = regexp.MustCompile(`^[A-Za-z0-9][A-Za-z0-9._:/~+=@-]*$`) + +// yamlScalar 把值寫成 YAML 純量：安全字元集直接輸出，其餘加雙引號。 +func yamlScalar(s string) string { + if plainScalar.MatchString(s) { + return s + } + return strconv.Quote(s) +} + +// HostOf 取 URL 的主機部分（連埠，小寫）；解析失敗回空字串。 +// 供比對「同一站點」的登入時使用。 +func HostOf(rawURL string) string { return hostOf(rawURL) } + +// splitLines 把內容拆成行（去掉行尾換行與 CR）。 +func splitLines(data []byte) []string { + if len(data) == 0 { + return nil + } + s := strings.TrimSuffix(string(data), "\n") + if s == "" { + return []string{""} + } + return strings.Split(s, "\n") +} + +// joinLines 把行組回內容，保證以單一換行結尾。 +func joinLines(lines []string) []byte { + if len(lines) == 0 { + return nil + } + s := strings.Join(lines, "\n") + if !strings.HasSuffix(s, "\n") { + s += "\n" + } + return []byte(s) +} + +// SaveTeaConfigFile 把組態內容原子寫入 path：先寫同目錄暫存檔（0600）， +// 再 rename 取代，避免半寫入狀態。必要時建立上層目錄（0700）。 +func SaveTeaConfigFile(path string, data []byte) error { + dir := filepath.Dir(path) + if err := os.MkdirAll(dir, 0o700); err != nil { + return fmt.Errorf("gitea: create config dir: %w", err) + } + tmp, err := os.CreateTemp(dir, ".config-*.yml") + if err != nil { + return fmt.Errorf("gitea: create temp file: %w", err) + } + tmpName := tmp.Name() + defer func() { + if tmpName != "" { + _ = os.Remove(tmpName) + } + }() + if _, err := tmp.Write(data); err != nil { + tmp.Close() + return fmt.Errorf("gitea: write temp file: %w", err) + } + if err := tmp.Chmod(0o600); err != nil { + tmp.Close() + return fmt.Errorf("gitea: chmod temp file: %w", err) + } + if err := tmp.Close(); err != nil { + return fmt.Errorf("gitea: close temp file: %w", err) + } + if err := os.Rename(tmpName, path); err != nil { + return fmt.Errorf("gitea: rename config: %w", err) + } + tmpName = "" // 已改名成功，不必清理。 + return nil +} diff --git a/internal/gitea/config_test.go b/internal/gitea/config_test.go new file mode 100644 index 0000000..0815761 --- /dev/null +++ b/internal/gitea/config_test.go @@ -0,0 +1,263 @@ +// config_test.go 驗證 tea 相容組態的行級編輯：新增、更新、設預設、 +// 移除，以及「未知欄位與其他區段逐字保留」的關鍵性質。 +package gitea + +import ( + "bytes" + "os" + "path/filepath" + "strings" + "testing" +) + +// realWorldTeaConfig 是 tea 實際寫出的組態（含 ssh_* 等未知欄位與 preferences）。 +const realWorldTeaConfig = `logins: + - name: alterminal + url: https://gitea.alterminal.com + token: tok-1 + default: true + ssh_host: "" + ssh_key: "" + insecure: false + ssh_certificate_principal: "" + ssh_agent: false + ssh_key_agent_pub: "" + version_check: false + user: ceo + created: 0 +preferences: + editor: false + flag_defaults: + remote: "" +` + +func TestListLoginsParsesAllEntries(t *testing.T) { + logins := ListLogins([]byte(realWorldTeaConfig)) + if len(logins) != 1 { + t.Fatalf("want 1 login, got %d", len(logins)) + } + l := logins[0] + if l.Name != "alterminal" || l.URL != "https://gitea.alterminal.com" || l.Token != "tok-1" || !l.Default || l.User != "ceo" { + t.Fatalf("unexpected entry: %+v", l) + } +} + +func TestUpsertLoginUpdatesExistingPreservesRest(t *testing.T) { + out, final, err := UpsertLogin([]byte(realWorldTeaConfig), LoginEntry{ + Name: "alterminal", URL: "https://gitea.alterminal.com", Token: "tok-2", User: "ceo", + }, false) + if err != nil { + t.Fatal(err) + } + s := string(out) + // 更新 token、保留其他欄位。 + if !strings.Contains(s, "token: tok-2") || strings.Contains(s, "tok-1") { + t.Fatalf("token not updated:\n%s", s) + } + for _, want := range []string{ + "ssh_host: \"\"", "insecure: false", "ssh_key_agent_pub: \"\"", + "user: ceo", "created: 0", "default: true", + "preferences:", "editor: false", "flag_defaults:", `remote: ""`, + } { + if !strings.Contains(s, want) { + t.Fatalf("missing %q after edit:\n%s", want, s) + } + } + if final.Default != true { + t.Fatalf("existing default should stay default, got %+v", final) + } + // 編輯後仍可解析出正確值。 + logins := ListLogins(out) + if len(logins) != 1 || logins[0].Token != "tok-2" || !logins[0].Default { + t.Fatalf("reparse mismatch: %+v", logins) + } +} + +func TestUpsertLoginAppendsNewAndMakesDefault(t *testing.T) { + out, final, err := UpsertLogin([]byte(realWorldTeaConfig), LoginEntry{ + Name: "second", URL: "https://git.example.com", Token: "tok-b", User: "bob", + }, true) + if err != nil { + t.Fatal(err) + } + logins := ListLogins(out) + if len(logins) != 2 { + t.Fatalf("want 2 logins, got %d:\n%s", len(logins), out) + } + if logins[0].Default || !logins[1].Default { + t.Fatalf("only the new login should be default: %+v", logins) + } + if logins[1].Name != "second" || logins[1].Token != "tok-b" || logins[1].User != "bob" { + t.Fatalf("new entry mismatch: %+v", logins[1]) + } + if !final.Default { + t.Fatalf("final should be default: %+v", final) + } + // tea 的欄位順序仍在。 + s := string(out) + if !strings.Contains(s, " - name: second\n") { + t.Fatalf("new item not appended in tea style:\n%s", s) + } +} + +func TestUpsertLoginFirstEverLoginCreatesSection(t *testing.T) { + out, final, err := UpsertLogin(nil, LoginEntry{ + Name: "only", URL: "https://gitea.alterminal.com", Token: "tok", User: "ceo", + }, false) + if err != nil { + t.Fatal(err) + } + logins := ListLogins(out) + if len(logins) != 1 || !logins[0].Default || logins[0].Token != "tok" { + t.Fatalf("first login should auto-default: %s", out) + } + if !final.Default { + t.Fatalf("final should be default: %+v", final) + } + if !strings.HasPrefix(string(out), "logins:\n") { + t.Fatalf("section not created:\n%s", out) + } +} + +func TestUpsertLoginRejectsBadInput(t *testing.T) { + cases := []LoginEntry{ + {Name: "", URL: "https://x", Token: "t"}, + {Name: "n", URL: " ", Token: "t"}, + {Name: "n", URL: "https://x", Token: ""}, + } + for _, e := range cases { + if _, _, err := UpsertLogin(nil, e, true); err == nil { + t.Errorf("UpsertLogin(%+v) should fail", e) + } + } +} + +func TestSetDefaultLoginSwitchesFlag(t *testing.T) { + cfg := `logins: + - name: a + url: https://a.example.com + token: ta + default: true + - name: b + url: https://b.example.com + token: tb + default: false +` + out, err := SetDefaultLogin([]byte(cfg), "b") + if err != nil { + t.Fatal(err) + } + logins := ListLogins(out) + if logins[0].Default || !logins[1].Default { + t.Fatalf("default flag not switched:\n%s", out) + } + // b 之後的內容（如有）不受影響。 + if !strings.Contains(string(out), "token: ta") || !strings.Contains(string(out), "token: tb") { + t.Fatalf("tokens lost:\n%s", out) + } +} + +func TestSetDefaultLoginUnknownNameErrors(t *testing.T) { + if _, err := SetDefaultLogin([]byte(realWorldTeaConfig), "nope"); err == nil { + t.Fatal("unknown name should error") + } +} + +func TestRemoveLoginPromotesNextDefault(t *testing.T) { + // 第二個登入放在 logins 區段內（preferences 之前）。 + cfg := `logins: + - name: alterminal + url: https://gitea.alterminal.com + token: tok-1 + default: true + user: ceo + - name: backup + url: https://backup.example.com + token: tb + default: false +preferences: + editor: false +` + out, promoted, err := RemoveLogin([]byte(cfg), "alterminal") + if err != nil { + t.Fatal(err) + } + if promoted != "backup" { + t.Fatalf("promoted = %q, want backup:\n%s", promoted, out) + } + logins := ListLogins(out) + if len(logins) != 1 || logins[0].Name != "backup" || !logins[0].Default { + t.Fatalf("remaining login mismatch: %+v", logins) + } + if strings.Contains(string(out), "tok-1") || strings.Contains(string(out), "name: alterminal") { + t.Fatalf("login not fully removed:\n%s", out) + } +} + +func TestRemoveLoginLastOne(t *testing.T) { + out, promoted, err := RemoveLogin([]byte(realWorldTeaConfig), "alterminal") + if err != nil || promoted != "" { + t.Fatalf("want clean removal, promoted=%q err=%v", promoted, err) + } + if strings.Contains(string(out), "alterminal") { + t.Fatalf("login not removed:\n%s", out) + } + if !strings.Contains(string(out), "preferences:") { + t.Fatalf("preferences section lost:\n%s", out) + } +} + +func TestSaveTeaConfigFileAtomicAndMode(t *testing.T) { + dir := t.TempDir() + path := filepath.Join(dir, "tea", "config.yml") + if err := SaveTeaConfigFile(path, []byte("logins: []\n")); err != nil { + t.Fatal(err) + } + info, err := os.Stat(path) + if err != nil { + t.Fatal(err) + } + if info.Mode().Perm() != 0o600 { + t.Fatalf("perm = %v, want 0600", info.Mode().Perm()) + } + // 再寫一次（覆蓋既有檔），不留暫存殘檔。 + if err := SaveTeaConfigFile(path, []byte("logins: []\n# v2\n")); err != nil { + t.Fatal(err) + } + entries, _ := os.ReadDir(filepath.Dir(path)) + if len(entries) != 1 { + for _, e := range entries { + t.Logf("leftover: %s", e.Name()) + } + t.Fatalf("want exactly 1 file, got %d", len(entries)) + } + data, _ := os.ReadFile(path) + if !bytes.Contains(data, []byte("# v2")) { + t.Fatalf("overwrite failed: %s", data) + } +} + +func TestSplitJoinLinesRoundTrip(t *testing.T) { + original := "a\nb\n" + got := string(joinLines(splitLines([]byte(original)))) + if got != original { + t.Fatalf("round trip: %q", got) + } + if joinLines(splitLines(nil)) != nil { + t.Fatal("nil input should stay nil") + } +} + +func TestYamlScalarQuoting(t *testing.T) { + cases := map[string]string{ + "https://gitea.alterminal.com": "https://gitea.alterminal.com", // 含 : 與 / 的純量在 YAML 合法，不必引號 + "tok-abc_123": "tok-abc_123", + "has space": `"has space"`, + "ceo": "ceo", + } + for in, want := range cases { + if got := yamlScalar(in); got != want { + t.Errorf("yamlScalar(%q) = %s, want %s", in, got, want) + } + } +}