feat: 實作管理端指令群 jwks/accounts/audit-logs(issue #12)

- docs/commands.md 新增 §3.8 jwks、§3.9 accounts、§3.10 audit-logs 規格
- Api 新增 jwks/accounts/audit-logs 端點(共用 api_request)
- 新增 Jwks/Accounts/AuditLogs/Admin 模組;CLI 接線三個指令群
- 403 → 退出碼 8 提示需 admin;一次性密碼只在成功當下輸出
- 測試 100 例全綠(fake API 注入,比照 cli_test.exs)
This commit is contained in:
2026-09-10 03:07:40 +08:00
parent a220f8c5e6
commit 464db21745
9 changed files with 1737 additions and 9 deletions
+6
View File
@@ -24,6 +24,9 @@ Bear 目前所有流程都依賴「瀏覽器」:登入 `/login`、儀表板 La
| `bear logout` | 撤銷 refresh token(`POST /revoke`) | P2 | | `bear logout` | 撤銷 refresh token(`POST /revoke`) | P2 |
| `bear status` | 顯示登入狀態與 token 剩餘效期 | P2 | | `bear status` | 顯示登入狀態與 token 剩餘效期 | P2 |
| `bear apps list/show/create/update/rotate-secret/toggle` | App 管理(需 bear App 管理 JSON API,PAT 登入、admin 限定) | P3 | | `bear apps list/show/create/update/rotate-secret/toggle` | App 管理(需 bear App 管理 JSON API,PAT 登入、admin 限定) | P3 |
| `bear jwks list/show/create/toggle` | 簽章金鑰管理(admin 限定) | P3 |
| `bear accounts list/show/create/update/set-password/delete` | 帳號管理(admin 限定) | P3 |
| `bear audit-logs list` | 稽核日誌查襟(admin 限定) | P3 |
| `bear profile show/set` | 個人資料檢視/更新(需 bear 個人自助 JSON API) | P3 | | `bear profile show/set` | 個人資料檢視/更新(需 bear 個人自助 JSON API) | P3 |
| `bear password change` | 變更密碼(互動輸入,不進 shell history) | P3 | | `bear password change` | 變更密碼(互動輸入,不進 shell history) | P3 |
| `bear email change --new EMAIL` | 變更 email(雙向驗證碼流程) | P3 | | `bear email change --new EMAIL` | 變更 email(雙向驗證碼流程) | P3 |
@@ -47,6 +50,9 @@ Bear 目前所有流程都依賴「瀏覽器」:登入 `/login`、儀表板 La
| `bear logout` | ✅ 已實作(清除本機憑證;PAT 需至網頁撤銷) | | `bear logout` | ✅ 已實作(清除本機憑證;PAT 需至網頁撤銷) |
| `bear status` | ✅ 已實作(純本機判定,顯示 PAT/環境變數模式) | | `bear status` | ✅ 已實作(純本機判定,顯示 PAT/環境變數模式) |
| `bear apps` | ✅ 已實作(`list`/`show`/`create`/`update`/`rotate-secret`/`toggle`;issue #10,對接 alterminal/bear#28 的 `/api/v1/apps` JSON API,admin PAT 限定) | | `bear apps` | ✅ 已實作(`list`/`show`/`create`/`update`/`rotate-secret`/`toggle`;issue #10,對接 alterminal/bear#28 的 `/api/v1/apps` JSON API,admin PAT 限定) |
| `bear jwks` | ✅ 已實作(`list`/`show`/`create`/`toggle`;issue #12,對接 alterminal/bear#46 的 `/api/v1/jwks` JSON API,admin PAT 限定) |
| `bear accounts` | ✅ 已實作(`list`/`show`/`create`/`update`/`set-password`/`delete`;issue #12,對接 alterminal/bear#46 的 `/api/v1/accounts` JSON API;密碼不進命令列,初始/新密碼一次性輸出) |
| `bear audit-logs` | ✅ 已實作(`list` 含 `--category` 過濾與 emails 對照;issue #12,對接 alterminal/bear#46 的 `/api/v1/audit-logs` JSON API) |
| `bear profile`/`password`/`email`/`sessions`/`tokens`/`mfa` | ⏳ 規格已納入 `docs/commands.md` §3.7(#11);待 alterminal/bear#35 API 就緒後實作 | | `bear profile`/`password`/`email`/`sessions`/`tokens`/`mfa` | ⏳ 規格已納入 `docs/commands.md` §3.7(#11);待 alterminal/bear#35 API 就緒後實作 |
### 建置與執行 ### 建置與執行
+170 -1
View File
@@ -513,6 +513,162 @@ TOTP 兩因子管理(WebAuthn/passkey 不在範圍)。
--- ---
### 3.8 `bear jwks`:簽章金鑰管理指令群(admin,已實作)
> 依賴:bear 伺服器端 **JWK 管理 JSON API**(alterminal/bear#36/PR #46,資源前綴 `/api/v1/jwks`,PAT Bearer 認證、admin 限定)。API 已上線,本節指令群已實作(issue #12)。
比照 `apps` 的「資源群組」結構。金鑰材質(`key_data`)**永不經 CLI 顯示**(API 端即不序列化;公開 JWK 走 `/.well-known/jwks.json`),本群組僅管理公開中繼資料。
```
bear jwks list [--json]
bear jwks show <kid> [--json]
bear jwks create --kid KID [--alg ALG] [--json]
bear jwks toggle <kid> [--json]
```
**認證與授權(群組共通)**:一律使用既有 PAT 憑證(`bear login --token` 或 `BEAR_TOKEN` 環境變數)作為 Bearer,僅限 admin 角色。
`401`(token 無效)→ 退出碼 `3`,提示重新 `bear login`;`403`(非 admin)→ 退出碼 `8`,提示此操作需 admin 權限,不重試。
**識別與退出碼**:金鑰一律以 `kid`(人類可讀)識別;API 路徑參數為 UUID,由 CLI 先以 list 比對解析。退出碼同 §3.6 群組共通表(0/1/2/3/6/8)。
#### 3.8.1 `bear jwks list`
**行為**:`GET /api/v1/jwks`(Bearer PAT),列出所有金鑰(active 與 inactive),最新在前;人類可讀輸出為表格(ID 前 8 碼、KID、KTY、ALG、ACTIVE、CREATED AT)。
```
ID KID KTY ALG ACTIVE CREATED AT
0192cccc sig-2026-01 RSA RS256 active 2026-09-09T00:00:00Z
0192cccc sig-2025-12 EC ES256 inactive 2025-12-01T00:00:00Z
```
**`--json` 輸出範例**:`{"ok": true, "jwks": [{…}]}`(僅公開欄位,無 `key_data`)。
#### 3.8.2 `bear jwks show <kid>`
**行為**:`GET /api/v1/jwks/{id}`(以 kid 解析),印出公開欄位(id、kid、kty、alg、use、active、created_at);找不到 kid → 退出碼 `1`。
#### 3.8.3 `bear jwks create --kid KID [--alg ALG]`
| 選項 | 預設 | 說明 |
|------|------|------|
| `--kid` | (必填) | 金鑰識別碼 |
| `--alg` | `RS256` | `RS256`/`RS384`/`RS512`/`ES256`/`ES384`/`ES512` |
**行為**:`POST /api/v1/jwks`(body 為 kid 與 alg;金鑰由伺服器產生)。成功印出 `JWK 已建立:<kid>(<alg>/active)`。`alg` 非法 → 退出碼 `2`(本地檢查);kid 重複等 422 → 退出碼 `1` 逐欄位列錯。
**`--json` 輸出範例**:`{"ok": true, "jwk": {…}}`
#### 3.8.4 `bear jwks toggle <kid>`
**行為**:`POST /api/v1/jwks/{id}/toggle`(以 kid 解析),切換 `active ⇄ inactive`;成功印出如 `sig-2026-01:active → inactive`。
**`--json` 輸出範例**:`{"ok": true, "jwk": {"id": "…", "kid": "…", "active": false}}`
---
### 3.9 `bear accounts`:帳號管理指令群(admin,已實作)
> 依賵:bear 伺服器端 **帳號管理 JSON API**(alterminal/bear#36/PR #46,資源前綴 `/api/v1/accounts`,PAT Bearer 認證、admin 限定)。API 已上線,本節指令群已實作(issue #12)。
帳號 JSON 不含機密欄位(hash_password、totp_secret、recovery codes;API 端保證),CLI 亦不顯示。敏感規則與伺服器端一致:不可移除自己的 admin 角色(403)、不可刪除自己(403)。
```
bear accounts list [--page N] [--per-page N] [--json]
bear accounts show <email> [--json]
bear accounts create --email EMAIL [--role user|admin] [--generate-password] [--json]
bear accounts update <email> --role user|admin [--json]
bear accounts set-password <email> [--generate-password] [--json]
bear accounts delete <email> [--json]
```
**認證與授權(群組共通)**:同 §3.8(PAT Bearer、僅限 admin;401 → 3;403 → 8)。退出碼同 §3.6 群組共通表。
**識別與密碼**:帳號一律以 `email` 識別;API 路徑參數為 UUID,由 CLI 先以 list 分頁比對解析。密碼不進命令列(避免 shell history 與 ps):交互提示輸入(不回顧)或 `--generate-password` 由 CLI 產生。初始/新密碼只在成功當下一次性輸出。
#### 3.9.1 `bear accounts list`
**行為**:`GET /api/v1/accounts`(Bearer PAT,分頁,最新在前);人類可讀輸出為表格。
```
EMAIL ROLE TOTP CREATED AT
admin@example.com admin on 2026-01-01T00:00:00Z
alice@example.com user off 2026-02-01T00:00:00Z
```
**`--json` 輸出範例**:`{"ok": true, "page": 1, "per_page": 20, "total": 2, "accounts": […]}`
#### 3.9.2 `bear accounts show <email>`
**行為**:`GET /api/v1/accounts/{id}`(以 email 解析),印出公開欄位(id、email、role、totp_enabled、created_at、updated_at);找不到 → 退出碼 `1`。
#### 3.9.3 `bear accounts create`
| 選項 | 預設 | 說明 |
|------|------|------|
| `--email` | (必填) | 帳號 email(唯一) |
| `--role` | `user` | `user` 或 `admin` |
| `--generate-password` | 互動輸入 | 由 CLI 產生 16 字元隨機密碼(含字母與數字) |
**行為**:`POST /api/v1/accounts`(免信箱驗證;密碼以明文放入 `hash_password`,伺服器端驗強度後雜湏)。成功印出帳號摘要與一次性密碼區塊:
```
帳號已建立:new@example.com(user)
初始密碼(只顯示這一次,請立即保存並轉交當事人):
xK7mP9qR2sL4wY6z
```
**`--json` 輸出範例**:`{"ok": true, "account": {…}, "initial_password": "…"}`(密碼只出現這一次)。
#### 3.9.4 `bear accounts update <email> --role user|admin`
**行為**:`PUT /api/v1/accounts/{id}`(body 為 role)。成功印出 `alice@example.com:角色 → admin`。伺服器拒絕自降 admin(403)→ 退出碼 `8`。`--role` 罪給或非法 → 退出碼 `2`。
#### 3.9.5 `bear accounts set-password <email>`
**行為**:`PUT /api/v1/accounts/{id}/password`(管理員設新密碼,免舊密碼)。密碼來源同 create;非 TTY 且未給 `--generate-password` → 退出碼 `2`,提示加 `--generate-password`。成功後一次性顯示新密碼(同 create 提示)。
#### 3.9.6 `bear accounts delete <email>`
**行為**:`DELETE /api/v1/accounts/{id}`(管理端硬刪除,免驗證碼)。成功印出 `已刪除帳號:<email>`;伺服器拒絕自刪(403)→ 退出碼 `8`。
**`--json` 輸出範例**:`{"ok": true, "email": "alice@example.com", "deleted": true}`
---
### 3.10 `bear audit-logs`:稽核日誌指令群(admin,已實作)
> 依賵:bear 伺服器端 **稽核日誌 JSON API**(alterminal/bear#36/PR #46,`/api/v1/audit-logs`,PAT Bearer 認證、admin 限定)。API 已上線,本節指令群已實作(issue #12)。
```
bear audit-logs list [--page N] [--per-page N] [--category CATEGORY] [--json]
```
**認證與授權**:同 §3.8(PAT Bearer、僅限 admin;401 → 3;403 → 8)。
#### 3.10.1 `bear audit-logs list`
| 選項 | 預設 | 說明 |
|------|------|------|
| `--page` | `1` | 分頁頁碼 |
| `--per-page` | `50` | 每頁筆數(伺服器上限 200) |
| `--category` | 全部 | 過濾類別(伺服器端支援;如 `account`、`jwk`) |
**行為**:`GET /api/v1/audit-logs`(Bearer PAT,最新在前);回應附 `emails` 對照(account/actor id → email),人類可讀輸出以 email 呈現、無對照時顯示 id 前 8 碼:
```
TIME CATEGORY EVENT ACTOR ACCOUNT
2026-09-09T01:00:00Z account account_created_by_admin admin@example.com alice@example.com
```
**`--json` 輸出範例**:`{"ok": true, "page": 1, "per_page": 50, "total": 1, "total_pages": 1, "emails": {…}, "entries": […]}`
---
## 4. 退出碼總表 ## 4. 退出碼總表
| 碼 | 語意 | | 碼 | 語意 |
@@ -525,7 +681,7 @@ TOTP 兩因子管理(WebAuthn/passkey 不在範圍)。
| `5` | 授權被拒絕(access_denied) | | `5` | 授權被拒絕(access_denied) |
| `6` | 網路/伺服器錯誤 | | `6` | 網路/伺服器錯誤 |
| `7` | 設定檔/憑證檔格式損毀 | | `7` | 設定檔/憑證檔格式損毀 |
| `8` | 權限不足(HTTP 403;App 管理操作僅限 admin) | | `8` | 權限不足(HTTP 403;管理端操作僅限 admin:apps/jwks/accounts/audit-logs) |
--- ---
@@ -549,6 +705,7 @@ TOTP 兩因子管理(WebAuthn/passkey 不在範圍)。
- 所有診斷訊息走 stderr;`--json` 模式將錯誤以 `{"ok": false, "error": "...", "code": N}` 輸出。 - 所有診斷訊息走 stderr;`--json` 模式將錯誤以 `{"ok": false, "error": "...", "code": N}` 輸出。
- token、user_code、device_code 一律不入 log、不入 stdout(除 `bear token` 之目的外)、不入版本庫。 - token、user_code、device_code 一律不入 log、不入 stdout(除 `bear token` 之目的外)、不入版本庫。
- `client_secret`(App 管理)僅於 `apps create`/`apps rotate-secret` 成功當下一次性輸出;`403` 顯示「此操作需 admin 權限」並以退出碼 `8` 結束,不重試。 - `client_secret`(App 管理)僅於 `apps create`/`apps rotate-secret` 成功當下一次性輸出;`403` 顯示「此操作需 admin 權限」並以退出碼 `8` 結束,不重試。
- 管理端指令群(jwks/accounts/audit-logs)同樣 admin 限定;帳號的初始/新密碼僅於 `accounts create`/`accounts set-password` 成功當下一次性輸出;密碼不進命令列(互動輸入不回顧,或 `--generate-password`);JWK 的 `key_data` 永不經顯示。
- 個人自助的敏感輸入(密碼、email/MFA 驗證碼)一律互動提示、不回顧、不接受命令列參數;一次性明文(`tokens create` 的 PAT、`mfa` 的 recovery codes)僅於成功當下輸出(見 §3.7)。 - 個人自助的敏感輸入(密碼、email/MFA 驗證碼)一律互動提示、不回顧、不接受命令列參數;一次性明文(`tokens create` 的 PAT、`mfa` 的 recovery codes)僅於成功當下輸出(見 §3.7)。
- 網路層一律使用 `Req`,遵循 bear 倉庫 HTTP 客戶端慣例。 - 網路層一律使用 `Req`,遵循 bear 倉庫 HTTP 客戶端慣例。
@@ -596,6 +753,17 @@ TOTP 兩因子管理(WebAuthn/passkey 不在範圍)。
| `mfa setup` | `POST /api/v1/profile/mfa/setup`(先無 code 取 secret,再帶 code 確認) | | `mfa setup` | `POST /api/v1/profile/mfa/setup`(先無 code 取 secret,再帶 code 確認) |
| `mfa disable` | `POST /api/v1/profile/mfa/disable` | | `mfa disable` | `POST /api/v1/profile/mfa/disable` |
| `mfa recovery-codes` | `POST /api/v1/profile/mfa/recovery-codes` | | `mfa recovery-codes` | `POST /api/v1/profile/mfa/recovery-codes` |
| `jwks list` | `GET /api/v1/jwks` |
| `jwks show` | `GET /api/v1/jwks/{id}` |
| `jwks create` | `POST /api/v1/jwks` |
| `jwks toggle` | `POST /api/v1/jwks/{id}/toggle` |
| `accounts list` | `GET /api/v1/accounts` |
| `accounts show` | `GET /api/v1/accounts/{id}` |
| `accounts create` | `POST /api/v1/accounts` |
| `accounts update` | `PUT /api/v1/accounts/{id}` |
| `accounts set-password` | `PUT /api/v1/accounts/{id}/password` |
| `accounts delete` | `DELETE /api/v1/accounts/{id}` |
| `audit-logs list` | `GET /api/v1/audit-logs` |
> `apps` 群組依賴 alterminal/bear#28 的 App 管理 JSON API(PAT Bearer、admin 限定);`profile` 系列依賴 alterminal/bear#35 的個人自助 JSON API(PAT Bearer、任何有效帳號)。 > `apps` 群組依賴 alterminal/bear#28 的 App 管理 JSON API(PAT Bearer、admin 限定);`profile` 系列依賴 alterminal/bear#35 的個人自助 JSON API(PAT Bearer、任何有效帳號)。
@@ -613,6 +781,7 @@ TOTP 兩因子管理(WebAuthn/passkey 不在範圍)。
| `logout` | `POST /revoke`(撤銷 refresh token) | 僅清除本機憑證;PAT 需至網頁 `/profile/tokens` 撤銷 | | `logout` | `POST /revoke`(撤銷 refresh token) | 僅清除本機憑證;PAT 需至網頁 `/profile/tokens` 撤銷 |
| `status` | 顯示 access token 剩餘秒數 | 純本機判定:顯示模式(PAT/BEAR_TOKEN 環境變數)與 issuer | | `status` | 顯示 access token 剩餘秒數 | 純本機判定:顯示模式(PAT/BEAR_TOKEN 環境變數)與 issuer |
| `apps` | P3 暫緩 | ✅ 已實作(issue #10):`list`/`show`/`create`/`update`/`rotate-secret`/`toggle`,對接 alterminal/bear#28 的 `/api/v1/apps` JSON API(PAT Bearer、admin 限定)。`client_id` → UUID 由 CLI 以 list 解析;一次性 `client_secret` 僅於 create/rotate-secret 成功當下輸出 | | `apps` | P3 暫緩 | ✅ 已實作(issue #10):`list`/`show`/`create`/`update`/`rotate-secret`/`toggle`,對接 alterminal/bear#28 的 `/api/v1/apps` JSON API(PAT Bearer、admin 限定)。`client_id` → UUID 由 CLI 以 list 解析;一次性 `client_secret` 僅於 create/rotate-secret 成功當下輸出 |
| `jwks`/`accounts`/`audit-logs` | P3 暫緩 | ✔ 已實作(issue #12):對接 alterminal/bear#46 的管理端 JSON API(PAT Bearer、admin 限定);規格見 §3.8–§3.10 |
| `profile`/`password`/`email`/`sessions`/`tokens`/`mfa` | P3 暫緩 | 未實作;個人自助指令規格見 #11(§3.7),伺服器端 API 見 alterminal/bear#35 | | `profile`/`password`/`email`/`sessions`/`tokens`/`mfa` | P3 暫緩 | 未實作;個人自助指令規格見 #11(§3.7),伺服器端 API 見 alterminal/bear#35 |
退出碼差異:`login`/`whoami` 的 token 無效(401)依 §3.1 為 `3`(本節實作一致)。 退出碼差異:`login`/`whoami` 的 token 無效(401)依 §3.1 為 `3`(本節實作一致)。
+348
View File
@@ -0,0 +1,348 @@
defmodule BearCli.Accounts do
@moduledoc """
`bear accounts` 指令群(帳號管理;docs/commands.md §3.9、issue #12)。
對應伺服器端帳號管理 JSON API(alterminal/bear#46,`/api/v1/accounts`、
PAT Bearer、admin 限定)。認證沿用既有 PAT 憑證(`BEAR_TOKEN` 或憑證檔)。
CLI 對外介面一律以 `email` 識別帳號(人類可讀、唯一);API 路徑參數為
UUID,由本模組先以 list 分頁比對解析。帳號 JSON 不含 `hash_password`、
`totp_secret` 等機密欄位(API 端保證),CLI 亦不顯示。
`create`/`set-password` 未給 `--password` 時由 CLI 產生隨機密碼,並只在
成功當下一次性輸出(不寫入憑證檔/log/`--verbose`);密碼一律不進命令列
(避免 shell history/`ps`),改以互動輸入(不回顧)或 `--generate-password`。
敏感規則與伺服器端一致:不可移除自己的 admin 角色(403)、不可刪除自己(403)。
退出碼:0 成功;1 404/422;2 用法錯誤;3 未登入或 401;6 網路/伺服器
錯誤;8 權限不足(403,僅限 admin)。
"""
import BearCli.Admin, only: [context: 1, fail: 3, format_api_error: 2]
alias BearCli.Api
@list_per_page_fetch 100
@max_fetch_pages 50
# -- 入口 --
@doc """
執行 `bear accounts <動詞>`,回傳退出碼。`opts[:accounts_api]` 可注入假
API 模組供測試(需實作 `accounts_list/3`、`accounts_create/3`、
`accounts_get/3`、`accounts_update_role/4`、`accounts_set_password/4`、
`accounts_delete/3`)。
"""
def run(verb, opts) do
api = opts[:accounts_api] || Api
with {:ok, ctx} <- context(opts) do
execute(verb, ctx, opts, api)
else
{:error, message, code} -> fail(opts, message, code)
end
end
# -- 各動詞 --
defp execute(:list, ctx, opts, api) do
params = [page: opts[:page] || 1, per_page: opts[:per_page] || 20]
case api.accounts_list(ctx.issuer, ctx.token, params) do
{:ok, body} ->
accounts = body["data"] || []
page = body["page"] || params[:page]
per_page = body["per_page"] || params[:per_page]
total = body["total"] || length(accounts)
render_list(opts, accounts, page, per_page, total)
0
{:error, _kind, _detail} = error ->
fail_api(opts, ctx, error)
end
end
defp execute(:show, ctx, opts, api) do
with {:ok, account} <- resolve_account(ctx, opts[:email_arg], api) do
case api.accounts_get(ctx.issuer, ctx.token, account["id"]) do
{:ok, body} ->
show_account(body["data"] || %{}, opts)
0
{:error, _kind, _detail} = error ->
fail_api(opts, ctx, error)
end
else
{:error, message, code} -> fail(opts, message, code)
end
end
defp execute(:create, ctx, opts, api) do
with {:ok, password} <- read_password(opts) do
attrs = %{"email" => opts[:email], "hash_password" => password}
attrs = if opts[:role], do: Map.put(attrs, "role", opts[:role]), else: attrs
case api.accounts_create(ctx.issuer, ctx.token, attrs) do
{:ok, body} ->
account = body["data"] || %{}
if opts[:json] do
IO.puts(Jason.encode!(%{ok: true, account: account, initial_password: password}))
else
IO.puts("帳號已建立:#{account["email"]}(#{account["role"]})")
print_password_block(password)
end
0
{:error, _kind, _detail} = error ->
fail_api(opts, ctx, error)
end
else
{:error, message, code} -> fail(opts, message, code)
end
end
defp execute(:update, ctx, opts, api) do
with {:ok, account} <- resolve_account(ctx, opts[:email_arg], api) do
case api.accounts_update_role(ctx.issuer, ctx.token, account["id"], %{"role" => opts[:role]}) do
{:ok, body} ->
updated = body["data"] || %{}
if opts[:json] do
IO.puts(Jason.encode!(%{ok: true, account: updated}))
else
IO.puts("#{updated["email"]}:角色 → #{updated["role"]}")
end
0
{:error, _kind, _detail} = error ->
fail_api(opts, ctx, error)
end
else
{:error, message, code} -> fail(opts, message, code)
end
end
defp execute(:"set-password", ctx, opts, api) do
with {:ok, account} <- resolve_account(ctx, opts[:email_arg], api),
{:ok, password} <- read_password(opts) do
case api.accounts_set_password(ctx.issuer, ctx.token, account["id"], %{
"hash_password" => password
}) do
{:ok, _body} ->
if opts[:json] do
IO.puts(Jason.encode!(%{ok: true, email: account["email"], new_password: password}))
else
IO.puts("已為 #{account["email"]} 設定新密碼。")
print_password_block(password)
end
0
{:error, _kind, _detail} = error ->
fail_api(opts, ctx, error)
end
else
{:error, message, code} -> fail(opts, message, code)
end
end
defp execute(:delete, ctx, opts, api) do
with {:ok, account} <- resolve_account(ctx, opts[:email_arg], api) do
case api.accounts_delete(ctx.issuer, ctx.token, account["id"]) do
{:ok, _body} ->
if opts[:json] do
IO.puts(Jason.encode!(%{ok: true, email: account["email"], deleted: true}))
else
IO.puts("已刪除帳號:#{account["email"]}")
end
0
{:error, _kind, _detail} = error ->
fail_api(opts, ctx, error)
end
else
{:error, message, code} -> fail(opts, message, code)
end
end
# -- email → UUID 解析(分頁全量列舉比對;設頁數上限避免無限迴圈)--
defp resolve_account(_ctx, nil, _api), do: {:error, "缺少 <email> 參數", 2}
defp resolve_account(ctx, email, api) do
with {:ok, all} <- fetch_all(ctx, api) do
case Enum.find(all, &(&1["email"] == email)) do
nil -> {:error, "找不到 email 為 #{email} 的帳號", 1}
account -> {:ok, account}
end
else
{:error, message, code} -> {:error, message, code}
end
end
defp fetch_all(ctx, api) do
do_fetch_all(ctx, api, 1, [])
end
defp do_fetch_all(_ctx, _api, page, acc) when page > @max_fetch_pages, do: {:ok, acc}
defp do_fetch_all(ctx, api, page, acc) do
case api.accounts_list(ctx.issuer, ctx.token, page: page, per_page: @list_per_page_fetch) do
{:ok, body} ->
entries = body["data"] || []
acc = acc ++ entries
total = body["total"]
if entries == [] or length(entries) < @list_per_page_fetch or
(is_integer(total) and length(acc) >= total) do
{:ok, acc}
else
do_fetch_all(ctx, api, page + 1, acc)
end
{:error, _kind, _detail} = error ->
{message, code} = format_api_error(ctx, error)
{:error, message, code}
end
end
# -- 密碼輸入(不進命令列;非 TTY 且未 --generate-password → 用法錯誤)--
defp read_password(%{generate_password: true}), do: {:ok, generate_password()}
defp read_password(_opts) do
if tty?() do
password = prompt_password("新密碼(至少 8 字元,含字母與數字):")
confirm = prompt_password("再次輸入新密碼:")
cond do
password != confirm ->
{:error, "兩次輸入的密碼不一致", 2}
weak_password?(password) ->
{:error, "密碼至少 8 字元且須包含字母與數字", 2}
true ->
{:ok, password}
end
else
{:error, "非 TTY 環境無法互動輸入密碼;請加 --generate-password 由 CLI 產生", 2}
end
end
@password_chars "ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnpqrstuvwxyz23456789"
@password_length 16
defp generate_password do
@password_chars
|> String.codepoints()
|> Enum.take_random(@password_length)
|> Enum.join()
end
defp weak_password?(password) when is_binary(password) do
String.length(password) >= 8 and Regex.match?(~r/[a-zA-Z]/, password) and
Regex.match?(~r/[0-9]/, password)
end
defp weak_password?(_), do: true
defp tty? do
:io.columns() != {:error, :enotsup}
end
defp prompt_password(prompt) do
IO.puts(:stderr, prompt)
IO.gets("") |> String.trim_trailing("\n")
end
# -- 輸出 --
defp render_list(opts, accounts, page, per_page, total) do
if opts[:json] do
IO.puts(
Jason.encode!(%{
ok: true,
page: page,
per_page: per_page,
total: total,
accounts: accounts
})
)
else
print_table(accounts)
end
end
@table_headers ["EMAIL", "ROLE", "TOTP", "CREATED AT"]
defp print_table(accounts) do
rows =
Enum.map(accounts, fn account ->
[
account["email"] || "",
account["role"] || "",
totp_label(account["totp_enabled"]),
account["created_at"] || ""
]
end)
widths =
Enum.with_index(@table_headers, fn _header, i ->
Enum.max([
String.length(Enum.at(@table_headers, i))
| Enum.map(rows, &String.length(Enum.at(&1, i)))
])
end)
render_row = fn cells ->
cells
|> Enum.with_index()
|> Enum.map(fn {cell, i} -> String.pad_trailing(cell, Enum.at(widths, i)) end)
|> Enum.join(" ")
|> String.trim_trailing()
end
IO.puts(render_row.(@table_headers))
Enum.each(rows, fn cells -> IO.puts(render_row.(cells)) end)
end
@account_fields ~w(id email role totp_enabled created_at updated_at)
defp show_account(account, opts) do
if opts[:json] do
IO.puts(Jason.encode!(%{ok: true, account: account}))
else
Enum.each(@account_fields, fn field ->
IO.puts("#{String.pad_trailing(field, 16)}: #{format_account_value(account[field])}")
end)
end
end
defp format_account_value(nil), do: "(無)"
defp format_account_value(true), do: "已啟用"
defp format_account_value(false), do: "未啟用"
defp format_account_value(value) when is_binary(value), do: value
defp format_account_value(value), do: Jason.encode!(value)
defp totp_label(true), do: "on"
defp totp_label(false), do: "off"
defp totp_label(_), do: "(未知)"
# 初始/新密碼只在成功當下一次性輸出(不寫入憑證檔/log/--verbose)。
defp print_password_block(password) do
IO.puts("初始密碼(只顯示這一次,請立即保存並轉交當事人):")
IO.puts(" #{password}")
end
# -- 錯誤處理 --
defp fail_api(opts, ctx, error) do
{message, code} = format_api_error(ctx, error)
fail(opts, message, code)
end
end
+273
View File
@@ -0,0 +1,273 @@
defmodule BearCli.Admin do
@moduledoc """
`bear jwks`/`bear accounts`/`bear audit-logs` 管理端指令群的共用層
(docs/commands.md §3.8–§3.10、issue #12)。
`parse/3` 由 `BearCli.CLI` 的 fallback 分派呼叫,負責解析三個資源群組的
子指令與選項並做本地用法驗證;`context/1`/`fail/3`/`format_api_error/3`
為各群組模組共用的背景與錯誤處理。
"""
alias BearCli.{Accounts, AuditLogs, Config, Credentials, Jwks}
@jwks_verbs ~w(list show create toggle)
@accounts_verbs ~w(list show create update set-password delete)
@audit_logs_verbs ~w(list)
@jwks_create_switches [kid: :string, alg: :string]
@accounts_list_switches [page: :integer, per_page: :integer]
@accounts_create_switches [email: :string, role: :string, generate_password: :boolean]
@accounts_update_switches [role: :string]
@accounts_set_password_switches [generate_password: :boolean]
@audit_logs_list_switches [page: :integer, per_page: :integer, category: :string]
@algs ~w(RS256 RS384 RS512 ES256 ES384 ES512)
@roles ~w(user admin)
@global_switches [
issuer: :string,
config: :string,
json: :boolean,
verbose: :boolean,
help: :boolean,
version: :boolean
]
# -- 解析(非管理端指令回 :error,交回 CLI 報未知指令)--
@doc """
解析 `jwks`/`accounts`/`audit-logs` 群組的 argv,回傳 `{:ok, {module, verb}, opts}`
或 `{:error, message, code}`;非本層負責的指令回 `:error`。
"""
def parse(["jwks" | rest], global), do: parse_group("jwks", @jwks_verbs, rest, global)
def parse(["accounts" | rest], global),
do: parse_group("accounts", @accounts_verbs, rest, global)
def parse(["audit-logs" | rest], global),
do: parse_group("audit-logs", @audit_logs_verbs, rest, global)
def parse(_, _), do: :error
defp parse_group(group, verbs, rest, global) do
case rest do
[verb | args] ->
if verb in verbs do
switches = group_switches(group, verb)
case OptionParser.parse(args, strict: @global_switches ++ switches) do
{opts, positionals, []} ->
validate(group, verb, positionals, merge_opts(global, opts_to_map(opts)))
{_opts, _extra, [{opt, _} | _]} ->
{:error, "無法解析選項:#{opt}", 2}
end
else
{:error, "未知的 #{group} 子指令:#{verb}(可用:#{Enum.join(verbs, " ")})", 2}
end
[] ->
{:error, "#{group} 缺少子指令(可用:#{Enum.join(verbs, " ")})", 2}
end
end
defp group_switches("jwks", "list"), do: []
defp group_switches("jwks", "show"), do: []
defp group_switches("jwks", "create"), do: @jwks_create_switches
defp group_switches("jwks", "toggle"), do: []
defp group_switches("accounts", "list"), do: @accounts_list_switches
defp group_switches("accounts", "show"), do: []
defp group_switches("accounts", "create"), do: @accounts_create_switches
defp group_switches("accounts", "update"), do: @accounts_update_switches
defp group_switches("accounts", "set-password"), do: @accounts_set_password_switches
defp group_switches("accounts", "delete"), do: []
defp group_switches("audit-logs", "list"), do: @audit_logs_list_switches
# keyword 轉 map(本層無 :keep 選項,直接 Map.new)。
defp opts_to_map(opts), do: Map.new(opts)
defp merge_opts(global, opts), do: Map.merge(Map.new(global), opts)
# -- 本地用法驗證(用法錯誤 → 退出碼 2)--
# jwks
defp validate("jwks", "list", [], opts), do: {:ok, {Jwks, :list}, opts}
defp validate("jwks", "list", extra, _opts), do: positional_error("jwks list", extra, 0)
defp validate("jwks", "show", [kid], opts),
do: {:ok, {Jwks, :show}, Map.put(opts, :kid_arg, kid)}
defp validate("jwks", "show", [], _opts), do: {:error, "jwks show 缺少 <kid>", 2}
defp validate("jwks", "show", extra, _opts), do: positional_error("jwks show", extra, 1)
defp validate("jwks", "create", [], opts) do
cond do
blank?(opts[:kid]) ->
{:error, "jwks create 缺少必選參數:--kid", 2}
opts[:alg] && opts[:alg] not in @algs ->
{:error, "--alg 不接受的值:#{opts[:alg]}(可用:#{Enum.join(@algs, "、")})", 2}
true ->
{:ok, {Jwks, :create}, opts}
end
end
defp validate("jwks", "create", extra, _opts), do: positional_error("jwks create", extra, 0)
defp validate("jwks", "toggle", [kid], opts),
do: {:ok, {Jwks, :toggle}, Map.put(opts, :kid_arg, kid)}
defp validate("jwks", "toggle", [], _opts), do: {:error, "jwks toggle 缺少 <kid>", 2}
defp validate("jwks", "toggle", extra, _opts), do: positional_error("jwks toggle", extra, 1)
# accounts
defp validate("accounts", "list", [], opts), do: {:ok, {Accounts, :list}, opts}
defp validate("accounts", "list", extra, _opts), do: positional_error("accounts list", extra, 0)
defp validate("accounts", "show", [email], opts),
do: {:ok, {Accounts, :show}, Map.put(opts, :email_arg, email)}
defp validate("accounts", "show", [], _opts), do: {:error, "accounts show 缺少 <email>", 2}
defp validate("accounts", "show", extra, _opts), do: positional_error("accounts show", extra, 1)
defp validate("accounts", "create", [], opts) do
cond do
blank?(opts[:email]) ->
{:error, "accounts create 缺少必選參數:--email", 2}
opts[:role] && opts[:role] not in @roles ->
{:error, "--role 不接受的值:#{opts[:role]}(可用:#{Enum.join(@roles, "、")})", 2}
true ->
{:ok, {Accounts, :create}, opts}
end
end
defp validate("accounts", "create", extra, _opts),
do: positional_error("accounts create", extra, 0)
defp validate("accounts", "update", [email], opts) do
if blank?(opts[:role]) or opts[:role] not in @roles do
{:error, "accounts update 必須給 --role user|admin", 2}
else
{:ok, {Accounts, :update}, Map.put(opts, :email_arg, email)}
end
end
defp validate("accounts", "update", [], _opts), do: {:error, "accounts update 缺少 <email>", 2}
defp validate("accounts", "update", extra, _opts),
do: positional_error("accounts update", extra, 1)
defp validate("accounts", "set-password", [email], opts),
do: {:ok, {Accounts, :"set-password"}, Map.put(opts, :email_arg, email)}
defp validate("accounts", "set-password", [], _opts),
do: {:error, "accounts set-password 缺少 <email>", 2}
defp validate("accounts", "set-password", extra, _opts),
do: positional_error("accounts set-password", extra, 1)
defp validate("accounts", "delete", [email], opts),
do: {:ok, {Accounts, :delete}, Map.put(opts, :email_arg, email)}
defp validate("accounts", "delete", [], _opts), do: {:error, "accounts delete 缺少 <email>", 2}
defp validate("accounts", "delete", extra, _opts),
do: positional_error("accounts delete", extra, 1)
# audit-logs
defp validate("audit-logs", "list", [], opts), do: {:ok, {AuditLogs, :list}, opts}
defp validate("audit-logs", "list", extra, _opts),
do: positional_error("audit-logs list", extra, 0)
defp positional_error(command, extra, _max) do
{:error, "#{command} 不接受位置參數:#{Enum.join(extra, " ")}", 2}
end
# -- 共用背景(token/issuer;三個群組模組共用)--
@doc "解析 token/issuer 背景,回傳 {:ok, ctx} 或 {:error, message, code}。"
def context(opts) do
if token = Config.env_token() do
# BEAR_TOKEN 優先於憑證檔(不讀檔、不寫檔)。
{:ok, %{token: token, issuer: resolve_issuer(opts, nil)}}
else
case Credentials.load() do
{:ok, creds} ->
token = creds["access_token"]
if blank?(token) do
{:error, "憑證檔缺少 access_token,請重新 bear login", 7}
else
{:ok, %{token: token, issuer: resolve_issuer(opts, creds["issuer"])}}
end
:error ->
{:error, "未登入(請先執行 bear login)", 3}
end
end
end
defp resolve_issuer(opts, stored_issuer) do
opts[:issuer] || stored_issuer || Config.resolve_issuer(nil, opts[:config])
end
# -- 共用錯誤處理 --
@doc "輸出錯誤(--json 走 stdout JSON、人類模式走 stderr),回傳退出碼。"
def fail(opts, message, code) do
if opts[:json] do
IO.puts(Jason.encode!(%{ok: false, error: message, code: code}))
else
IO.puts(:stderr, "錯誤:#{message}")
end
code
end
@doc "API 錯誤 → 訊息與退出碼(管理端共通對應)。"
def format_api_error(_ctx, {:error, :unauthorized, desc}) do
{"token 無效或已過期(#{desc}),請重新 bear login", 3}
end
def format_api_error(_ctx, {:error, :forbidden, _desc}) do
{"此操作需 admin 權限(HTTP 403)", 8}
end
def format_api_error(_ctx, {:error, :not_found, _desc}) do
{"找不到目標資源(HTTP 404)", 1}
end
def format_api_error(_ctx, {:error, :unprocessable_entity, body}) do
details =
body
|> Map.get("errors", %{})
|> Enum.map(fn {field, messages} ->
"#{field}: #{Enum.join(List.wrap(messages), "、")}"
end)
|> Enum.join(";")
if details == "" do
{"驗證失敗(HTTP 422)", 1}
else
{"驗證失敗(HTTP 422):#{details}", 1}
end
end
def format_api_error(_ctx, {:error, :server_error, status}) do
{"伺服器回應 #{status}", 6}
end
def format_api_error(ctx, {:error, :network, reason}) do
{"無法連線到 #{ctx.issuer}:#{reason}", 6}
end
defp blank?(nil), do: true
defp blank?(""), do: true
defp blank?(_), do: false
end
+88 -7
View File
@@ -61,12 +61,12 @@ defmodule BearCli.Api do
成功回 `{:ok, %{"data" => [apps], "page" => n, "per_page" => n, "total" => n}}`。 成功回 `{:ok, %{"data" => [apps], "page" => n, "per_page" => n, "total" => n}}`。
""" """
def apps_list(issuer, token, params \\ []) do def apps_list(issuer, token, params \\ []) do
apps_request(issuer, token, :get, "/api/v1/apps", params: params) api_request(issuer, token, :get, "/api/v1/apps", params: params)
end end
@doc "`GET /api/v1/apps/{id}`:單一 App(`client_secret` 永不回傳)。" @doc "`GET /api/v1/apps/{id}`:單一 App(`client_secret` 永不回傳)。"
def apps_get(issuer, token, id) do def apps_get(issuer, token, id) do
apps_request(issuer, token, :get, "/api/v1/apps/" <> URI.encode(id)) api_request(issuer, token, :get, "/api/v1/apps/" <> URI.encode(id))
end end
@doc """ @doc """
@@ -75,12 +75,12 @@ defmodule BearCli.Api do
(`%{"data" => app, "client_secret" => secret}`)。 (`%{"data" => app, "client_secret" => secret}`)。
""" """
def apps_create(issuer, token, attrs) do def apps_create(issuer, token, attrs) do
apps_request(issuer, token, :post, "/api/v1/apps", json: attrs) api_request(issuer, token, :post, "/api/v1/apps", json: attrs)
end end
@doc "`PUT /api/v1/apps/{id}`:部分更新(只送有給的欄位)。" @doc "`PUT /api/v1/apps/{id}`:部分更新(只送有給的欄位)。"
def apps_update(issuer, token, id, attrs) do def apps_update(issuer, token, id, attrs) do
apps_request(issuer, token, :put, "/api/v1/apps/" <> URI.encode(id), json: attrs) api_request(issuer, token, :put, "/api/v1/apps/" <> URI.encode(id), json: attrs)
end end
@doc """ @doc """
@@ -88,21 +88,21 @@ defmodule BearCli.Api do
一次性明文。PKCE App 回 422 `%{"error" => "pkce_app"}`。 一次性明文。PKCE App 回 422 `%{"error" => "pkce_app"}`。
""" """
def apps_rotate_secret(issuer, token, id) do def apps_rotate_secret(issuer, token, id) do
apps_request(issuer, token, :post, "/api/v1/apps/" <> URI.encode(id) <> "/rotate-secret", api_request(issuer, token, :post, "/api/v1/apps/" <> URI.encode(id) <> "/rotate-secret",
json: %{} json: %{}
) )
end end
@doc "`POST /api/v1/apps/{id}/toggle`:切換 active ↔ inactive。" @doc "`POST /api/v1/apps/{id}/toggle`:切換 active ↔ inactive。"
def apps_toggle(issuer, token, id) do def apps_toggle(issuer, token, id) do
apps_request(issuer, token, :post, "/api/v1/apps/" <> URI.encode(id) <> "/toggle", json: %{}) api_request(issuer, token, :post, "/api/v1/apps/" <> URI.encode(id) <> "/toggle", json: %{})
end end
# App 管理 API 共用請求。回傳: # App 管理 API 共用請求。回傳:
# {:ok, body} | {:error, :unauthorized, desc} | {:error, :forbidden, desc} # {:ok, body} | {:error, :unauthorized, desc} | {:error, :forbidden, desc}
# | {:error, :not_found, desc} | {:error, :unprocessable_entity, body} # | {:error, :not_found, desc} | {:error, :unprocessable_entity, body}
# | {:error, :server_error, status} | {:error, :network, reason} # | {:error, :server_error, status} | {:error, :network, reason}
defp apps_request(issuer, token, method, path, extra \\ []) do defp api_request(issuer, token, method, path, extra \\ []) do
url = String.trim_trailing(issuer, "/") <> path url = String.trim_trailing(issuer, "/") <> path
opts = opts =
@@ -136,4 +136,85 @@ defmodule BearCli.Api do
{:error, :network, Exception.message(exception)} {:error, :network, Exception.message(exception)}
end end
end end
@doc "`GET /api/v1/jwks`: list all keys (active and inactive), newest first (no pagination)."
def jwks_list(issuer, token) do
api_request(issuer, token, :get, "/api/v1/jwks")
end
@doc """
`POST /api/v1/jwks`: create a new signing key. attrs: `%{"kid" => "...", "alg" => "RS256"}`
(`alg` optional; RS256/384/512, ES256/384/512). Key material is never serialized.
"""
def jwks_create(issuer, token, attrs) do
api_request(issuer, token, :post, "/api/v1/jwks", json: attrs)
end
@doc "`GET /api/v1/jwks/{id}`: single key (public metadata only)."
def jwks_get(issuer, token, id) do
api_request(issuer, token, :get, "/api/v1/jwks/" <> URI.encode(id))
end
@doc "`POST /api/v1/jwks/{id}/toggle`: switch key between active and inactive."
def jwks_toggle(issuer, token, id) do
api_request(issuer, token, :post, "/api/v1/jwks/" <> URI.encode(id) <> "/toggle", json: %{})
end
# -- Accounts API (alterminal/bear#46; PAT Bearer, admin only) --
@doc """
`GET /api/v1/accounts`: paginated list (newest first; per_page max 100).
Returns `{:ok, %{"data" => [accounts], "page" => n, "per_page" => n, "total" => n}}`.
"""
def accounts_list(issuer, token, params \\ []) do
api_request(issuer, token, :get, "/api/v1/accounts", params: params)
end
@doc """
`POST /api/v1/accounts`: create an account directly (no email verification).
attrs: `%{"email" => "...", "hash_password" => "<plaintext>", "role" => "user|admin"}`
(`role` optional, default `user`).
"""
def accounts_create(issuer, token, attrs) do
api_request(issuer, token, :post, "/api/v1/accounts", json: attrs)
end
@doc "`GET /api/v1/accounts/{id}`: single account (no credential fields)."
def accounts_get(issuer, token, id) do
api_request(issuer, token, :get, "/api/v1/accounts/" <> URI.encode(id))
end
@doc """
`PUT /api/v1/accounts/{id}`: update role; attrs: `%{"role" => "user|admin"}`.
"""
def accounts_update_role(issuer, token, id, attrs) do
api_request(issuer, token, :put, "/api/v1/accounts/" <> URI.encode(id), json: attrs)
end
@doc """
`PUT /api/v1/accounts/{id}/password`: admin sets a new password (no old password
needed); attrs: `%{"hash_password" => "<plaintext>"}`.
"""
def accounts_set_password(issuer, token, id, attrs) do
api_request(issuer, token, :put, "/api/v1/accounts/" <> URI.encode(id) <> "/password",
json: attrs
)
end
@doc "`DELETE /api/v1/accounts/{id}`: hard-delete an account (admin path). Returns `{:ok, %{}}` (204 empty)."
def accounts_delete(issuer, token, id) do
api_request(issuer, token, :delete, "/api/v1/accounts/" <> URI.encode(id))
end
# -- Audit logs API (alterminal/bear#46; PAT Bearer, admin only) --
@doc """
`GET /api/v1/audit-logs`: paginated list (newest first). params: `page:` /
`per_page:` (max 200) / `category:` filter. Returns `{:ok, %{"data" => [entries],
"page" => n, "per_page" => n, "total" => n, "total_pages" => n,
"emails" => %{id => email}}}`.
"""
def audit_logs_list(issuer, token, params \\ []) do
api_request(issuer, token, :get, "/api/v1/audit-logs", params: params)
end
end end
+103
View File
@@ -0,0 +1,103 @@
defmodule BearCli.AuditLogs do
@moduledoc """
`bear audit-logs` 指令群(稽核日誌;docs/commands.md §3.10、issue #12)。
對應伺服器端稽核日誌 JSON API(alterminal/bear#46,`/api/v1/audit-logs`、
PAT Bearer、admin 限定)。認證沿用既有 PAT 憑證(`BEAR_TOKEN` 或憑證檔)。
退出碼:0 成功;2 用法錯誤;3 未登入或 401;6 網路/伺服器錯誤;
8 權限不足(403,僅限 admin)。
"""
import BearCli.Admin, only: [context: 1, fail: 3, format_api_error: 2]
alias BearCli.Api
# -- 入口 --
@doc """
執行 `bear audit-logs <動詞>`,回傳退出碼。`opts[:audit_logs_api]` 可注入
假 API 模組供測試(需實作 `audit_logs_list/3`)。
"""
def run(:list, opts) do
api = opts[:audit_logs_api] || Api
with {:ok, ctx} <- context(opts) do
params =
[page: opts[:page] || 1, per_page: opts[:per_page] || 50]
|> maybe_put(:category, opts[:category])
case api.audit_logs_list(ctx.issuer, ctx.token, params) do
{:ok, body} ->
entries = body["data"] || []
if opts[:json] do
IO.puts(
Jason.encode!(
Map.take(body, ["page", "per_page", "total", "total_pages", "emails"])
|> Map.merge(%{ok: true, entries: entries})
)
)
else
print_table(entries, body["emails"] || %{})
end
0
{:error, _kind, _detail} = error ->
{message, code} = format_api_error(ctx, error)
fail(opts, message, code)
end
else
{:error, message, code} -> fail(opts, message, code)
end
end
defp maybe_put(params, _key, nil), do: params
defp maybe_put(params, _key, ""), do: params
defp maybe_put(params, key, value), do: Keyword.put(params, key, value)
# -- 輸出 --
@table_headers ["TIME", "CATEGORY", "EVENT", "ACTOR", "ACCOUNT"]
defp print_table(entries, emails) do
rows =
Enum.map(entries, fn entry ->
[
entry["created_at"] || "",
entry["category"] || "",
entry["event"] || "",
email_of(emails, entry["actor_id"]),
email_of(emails, entry["account_id"])
]
end)
widths =
Enum.with_index(@table_headers, fn _header, i ->
Enum.max([
String.length(Enum.at(@table_headers, i))
| Enum.map(rows, &String.length(Enum.at(&1, i)))
])
end)
render_row = fn cells ->
cells
|> Enum.with_index()
|> Enum.map(fn {cell, i} -> String.pad_trailing(cell, Enum.at(widths, i)) end)
|> Enum.join(" ")
|> String.trim_trailing()
end
IO.puts(render_row.(@table_headers))
Enum.each(rows, fn cells -> IO.puts(render_row.(cells)) end)
end
defp email_of(_emails, nil), do: "-"
defp email_of(emails, id) do
case Map.get(emails, id) do
nil -> String.slice(id || "", 0, 8)
email -> email
end
end
end
+25 -1
View File
@@ -8,7 +8,7 @@ defmodule BearCli.CLI do
優先使用該值,不讀寫本機憑證檔。 優先使用該值,不讀寫本機憑證檔。
""" """
alias BearCli.{Api, Apps, Config, Credentials} alias BearCli.{Accounts, Admin, Api, Apps, AuditLogs, Config, Credentials, Jwks}
@global_switches [ @global_switches [
issuer: :string, issuer: :string,
@@ -177,6 +177,14 @@ defmodule BearCli.CLI do
end end
end end
# 管理端指令群(jwks/accounts/audit-logs;解析委由 BearCli.Admin)
defp parse_command(group, args, global) when group in ~w(jwks accounts audit-logs) do
case Admin.parse([group | args], global) do
:error -> {:error, "未知指令:#{group}(可用 bear --help 查看說明)", 2}
parsed -> parsed
end
end
defp parse_command(unknown, _args, _global) do defp parse_command(unknown, _args, _global) do
{:error, "未知指令:#{unknown}(可用 bear --help 查看說明)", 2} {:error, "未知指令:#{unknown}(可用 bear --help 查看說明)", 2}
end end
@@ -345,6 +353,19 @@ defmodule BearCli.CLI do
apps_api = cmd_opts[:apps_api] || opts[:apps_api] || Api apps_api = cmd_opts[:apps_api] || opts[:apps_api] || Api
Apps.run(verb, Map.put(cmd_opts, :apps_api, apps_api)) Apps.run(verb, Map.put(cmd_opts, :apps_api, apps_api))
# 管理端指令群(jwks/accounts/audit-logs;各自注入對應的 api 模組)
{:ok, {Jwks, verb}, cmd_opts} when is_atom(verb) ->
jwks_api = cmd_opts[:jwks_api] || opts[:jwks_api] || Api
Jwks.run(verb, Map.put(cmd_opts, :jwks_api, jwks_api))
{:ok, {Accounts, verb}, cmd_opts} when is_atom(verb) ->
accounts_api = cmd_opts[:accounts_api] || opts[:accounts_api] || Api
Accounts.run(verb, Map.put(cmd_opts, :accounts_api, accounts_api))
{:ok, {AuditLogs, verb}, cmd_opts} when is_atom(verb) ->
audit_logs_api = cmd_opts[:audit_logs_api] || opts[:audit_logs_api] || Api
AuditLogs.run(verb, Map.put(cmd_opts, :audit_logs_api, audit_logs_api))
{:ok, command, cmd_opts} -> {:ok, command, cmd_opts} ->
cond do cond do
cmd_opts[:version] -> cmd_opts[:version] ->
@@ -653,6 +674,9 @@ defmodule BearCli.CLI do
logout 登出(清除本機憑證) logout 登出(清除本機憑證)
status 顯示登入狀態 status 顯示登入狀態
apps <動詞> App 管理(admin;bear apps --help 查看) apps <動詞> App 管理(admin;bear apps --help 查看)
jwks <動詞> 簽章金鑰管理(admin)
accounts <動詞> 帳號管理(admin)
audit-logs list 稽核日誌(admin)
apps 指令群(需 admin 權限的 PAT): apps 指令群(需 admin 權限的 PAT):
apps list [--visibility public|internal] [--status active|inactive] apps list [--visibility public|internal] [--status active|inactive]
+198
View File
@@ -0,0 +1,198 @@
defmodule BearCli.Jwks do
@moduledoc """
`bear jwks` 指令群(簽章金鑰管理;docs/commands.md §3.8、issue #12)。
對應伺服器端 JWK 管理 JSON API(alterminal/bear#46,`/api/v1/jwks`、
PAT Bearer、admin 限定)。認證沿用既有 PAT 憑證(`BEAR_TOKEN` 或憑證檔)。
金鑰材質(`key_data`)永不經 CLI 顯示(API 端即不序列化);本群組只管理
公開中繼資料(kid/kty/alg/active 等)。
退出碼:0 成功;1 404/422;2 用法錯誤;3 未登入或 401;6 網路/伺服器
錯誤;8 權限不足(403,僅限 admin)。
"""
import BearCli.Admin, only: [context: 1, fail: 3, format_api_error: 2]
alias BearCli.Api
# -- 入口 --
@doc """
執行 `bear jwks <動詞>`,回傳退出碼。`opts[:jwks_api]` 可注入假 API 模組
供測試(需實作 `jwks_list/2`、`jwks_create/3`、`jwks_get/3`、`jwks_toggle/3`)。
"""
def run(verb, opts) do
api = opts[:jwks_api] || Api
with {:ok, ctx} <- context(opts) do
execute(verb, ctx, opts, api)
else
{:error, message, code} -> fail(opts, message, code)
end
end
# -- 各動詞 --
defp execute(:list, ctx, opts, api) do
case api.jwks_list(ctx.issuer, ctx.token) do
{:ok, body} ->
render_list(opts, body["data"] || [])
0
{:error, _kind, _detail} = error ->
fail_api(opts, ctx, error)
end
end
defp execute(:show, ctx, opts, api) do
with {:ok, key} <- resolve_key(ctx, opts[:kid_arg], api) do
case api.jwks_get(ctx.issuer, ctx.token, key["id"]) do
{:ok, body} ->
show_key(body["data"] || %{}, opts)
0
{:error, _kind, _detail} = error ->
fail_api(opts, ctx, error)
end
else
{:error, message, code} -> fail(opts, message, code)
end
end
defp execute(:create, ctx, opts, api) do
attrs = %{"kid" => opts[:kid], "alg" => opts[:alg] || "RS256"}
case api.jwks_create(ctx.issuer, ctx.token, attrs) do
{:ok, body} ->
key = body["data"] || %{}
if opts[:json] do
IO.puts(Jason.encode!(%{ok: true, jwk: key}))
else
IO.puts("JWK 已建立:#{key["kid"]}(#{key["alg"]}/#{status_label(key)})")
end
0
{:error, _kind, _detail} = error ->
fail_api(opts, ctx, error)
end
end
defp execute(:toggle, ctx, opts, api) do
with {:ok, key} <- resolve_key(ctx, opts[:kid_arg], api) do
case api.jwks_toggle(ctx.issuer, ctx.token, key["id"]) do
{:ok, body} ->
updated = body["data"] || %{}
if opts[:json] do
IO.puts(
Jason.encode!(%{
ok: true,
jwk: %{id: updated["id"], kid: updated["kid"], active: updated["active"]}
})
)
else
IO.puts("#{key["kid"]}:#{status_label(key)} → #{status_label(updated)}")
end
0
{:error, _kind, _detail} = error ->
fail_api(opts, ctx, error)
end
else
{:error, message, code} -> fail(opts, message, code)
end
end
# -- kid → UUID 解析(API 路徑參數為 UUID,CLI 對外介面用 kid)--
defp resolve_key(_ctx, nil, _api), do: {:error, "缺少 <kid> 參數", 2}
defp resolve_key(ctx, kid, api) do
case api.jwks_list(ctx.issuer, ctx.token) do
{:ok, body} ->
case Enum.find(body["data"] || [], &(&1["kid"] == kid)) do
nil -> {:error, "找不到 kid 為 #{kid} 的金鑰", 1}
key -> {:ok, key}
end
{:error, _kind, _detail} = error ->
{message, code} = format_api_error(ctx, error)
{:error, message, code}
end
end
# -- 輸出 --
defp render_list(opts, keys) do
if opts[:json] do
IO.puts(Jason.encode!(%{ok: true, jwks: keys}))
else
print_table(keys)
end
end
@table_headers ["ID", "KID", "KTY", "ALG", "ACTIVE", "CREATED AT"]
defp print_table(keys) do
rows =
Enum.map(keys, fn key ->
[
String.slice(key["id"] || "", 0, 8),
key["kid"] || "",
key["kty"] || "",
key["alg"] || "",
status_label(key),
key["created_at"] || ""
]
end)
widths =
Enum.with_index(@table_headers, fn _header, i ->
Enum.max([
String.length(Enum.at(@table_headers, i))
| Enum.map(rows, &String.length(Enum.at(&1, i)))
])
end)
render_row = fn cells ->
cells
|> Enum.with_index()
|> Enum.map(fn {cell, i} -> String.pad_trailing(cell, Enum.at(widths, i)) end)
|> Enum.join(" ")
|> String.trim_trailing()
end
IO.puts(render_row.(@table_headers))
Enum.each(rows, fn cells -> IO.puts(render_row.(cells)) end)
end
@key_fields ~w(id kid kty alg use active created_at)
defp show_key(key, opts) do
if opts[:json] do
IO.puts(Jason.encode!(%{ok: true, jwk: key}))
else
Enum.each(@key_fields, fn field ->
IO.puts("#{String.pad_trailing(field, 14)}: #{format_key_value(key[field])}")
end)
end
end
defp format_key_value(nil), do: "(無)"
defp format_key_value(value) when is_binary(value), do: value
defp format_key_value(value), do: Jason.encode!(value)
defp status_label(%{"active" => true}), do: "active"
defp status_label(%{"active" => false}), do: "inactive"
defp status_label(_), do: "(未知)"
# -- 錯誤處理 --
defp fail_api(opts, ctx, error) do
{message, code} = format_api_error(ctx, error)
fail(opts, message, code)
end
end
+526
View File
@@ -0,0 +1,526 @@
defmodule BearCli.AdminCommandsTest do
@moduledoc """
`bear jwks`/`bear accounts`/`bear audit-logs` 管理端指令群單元測試(issue #12):
注入 fake API,涵蓋解析、輸出、退出碼與 401/403/404/422 分流。
"""
use ExUnit.Case, async: false
alias BearCli.{Accounts, AuditLogs, CLI, Jwks}
# -- fake API --
defmodule FakeApi do
@jwks [
%{
"id" => "0192cccc-0000-7000-8000-000000000001",
"kid" => "sig-2026-01",
"kty" => "RSA",
"alg" => "RS256",
"use" => "sig",
"active" => true,
"created_at" => "2026-09-09T00:00:00Z"
},
%{
"id" => "0192cccc-0000-7000-8000-000000000002",
"kid" => "sig-2025-12",
"kty" => "EC",
"alg" => "ES256",
"use" => "sig",
"active" => false,
"created_at" => "2025-12-01T00:00:00Z"
}
]
@accounts [
%{
"id" => "0192bbbb-0000-7000-8000-000000000001",
"email" => "admin@example.com",
"role" => "admin",
"totp_enabled" => true,
"created_at" => "2026-01-01T00:00:00Z",
"updated_at" => "2026-01-01T00:00:00Z"
},
%{
"id" => "0192bbbb-0000-7000-8000-000000000002",
"email" => "alice@example.com",
"role" => "user",
"totp_enabled" => false,
"created_at" => "2026-02-01T00:00:00Z",
"updated_at" => "2026-02-01T00:00:00Z"
}
]
@audit_entries [
%{
"id" => "0192dddd-0000-7000-8000-000000000001",
"event" => "account_created_by_admin",
"category" => "account",
"account_id" => "0192bbbb-0000-7000-8000-000000000002",
"actor_id" => "0192bbbb-0000-7000-8000-000000000001",
"ip" => "127.0.0.1",
"metadata" => %{"via" => "api"},
"created_at" => "2026-09-09T01:00:00Z"
}
]
@emails %{
"0192bbbb-0000-7000-8000-000000000001" => "admin@example.com",
"0192bbbb-0000-7000-8000-000000000002" => "alice@example.com"
}
def jwks_list(_issuer, _token), do: ok_or_error(%{"data" => @jwks})
def jwks_create(_issuer, _token, attrs) do
key = %{
"id" => "0192cccc-0000-7000-8000-000000000003",
"kid" => attrs["kid"],
"kty" => "RSA",
"alg" => attrs["alg"],
"use" => "sig",
"active" => true,
"created_at" => "2026-09-09T02:00:00Z"
}
ok_or_error(%{"data" => key})
end
def jwks_get(_issuer, _token, id) do
case Enum.find(@jwks, &(&1["id"] == id)) do
nil -> {:error, :not_found, "not_found"}
key -> ok_or_error(%{"data" => key})
end
end
def jwks_toggle(_issuer, _token, id) do
case Enum.find(@jwks, &(&1["id"] == id)) do
nil ->
{:error, :not_found, "not_found"}
key ->
new_active = !key["active"]
ok_or_error(%{"data" => %{key | "active" => new_active}})
end
end
def accounts_list(_issuer, _token, params) do
page = params[:page] || 1
per_page = params[:per_page] || 20
ok_or_error(%{
"data" => Enum.slice(@accounts, (page - 1) * per_page, per_page),
"page" => page,
"per_page" => per_page,
"total" => length(@accounts)
})
end
def accounts_create(_issuer, _token, attrs) do
account = %{
"id" => "0192bbbb-0000-7000-8000-000000000003",
"email" => attrs["email"],
"role" => attrs["role"] || "user",
"totp_enabled" => false,
"created_at" => "2026-09-09T00:00:00Z",
"updated_at" => "2026-09-09T00:00:00Z"
}
ok_or_error(%{"data" => account})
end
def accounts_get(_issuer, _token, id) do
case Enum.find(@accounts, &(&1["id"] == id)) do
nil -> {:error, :not_found, "not_found"}
account -> ok_or_error(%{"data" => account})
end
end
def accounts_update_role(_issuer, _token, id, attrs) do
case Enum.find(@accounts, &(&1["id"] == id)) do
nil ->
{:error, :not_found, "not_found"}
account ->
ok_or_error(%{"data" => %{account | "role" => attrs["role"]}})
end
end
def accounts_set_password(_issuer, _token, id, _attrs) do
case Enum.find(@accounts, &(&1["id"] == id)) do
nil -> {:error, :not_found, "not_found"}
_account -> ok_or_error(%{})
end
end
def accounts_delete(_issuer, _token, id) do
case Enum.find(@accounts, &(&1["id"] == id)) do
nil -> {:error, :not_found, "not_found"}
_account -> ok_or_error(%{})
end
end
def audit_logs_list(_issuer, _token, params) do
category = params[:category]
entries =
if category,
do: Enum.filter(@audit_entries, &(&1["category"] == category)),
else: @audit_entries
ok_or_error(%{
"data" => entries,
"page" => params[:page] || 1,
"per_page" => params[:per_page] || 50,
"total" => length(entries),
"total_pages" => 1,
"emails" => @emails
})
end
defp ok_or_error(body) do
if error = Process.get(:fake_api_error) do
error
else
{:ok, body}
end
end
end
# -- 測試輔助 --
setup do
old_token = System.get_env("BEAR_TOKEN")
old_creds = System.get_env("BEAR_CREDENTIALS")
on_exit(fn ->
restore(old_token, "BEAR_TOKEN")
restore(old_creds, "BEAR_CREDENTIALS")
end)
System.put_env("BEAR_TOKEN", "admin-pat")
System.put_env("BEAR_CREDENTIALS", "/nonexistent/credentials.json")
:ok
end
defp run_out(argv) do
ExUnit.CaptureIO.with_io(fn ->
CLI.dispatch(CLI.parse(argv), admin_apis())
end)
end
defp run_err(argv) do
ExUnit.CaptureIO.with_io(:stderr, "", fn ->
CLI.dispatch(CLI.parse(argv), admin_apis())
end)
end
defp admin_apis do
[jwks_api: FakeApi, accounts_api: FakeApi, audit_logs_api: FakeApi]
end
defp with_api_error(error) do
Process.put(:fake_api_error, error)
end
# -- jwks --
test "jwks list renders table" do
{code, out} = run_out(["jwks", "list"])
assert code == 0
assert out =~ "KID"
assert out =~ "sig-2026-01"
assert out =~ "sig-2025-12"
assert out =~ "active"
assert out =~ "inactive"
end
test "jwks list --json outputs spec shape" do
{code, out} = run_out(["jwks", "list", "--json"])
assert code == 0
assert {:ok, decoded} = Jason.decode(out)
assert decoded["ok"] == true
assert Enum.any?(decoded["jwks"], &(&1["kid"] == "sig-2026-01"))
# key_data 永不出現
refute out =~ "key_data"
end
test "jwks show resolves kid and prints public metadata" do
{code, out} = run_out(["jwks", "show", "sig-2026-01"])
assert code == 0
assert out =~ "kid"
assert out =~ "sig-2026-01"
assert out =~ "RS256"
refute out =~ "key_data"
end
test "jwks show unknown kid exits 1" do
{code, err} = run_err(["jwks", "show", "no-such-key"])
assert code == 1
assert err =~ "找不到"
end
test "jwks create sends kid/alg and prints summary" do
{code, out} = run_out(["jwks", "create", "--kid", "sig-2026-09", "--alg", "ES256"])
assert code == 0
assert out =~ "JWK 已建立:sig-2026-09"
assert out =~ "ES256"
end
test "jwks create without --kid exits 2" do
{code, err} = run_err(["jwks", "create"])
assert code == 2
assert err =~ "--kid"
end
test "jwks create invalid alg exits 2" do
{code, err} = run_err(["jwks", "create", "--kid", "k", "--alg", "HS256"])
assert code == 2
assert err =~ "--alg"
end
test "jwks toggle prints transition" do
{code, out} = run_out(["jwks", "toggle", "sig-2026-01"])
assert code == 0
assert out =~ "sig-2026-01:active → inactive"
end
test "jwks toggle --json returns new state" do
{code, out} = run_out(["jwks", "toggle", "sig-2026-01", "--json"])
assert code == 0
assert {:ok, decoded} = Jason.decode(out)
assert decoded["ok"] == true
assert decoded["jwk"]["kid"] == "sig-2026-01"
assert decoded["jwk"]["active"] == false
end
test "jwks list 403 exits 8 with admin hint" do
with_api_error({:error, :forbidden, "Admin role required."})
{code, err} = run_err(["jwks", "list"])
assert code == 8
assert err =~ "admin"
end
test "jwks list 401 exits 3" do
with_api_error({:error, :unauthorized, "invalid_token"})
{code, err} = run_err(["jwks", "list"])
assert code == 3
assert err =~ "bear login"
end
test "jwks unknown verb exits 2" do
{code, err} = run_err(["jwks", "rotate"])
assert code == 2
assert err =~ "未知的 jwks 子指令"
end
# -- accounts --
test "accounts list renders table" do
{code, out} = run_out(["accounts", "list"])
assert code == 0
assert out =~ "EMAIL"
assert out =~ "admin@example.com"
assert out =~ "alice@example.com"
end
test "accounts list --json outputs spec shape" do
{code, out} = run_out(["accounts", "list", "--json"])
assert code == 0
assert {:ok, decoded} = Jason.decode(out)
assert decoded["ok"] == true
assert decoded["page"] == 1
assert decoded["total"] == 2
assert Enum.any?(decoded["accounts"], &(&1["email"] == "alice@example.com"))
end
test "accounts list pagination params pass through" do
{code, out} = run_out(["accounts", "list", "--per-page", "1", "--page", "2"])
assert code == 0
assert out =~ "alice@example.com"
refute out =~ "admin@example.com"
end
test "accounts show resolves email and prints fields" do
{code, out} = run_out(["accounts", "show", "alice@example.com"])
assert code == 0
assert out =~ "email"
assert out =~ "alice@example.com"
refute out =~ "hash_password"
refute out =~ "totp_secret"
end
test "accounts show unknown email exits 1" do
{code, err} = run_err(["accounts", "show", "nobody@example.com"])
assert code == 1
assert err =~ "找不到"
end
test "accounts create --generate-password sends plaintext once" do
{code, out} =
run_out([
"accounts",
"create",
"--email",
"new@example.com",
"--generate-password",
"--role",
"admin"
])
assert code == 0
assert out =~ "帳號已建立:new@example.com"
assert out =~ "初始密碼(只顯示這一次"
end
test "accounts create without email exits 2" do
{code, err} = run_err(["accounts", "create", "--generate-password"])
assert code == 2
assert err =~ "--email"
end
test "accounts create invalid role exits 2" do
{code, err} =
run_err([
"accounts",
"create",
"--email",
"x@example.com",
"--role",
"root",
"--generate-password"
])
assert code == 2
assert err =~ "--role"
end
test "accounts update requires --role" do
{code, err} = run_err(["accounts", "update", "alice@example.com"])
assert code == 2
assert err =~ "--role"
end
test "accounts update sends role and prints transition" do
{code, out} = run_out(["accounts", "update", "alice@example.com", "--role", "admin"])
assert code == 0
assert out =~ "alice@example.com:角色 → admin"
end
test "accounts set-password non-tty without generate exits 2" do
{code, err} = run_err(["accounts", "set-password", "alice@example.com"])
assert code == 2
assert err =~ "--generate-password"
end
test "accounts set-password --generate-password prints one-time password" do
{code, out} =
run_out(["accounts", "set-password", "alice@example.com", "--generate-password"])
assert code == 0
assert out =~ "只顯示這一次"
end
test "accounts delete prints confirmation" do
{code, out} = run_out(["accounts", "delete", "alice@example.com"])
assert code == 0
assert out =~ "已刪除帳號:alice@example.com"
end
test "accounts delete 403 self-delete exits 8" do
with_api_error({:error, :forbidden, "cannot delete yourself"})
{code, err} = run_err(["accounts", "delete", "admin@example.com"])
assert code == 8
assert err =~ "admin"
end
test "accounts list 403 exits 8" do
with_api_error({:error, :forbidden, "Admin role required."})
{code, _err} = run_err(["accounts", "list"])
assert code == 8
end
# -- audit-logs --
test "audit-logs list renders table with emails" do
{code, out} = run_out(["audit-logs", "list"])
assert code == 0
assert out =~ "EVENT"
assert out =~ "account_created_by_admin"
assert out =~ "admin@example.com"
assert out =~ "alice@example.com"
end
test "audit-logs list --json outputs spec shape" do
{code, out} = run_out(["audit-logs", "list", "--json"])
assert code == 0
assert {:ok, decoded} = Jason.decode(out)
assert decoded["ok"] == true
assert decoded["total"] == 1
assert decoded["total_pages"] == 1
assert decoded["emails"]["0192bbbb-0000-7000-8000-000000000002"] == "alice@example.com"
assert Enum.any?(decoded["entries"], &(&1["event"] == "account_created_by_admin"))
end
test "audit-logs list --category filters server-side" do
{code, out} = run_out(["audit-logs", "list", "--category", "account"])
assert code == 0
assert out =~ "account_created_by_admin"
end
test "audit-logs list --category jwk filters to empty" do
{code, out} = run_out(["audit-logs", "list", "--category", "jwk"])
assert code == 0
refute out =~ "account_created_by_admin"
end
test "audit-logs list 403 exits 8" do
with_api_error({:error, :forbidden, "Admin role required."})
{code, err} = run_err(["audit-logs", "list"])
assert code == 8
assert err =~ "admin"
end
test "audit-logs list network error exits 6" do
with_api_error({:error, :network, "econnrefused"})
{code, err} = run_err(["audit-logs", "list"])
assert code == 6
assert err =~ "econnrefused"
end
# -- 解析 --
test "parse returns group module and verb" do
assert {:ok, {Jwks, :list}, opts} = CLI.parse(["jwks", "list", "--json"])
assert opts[:json] == true
assert {:ok, {Accounts, :create}, opts2} =
CLI.parse(["accounts", "create", "--email", "x@example.com", "--generate-password"])
assert opts2[:email] == "x@example.com"
assert opts2[:generate_password] == true
assert {:ok, {AuditLogs, :list}, opts3} = CLI.parse(["audit-logs", "list", "--page", "2"])
assert opts3[:page] == 2
end
test "unknown group verb reports in group error" do
assert {:error, msg, 2} = CLI.parse(["accounts", "purge"])
assert msg =~ "未知的 accounts 子指令"
end
test "accounts update keeps positional email" do
assert {:ok, {Accounts, :update}, opts} =
CLI.parse(["accounts", "update", "a@example.com", "--role", "admin"])
assert opts[:email_arg] == "a@example.com"
assert opts[:role] == "admin"
end
# -- 輔助 --
defp restore(nil, key), do: System.delete_env(key)
defp restore(value, key), do: System.put_env(key, value)
end