Merge branch 'merge-fix' into feat/admin-commands

merge: 吸納 main 的個人自助指令群（PR #15），衝突以管理端＋個人自助並存解算
feat: 實作管理端指令群 jwks/accounts/audit-logs（issue #12）
2026-09-10 03:16:22 +08:00 · 2026-09-10 03:16:17 +08:00 · 2026-09-10 03:15:53 +08:00 · 2026-09-10 03:15:11 +08:00 · 2026-09-10 03:07:40 +08:00 · 2026-09-10 01:08:17 +08:00
15 changed files with 4853 additions and 37 deletions
@@ -2,7 +2,7 @@

 **Bear CLI** 是 [澳特科技](https://alterminal.com)（Alter Technology）單點登入系統 [Bear](https://gitea.alterminal.com/alterminal/bear) 的**終端機（CLI）客戶端**：讓使用者在 Linux 終端機以 Bear 帳號登入（Device Flow 或個人存取權杖）、查詢身分、取得 Token，作為 SSO 的終端入口。

-> **狀態：已實作 PAT 模式 MVP（Elixir + Req，issue #6）**。`login --token <PAT>`、`whoami`、`token`、`logout`、`status` 已可用；Device Authorization Grant（RFC 8628）登入待伺服器端 P1（bear 倉庫）完成後再接。
+> **狀態：已實作 PAT 模式 MVP（Elixir + Req，issue #6）＋ App 管理（#10）＋ 個人自助指令群（#11）**。`login --token <PAT>`、`whoami`、`token`、`logout`、`status`、`apps`、`profile`／`password`／`email`／`sessions`／`tokens`／`mfa` 已可用；Device Authorization Grant（RFC 8628）登入待伺服器端 P1（bear 倉庫）完成後再接。
 > 伺服器端採用的 OIDC **Device Authorization Grant（RFC 8628）** 方向，詳見 bear 倉庫的設計文件 `docs/cli-feature-plan.md`（issue #17）。
 > Bear 已支援**個人存取權杖（Personal Access Token，PAT）**；CLI 規劃以其作為完全免瀏覽器的替代登入方式（見下文）。

@@ -23,13 +23,16 @@ Bear 目前所有流程都依賴「瀏覽器」：登入 `/login`、儀表板 La
 | `bear token [--refresh]` | 印出 access token（過期自動 refresh），供 pipe 給其他工具 | P2 |
 | `bear logout` | 撤銷 refresh token（`POST /revoke`） | P2 |
 | `bear status` | 顯示登入狀態與 token 剩餘效期 | P2 |
-| `bear apps list/show/create/update/rotate-secret/toggle` | App 管理（需 bear App 管理 JSON API，PAT 登入、admin 限定） | P3 |
-| `bear profile show/set` | 個人資料檢視／更新（需 bear 個人自助 JSON API） | P3 |
-| `bear password change` | 變更密碼（互動輸入，不進 shell history） | P3 |
-| `bear email change --new EMAIL` | 變更 email（雙向驗證碼流程） | P3 |
-| `bear sessions list/revoke/revoke-others` | 管理網頁 session | P3 |
-| `bear tokens list/create/revoke` | 管理 PAT（create 一次性顯示明文） | P3 |
-| `bear mfa status/setup/disable/recovery-codes` | TOTP 兩因子管理 | 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 password change` | 變更密碼（互動輸入，不進 shell history） | P3（✅ 已實作） |
+| `bear email change --new EMAIL` | 變更 email（雙向驗證碼流程） | P3（✅ 已實作） |
+| `bear sessions list/revoke/revoke-others` | 管理網頁 session | P3（✅ 已實作） |
+| `bear tokens list/create/revoke` | 管理 PAT（create 一次性顯示明文） | P3（✅ 已實作） |
+| `bear mfa status/setup/disable/recovery-codes` | TOTP 兩因子管理 | P3（✅ 已實作） |

 完整指令規格（選項、行為、輸出、退出碼）見 [`docs/commands.md`](docs/commands.md)。

@@ -46,8 +49,11 @@ Bear 目前所有流程都依賴「瀏覽器」：登入 `/login`、儀表板 La
 | `bear token` | ✅ 已實作（印出 PAT；`--refresh` 為用法錯誤） |
 | `bear logout` | ✅ 已實作（清除本機憑證；PAT 需至網頁撤銷） |
 | `bear status` | ✅ 已實作（純本機判定，顯示 PAT／環境變數模式） |
-| `bear apps` | ⏳ 待 #5 規格與 alterminal/bear#28 API 就緒後實作 |
-| `bear profile`／`password`／`email`／`sessions`／`tokens`／`mfa` | ⏳ 規格已納入 `docs/commands.md` §3.7（#11）；待 alterminal/bear#35 API 就緒後實作 |
+| `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` | ✅ 已實作（issue #11，對接 alterminal/bear#38 的 `/api/v1/profile*` JSON API，任何有效 PAT 皆可）：`profile show/set`、`password change`、`email change --new`、`sessions list/revoke/revoke-others`、`tokens list/create/revoke`、`mfa status/setup/disable/recovery-codes`。規格見 `docs/commands.md` §3.7 |

 ### 建置與執行

@@ -183,9 +183,9 @@ issuer：https://alterminal.com

 ---

-### 3.6 `bear apps`：App 管理指令群（P3，規劃中）
+### 3.6 `bear apps`：App 管理指令群（P3，已實作）

-> 依賴：bear 伺服器端 **App 管理 JSON API**（alterminal/bear#28，資源前綴 `/api/v1/apps`，PAT Bearer 認證、管理操作限 admin）。API 落地前本節僅為規格。
+> 依賴：bear 伺服器端 **App 管理 JSON API**（alterminal/bear#28，資源前綴 `/api/v1/apps`，PAT Bearer 認證、管理操作限 admin）。API 已上線（PR alterminal/bear#29），本節指令群已實作（issue #10）；`--visibility`／`--status` 過濾目前由 CLI 全量列舉後本地套用（伺服器 list 端點尚無對應查詢參數）。

 `bear apps` 是「資源群組」指令：`bear apps <動詞>`。這是第 1 節「扁平結構」原則的首個例外——App 的管理操作（列表、檢視、建立、更新、輪轉 secret、啟停用）若攤平命名會造成指令名爆炸（`bear apps-create`…），故收斂為單一群組；未來同類資源管理指令比照。

@@ -338,9 +338,9 @@ bear apps update <client-id> [--url URL] [--title TITLE]

 ---

-### 3.7 `bear profile`：個人自助指令群（P3，規劃中）
+### 3.7 `bear profile`：個人自助指令群（P3，已實作）

-> 依賴：bear 伺服器端**個人自助 JSON API**（alterminal/bear#35，資源前綴 `/api/v1/profile`，PAT Bearer 認證、**任何有效 PAT 帳號**可用，不限 admin）。API 落地前本節僅為規格；端點細節以 #35 定案為準。
+> 依賴：bear 伺服器端**個人自助 JSON API**（alterminal/bear#35，資源前綴 `/api/v1/profile`，PAT Bearer 認證、**任何有效 PAT 帳號**可用，不限 admin）。API 已上線（PR alterminal/bear#38），本節指令群已實作（issue #11）；端點細節以 #38 實作為準。

 比照 `bear apps` 的「資源群組」例外：個人自助操作若攤平命名同樣會造成指令名爆炸（`bear password-change`…），收斂為 `bear <資源> <動詞>` 的六個子群組。頭像（picture）檔案上傳需要 multipart 與本機圖片，終端體驗差，**不在本期範圍**（#35 有對應端點，未來有需要再評估）；如需更換頭像，可自行上傳圖片後以 `profile set --picture URL` 設定。

@@ -421,7 +421,7 @@ bear profile set [--name NAME] [--given-name NAME] [--family-name NAME]

 1. 互動提示（不回顯）依序讀取：`目前密碼`、`新密碼`、`確認新密碼`。
 2. 兩次新密碼不一致 → 退出碼 `2`（本地檢查），不發請求。
-3. `POST /api/v1/profile/password`（Bearer PAT，body 帶 `current_password`／`new_password`）。
+3. `POST /api/v1/profile/password`（Bearer PAT，body 帶 `current_password`／`new_password`／`password_confirmation`；CLI 以兩次輸入一致的新密碼填 `password_confirmation`）。
 4. 成功 → 印出 `密碼已變更`；現行密碼錯誤 → 退出碼 `1`；新密碼不符伺服器強度規則 → `422`，退出碼 `1`。

 比照網頁流程，變更密碼**不**自動撤銷其他 session；需要時另用 `bear sessions revoke-others`。
@@ -437,8 +437,8 @@ bear profile set [--name NAME] [--given-name NAME] [--family-name NAME]
 **行為**：

 1. `POST /api/v1/profile/email/request-codes`（Bearer PAT，`new_email`）→ 伺服器向**現有與新**信箱各寄一組驗證碼。
-2. 終端印出 `驗證碼已寄至 alice@example.com 與 new@example.com`，互動提示（不回顯）讀取：`現有信箱驗證碼`、`新信箱驗證碼`。
-3. `POST /api/v1/profile/email`（`current_code`／`new_code`）。
+2. 終端印出 `驗證碼已寄至現有信箱與 <new>`，互動提示（不回顧）讀取：`現有信箱驗證碼`、`新信箱驗證碼`。
+3. `POST /api/v1/profile/email`（`new_email`／`current_code`／`new_code`；API 版需再帶一次 `new_email`，CLI 自動帶入）。
 4. 成功 → 印出 `email 已更新：new@example.com`，並提醒 `bear login` 用的 PAT 不受影響（PAT 不綁 email）。

 錯誤：`same_email`／`email_taken`／`invalid_email` → 退出碼 `1`；驗證碼錯誤或逾期 → 退出碼 `1`，提示重新執行（會重寄驗證碼）；伺服器限流（`429`）→ 退出碼 `1`，提示稍後再試。
@@ -452,11 +452,11 @@ bear profile set [--name NAME] [--given-name NAME] [--family-name NAME]
 - **`bear sessions list`**：`GET /api/v1/profile/sessions`（Bearer PAT），表格輸出，新到舊排序：

 ```
-ID                                    IP              USER AGENT                  CREATED               LAST SEEN             EXPIRES
-0192a1b0-…                            203.0.113.10    Mozilla/5.0 (X11; Linux…)  2026-09-07 10:00:00Z  2026-09-08 09:00:00Z  2026-09-21 10:00:00Z
+ID                                    IP              USER AGENT                  CREATED               LAST SEEN
+0192a1b0-…                            203.0.113.10    Mozilla/5.0 (X11; Linux…)  2026-09-07 10:00:00Z  2026-09-08 09:00:00Z
 ```

-  （`user_agent` 截斷至欄寬；`--json` 輸出完整值。）
+  （`user_agent` 截斷至欄寬；`--json` 輸出完整值。API 回應欄位為 `id`／`ip`／`user_agent`／`created_at`／`last_seen_at`，不含 `expires_at`。）
 - **`bear sessions revoke <id>`**：`POST /api/v1/profile/sessions/{id}/revoke`。成功印出 `session 已撤銷`；不存在或非本人 → `404`，退出碼 `1`。
 - **`bear sessions revoke-others`**：`POST /api/v1/profile/sessions/revoke-others`。成功印出 `已撤銷 N 個其他 session`。

@@ -473,11 +473,11 @@ ID                                    IP              USER AGENT
 ```
 ID                                    NAME       SCOPE                 CREATED               EXPIRES               LAST USED             STATUS
 0192a1c0-…                            ci-token   openid, profile       2026-09-01 00:00:00Z  2026-10-01 00:00:00Z  2026-09-08 08:00:00Z  active
-0192a1b0-…                            old-laptop openid, profile      2026-08-01 00:00:00Z  (無到期)              (未使用)              revoked
+0192a1b0-…                            old-laptop openid, profile      2026-08-01 00:00:00Z  (無到期)              (未使用)              expired
 ```

-  `STATUS`：`active`／`expired`／`revoked`（CLI 依 `expires_at`／`revoked_at` 本地判定）。
- **`bear tokens create --name NAME [--expires-in DAYS|never] [--scope SCOPES]`**：`POST /api/v1/profile/tokens`（Bearer PAT）。成功後一次性顯示：
+  `STATUS`：`active`／`expired`（CLI 依 `expires_at` 本地判定）。API 的 list 端點只回**未撤銷**的 token，故 `revoked` 不會出現在清單。
+- **`bear tokens create --name NAME [--expires-in DAYS|never]`**：`POST /api/v1/profile/tokens`（Bearer PAT，body `name`／`expires_in`；scope 由伺服器給預設 `openid profile email`，API 不接受指定）。成功後一次性顯示：

 ```
 PAT 已建立：ci-token（30 天後到期）
@@ -489,20 +489,19 @@ token（只顯示這一次，請立即保存）：
  |------|------|------|
  | `--name` | （必填） | 顯示名稱；空白或重複名稱依伺服器規則 `422` → 退出碼 `1` |
  | `--expires-in` | `30` | 天數（正整數）或 `never`（永不過期） |
-  | `--scope` | `openid profile email` | 空白分隔的 scope 清單（同伺服器預設） |

  `--json` 輸出範例：`{"ok": true, "token": {…list 之單一物件…}, "raw": "9f3a…"}`（`raw` 只出現這一次。）
  提醒：新 PAT 要使用須另以 `bear login --token` 登入（或設 `BEAR_TOKEN`）。
- **`bear tokens revoke <id>`**：`POST /api/v1/profile/tokens/{id}/revoke`（`<id>` 為 UUID）。成功印出 `PAT 已撤銷：<name>`；若撤銷的是**目前憑證用的 PAT**，後續指令會得到 `401`（退出碼 `3`），屆時重新 `bear login`；CLI 在撤銷成功後偵測到 `id` 對應本機憑證時，主動提示執行 `bear logout` 清除本機憑證。
+- **`bear tokens revoke <id>`**：`POST /api/v1/profile/tokens/{id}/revoke`（`<id>` 為 UUID）。成功印出 `PAT 已撤銷`；若撤銷的是**目前憑證用的 PAT**，後續指令會得到 `401`（退出碼 `3`），屆時重新 `bear login`（本機憑證檔未存 token id，CLI 無法預先比對，僅能提示此退路）。

 #### 3.7.7 `bear mfa`

 TOTP 兩因子管理（WebAuthn／passkey 不在範圍）。

- **`bear mfa status`**：讀 `GET /api/v1/profile` 的 MFA 欄位，印出 `MFA（TOTP）：已啟用／未啟用`。
+- **`bear mfa status`**：讀 `GET /api/v1/profile` 的 `mfa_enabled` 欄位，印出 `MFA（TOTP）：已啟用／未啟用`。
 - **`bear mfa setup`**：兩步互動流程——
-  1. `POST /api/v1/profile/mfa/setup`（無 code，Bearer PAT）→ 回傳 Base32 `secret` 與 `otpauth://` URI。終端印出 URI、secret，並在本機產生 ASCII QR（掃碼加入驗證器；QR 由 CLI 本地生成，不經伺服器）。
-  2. 互動提示（不回顯）讀取 6 位碼 → `POST /api/v1/profile/mfa/setup`（帶 code）確認。
+  1. `POST /api/v1/profile/mfa/setup`（無 body，Bearer PAT）→ 回傳 Base32 `secret` 與 `otpauth://` URI。終端印出 URI、secret，並在本機產生 ASCII QR（掃碼加入驗證器；QR 由 CLI 本地生成，不經伺服器；`--json` 模式此步資訊走 stderr，stdout 留給最終結果）。
+  2. 互動提示（不回顧）讀取 6 位碼 → `POST /api/v1/profile/mfa/setup/confirm`（`code`）確認。
  3. 成功 → **一次性**顯示 recovery codes（提示同 PAT：只顯示這一次）。

  已啟用 MFA 再執行 → 退出碼 `1`，提示已啟用。驗證碼錯誤 → 退出碼 `1`，可重試（不重產 secret）。
@@ -513,6 +512,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. 退出碼總表

 | 碼 | 語意 |
@@ -525,7 +680,7 @@ TOTP 兩因子管理（WebAuthn／passkey 不在範圍）。
 | `5` | 授權被拒絕（access_denied） |
 | `6` | 網路／伺服器錯誤 |
 | `7` | 設定檔／憑證檔格式損毀 |
-| `8` | 權限不足（HTTP 403；App 管理操作僅限 admin） |
+| `8` | 權限不足（HTTP 403；管理端操作僅限 admin：apps／jwks/accounts/audit-logs） |

 ---

@@ -562,8 +717,8 @@ TOTP 兩因子管理（WebAuthn／passkey 不在範圍）。
 4. 是否支援 `offline_access` scope，或沿用現行 refresh 輪轉即可？
 5. 是否在 CLI 提供「建立／撤銷 PAT」？原規劃傾向 CLI 只「使用」不「管理」；#35 的 PAT 端點落地後，`bear tokens` 已納入 §3.7.6 規格（管理自己帳號的 PAT），此題視為已解。
 6. App 管理 API 的路徑參數最終採 UUID 或 `client_id`（alterminal/bear#28 規格為 `{id}`）？若為 UUID，CLI 需先以 list 解析 `client_id` → UUID，或伺服器提供以 `client_id` 直取的端點。
-7. `bear profile set --phone-verified`（自我標記電話已驗證）是否開放？#35 需決定 API 是否接受該欄位；不開放則 CLI 移除此選項。
-8. `mfa setup` 的 `secret`／`otpauth://` 屬敏感資料，#35 的 API 回應是否應限制僅 setup 流程期間回傳（未確認前不重送）？
+7. `bear profile set --phone-verified`（自我標記電話已驗證）是否開放？#35 已定案：API 接受該欄位（`profile_changeset` 的 `profile_fields` 含 `phone_number_verified`），CLI 保留 `--phone-verified` 旗標（僅設定，清除不在本期）。
+8. `mfa setup` 的 `secret`／`otpauth://` 屬敏感資料，#35 的 API 回應是否應限制僅 setup 流程期間回傳（未確認前不重送）？#38 實作為 setup 回應一次性回傳，未確認前重呼 setup 會重產 secret；CLI 依此實作（第二步走 `/mfa/setup/confirm`）。

 ---

@@ -593,7 +748,7 @@ TOTP 兩因子管理（WebAuthn／passkey 不在範圍）。
 | `tokens create` | `POST /api/v1/profile/tokens` |
 | `tokens revoke <id>` | `POST /api/v1/profile/tokens/{id}/revoke` |
 | `mfa status` | `GET /api/v1/profile`（讀 MFA 欄位） |
-| `mfa setup` | `POST /api/v1/profile/mfa/setup`（先無 code 取 secret，再帶 code 確認） |
+| `mfa setup` | `POST /api/v1/profile/mfa/setup`（取 secret）→ `POST /api/v1/profile/mfa/setup/confirm`（帶 code 確認） |
 | `mfa disable` | `POST /api/v1/profile/mfa/disable` |
 | `mfa recovery-codes` | `POST /api/v1/profile/mfa/recovery-codes` |

@@ -612,8 +767,9 @@ TOTP 兩因子管理（WebAuthn／passkey 不在範圍）。
 | `token` | refresh token 輪轉換新 | 直接印出 PAT；`--refresh` 為用法錯誤（退出碼 2）；`BEAR_TOKEN` 提供時優先印出 |
 | `logout` | `POST /revoke`（撤銷 refresh token） | 僅清除本機憑證；PAT 需至網頁 `/profile/tokens` 撤銷 |
 | `status` | 顯示 access token 剩餘秒數 | 純本機判定：顯示模式（PAT／BEAR_TOKEN 環境變數）與 issuer |
-| `apps` | P3 暫緩 | 未實作；App 管理指令規格見 #5，伺服器端 API 見 alterminal/bear#28 |
-| `profile`／`password`／`email`／`sessions`／`tokens`／`mfa` | P3 暫緩 | 未實作；個人自助指令規格見 #11（§3.7），伺服器端 API 見 alterminal/bear#35 |
+| `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 成功當下輸出 |
+| `profile`／`password`／`email`／`sessions`／`tokens`／`mfa` | P3 暫緩 | ✅ 已實作（issue #11）：`profile show/set`、`password change`、`email change`、`sessions list/revoke/revoke-others`、`tokens list/create/revoke`、`mfa status/setup/disable/recovery-codes`，對接 alterminal/bear#38 的 `/api/v1/profile*` JSON API（PAT Bearer、任何有效帳號）。敏感輸入互動提示；一次性明文（PAT 明文、recovery codes）僅於成功當下輸出；mfa setup 的 ASCII QR 由本機 eqrcode 生成 |
+| `jwks`／`accounts`／`audit-logs` | P3 暫緩 | ✅ 已實作（issue #12）：對接 alterminal/bear#46 的管理端 JSON API（PAT Bearer、admin 限定）；規格見 §3.8–§3.10 |

 退出碼差異：`login`／`whoami` 的 token 無效（401）依 §3.1 為 `3`（本節實作一致）。

@@ -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
@@ -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
@@ -2,7 +2,12 @@ defmodule BearCli.Api do
  @moduledoc """
  Bear 伺服器 HTTP 介面（一律使用 `Req`）。

-  目前僅實作 PAT 模式所需的 `GET /userinfo`。
+  - `GET /userinfo`：PAT 模式身分驗證（issue #6）。
+  - App 管理 API `/api/v1/apps`（alterminal/bear#28；PAT Bearer、admin 限定）。
+  - 個人自助 API `/api/v1/profile*`（alterminal/bear#35；PAT Bearer、
+    任何有效帳號）：profile／密碼／email／sessions／PAT／MFA。
+  - 管理端 API `/api/v1/jwks`/`/api/v1/accounts`/`/api/v1/audit-logs`
+    (alterminal/bear#36; PAT Bearer, admin only).
  """

  @finch BearCli.Finch
@@ -51,4 +56,296 @@ defmodule BearCli.Api do
  end

  defp error_description(_), do: "invalid_token"
+
+  # -- App 管理 API（alterminal/bear#28；PAT Bearer、admin 限定）--
+
+  @doc """
+  `GET /api/v1/apps`：列出 App（分頁）。
+
+  `params` 為 keyword（`page:`／`per_page:`，可加 `visibility:`／`status:` 過濾）。
+  成功回 `{:ok, %{"data" => [apps], "page" => n, "per_page" => n, "total" => n}}`。
+  """
+  def apps_list(issuer, token, params \\ []) do
+    api_request(issuer, token, :get, "/api/v1/apps", params: params)
+  end
+
+  @doc "`GET /api/v1/apps/{id}`：單一 App（`client_secret` 永不回傳）。"
+  def apps_get(issuer, token, id) do
+    api_request(issuer, token, :get, "/api/v1/apps/" <> URI.encode(id))
+  end
+
+  @doc """
+  `POST /api/v1/apps`：建立 App。`method=client_secret` 且未給
+  `client_secret` 時由伺服器產生，成功回應內含一次性明文
+  （`%{"data" => app, "client_secret" => secret}`）。
+  """
+  def apps_create(issuer, token, attrs) do
+    api_request(issuer, token, :post, "/api/v1/apps", json: attrs)
+  end
+
+  @doc "`PUT /api/v1/apps/{id}`：部分更新（只送有給的欄位）。"
+  def apps_update(issuer, token, id, attrs) do
+    api_request(issuer, token, :put, "/api/v1/apps/" <> URI.encode(id), json: attrs)
+  end
+
+  @doc """
+  `POST /api/v1/apps/{id}/rotate-secret`：輪轉 client secret，回應內含
+  一次性明文。PKCE App 回 422 `%{"error" => "pkce_app"}`。
+  """
+  def apps_rotate_secret(issuer, token, id) do
+    api_request(issuer, token, :post, "/api/v1/apps/" <> URI.encode(id) <> "/rotate-secret",
+      json: %{}
+    )
+  end
+
+  @doc "`POST /api/v1/apps/{id}/toggle`：切換 active ↔ inactive。"
+  def apps_toggle(issuer, token, id) do
+    api_request(issuer, token, :post, "/api/v1/apps/" <> URI.encode(id) <> "/toggle", json: %{})
+  end
+
+  # -- 個人自助 API（alterminal/bear#35；PAT Bearer、任何有效帳號）--
+
+  @doc "`GET /api/v1/profile`：完整個人資料（含 MFA 狀態）。"
+  def profile_get(issuer, token) do
+    api_request(issuer, token, :get, "/api/v1/profile")
+  end
+
+  @doc "`PUT /api/v1/profile`：更新個人資料欄位（只送有給的欄位）。"
+  def profile_update(issuer, token, attrs) do
+    api_request(issuer, token, :put, "/api/v1/profile", json: attrs)
+  end
+
+  @doc """
+  `POST /api/v1/profile/password`：變更密碼（body：`current_password`、
+  `new_password`、`password_confirmation`；伺服器驗舊密碼，不因 CLI 放寬）。
+  """
+  def profile_change_password(issuer, token, current_password, new_password) do
+    api_request(issuer, token, :post, "/api/v1/profile/password",
+      json: %{
+        current_password: current_password,
+        new_password: new_password,
+        password_confirmation: new_password
+      }
+    )
+  end
+
+  @doc "`POST /api/v1/profile/email/request-codes`：寄發 email 變更雙向驗證碼。"
+  def profile_email_request_codes(issuer, token, new_email) do
+    api_request(issuer, token, :post, "/api/v1/profile/email/request-codes",
+      json: %{new_email: new_email}
+    )
+  end
+
+  @doc """
+  `POST /api/v1/profile/email`：確認變更 email（body：`new_email`、
+  `current_code`、`new_code`）。
+  """
+  def profile_email_change(issuer, token, new_email, current_code, new_code) do
+    api_request(issuer, token, :post, "/api/v1/profile/email",
+      json: %{new_email: new_email, current_code: current_code, new_code: new_code}
+    )
+  end
+
+  @doc "`GET /api/v1/profile/sessions`：列出作用中 session（新到舊）。"
+  def sessions_list(issuer, token) do
+    api_request(issuer, token, :get, "/api/v1/profile/sessions")
+  end
+
+  @doc "`POST /api/v1/profile/sessions/{id}/revoke`：撤銷單一 session。"
+  def sessions_revoke(issuer, token, id) do
+    api_request(issuer, token, :post, "/api/v1/profile/sessions/" <> URI.encode(id) <> "/revoke",
+      json: %{}
+    )
+  end
+
+  @doc """
+  `POST /api/v1/profile/sessions/revoke-others`：撤銷其他 session
+  （body `keep` 可省略＝全部撤銷）。
+  """
+  def sessions_revoke_others(issuer, token, keep \\ nil) do
+    api_request(issuer, token, :post, "/api/v1/profile/sessions/revoke-others",
+      json: %{keep: keep} |> Map.reject(fn {_k, v} -> is_nil(v) end)
+    )
+  end
+
+  @doc "`GET /api/v1/profile/tokens`：列出未撤銷的 PAT（新到舊）。"
+  def tokens_list(issuer, token) do
+    api_request(issuer, token, :get, "/api/v1/profile/tokens")
+  end
+
+  @doc """
+  `POST /api/v1/profile/tokens`：建立 PAT；明文 `token` 只在成功回應
+  出現一次（body：`name`、`expires_in`＝天數或 `never`）。
+  """
+  def tokens_create(issuer, token, name, expires_in) do
+    api_request(issuer, token, :post, "/api/v1/profile/tokens",
+      json: %{name: name, expires_in: expires_in}
+    )
+  end
+
+  @doc "`POST /api/v1/profile/tokens/{id}/revoke`：撤銷單一 PAT。"
+  def tokens_revoke(issuer, token, id) do
+    api_request(issuer, token, :post, "/api/v1/profile/tokens/" <> URI.encode(id) <> "/revoke",
+      json: %{}
+    )
+  end
+
+  @doc """
+  `POST /api/v1/profile/mfa/setup`（無 body）：開始 TOTP 設定，回
+  `%{"data" => %{"secret" => ..., "otpauth_uri" => ...}}`。已啟用 MFA 回
+  422 `already_enabled`。
+  """
+  def mfa_setup(issuer, token) do
+    api_request(issuer, token, :post, "/api/v1/profile/mfa/setup", json: %{})
+  end
+
+  @doc """
+  `POST /api/v1/profile/mfa/setup/confirm`（body：`code`）：確認設定並
+  啟用 MFA，回一次性 recovery codes。
+  """
+  def mfa_setup_confirm(issuer, token, code) do
+    api_request(issuer, token, :post, "/api/v1/profile/mfa/setup/confirm", json: %{code: code})
+  end
+
+  @doc """
+  `POST /api/v1/profile/mfa/disable`（body：`code`＝目前 TOTP 或
+  recovery code）：停用 MFA。
+  """
+  def mfa_disable(issuer, token, code) do
+    api_request(issuer, token, :post, "/api/v1/profile/mfa/disable", json: %{code: code})
+  end
+
+  @doc """
+  `POST /api/v1/profile/mfa/recovery-codes`（body：`code`）：重產一組
+  一次性 recovery codes（舊組全部失效）。
+  """
+  def mfa_recovery_codes(issuer, token, code) do
+    api_request(issuer, token, :post, "/api/v1/profile/mfa/recovery-codes", json: %{code: code})
+  end
+
+  # -- 共用請求輔助 --
+
+  # 回傳：
+  #   {:ok, body} | {:error, :unauthorized, desc} | {:error, :forbidden, desc}
+  #   | {:error, :not_found, desc} | {:error, :unprocessable_entity, body}
+  #   | {:error, :too_many_requests, body}
+  #   | {:error, :server_error, status} | {:error, :network, reason}
+  defp api_request(issuer, token, method, path, extra \\ []) do
+    url = String.trim_trailing(issuer, "/") <> path
+
+    opts =
+      [
+        headers: [authorization: "Bearer " <> token, accept: "application/json"],
+        retry: false,
+        finch: [name: @finch]
+      ]
+      |> Keyword.merge(extra)
+
+    case apply(Req, method, [url, opts]) do
+      {:ok, %Req.Response{status: status, body: body}} when status in 200..299 ->
+        {:ok, decode_body(body)}
+
+      {:ok, %Req.Response{status: 401, body: body}} ->
+        {:error, :unauthorized, error_description(decode_body(body))}
+
+      {:ok, %Req.Response{status: 403, body: body}} ->
+        {:error, :forbidden, error_description(decode_body(body))}
+
+      {:ok, %Req.Response{status: 404, body: body}} ->
+        {:error, :not_found, error_description(decode_body(body))}
+
+      {:ok, %Req.Response{status: 422, body: body}} ->
+        {:error, :unprocessable_entity, decode_body(body)}
+
+      {:ok, %Req.Response{status: 429, body: body}} ->
+        {:error, :too_many_requests, decode_body(body)}
+
+      {:ok, %Req.Response{status: status}} ->
+        {:error, :server_error, status}
+
+      {:error, exception} ->
+        {:error, :network, Exception.message(exception)}
+    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
@@ -0,0 +1,446 @@
+defmodule BearCli.Apps do
+  @moduledoc """
+  `bear apps` 指令群（App 管理；docs/commands.md §3.6、issue #10）。
+
+  對應伺服器端 App 管理 JSON API（alterminal/bear#28，`/api/v1/apps`、
+  PAT Bearer、admin 限定）。認證沿用既有 PAT 憑證（`BEAR_TOKEN` 或憑證檔）。
+
+  API 路徑參數為資料庫 UUID，CLI 對外介面一律使用 `client_id`；show／
+  update／rotate-secret／toggle 先以 list 比對解析（§7 開放問題 6 的結論）。
+
+  `client_secret` 僅於 create／rotate-secret 成功當下一次性輸出，不寫入
+  憑證檔／log／`--verbose`。
+
+  退出碼：0 成功；1 404／422；2 用法錯誤；3 未登入或 401；6 網路／伺服器
+  錯誤；8 權限不足（403，僅限 admin）。
+  """
+
+  alias BearCli.{Api, Config, Credentials}
+
+  @list_per_page_fetch 100
+  @max_fetch_pages 50
+
+  # -- 入口 --
+
+  @doc """
+  執行 `bear apps <動詞>`，回傳退出碼。
+
+  `opts[:apps_api]` 可注入假 API 模組供測試（需實作 `apps_list/3`、
+  `apps_get/3`、`apps_create/3`、`apps_update/4`、`apps_rotate_secret/3`、
+  `apps_toggle/3`）。
+  """
+  def run(verb, opts) do
+    api = opts[:apps_api] || Api
+
+    with {:ok, ctx} <- context(opts) do
+      execute(verb, ctx, opts, api)
+    else
+      {:error, message, code} -> fail(opts, message, code)
+    end
+  end
+
+  # -- 共用背景（token／issuer）--
+
+  defp 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
+
+  # -- 各動詞 --
+
+  defp execute(:list, ctx, opts, api) do
+    filters =
+      opts
+      |> Map.take([:visibility, :status])
+      |> Enum.reject(fn {_k, v} -> blank?(v) end)
+      |> Map.new()
+
+    if filters == %{} do
+      params = [page: opts[:page] || 1, per_page: opts[:per_page] || 20]
+
+      case api.apps_list(ctx.issuer, ctx.token, params) do
+        {:ok, body} ->
+          apps = body["data"] || []
+          page = body["page"] || params[:page]
+          per_page = body["per_page"] || params[:per_page]
+          total = body["total"] || length(apps)
+          render_list(opts, sort_apps(apps), page, per_page, total)
+          0
+
+        {:error, _kind, _detail} = error ->
+          fail_api(opts, ctx, error)
+      end
+    else
+      # 伺服器 list 端點目前僅支援分頁（bear#28），無 visibility/status
+      # 過濾參數；有過濾時以全量列舉後在本地過濾、排序與分頁。
+      with {:ok, all} <- fetch_all(ctx, api) do
+        filtered =
+          all
+          |> Enum.filter(&matches_filters?(&1, filters))
+          |> sort_apps()
+
+        page = opts[:page] || 1
+        per_page = opts[:per_page] || 20
+        page_apps = filtered |> Enum.drop((page - 1) * per_page) |> Enum.take(per_page)
+        render_list(opts, page_apps, page, per_page, length(filtered))
+        0
+      else
+        {:error, message, code} -> fail(opts, message, code)
+      end
+    end
+  end
+
+  defp execute(:show, ctx, opts, api) do
+    with {:ok, app} <- resolve_app(ctx, opts[:client_id_arg], api) do
+      case api.apps_get(ctx.issuer, ctx.token, app["id"]) do
+        {:ok, body} ->
+          show_app(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 = build_attrs(opts, :create)
+
+    case api.apps_create(ctx.issuer, ctx.token, attrs) do
+      {:ok, body} ->
+        app = body["data"] || %{}
+        secret = body["client_secret"]
+
+        if opts[:json] do
+          output = %{ok: true, app: app} |> maybe_put(:client_secret, secret)
+          IO.puts(Jason.encode!(output))
+        else
+          IO.puts("App 已建立：#{app["client_id"]}（#{app["visibility"]}／#{app["status"]}）")
+          print_secret_block(secret, rotated?: false)
+        end
+
+        0
+
+      {:error, _kind, _detail} = error ->
+        fail_api(opts, ctx, error)
+    end
+  end
+
+  defp execute(:update, ctx, opts, api) do
+    attrs = build_attrs(opts, :update)
+
+    with {:ok, app} <- resolve_app(ctx, opts[:client_id_arg], api) do
+      case api.apps_update(ctx.issuer, ctx.token, app["id"], attrs) do
+        {:ok, body} ->
+          show_app(body["data"] || %{}, opts, summary?: true)
+          0
+
+        {:error, _kind, _detail} = error ->
+          fail_api(opts, ctx, error)
+      end
+    else
+      {:error, message, code} -> fail(opts, message, code)
+    end
+  end
+
+  defp execute(:"rotate-secret", ctx, opts, api) do
+    with {:ok, app} <- resolve_app(ctx, opts[:client_id_arg], api) do
+      case api.apps_rotate_secret(ctx.issuer, ctx.token, app["id"]) do
+        {:ok, body} ->
+          secret = body["client_secret"]
+
+          if opts[:json] do
+            IO.puts(Jason.encode!(%{ok: true, client_secret: secret}))
+          else
+            print_secret_block(secret, rotated?: true)
+          end
+
+          0
+
+        {:error, _kind, _detail} = error ->
+          fail_api(opts, ctx, error)
+      end
+    else
+      {:error, message, code} -> fail(opts, message, code)
+    end
+  end
+
+  defp execute(:toggle, ctx, opts, api) do
+    with {:ok, app} <- resolve_app(ctx, opts[:client_id_arg], api) do
+      case api.apps_toggle(ctx.issuer, ctx.token, app["id"]) do
+        {:ok, body} ->
+          updated = body["data"] || %{}
+
+          if opts[:json] do
+            IO.puts(
+              Jason.encode!(%{
+                ok: true,
+                app: %{client_id: updated["client_id"], status: updated["status"]}
+              })
+            )
+          else
+            IO.puts("#{app["client_id"]}：#{app["status"]} → #{updated["status"]}")
+          end
+
+          0
+
+        {:error, _kind, _detail} = error ->
+          fail_api(opts, ctx, error)
+      end
+    else
+      {:error, message, code} -> fail(opts, message, code)
+    end
+  end
+
+  # -- client_id → UUID 解析 --
+
+  defp resolve_app(_ctx, nil, _api), do: {:error, "缺少 <client-id> 參數", 2}
+
+  defp resolve_app(ctx, client_id, api) do
+    with {:ok, all} <- fetch_all(ctx, api) do
+      case Enum.find(all, &(&1["client_id"] == client_id)) do
+        nil -> {:error, "找不到 client_id 為 #{client_id} 的 App", 1}
+        app -> {:ok, app}
+      end
+    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.apps_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
+
+  # -- 請求屬性組裝 --
+
+  # create：必填欄位已在解析層驗證（缺 → 用法錯誤 2），這裡只組裝。
+  defp build_attrs(opts, :create) do
+    %{}
+    |> put_value("client_id", opts[:client_id])
+    |> put_value("url", opts[:url])
+    |> put_value("title", opts[:title])
+    |> put_value("method", opts[:method])
+    |> put_value("visibility", opts[:visibility])
+    |> put_list("redirect_urls", opts[:redirect_url])
+    |> put_list("post_logout_redirect_uris", opts[:post_logout_redirect_uri])
+    |> put_list("scopes", opts[:scope])
+    |> put_value("sub", opts[:sub])
+    |> put_value("jwk_id", opts[:jwk_id])
+    |> put_value("client_secret", opts[:secret])
+  end
+
+  # update：只送有給的欄位（部分更新）；清單類整組覆寫。
+  defp build_attrs(opts, :update) do
+    %{}
+    |> put_value("url", opts[:url])
+    |> put_value("title", opts[:title])
+    |> put_value("method", opts[:method])
+    |> put_value("visibility", opts[:visibility])
+    |> put_list("redirect_urls", opts[:redirect_url])
+    |> put_list("post_logout_redirect_uris", opts[:post_logout_redirect_uri])
+    |> put_list("scopes", opts[:scope])
+    |> put_value("sub", opts[:sub])
+    |> put_value("jwk_id", opts[:jwk_id])
+  end
+
+  defp put_value(map, _key, nil), do: map
+  defp put_value(map, _key, ""), do: map
+  defp put_value(map, key, value), do: Map.put(map, key, value)
+
+  defp put_list(map, _key, nil), do: map
+  defp put_list(map, _key, []), do: map
+  defp put_list(map, key, values), do: Map.put(map, key, values)
+
+  # -- 過濾與排序 --
+
+  defp matches_filters?(app, filters) do
+    Enum.all?(filters, fn {k, v} -> app[to_string(k)] == v end)
+  end
+
+  defp sort_apps(apps), do: Enum.sort_by(apps, &{&1["client_id"] || "", &1["id"] || ""})
+
+  # -- 輸出 --
+
+  defp render_list(opts, apps, page, per_page, total) do
+    if opts[:json] do
+      IO.puts(
+        Jason.encode!(%{ok: true, page: page, per_page: per_page, total: total, apps: apps})
+      )
+    else
+      print_table(apps)
+    end
+  end
+
+  @table_headers ["CLIENT ID", "TITLE", "VISIBILITY", "STATUS", "METHOD", "SCOPES"]
+
+  defp print_table(apps) do
+    rows =
+      Enum.map(apps, fn app ->
+        [
+          app["client_id"] || "",
+          app["title"] || "",
+          app["visibility"] || "",
+          app["status"] || "",
+          app["method"] || "",
+          Enum.join(app["scopes"] || [], ", ")
+        ]
+      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
+
+  @app_fields ~w(client_id title url method visibility status scopes redirect_urls post_logout_redirect_uris sub jwk_id created_at updated_at)
+
+  defp show_app(app, opts, summary? \\ false)
+
+  defp show_app(app, opts, _summary?) do
+    if opts[:json] do
+      IO.puts(Jason.encode!(%{ok: true, app: app}))
+    else
+      Enum.each(@app_fields, fn key ->
+        IO.puts("#{String.pad_trailing(key, 26)}: #{format_app_value(app[key])}")
+      end)
+    end
+  end
+
+  defp format_app_value(nil), do: "(無)"
+  defp format_app_value([]), do: "(無)"
+  defp format_app_value(values) when is_list(values), do: Enum.join(values, ", ")
+  defp format_app_value(value) when is_binary(value), do: value
+  defp format_app_value(value), do: to_string(value)
+
+  # secret 只在成功當下一次性輸出（不寫入憑證檔／log／--verbose）。
+  defp print_secret_block(nil, _opts), do: :ok
+
+  defp print_secret_block(secret, rotated?: rotated?) do
+    lead = if rotated?, do: "client_secret 已輪轉", else: "client_secret"
+    IO.puts("#{lead}（只顯示這一次，請立即保存）：")
+    IO.puts("  #{secret}")
+  end
+
+  defp maybe_put(map, _key, nil), do: map
+  defp maybe_put(map, key, value), do: Map.put(map, key, value)
+
+  # -- 錯誤處理 --
+
+  # API 錯誤 → 依 §3.6 群組共通退出碼輸出，回傳退出碼。
+  defp fail_api(opts, ctx, error) do
+    {message, code} = format_api_error(ctx, error)
+    fail(opts, message, code)
+  end
+
+  defp format_api_error(_ctx, {:error, :unauthorized, desc}) do
+    {"token 無效或已過期（#{desc}），請重新 bear login", 3}
+  end
+
+  defp format_api_error(_ctx, {:error, :forbidden, _desc}) do
+    {"此操作需 admin 權限（HTTP 403）", 8}
+  end
+
+  defp format_api_error(_ctx, {:error, :not_found, _desc}) do
+    {"找不到目標 App（HTTP 404）", 1}
+  end
+
+  defp format_api_error(_ctx, {:error, :unprocessable_entity, %{"error" => "pkce_app"}}) do
+    {"此 App 為 PKCE，無 client secret 可輪轉", 1}
+  end
+
+  defp 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
+
+  defp format_api_error(_ctx, {:error, :server_error, status}) do
+    {"伺服器回應 #{status}", 6}
+  end
+
+  defp format_api_error(ctx, {:error, :network, reason}) do
+    {"無法連線到 #{ctx.issuer}：#{reason}", 6}
+  end
+
+  defp 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
+
+  defp blank?(nil), do: true
+
+  defp blank?(""), do: true
+  defp blank?(_), do: false
+end
@@ -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
@@ -8,7 +8,7 @@ defmodule BearCli.CLI do
  優先使用該值，不讀寫本機憑證檔。
  """

-  alias BearCli.{Api, Config, Credentials}
+  alias BearCli.{Accounts, Admin, Api, Apps, AuditLogs, Config, Credentials, Jwks, SelfService}

  @global_switches [
    issuer: :string,
@@ -23,6 +23,81 @@ defmodule BearCli.CLI do
  @login_switches [token: :string, scope: :string, "client-id": :string]
  @token_switches [refresh: :boolean]

+  # -- apps 指令群（docs/commands.md §3.6）--
+  # 注意：OptionParser 會把選項名的連字號正規化為底線
+  # （--client-id → :client_id），switch 定義需用底線 atom。
+  @apps_verbs ~w(list show create update rotate-secret toggle)
+
+  @apps_list_switches [
+    visibility: :string,
+    status: :string,
+    page: :integer,
+    per_page: :integer
+  ]
+
+  @apps_create_switches [
+    client_id: :string,
+    url: :string,
+    title: :string,
+    method: :string,
+    visibility: :string,
+    redirect_url: :keep,
+    post_logout_redirect_uri: :keep,
+    scope: :keep,
+    sub: :string,
+    jwk_id: :string,
+    secret: :string
+  ]
+
+  @apps_update_switches [
+    url: :string,
+    title: :string,
+    method: :string,
+    visibility: :string,
+    redirect_url: :keep,
+    post_logout_redirect_uri: :keep,
+    scope: :keep,
+    sub: :string,
+    jwk_id: :string
+  ]
+
+  @visibilities ~w(public internal)
+  @statuses ~w(active inactive)
+  @methods ~w(client_secret PKCE)
+
+  # -- 個人自助指令群（docs/commands.md §3.7）--
+
+  @profile_verbs ~w(show set)
+  @sessions_verbs ~w(list revoke revoke-others)
+  @tokens_verbs ~w(list create revoke)
+  @mfa_verbs ~w(status setup disable recovery-codes)
+
+  @profile_set_switches [
+    name: :string,
+    given_name: :string,
+    family_name: :string,
+    nickname: :string,
+    preferred_username: :string,
+    profile: :string,
+    picture: :string,
+    website: :string,
+    gender: :string,
+    birthdate: :string,
+    zoneinfo: :string,
+    locale: :string,
+    phone_number: :string,
+    phone_verified: :boolean,
+    address_formatted: :string,
+    address_street_address: :string,
+    address_locality: :string,
+    address_region: :string,
+    address_postal_code: :string,
+    address_country: :string
+  ]
+
+  @email_switches [new: :string]
+  @tokens_create_switches [name: :string, expires_in: :string]
+
  # -- escript 入口 --

  @doc "escript 主函式。執行後以 `System.halt/1` 設定退出碼。"
@@ -114,10 +189,164 @@ defmodule BearCli.CLI do
    end
  end

+  defp parse_command("apps", args, global) do
+    case args do
+      [verb | rest] when verb in @apps_verbs ->
+        switches = apps_switches(verb)
+
+        case OptionParser.parse(rest, strict: @global_switches ++ switches) do
+          {opts, positionals, []} ->
+            validate_apps(verb, positionals, merge_opts(global, opts_to_map(opts)))
+
+          {_opts, _extra, [{opt, _} | _]} ->
+            {:error, "無法解析選項：#{opt}", 2}
+        end
+
+      [] ->
+        {:error, "apps 缺少子指令（可用：#{Enum.join(@apps_verbs, " ")}）", 2}
+
+      [unknown | _] ->
+        {:error, "未知的 apps 子指令：#{unknown}（可用：#{Enum.join(@apps_verbs, " ")}）", 2}
+    end
+  end
+
+  defp parse_command("profile", args, global) do
+    case args do
+      [verb | rest] when verb in @profile_verbs ->
+        switches = if verb == "set", do: @profile_set_switches, else: []
+
+        case OptionParser.parse(rest, strict: @global_switches ++ switches) do
+          {opts, positionals, []} ->
+            validate_self_service(
+              :profile,
+              verb,
+              positionals,
+              merge_opts(global, opts_to_map(opts))
+            )
+
+          {_opts, _extra, [{opt, _} | _]} ->
+            {:error, "無法解析選項：#{opt}", 2}
+        end
+
+      [] ->
+        {:error, "profile 缺少子指令（可用：#{Enum.join(@profile_verbs, " ")}）", 2}
+
+      [unknown | _] ->
+        {:error, "未知的 profile 子指令：#{unknown}（可用：#{Enum.join(@profile_verbs, " ")}）", 2}
+    end
+  end
+
+  defp parse_command("password", args, global) do
+    case args do
+      ["change" | rest] ->
+        case OptionParser.parse(rest, strict: @global_switches) do
+          {opts, [], []} ->
+            {:ok, {:self_service, :password, :change}, merge_opts(global, opts_to_map(opts))}
+
+          {_opts, extra, []} ->
+            {:error, "password change 不接受參數：#{Enum.join(extra, " ")}", 2}
+
+          {_opts, _extra, [{opt, _} | _]} ->
+            {:error, "無法解析選項：#{opt}", 2}
+        end
+
+      [] ->
+        {:error, "password 缺少子指令（可用：change）", 2}
+
+      [unknown | _] ->
+        {:error, "未知的 password 子指令：#{unknown}（可用：change）", 2}
+    end
+  end
+
+  defp parse_command("email", args, global) do
+    case args do
+      ["change" | rest] ->
+        case OptionParser.parse(rest, strict: @global_switches ++ @email_switches) do
+          {opts, [], []} ->
+            {:ok, {:self_service, :email, :change}, merge_opts(global, opts_to_map(opts))}
+
+          {_opts, extra, []} ->
+            {:error, "email change 不接受位置參數：#{Enum.join(extra, " ")}", 2}
+
+          {_opts, _extra, [{opt, _} | _]} ->
+            {:error, "無法解析選項：#{opt}", 2}
+        end
+
+      [] ->
+        {:error, "email 缺少子指令（可用：change）", 2}
+
+      [unknown | _] ->
+        {:error, "未知的 email 子指令：#{unknown}（可用：change）", 2}
+    end
+  end
+
+  defp parse_command("sessions", args, global) do
+    case args do
+      [verb | rest] when verb in @sessions_verbs ->
+        parse_group_verb("sessions", verb, rest, [], global)
+
+      [] ->
+        {:error, "sessions 缺少子指令（可用：#{Enum.join(@sessions_verbs, " ")}）", 2}
+
+      [unknown | _] ->
+        {:error, "未知的 sessions 子指令：#{unknown}（可用：#{Enum.join(@sessions_verbs, " ")}）", 2}
+    end
+  end
+
+  defp parse_command("tokens", args, global) do
+    case args do
+      [verb | rest] when verb in @tokens_verbs ->
+        parse_group_verb("tokens", verb, rest, [], global)
+
+      [] ->
+        {:error, "tokens 缺少子指令（可用：#{Enum.join(@tokens_verbs, " ")}）", 2}
+
+      [unknown | _] ->
+        {:error, "未知的 tokens 子指令：#{unknown}（可用：#{Enum.join(@tokens_verbs, " ")}）", 2}
+    end
+  end
+
+  defp parse_command("mfa", args, global) do
+    case args do
+      [verb | rest] when verb in @mfa_verbs ->
+        parse_group_verb("mfa", verb, rest, [], global)
+
+      [] ->
+        {:error, "mfa 缺少子指令（可用：#{Enum.join(@mfa_verbs, " ")}）", 2}
+
+      [unknown | _] ->
+        {:error, "未知的 mfa 子指令：#{unknown}（可用：#{Enum.join(@mfa_verbs, " ")}）", 2}
+    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
    {:error, "未知指令：#{unknown}（可用 bear --help 查看說明）", 2}
  end

+  # sessions／tokens／mfa 共用：verb 已驗證合法後解析選項與位置參數。
+  defp parse_group_verb(group, verb, rest, extra_switches, global) do
+    switches = group_switches(group, verb) ++ extra_switches
+
+    case OptionParser.parse(rest, strict: @global_switches ++ switches) do
+      {opts, positionals, []} ->
+        validate_self_service(group, verb, positionals, merge_opts(global, opts_to_map(opts)))
+
+      {_opts, _extra, [{opt, _} | _]} ->
+        {:error, "無法解析選項：#{opt}", 2}
+    end
+  end
+
+  defp group_switches("tokens", "create"), do: @tokens_create_switches
+  defp group_switches(_group, _verb), do: []
+
  defp parse_opts(args, switches) do
    case OptionParser.parse(args, strict: switches) do
      {opts, [], []} ->
@@ -131,10 +360,217 @@ defmodule BearCli.CLI do
    end
  end

+  # -- apps 解析輔助 --
+
+  defp apps_switches("list"), do: @apps_list_switches
+  defp apps_switches("show"), do: []
+  defp apps_switches("create"), do: @apps_create_switches
+  defp apps_switches("update"), do: @apps_update_switches
+  defp apps_switches("rotate-secret"), do: []
+  defp apps_switches("toggle"), do: []
+
+  # apps 子指令的本地用法驗證（§3.6：用法錯誤 → 退出碼 2）。
+  defp validate_apps("list", [], opts) do
+    cond do
+      invalid_enum?(opts[:visibility], @visibilities, "--visibility") ->
+        usage_error(opts[:visibility], "--visibility", @visibilities)
+
+      invalid_enum?(opts[:status], @statuses, "--status") ->
+        usage_error(opts[:status], "--status", @statuses)
+
+      true ->
+        {:ok, {Apps, :list}, opts}
+    end
+  end
+
+  defp validate_apps("list", extra, _opts),
+    do: {:error, "apps list 不接受位置參數：#{Enum.join(extra, " ")}", 2}
+
+  defp validate_apps("show", [client_id], opts),
+    do: {:ok, {Apps, :show}, Map.put(opts, :client_id_arg, client_id)}
+
+  defp validate_apps("show", [], _opts), do: {:error, "apps show 缺少 <client-id>", 2}
+
+  defp validate_apps("show", extra, _opts),
+    do: {:error, "apps show 只接受一個 <client-id>（多餘：#{Enum.join(Enum.drop(extra, 1), " ")}）", 2}
+
+  defp validate_apps("create", [], opts) do
+    missing =
+      [{"client-id", opts[:client_id]}, {"url", opts[:url]}, {"title", opts[:title]}]
+      |> Enum.filter(fn {_name, v} -> blank?(v) end)
+      |> Enum.map(&elem(&1, 0))
+
+    cond do
+      missing != [] ->
+        {:error, "apps create 缺少必選參數：#{Enum.join(missing, "、")}", 2}
+
+      invalid_enum?(opts[:method], @methods, "--method") ->
+        usage_error(opts[:method], "--method", @methods)
+
+      invalid_enum?(opts[:visibility], @visibilities, "--visibility") ->
+        usage_error(opts[:visibility], "--visibility", @visibilities)
+
+      opts[:method] == "PKCE" and blank?(opts[:jwk_id]) ->
+        {:error, "method=PKCE 必須給 --jwk-id", 2}
+
+      true ->
+        {:ok, {Apps, :create}, opts}
+    end
+  end
+
+  defp validate_apps("create", extra, _opts),
+    do: {:error, "apps create 不接受位置參數：#{Enum.join(extra, " ")}", 2}
+
+  defp validate_apps("update", [client_id], opts) do
+    cond do
+      invalid_enum?(opts[:method], @methods, "--method") ->
+        usage_error(opts[:method], "--method", @methods)
+
+      invalid_enum?(opts[:visibility], @visibilities, "--visibility") ->
+        usage_error(opts[:visibility], "--visibility", @visibilities)
+
+      opts[:method] == "PKCE" and blank?(opts[:jwk_id]) ->
+        {:error, "method=PKCE 必須給 --jwk-id", 2}
+
+      true ->
+        {:ok, {Apps, :update}, Map.put(opts, :client_id_arg, client_id)}
+    end
+  end
+
+  defp validate_apps("update", [], _opts), do: {:error, "apps update 缺少 <client-id>", 2}
+
+  defp validate_apps("update", extra, _opts),
+    do: {:error, "apps update 只接受一個 <client-id>（多餘：#{Enum.join(Enum.drop(extra, 1), " ")}）", 2}
+
+  defp validate_apps("rotate-secret", [client_id], opts),
+    do: {:ok, {Apps, :"rotate-secret"}, Map.put(opts, :client_id_arg, client_id)}
+
+  defp validate_apps("rotate-secret", [], _opts),
+    do: {:error, "apps rotate-secret 缺少 <client-id>", 2}
+
+  defp validate_apps("rotate-secret", extra, _opts),
+    do:
+      {:error, "apps rotate-secret 只接受一個 <client-id>（多餘：#{Enum.join(Enum.drop(extra, 1), " ")}）",
+       2}
+
+  defp validate_apps("toggle", [client_id], opts),
+    do: {:ok, {Apps, :toggle}, Map.put(opts, :client_id_arg, client_id)}
+
+  defp validate_apps("toggle", [], _opts), do: {:error, "apps toggle 缺少 <client-id>", 2}
+
+  defp validate_apps("toggle", extra, _opts),
+    do: {:error, "apps toggle 只接受一個 <client-id>（多餘：#{Enum.join(Enum.drop(extra, 1), " ")}）", 2}
+
+  defp invalid_enum?(nil, _allowed, _flag), do: false
+  defp invalid_enum?(value, allowed, _flag), do: value not in allowed
+
+  defp usage_error(value, flag, allowed) do
+    {:error, "#{flag} 不接受的值：#{value}（可用：#{Enum.join(allowed, "、")}）", 2}
+  end
+
+  # -- 個人自助指令群解析輔助（§3.7）--
+
+  # 各群組的位置參數驗證；通過後回 {:ok, {:self_service, group, verb}, opts}。
+  defp validate_self_service(:profile, "show", [], opts),
+    do: {:ok, {:self_service, :profile, :show}, opts}
+
+  defp validate_self_service(:profile, "show", extra, _opts),
+    do: {:error, "profile show 不接受位置參數：#{Enum.join(extra, " ")}", 2}
+
+  defp validate_self_service(:profile, "set", [], opts),
+    do: {:ok, {:self_service, :profile, :set}, opts}
+
+  defp validate_self_service(:profile, "set", extra, _opts),
+    do: {:error, "profile set 不接受位置參數：#{Enum.join(extra, " ")}", 2}
+
+  defp validate_self_service("sessions", "list", [], opts),
+    do: {:ok, {:self_service, :sessions, :list}, opts}
+
+  defp validate_self_service("sessions", "list", extra, _opts),
+    do: {:error, "sessions list 不接受位置參數：#{Enum.join(extra, " ")}", 2}
+
+  defp validate_self_service("sessions", "revoke", [id], opts),
+    do: {:ok, {:self_service, :sessions, :revoke}, Map.put(opts, :id_arg, id)}
+
+  defp validate_self_service("sessions", "revoke", [], _opts),
+    do: {:error, "sessions revoke 缺少 <id>", 2}
+
+  defp validate_self_service("sessions", "revoke", extra, _opts),
+    do: {:error, "sessions revoke 只接受一個 <id>（多餘：#{Enum.join(Enum.drop(extra, 1), " ")}）", 2}
+
+  defp validate_self_service("sessions", "revoke-others", [], opts),
+    do: {:ok, {:self_service, :sessions, :"revoke-others"}, opts}
+
+  defp validate_self_service("sessions", "revoke-others", extra, _opts),
+    do: {:error, "sessions revoke-others 不接受位置參數：#{Enum.join(extra, " ")}", 2}
+
+  defp validate_self_service("tokens", "list", [], opts),
+    do: {:ok, {:self_service, :tokens, :list}, opts}
+
+  defp validate_self_service("tokens", "list", extra, _opts),
+    do: {:error, "tokens list 不接受位置參數：#{Enum.join(extra, " ")}", 2}
+
+  defp validate_self_service("tokens", "create", [], opts) do
+    if blank?(opts[:name]) do
+      {:error, "tokens create 缺少 --name NAME", 2}
+    else
+      {:ok, {:self_service, :tokens, :create}, opts}
+    end
+  end
+
+  defp validate_self_service("tokens", "create", extra, _opts),
+    do: {:error, "tokens create 不接受位置參數：#{Enum.join(extra, " ")}", 2}
+
+  defp validate_self_service("tokens", "revoke", [id], opts),
+    do: {:ok, {:self_service, :tokens, :revoke}, Map.put(opts, :id_arg, id)}
+
+  defp validate_self_service("tokens", "revoke", [], _opts),
+    do: {:error, "tokens revoke 缺少 <id>", 2}
+
+  defp validate_self_service("tokens", "revoke", extra, _opts),
+    do: {:error, "tokens revoke 只接受一個 <id>（多餘：#{Enum.join(Enum.drop(extra, 1), " ")}）", 2}
+
+  defp validate_self_service("mfa", "status", [], opts),
+    do: {:ok, {:self_service, :mfa, :status}, opts}
+
+  defp validate_self_service("mfa", "status", extra, _opts),
+    do: {:error, "mfa status 不接受位置參數：#{Enum.join(extra, " ")}", 2}
+
+  defp validate_self_service("mfa", "setup", [], opts),
+    do: {:ok, {:self_service, :mfa, :setup}, opts}
+
+  defp validate_self_service("mfa", "setup", extra, _opts),
+    do: {:error, "mfa setup 不接受位置參數：#{Enum.join(extra, " ")}", 2}
+
+  defp validate_self_service("mfa", "disable", [], opts),
+    do: {:ok, {:self_service, :mfa, :disable}, opts}
+
+  defp validate_self_service("mfa", "disable", extra, _opts),
+    do: {:error, "mfa disable 不接受位置參數：#{Enum.join(extra, " ")}", 2}
+
+  defp validate_self_service("mfa", "recovery-codes", [], opts),
+    do: {:ok, {:self_service, :mfa, :"recovery-codes"}, opts}
+
+  defp validate_self_service("mfa", "recovery-codes", extra, _opts),
+    do: {:error, "mfa recovery-codes 不接受位置參數：#{Enum.join(extra, " ")}", 2}
+
  defp merge_opts(global, opts) do
    Map.merge(Map.new(global), Map.new(opts))
  end

+  # keyword 轉 map：`:keep` 選項（@keep_keys）重複出現時收集為清單，其餘取最後值。
+  @keep_keys ~w(redirect_url post_logout_redirect_uri scope)a
+
+  defp opts_to_map(opts) do
+    Enum.reduce(opts, %{}, fn
+      {k, v}, acc when k in @keep_keys ->
+        Map.update(acc, k, [v], fn existing -> existing ++ [v] end)
+
+      {k, v}, acc ->
+        Map.put(acc, k, v)
+    end)
+  end
+
  # -- 分派 --

  @doc """
@@ -156,6 +592,30 @@ defmodule BearCli.CLI do
        IO.puts(:stderr, "錯誤：#{message}")
        code

+      # apps 指令群（{:ok, {module, verb}, opts} 形狀；注入的 api 模組同時作為 apps_api）
+      {:ok, {Apps, verb}, cmd_opts} when is_atom(verb) ->
+        apps_api = cmd_opts[:apps_api] || opts[:apps_api] || Api
+        Apps.run(verb, Map.put(cmd_opts, :apps_api, apps_api))
+
+      # 個人自助指令群（{:ok, {:self_service, group, verb}, opts} 形狀）
+      {:ok, {:self_service, group, verb}, cmd_opts} when is_atom(group) and is_atom(verb) ->
+        inject_opts = opts |> Map.new() |> Map.take([:ss_api, :io, :tty?])
+        ss_opts = Map.merge(inject_opts, Map.take(cmd_opts, [:ss_api, :io, :tty?]))
+        SelfService.run(group, verb, Map.merge(cmd_opts, ss_opts))
+
+      # 管理端指令群（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} ->
        cond do
          cmd_opts[:version] ->
@@ -463,6 +923,52 @@ defmodule BearCli.CLI do
      token [--refresh]     印出 access token（PAT 模式下 --refresh 為用法錯誤）
      logout                登出（清除本機憑證）
      status                顯示登入狀態
+      apps <動詞>            App 管理（admin；bear apps --help 查看）
+      jwks <動詞>            簽章金鑰管理（admin）
+      accounts <動詞>        帳號管理（admin）
+      audit-logs list        稽核日誌（admin）
+      profile <動詞>         個人資料（show／set）
+      password change       變更密碼（互動輸入，不進 shell history）
+      email change --new E  變更 email（雙向驗證碼流程）
+      sessions <動詞>        管理網頁 session（list／revoke／revoke-others）
+      tokens <動詞>          管理 PAT（list／create／revoke）
+      mfa <動詞>             TOTP 兩因子（status／setup／disable／recovery-codes）
+
+    apps 指令群（需 admin 權限的 PAT）：
+      apps list [--visibility public|internal] [--status active|inactive]
+                [--page N] [--per-page N]
+      apps show <client-id>
+      apps create --client-id ID --url URL --title TITLE
+                  [--method client_secret|PKCE] [--visibility public|internal]
+                  [--redirect-url URL]... [--post-logout-redirect-uri URI]...
+                  [--scope SCOPE]... [--sub FIELD] [--jwk-id ID] [--secret SECRET]
+      apps update <client-id> [同 create 的選項；只更新有給的欄位]
+      apps rotate-secret <client-id>
+      apps toggle <client-id>
+
+    個人自助指令群（任何有效 PAT 皆可）：
+      profile show
+      profile set [--name NAME] [--given-name NAME] [--family-name NAME]
+                  [--nickname NAME] [--preferred-username NAME]
+                  [--profile URL] [--picture URL] [--website URL]
+                  [--gender male|female|other] [--birthdate YYYY-MM-DD]
+                  [--zoneinfo TZ] [--locale LOC] [--phone-number E164]
+                  [--phone-verified] [--address-formatted TEXT]
+                  [--address-street-address TEXT] [--address-locality TEXT]
+                  [--address-region TEXT] [--address-postal-code TEXT]
+                  [--address-country TEXT]
+      password change
+      email change --new EMAIL
+      sessions list
+      sessions revoke <id>
+      sessions revoke-others
+      tokens list
+      tokens create --name NAME [--expires-in DAYS|never]
+      tokens revoke <id>
+      mfa status
+      mfa setup
+      mfa disable
+      mfa recovery-codes

    全域選項：
      --issuer URL          Bear（OIDC Provider）位址（預設 https://alterminal.com）
@@ -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
@@ -0,0 +1,775 @@
+defmodule BearCli.SelfService do
+  @moduledoc """
+  `bear` 個人自助指令群（docs/commands.md §3.7、issue #11）。
+
+  對應伺服器端個人自助 JSON API（alterminal/bear#35，`/api/v1/profile*`、
+  PAT Bearer、任何有效帳號）：profile／password／email／sessions／
+  tokens／mfa。
+
+  - 敏感輸入（密碼、email／MFA 驗證碼）一律互動提示讀取且不回顧，
+    不接受命令列明文參數；非 TTY 環境 → 退出碼 2。
+  - 一次性明文（`tokens create` 的 PAT、`mfa` 的 recovery codes）只於
+    成功當下輸出於 stdout，不寫入憑證檔／log／`--verbose` 輸出。
+
+  退出碼：0 成功；1 404／422／429；2 用法錯誤（含非 TTY 的互動輸入）；
+  3 未登入或 401；6 網路／伺服器錯誤；8 權限不足（403）。
+  """
+
+  alias BearCli.{Api, Config, Credentials}
+
+  @genders ~w(male female other)
+
+  # profile set 的可更新欄位：CLI 選項名（atom）→ API 欄位名。
+  @profile_set_fields [
+    name: "name",
+    given_name: "given_name",
+    family_name: "family_name",
+    nickname: "nickname",
+    preferred_username: "preferred_username",
+    profile: "profile",
+    picture: "picture",
+    website: "website",
+    gender: "gender",
+    birthdate: "birthdate",
+    zoneinfo: "zoneinfo",
+    locale: "locale",
+    phone_number: "phone_number",
+    phone_verified: "phone_number_verified",
+    address_formatted: "address_formatted",
+    address_street_address: "address_street_address",
+    address_locality: "address_locality",
+    address_region: "address_region",
+    address_postal_code: "address_postal_code",
+    address_country: "address_country"
+  ]
+
+  @url_fields ~w(profile picture website)
+
+  # -- 入口 --
+
+  @doc """
+  執行個人自助指令，回傳退出碼。`group` 為 :profile／:password／:email／
+  :sessions／:tokens／:mfa，`verb` 為子指令 atom，`opts` 為解析後選項。
+
+  `opts[:ss_api]` 可注入假 API 模組供測試；`opts[:io]` 可注入互動輸入
+  模組（實作 `prompt_secret/1`），`opts[:tty?]` 可覆寫 TTY 判定。
+  """
+  def run(group, verb, opts) do
+    api = opts[:ss_api] || Api
+
+    with {:ok, ctx} <- context(opts) do
+      execute(group, verb, ctx, opts, api)
+    else
+      {:error, message, code} -> fail(opts, message, code)
+    end
+  end
+
+  # -- 各指令實作（execute/5 子句群）--
+
+  defp execute(:profile, :show, ctx, opts, api) do
+    case api.profile_get(ctx.issuer, ctx.token) do
+      {:ok, body} ->
+        show_profile(body["data"] || %{}, opts)
+        0
+
+      {:error, _kind, _detail} = error ->
+        fail_api(opts, ctx, error)
+    end
+  end
+
+  defp execute(:profile, :set, ctx, opts, api) do
+    case build_profile_attrs(opts) do
+      {:ok, attrs} ->
+        case api.profile_update(ctx.issuer, ctx.token, attrs) do
+          {:ok, body} ->
+            show_profile(body["data"] || %{}, opts)
+            0
+
+          {:error, _kind, _detail} = error ->
+            fail_api(opts, ctx, error)
+        end
+
+      {:error, message, code} ->
+        fail(opts, message, code)
+    end
+  end
+
+  defp execute(:password, :change, ctx, opts, api) do
+    with {:ok, {current, new}} <- read_password_prompts(opts) do
+      case api.profile_change_password(ctx.issuer, ctx.token, current, new) do
+        {:ok, _body} ->
+          if opts[:json] do
+            IO.puts(Jason.encode!(%{ok: true}))
+          else
+            IO.puts("密碼已變更")
+            IO.puts("提醒：變更密碼不自動撤銷其他 session；需要時另用 bear sessions revoke-others。")
+          end
+
+          0
+
+        {:error, _kind, _detail} = error ->
+          fail_api(opts, ctx, error)
+      end
+    else
+      {:error, message, code} -> fail(opts, message, code)
+    end
+  end
+
+  defp execute(:email, :change, ctx, opts, api) do
+    # OptionParser 把 --new EMAIL 正規化為 :new（底線）。
+    new_email = opts[:new] || opts[:new_email]
+
+    with :ok <- require_new_email(new_email),
+         {:ok, {current_code, new_code}} <- request_and_read_codes(ctx, opts, api, new_email) do
+      case api.profile_email_change(ctx.issuer, ctx.token, new_email, current_code, new_code) do
+        {:ok, body} ->
+          updated = (body["data"] || %{})["email"] || new_email
+
+          if opts[:json] do
+            IO.puts(Jason.encode!(%{ok: true, email: updated}))
+          else
+            IO.puts("email 已更新：#{updated}")
+            IO.puts("提醒：bear login 用的 PAT 不綁 email，不受影響。")
+          end
+
+          0
+
+        {:error, _kind, _detail} = error ->
+          fail_api(opts, ctx, error)
+      end
+    else
+      {:error, message, code} -> fail(opts, message, code)
+    end
+  end
+
+  defp execute(:sessions, :list, ctx, opts, api) do
+    case api.sessions_list(ctx.issuer, ctx.token) do
+      {:ok, body} ->
+        sessions = body["data"] || []
+
+        if opts[:json] do
+          IO.puts(Jason.encode!(%{ok: true, sessions: sessions}))
+        else
+          print_sessions_table(sessions)
+        end
+
+        0
+
+      {:error, _kind, _detail} = error ->
+        fail_api(opts, ctx, error)
+    end
+  end
+
+  defp execute(:sessions, :revoke, ctx, opts, api) do
+    id = opts[:id_arg]
+
+    with :ok <- require_id(id, "sessions revoke") do
+      case api.sessions_revoke(ctx.issuer, ctx.token, id) do
+        {:ok, _body} ->
+          if opts[:json] do
+            IO.puts(Jason.encode!(%{ok: true, revoked: id}))
+          else
+            IO.puts("session 已撤銷")
+          end
+
+          0
+
+        {:error, _kind, _detail} = error ->
+          fail_api(opts, ctx, error)
+      end
+    else
+      {:error, message, code} -> fail(opts, message, code)
+    end
+  end
+
+  defp execute(:sessions, :"revoke-others", ctx, opts, api) do
+    case api.sessions_revoke_others(ctx.issuer, ctx.token) do
+      {:ok, body} ->
+        count = (body["data"] || %{})["revoked_count"]
+
+        if opts[:json] do
+          IO.puts(Jason.encode!(%{ok: true, revoked: count}))
+        else
+          IO.puts("已撤銷 #{count} 個其他 session")
+        end
+
+        0
+
+      {:error, _kind, _detail} = error ->
+        fail_api(opts, ctx, error)
+    end
+  end
+
+  defp execute(:tokens, :list, ctx, opts, api) do
+    case api.tokens_list(ctx.issuer, ctx.token) do
+      {:ok, body} ->
+        tokens = body["data"] || []
+
+        if opts[:json] do
+          IO.puts(Jason.encode!(%{ok: true, tokens: tokens}))
+        else
+          print_tokens_table(tokens)
+        end
+
+        0
+
+      {:error, _kind, _detail} = error ->
+        fail_api(opts, ctx, error)
+    end
+  end
+
+  defp execute(:tokens, :create, ctx, opts, api) do
+    name = opts[:name]
+
+    with {:ok, expires_in} <- parse_expires_in(opts[:expires_in]) do
+      case api.tokens_create(ctx.issuer, ctx.token, name, expires_in) do
+        {:ok, body} ->
+          token = body["data"] || %{}
+          raw = body["token"]
+
+          if opts[:json] do
+            IO.puts(Jason.encode!(%{ok: true, token: token, raw: raw}))
+          else
+            expires_at = token["expires_at"]
+            expiry_note = if expires_at, do: "（#{expires_at} 到期）", else: "（無到期日）"
+
+            IO.puts("PAT 已建立：#{token["name"]}#{expiry_note}")
+            IO.puts("token（只顯示這一次，請立即保存）：")
+            IO.puts("  #{raw}")
+            IO.puts("提醒：新 PAT 要使用須另以 bear login --token 登入（或設 BEAR_TOKEN）。")
+          end
+
+          0
+
+        {:error, _kind, _detail} = error ->
+          fail_api(opts, ctx, error)
+      end
+    else
+      {:error, message, code} -> fail(opts, message, code)
+    end
+  end
+
+  defp execute(:tokens, :revoke, ctx, opts, api) do
+    id = opts[:id_arg]
+
+    with :ok <- require_id(id, "tokens revoke") do
+      case api.tokens_revoke(ctx.issuer, ctx.token, id) do
+        {:ok, body} ->
+          if opts[:json] do
+            IO.puts(Jason.encode!(%{ok: true, revoked: (body["data"] || %{})["revoked"] || id}))
+          else
+            IO.puts("PAT 已撤銷")
+          end
+
+          # 撤銷目前憑證用的 PAT 時，後續指令會得 401；本機憑證檔只存 PAT
+          # 明文、未存 token id，CLI 無法可靠比對，一律提示重新登入的退路。
+          IO.puts(
+            :stderr,
+            "提醒：若撤銷的是本機憑證所用的 PAT，後續指令會得到 401；屆時重新 bear login。"
+          )
+
+          0
+
+        {:error, _kind, _detail} = error ->
+          fail_api(opts, ctx, error)
+      end
+    else
+      {:error, message, code} -> fail(opts, message, code)
+    end
+  end
+
+  defp execute(:mfa, :status, ctx, opts, api) do
+    case api.profile_get(ctx.issuer, ctx.token) do
+      {:ok, body} ->
+        data = body["data"] || %{}
+        enabled = data["mfa_enabled"] || data["totp_enabled"] || false
+
+        if opts[:json] do
+          IO.puts(Jason.encode!(%{ok: true, totp_enabled: enabled}))
+        else
+          IO.puts("MFA（TOTP）：#{if enabled, do: "已啟用", else: "未啟用"}")
+        end
+
+        0
+
+      {:error, _kind, _detail} = error ->
+        fail_api(opts, ctx, error)
+    end
+  end
+
+  defp execute(:mfa, :setup, ctx, opts, api) do
+    with {:ok, _data} <- mfa_begin(ctx, opts, api),
+         {:ok, code} <- prompt_secret(opts, "6 位驗證碼（掃描 QR 後由驗證器產生）") do
+      case api.mfa_setup_confirm(ctx.issuer, ctx.token, code) do
+        {:ok, body} ->
+          codes = (body["data"] || %{})["recovery_codes"] || []
+
+          if opts[:json] do
+            IO.puts(Jason.encode!(%{ok: true, recovery_codes: codes}))
+          else
+            IO.puts("MFA 已啟用。")
+            print_recovery_codes(codes)
+          end
+
+          0
+
+        {:error, _kind, _detail} = error ->
+          fail_api(opts, ctx, error)
+      end
+    else
+      {:error, message, code} -> fail(opts, message, code)
+    end
+  end
+
+  defp execute(:mfa, :disable, ctx, opts, api) do
+    with {:ok, code} <- prompt_secret(opts, "目前的 TOTP 碼或 recovery code") do
+      case api.mfa_disable(ctx.issuer, ctx.token, code) do
+        {:ok, _body} ->
+          if opts[:json] do
+            IO.puts(Jason.encode!(%{ok: true}))
+          else
+            IO.puts("MFA 已停用")
+          end
+
+          0
+
+        {:error, _kind, _detail} = error ->
+          fail_api(opts, ctx, error)
+      end
+    else
+      {:error, message, code} -> fail(opts, message, code)
+    end
+  end
+
+  defp execute(:mfa, :"recovery-codes", ctx, opts, api) do
+    with {:ok, code} <- prompt_secret(opts, "目前的 TOTP 碼或 recovery code") do
+      case api.mfa_recovery_codes(ctx.issuer, ctx.token, code) do
+        {:ok, body} ->
+          codes = (body["data"] || %{})["recovery_codes"] || []
+
+          if opts[:json] do
+            IO.puts(Jason.encode!(%{ok: true, recovery_codes: codes}))
+          else
+            print_recovery_codes(codes)
+          end
+
+          0
+
+        {:error, _kind, _detail} = error ->
+          fail_api(opts, ctx, error)
+      end
+    else
+      {:error, message, code} -> fail(opts, message, code)
+    end
+  end
+
+  # -- 共用背景（token／issuer）--
+
+  defp 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
+
+  # -- profile set 屬性組裝與本地驗證 --
+
+  # 只送有給的欄位（§3.7.2）；非法值本地檢查 → 用法錯誤 2，不發請求。
+  defp build_profile_attrs(opts) do
+    given =
+      @profile_set_fields
+      |> Enum.flat_map(fn {opt_key, api_key} ->
+        case Map.get(opts, opt_key) do
+          v when is_binary(v) and v != "" -> [{api_key, v}]
+          true -> [{api_key, true}]
+          _other -> []
+        end
+      end)
+      |> Map.new()
+
+    cond do
+      given == %{} ->
+        {:error, "profile set 未給任何欄位（可用選項見 bear --help）", 2}
+
+      invalid_gender?(given) ->
+        {:error, "--gender 不接受的值：#{given["gender"]}（可用：#{Enum.join(@genders, "、")}）", 2}
+
+      true ->
+        check_url_fields(given)
+    end
+  end
+
+  defp invalid_gender?(%{"gender" => g}), do: g not in @genders
+  defp invalid_gender?(_), do: false
+
+  # URL 類欄位本地檢查 http(s)://（§3.7.2）。
+  defp check_url_fields(given) do
+    bad =
+      Enum.find(@url_fields, fn field ->
+        case given[field] do
+          v when is_binary(v) ->
+            not (String.starts_with?(v, "http://") or String.starts_with?(v, "https://"))
+
+          _ ->
+            false
+        end
+      end)
+
+    case bad do
+      nil -> {:ok, given}
+      field -> {:error, "--#{String.replace(field, "_", "-")} 需為 http(s):// 開頭的 URL", 2}
+    end
+  end
+
+  # -- password 互動輸入 --
+
+  defp read_password_prompts(opts) do
+    with {:ok, current} <- prompt_secret(opts, "目前密碼"),
+         {:ok, new} <- prompt_secret(opts, "新密碼"),
+         {:ok, confirm} <- prompt_secret(opts, "確認新密碼") do
+      if new == confirm do
+        {:ok, {current, new}}
+      else
+        # 兩次新密碼不一致 → 本地檢查，不發請求（§3.7.3）。
+        {:error, "兩次輸入的新密碼不一致", 2}
+      end
+    end
+  end
+
+  # -- email 流程輔助 --
+
+  defp require_new_email(nil), do: {:error, "email change 缺少 --new EMAIL", 2}
+  defp require_new_email(""), do: {:error, "email change 缺少 --new EMAIL", 2}
+  defp require_new_email(_), do: :ok
+
+  defp request_and_read_codes(ctx, opts, api, new_email) do
+    case api.profile_email_request_codes(ctx.issuer, ctx.token, new_email) do
+      {:ok, _body} ->
+        IO.puts(:stderr, "驗證碼已寄至現有信箱與 #{new_email}，請查收。")
+
+        with {:ok, current_code} <- prompt_secret(opts, "現有信箱驗證碼"),
+             {:ok, new_code} <- prompt_secret(opts, "新信箱驗證碼") do
+          {:ok, {current_code, new_code}}
+        end
+
+      {:error, _kind, _detail} = error ->
+        {message, code} = format_api_error(ctx, error)
+        {:error, message, code}
+    end
+  end
+
+  # -- tokens create 選項 --
+
+  # --expires-in：正整數天數或 never；預設 30（§3.7.6）。
+  defp parse_expires_in(nil), do: {:ok, "30"}
+  defp parse_expires_in("never"), do: {:ok, "never"}
+
+  defp parse_expires_in(value) when is_binary(value) do
+    case Integer.parse(value) do
+      {n, ""} when n > 0 -> {:ok, value}
+      _ -> {:error, "--expires-in 需為正整數天數或 never", 2}
+    end
+  end
+
+  # -- mfa setup 第一步 --
+
+  defp mfa_begin(ctx, opts, api) do
+    case api.mfa_setup(ctx.issuer, ctx.token) do
+      {:ok, body} ->
+        data = body["data"] || %{}
+        secret = data["secret"]
+        uri = data["otpauth_uri"]
+
+        if opts[:json] do
+          # 兩步互動流程：第一步資訊走 stderr（stdout 保留給最終結果 JSON，
+          # 維持單一 JSON 物件的機器可讀輸出）。
+          IO.puts(
+            :stderr,
+            Jason.encode!(%{step: "setup", secret: secret, otpauth_uri: uri})
+          )
+        else
+          IO.puts("請用驗證器（Google Authenticator 等）掃描 QR，或手動輸入：")
+          IO.puts("  otpauth URI：#{uri}")
+          IO.puts("  secret（Base32）：#{secret}")
+          print_qr(uri)
+        end
+
+        {:ok, data}
+
+      {:error, _kind, _detail} = error ->
+        {message, code} = format_api_error(ctx, error)
+        {:error, message, code}
+    end
+  end
+
+  # -- 互動輸入 --
+
+  # 敏感輸入一律互動提示讀取且不回顯；非 TTY → 退出碼 2（§3.7 群組共通）。
+  # 測試可注入 opts[:io]（實作 prompt_secret/1）與 opts[:tty?]。
+  defp prompt_secret(opts, label) do
+    tty? = Map.get(opts, :tty?, true)
+    io = opts[:io]
+
+    cond do
+      not tty? ->
+        {:error, "此指令需要互動輸入（#{label}），請在終端機執行", 2}
+
+      io ->
+        case io.prompt_secret(label) do
+          :eof -> {:error, "未讀到輸入（#{label}）", 2}
+          {:ok, value} -> {:ok, value}
+        end
+
+      true ->
+        # 非 TTY（pipe／redirect）讀不到互動輸入 → 退出碼 2（§3.7 群組共通）。
+        if tty_stdin?() do
+          case IO.gets("#{label}：") do
+            :eof -> {:error, "未讀到輸入（#{label}）", 2}
+            line -> {:ok, String.trim(line)}
+          end
+        else
+          {:error, "此指令需要互動輸入（#{label}），請在終端機執行", 2}
+        end
+    end
+  end
+
+  # :io.rows/0 僅在終端機裝置成功；pipe／檔案重導回 {:error, :enotsup}。
+  defp tty_stdin? do
+    match?({:ok, _}, :io.rows())
+  end
+
+  # -- 輸出 --
+
+  @profile_fields ~w(id email role name given_name family_name nickname preferred_username profile picture website gender birthdate zoneinfo locale phone_number phone_number_verified address mfa_enabled created_at updated_at)
+
+  defp show_profile(profile, opts) do
+    if opts[:json] do
+      IO.puts(Jason.encode!(%{ok: true, profile: profile}))
+    else
+      Enum.each(@profile_fields, fn key ->
+        if Map.has_key?(profile, key) do
+          IO.puts("#{String.pad_trailing(key, 22)}: #{format_value(profile[key])}")
+        end
+      end)
+    end
+  end
+
+  defp format_value(nil), do: "(無)"
+  defp format_value(true), do: "true"
+  defp format_value(false), do: "false"
+  defp format_value(v) when is_binary(v), do: v
+  defp format_value(v) when is_number(v), do: to_string(v)
+  defp format_value(v), do: Jason.encode!(v)
+
+  @sessions_headers ["ID", "IP", "USER AGENT", "CREATED", "LAST SEEN"]
+
+  defp print_sessions_table(sessions) do
+    rows =
+      Enum.map(sessions, fn s ->
+        [
+          s["id"] || "",
+          s["ip"] || "",
+          truncate(s["user_agent"] || "", 28),
+          s["created_at"] || "",
+          s["last_seen_at"] || ""
+        ]
+      end)
+
+    print_table(@sessions_headers, rows)
+  end
+
+  @tokens_headers ["ID", "NAME", "SCOPE", "CREATED", "EXPIRES", "LAST USED", "STATUS"]
+
+  defp print_tokens_table(tokens) do
+    rows =
+      Enum.map(tokens, fn t ->
+        [
+          t["id"] || "",
+          t["name"] || "",
+          t["scope"] || "",
+          t["created_at"] || "",
+          t["expires_at"] || "(無到期)",
+          t["last_used_at"] || "(未使用)",
+          token_status(t)
+        ]
+      end)
+
+    print_table(@tokens_headers, rows)
+  end
+
+  # list 僅回未撤銷 token；STATUS 依 expires_at 本地判定（§3.7.6）。
+  defp token_status(%{"expires_at" => nil}), do: "active"
+
+  defp token_status(%{"expires_at" => expires_at}) when is_binary(expires_at) do
+    case DateTime.from_iso8601(expires_at) do
+      {:ok, dt, _} ->
+        if DateTime.compare(dt, DateTime.utc_now()) == :gt, do: "active", else: "expired"
+
+      _ ->
+        "active"
+    end
+  end
+
+  defp token_status(_), do: "active"
+
+  defp print_table(headers, rows) do
+    widths =
+      Enum.with_index(headers, fn _h, i ->
+        Enum.max([
+          String.length(Enum.at(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(to_string(cell), Enum.at(widths, i)) end)
+      |> Enum.join("  ")
+      |> String.trim_trailing()
+    end
+
+    IO.puts(render_row.(headers))
+
+    case rows do
+      [] -> IO.puts("(無資料)")
+      _ -> Enum.each(rows, fn cells -> IO.puts(render_row.(cells)) end)
+    end
+  end
+
+  defp truncate(text, max) do
+    if String.length(text) > max do
+      String.slice(text, 0, max - 1) <> "…"
+    else
+      text
+    end
+  end
+
+  # recovery codes 只顯示一次（同 PAT 明文處理）。
+  defp print_recovery_codes([]), do: IO.puts("(伺服器未回傳 recovery codes)")
+
+  defp print_recovery_codes(codes) do
+    IO.puts("recovery codes（只顯示這一次，請立即保存；舊組全部失效）：")
+
+    Enum.each(codes, fn code ->
+      IO.puts("  #{code}")
+    end)
+  end
+
+  # QR 由 CLI 本地生成（eqrcode），不經伺服器（§3.7.7）。產生失敗不阻斷流程，
+  # 只印 URI 與 secret 供手動輸入。
+  defp print_qr(uri) do
+    qr = EQRCode.encode(uri)
+    m = qr.matrix
+
+    IO.puts("QR（掃碼加入驗證器）：")
+
+    for i <- 0..(tuple_size(m) - 1) do
+      row =
+        for j <- 0..(tuple_size(m) - 1) do
+          if elem(elem(m, i), j) == 1, do: "██", else: "  "
+        end
+
+      IO.puts(Enum.join(row))
+    end
+  rescue
+    _ -> IO.puts(:stderr, "（QR 產生失敗，請手動輸入上列 otpauth URI／secret）")
+  end
+
+  # -- 錯誤處理 --
+
+  defp fail_api(opts, ctx, error) do
+    {message, code} = format_api_error(ctx, error)
+    fail(opts, message, code)
+  end
+
+  # API 錯誤 → 依 §3.7 群組共通退出碼輸出，回傳退出碼。
+  defp format_api_error(_ctx, {:error, :unauthorized, desc}) do
+    {"token 無效或已過期（#{desc}），請重新 bear login", 3}
+  end
+
+  defp format_api_error(_ctx, {:error, :forbidden, desc}) do
+    {"權限不足（HTTP 403：#{desc}）", 8}
+  end
+
+  defp format_api_error(_ctx, {:error, :not_found, _desc}) do
+    {"找不到目標（HTTP 404）", 1}
+  end
+
+  # 語意錯誤（same_email／email_taken／invalid_code／already_enabled 等）。
+  defp format_api_error(
+         _ctx,
+         {:error, :unprocessable_entity, %{"error" => error, "error_description" => desc}}
+       ) do
+    {"#{error}：#{desc}", 1}
+  end
+
+  # 422 逐欄位驗證錯誤（changeset errors）。
+  defp format_api_error(_ctx, {:error, :unprocessable_entity, %{"errors" => errors}}) do
+    details =
+      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
+
+  defp format_api_error(_ctx, {:error, :unprocessable_entity, _body}) do
+    {"驗證失敗（HTTP 422）", 1}
+  end
+
+  # 伺服器限流（email 驗證碼）→ 退出碼 1，提示稍後再試（§3.7.4）。
+  defp format_api_error(_ctx, {:error, :too_many_requests, _body}) do
+    {"請求過於頻繁（HTTP 429），請稍後再試", 1}
+  end
+
+  defp format_api_error(_ctx, {:error, :server_error, status}) do
+    {"伺服器回應 #{status}", 6}
+  end
+
+  defp format_api_error(ctx, {:error, :network, reason}) do
+    {"無法連線到 #{ctx.issuer}：#{reason}", 6}
+  end
+
+  defp 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
+
+  defp require_id(nil, command), do: {:error, "#{command} 缺少 <id>", 2}
+  defp require_id("", command), do: {:error, "#{command} 缺少 <id>", 2}
+  defp require_id(_, _command), do: :ok
+
+  defp blank?(nil), do: true
+  defp blank?(""), do: true
+  defp blank?(_), do: false
+end
@@ -37,7 +37,9 @@ defmodule BearCli.MixProject do
    [
      # HTTP 一律使用 Req（與 bear 主專案一致）。
      {:req, "~> 0.5"},
-      {:jason, "~> 1.2"}
+      {:jason, "~> 1.2"},
+      # MFA setup 的 otpauth URI 本地 ASCII QR（§3.7.7）。
+      {:eqrcode, "~> 0.2"}
    ]
  end

@@ -1,4 +1,5 @@
 %{
+  "eqrcode": {:hex, :eqrcode, "0.2.1", "d12838813e8fc87b8940cc05f9baadb189031f6009facdc56ff074375ec73b6e", [:mix], [], "hexpm", "d5828a222b904c68360e7dc2a40c3ef33a1328b7c074583898040f389f928025"},
  "finch": {:hex, :finch, "0.23.0", "e3f9287ac25a8832f848b144c2b57346aac65b205e2e0629a52adfe6507fd837", [:mix], [{:mime, "~> 1.0 or ~> 2.0", [hex: :mime, repo: "hexpm", optional: false]}, {:mint, "~> 1.8", [hex: :mint, repo: "hexpm", optional: false]}, {:nimble_options, "~> 0.4 or ~> 1.0", [hex: :nimble_options, repo: "hexpm", optional: false]}, {:nimble_pool, "~> 1.1", [hex: :nimble_pool, repo: "hexpm", optional: false]}, {:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "80e58d3f936f57e3fdf404f83a3642897ae6d9fb642934e46da4d8fe761b99d5"},
  "hpax": {:hex, :hpax, "1.0.4", "777de5d433b0fbdc7c418159c8055910faa8047ffdb3d6b31098d2a46cd7685c", [:mix], [], "hexpm", "afc7cb142ebcc2d01ce7816190b98ce5dd49e799111b24249f3443d730f377ca"},
  "jason": {:hex, :jason, "1.4.5", "2e3a008590b0b8d7388c20293e9dcc9cf3e5d642fd2a114e4cbbb52e595d940a", [:mix], [{:decimal, "~> 1.0 or ~> 2.0 or ~> 3.0", [hex: :decimal, repo: "hexpm", optional: true]}], "hexpm", "b0c823996102bcd0239b3c2444eb00409b72f6a140c1950bc8b457d836b30684"},
@@ -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
@@ -0,0 +1,517 @@
+defmodule BearCli.AppsTest do
+  @moduledoc """
+  `bear apps` 指令群單元測試（issue #10）：注入 fake API，涵蓋解析、
+  輸出、退出碼、client_id → UUID 解析與 401/403/404/422 分流。
+  """
+  use ExUnit.Case, async: false
+
+  alias BearCli.{Apps, CLI}
+
+  # -- fake API --
+
+  defmodule FakeApi do
+    @apps [
+      %{
+        "id" => "0192aaaa-0000-7000-8000-000000000001",
+        "client_id" => "my-app",
+        "title" => "My App",
+        "url" => "https://example.com",
+        "method" => "client_secret",
+        "status" => "active",
+        "visibility" => "public",
+        "scopes" => ["openid", "profile"],
+        "redirect_urls" => ["https://example.com/callback"],
+        "post_logout_redirect_uris" => [],
+        "sub" => "id",
+        "jwk_id" => nil,
+        "created_at" => "2026-09-07T00:00:00Z",
+        "updated_at" => "2026-09-07T00:00:00Z"
+      },
+      %{
+        "id" => "0192aaaa-0000-7000-8000-000000000002",
+        "client_id" => "internal-tool",
+        "title" => "Internal Tool",
+        "url" => "https://internal.example.com",
+        "method" => "PKCE",
+        "status" => "inactive",
+        "visibility" => "internal",
+        "scopes" => ["openid"],
+        "redirect_urls" => [],
+        "post_logout_redirect_uris" => [],
+        "sub" => "id",
+        "jwk_id" => "jwk-1",
+        "created_at" => "2026-09-06T00:00:00Z",
+        "updated_at" => "2026-09-06T00:00:00Z"
+      }
+    ]
+
+    def apps, do: @apps
+
+    def apps_list(_issuer, _token, params) do
+      if error = Process.get(:fake_api_error) do
+        error
+      else
+        page = params[:page] || 1
+        per_page = params[:per_page] || 20
+
+        {:ok,
+         %{
+           "data" => Enum.slice(@apps, (page - 1) * per_page, per_page),
+           "page" => page,
+           "per_page" => per_page,
+           "total" => length(@apps)
+         }}
+      end
+    end
+
+    def apps_get(_issuer, _token, id) do
+      if error = Process.get(:fake_api_error) do
+        error
+      else
+        case Enum.find(@apps, &(&1["id"] == id)) do
+          nil -> {:error, :not_found, "not_found"}
+          app -> {:ok, %{"data" => app}}
+        end
+      end
+    end
+
+    def apps_create(_issuer, _token, attrs) do
+      if error = Process.get(:fake_api_error) do
+        error
+      else
+        app =
+          %{
+            "id" => "0192aaaa-0000-7000-8000-000000000003",
+            "client_id" => attrs["client_id"],
+            "title" => attrs["title"],
+            "url" => attrs["url"],
+            "method" => attrs["method"] || "client_secret",
+            "status" => "active",
+            "visibility" => attrs["visibility"] || "internal",
+            "scopes" => attrs["scopes"] || ["openid"],
+            "redirect_urls" => attrs["redirect_urls"] || [],
+            "post_logout_redirect_uris" => attrs["post_logout_redirect_uris"] || [],
+            "sub" => attrs["sub"] || "id",
+            "jwk_id" => attrs["jwk_id"],
+            "created_at" => "2026-09-08T00:00:00Z",
+            "updated_at" => "2026-09-08T00:00:00Z"
+          }
+
+        {:ok, %{"data" => app, "client_secret" => "4f9c1d2e-new-secret"}}
+      end
+    end
+
+    def apps_update(_issuer, _token, id, _attrs) do
+      if error = Process.get(:fake_api_error) do
+        error
+      else
+        case Enum.find(@apps, &(&1["id"] == id)) do
+          nil -> {:error, :not_found, "not_found"}
+          app -> {:ok, %{"data" => app}}
+        end
+      end
+    end
+
+    def apps_rotate_secret(_issuer, _token, id) do
+      if error = Process.get(:fake_api_error) do
+        error
+      else
+        case Enum.find(@apps, &(&1["id"] == id)) do
+          %{"method" => "PKCE"} -> {:error, :unprocessable_entity, %{"error" => "pkce_app"}}
+          %{} -> {:ok, %{"client_secret" => "9a7b3c-rotated"}}
+          nil -> {:error, :not_found, "not_found"}
+        end
+      end
+    end
+
+    def apps_toggle(_issuer, _token, id) do
+      if error = Process.get(:fake_api_error) do
+        error
+      else
+        case Enum.find(@apps, &(&1["id"] == id)) do
+          nil ->
+            {:error, :not_found, "not_found"}
+
+          app ->
+            new_status = if app["status"] == "active", do: "inactive", else: "active"
+            {:ok, %{"data" => %{app | "status" => new_status}}}
+        end
+      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
+
+  # 成功路徑：捕獲 stdout，回傳 {退出碼, stdout}
+  defp run_out(argv) do
+    ExUnit.CaptureIO.with_io(fn ->
+      CLI.dispatch(CLI.parse(argv), apps_api: FakeApi)
+    end)
+  end
+
+  # 錯誤路徑：捕獲 stderr，回傳 {退出碼, stderr}
+  defp run_err(argv) do
+    ExUnit.CaptureIO.with_io(:stderr, "", fn ->
+      CLI.dispatch(CLI.parse(argv), apps_api: FakeApi)
+    end)
+  end
+
+  defp with_api_error(error) do
+    Process.put(:fake_api_error, error)
+  end
+
+  # -- list --
+
+  test "apps list renders table sorted by client_id" do
+    {code, out} = run_out(["apps", "list"])
+    assert code == 0
+    assert out =~ "CLIENT ID"
+    assert out =~ "internal-tool"
+    assert out =~ "my-app"
+    # 依 client_id 排序：internal-tool 在 my-app 之前
+    assert String.contains?(out, "internal-tool")
+    assert :binary.match(out, "internal-tool") < :binary.match(out, "my-app")
+  end
+
+  test "apps list --json outputs spec shape" do
+    {code, out} = run_out(["apps", "list", "--json"])
+    assert code == 0
+
+    assert {:ok, decoded} = Jason.decode(out)
+    assert decoded["ok"] == true
+    assert decoded["page"] == 1
+    assert decoded["per_page"] == 20
+    assert decoded["total"] == 2
+    assert Enum.any?(decoded["apps"], &(&1["client_id"] == "my-app"))
+    assert Enum.any?(decoded["apps"], &(&1["client_id"] == "internal-tool"))
+  end
+
+  test "apps list --visibility/--status filters locally" do
+    {code, out} = run_out(["apps", "list", "--visibility", "public", "--status", "active"])
+    assert code == 0
+    assert out =~ "my-app"
+    refute out =~ "internal-tool"
+  end
+
+  test "apps list server-side pagination (per-page 1, page 2)" do
+    # 無過濾 → 直接交給 API 分頁；fake API 第 2 頁（per_page=1）回傳第二筆
+    {code, out} = run_out(["apps", "list", "--per-page", "1", "--page", "2"])
+    assert code == 0
+    assert out =~ "internal-tool"
+    refute out =~ "my-app"
+  end
+
+  test "apps list 403 exits 8 with admin hint" do
+    with_api_error({:error, :forbidden, "Admin role required."})
+    {code, err} = run_err(["apps", "list"])
+    assert code == 8
+    assert err =~ "admin"
+  end
+
+  # -- show --
+
+  test "apps show <client-id> resolves UUID and prints fields" do
+    {code, out} = run_out(["apps", "show", "my-app"])
+    assert code == 0
+    assert out =~ "client_id"
+    assert out =~ "my-app"
+    assert out =~ "https://example.com"
+    # secret 值不會出現（method 欄位的 "client_secret" 是合法輸出）
+    refute out =~ "4f9c1d2e"
+    refute out =~ "9a7b3c"
+  end
+
+  test "apps show --json" do
+    {code, out} = run_out(["apps", "show", "my-app", "--json"])
+    assert code == 0
+
+    assert {:ok, decoded} = Jason.decode(out)
+    assert decoded["ok"] == true
+    assert decoded["app"]["client_id"] == "my-app"
+    assert decoded["app"]["id"] == "0192aaaa-0000-7000-8000-000000000001"
+  end
+
+  test "apps show unknown client_id exits 1" do
+    {code, err} = run_err(["apps", "show", "no-such-app"])
+    assert code == 1
+    assert err =~ "找不到"
+  end
+
+  test "apps show without client-id exits 2" do
+    {code, err} = run_err(["apps", "show"])
+    assert code == 2
+    assert err =~ "缺少"
+  end
+
+  # -- create --
+
+  test "apps create sends required attrs and prints one-time secret" do
+    {code, out} =
+      run_out([
+        "apps",
+        "create",
+        "--client-id",
+        "new-app",
+        "--url",
+        "https://new.example.com",
+        "--title",
+        "New App",
+        "--visibility",
+        "public",
+        "--scope",
+        "openid",
+        "--scope",
+        "profile"
+      ])
+
+    assert code == 0
+    assert out =~ "App 已建立：new-app"
+    assert out =~ "只顯示這一次"
+    assert out =~ "4f9c1d2e-new-secret"
+  end
+
+  test "apps create --json includes client_secret once" do
+    {code, out} =
+      run_out([
+        "apps",
+        "create",
+        "--client-id",
+        "new-app",
+        "--url",
+        "https://new.example.com",
+        "--title",
+        "New App",
+        "--json"
+      ])
+
+    assert code == 0
+
+    assert {:ok, decoded} = Jason.decode(out)
+    assert decoded["ok"] == true
+    assert decoded["client_secret"] == "4f9c1d2e-new-secret"
+  end
+
+  test "apps create missing required exits 2" do
+    {code, err} = run_err(["apps", "create", "--client-id", "x"])
+    assert code == 2
+    assert err =~ "缺少必選參數"
+    assert err =~ "url"
+    assert err =~ "title"
+  end
+
+  test "apps create invalid visibility exits 2" do
+    {code, err} =
+      run_err([
+        "apps",
+        "create",
+        "--client-id",
+        "x",
+        "--url",
+        "https://x",
+        "--title",
+        "X",
+        "--visibility",
+        "bogus"
+      ])
+
+    assert code == 2
+    assert err =~ "--visibility"
+  end
+
+  test "apps create PKCE without jwk-id exits 2" do
+    {code, err} =
+      run_err([
+        "apps",
+        "create",
+        "--client-id",
+        "x",
+        "--url",
+        "https://x",
+        "--title",
+        "X",
+        "--method",
+        "PKCE"
+      ])
+
+    assert code == 2
+    assert err =~ "--jwk-id"
+  end
+
+  test "apps create 422 renders field errors and exits 1" do
+    with_api_error(
+      {:error, :unprocessable_entity, %{"errors" => %{"client_id" => ["has already been taken"]}}}
+    )
+
+    {code, err} =
+      run_err([
+        "apps",
+        "create",
+        "--client-id",
+        "my-app",
+        "--url",
+        "https://x",
+        "--title",
+        "X"
+      ])
+
+    assert code == 1
+    assert err =~ "422"
+    assert err =~ "client_id"
+  end
+
+  # -- update --
+
+  test "apps update sends only given fields" do
+    {code, out} = run_out(["apps", "update", "my-app", "--title", "Renamed"])
+    assert code == 0
+    assert out =~ "client_id"
+    assert out =~ "my-app"
+  end
+
+  test "apps update --json" do
+    {code, out} = run_out(["apps", "update", "my-app", "--title", "Renamed", "--json"])
+    assert code == 0
+
+    assert {:ok, decoded} = Jason.decode(out)
+    assert decoded["ok"] == true
+    assert decoded["app"]["client_id"] == "my-app"
+  end
+
+  # -- rotate-secret --
+
+  test "apps rotate-secret prints one-time new secret" do
+    {code, out} = run_out(["apps", "rotate-secret", "my-app"])
+    assert code == 0
+    assert out =~ "已輪轉"
+    assert out =~ "9a7b3c-rotated"
+  end
+
+  test "apps rotate-secret on PKCE app exits 1" do
+    {code, err} = run_err(["apps", "rotate-secret", "internal-tool"])
+    assert code == 1
+    assert err =~ "PKCE"
+  end
+
+  # -- toggle --
+
+  test "apps toggle prints transition" do
+    {code, out} = run_out(["apps", "toggle", "my-app"])
+    assert code == 0
+    assert out =~ "my-app：active → inactive"
+  end
+
+  test "apps toggle --json returns new status" do
+    {code, out} = run_out(["apps", "toggle", "my-app", "--json"])
+    assert code == 0
+
+    assert {:ok, decoded} = Jason.decode(out)
+    assert decoded["ok"] == true
+    assert decoded["app"]["status"] == "inactive"
+  end
+
+  # -- 認證分流 --
+
+  test "apps list 401 exits 3" do
+    with_api_error({:error, :unauthorized, "Invalid or expired token"})
+    {code, err} = run_err(["apps", "list"])
+    assert code == 3
+    assert err =~ "bear login"
+  end
+
+  test "apps list network error exits 6" do
+    with_api_error({:error, :network, "connection refused"})
+    {code, err} = run_err(["apps", "list"])
+    assert code == 6
+    assert err =~ "無法連線"
+  end
+
+  test "not logged in exits 3 without credentials" do
+    System.delete_env("BEAR_TOKEN")
+    {code, err} = run_err(["apps", "list"])
+    assert code == 3
+    assert err =~ "未登入"
+  end
+
+  # -- 解析 --
+
+  test "apps without verb exits 2" do
+    assert {:error, msg, 2} = CLI.parse(["apps"])
+    assert msg =~ "子指令"
+  end
+
+  test "apps unknown verb exits 2" do
+    assert {:error, msg, 2} = CLI.parse(["apps", "frobnicate"])
+    assert msg =~ "未知的 apps 子指令"
+  end
+
+  test "apps list parses spec options" do
+    assert {:ok, {Apps, :list}, opts} =
+             CLI.parse([
+               "apps",
+               "list",
+               "--visibility",
+               "public",
+               "--page",
+               "2",
+               "--per-page",
+               "5"
+             ])
+
+    assert opts[:visibility] == "public"
+    assert opts[:page] == 2
+    assert opts[:per_page] == 5
+  end
+
+  test "apps create parses repeatable list options" do
+    assert {:ok, {Apps, :create}, opts} =
+             CLI.parse([
+               "apps",
+               "create",
+               "--client-id",
+               "x",
+               "--url",
+               "https://x",
+               "--title",
+               "X",
+               "--redirect-url",
+               "https://a/cb",
+               "--redirect-url",
+               "https://b/cb",
+               "--scope",
+               "openid",
+               "--scope",
+               "email",
+               "--post-logout-redirect-uri",
+               "https://a/logout"
+             ])
+
+    assert opts[:redirect_url] == ["https://a/cb", "https://b/cb"]
+    assert opts[:scope] == ["openid", "email"]
+    assert opts[:post_logout_redirect_uri] == ["https://a/logout"]
+  end
+
+  test "apps show keeps positional client-id" do
+    assert {:ok, {Apps, :show}, opts} = CLI.parse(["apps", "show", "my-app", "--json"])
+    assert opts[:client_id_arg] == "my-app"
+    assert opts[:json] == true
+  end
+
+  # -- 輔助 --
+
+  defp restore(nil, key), do: System.delete_env(key)
+  defp restore(value, key), do: System.put_env(key, value)
+end
@@ -0,0 +1,662 @@
+defmodule BearCli.SelfServiceTest do
+  @moduledoc """
+  `bear` 個人自助指令群單元測試（issue #11）：注入 fake API，涵蓋
+  解析、輸出、退出碼、互動輸入注入與 401／403／404／422／429 分流。
+  """
+
+  use ExUnit.Case, async: false
+
+  alias BearCli.{CLI, SelfService}
+
+  # -- fake API --
+
+  defmodule FakeApi do
+    @profile %{
+      "id" => "0190aaaa-0000-7000-8000-000000000001",
+      "email" => "alice@example.com",
+      "role" => "user",
+      "name" => "Alice Chen",
+      "given_name" => "Alice",
+      "family_name" => "Chen",
+      "nickname" => "ali",
+      "preferred_username" => "alice",
+      "locale" => "zh_TW",
+      "zoneinfo" => "Asia/Taipei",
+      "phone_number" => nil,
+      "phone_number_verified" => false,
+      "address" => nil,
+      "mfa_enabled" => false,
+      "created_at" => "2026-09-01T00:00:00Z",
+      "updated_at" => "2026-09-01T00:00:00Z"
+    }
+
+    @sessions [
+      %{
+        "id" => "0192a1b0-0000-7000-8000-0000000000aa",
+        "ip" => "203.0.113.10",
+        "user_agent" => "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36",
+        "created_at" => "2026-09-07T10:00:00Z",
+        "last_seen_at" => "2026-09-08T09:00:00Z"
+      }
+    ]
+
+    @tokens [
+      %{
+        "id" => "0192a1c0-0000-7000-8000-0000000000bb",
+        "name" => "ci-token",
+        "scope" => "openid profile email",
+        "expires_at" => "2999-01-01T00:00:00Z",
+        "revoked_at" => nil,
+        "last_used_at" => "2026-09-08T08:00:00Z",
+        "created_at" => "2026-09-01T00:00:00Z"
+      }
+    ]
+
+    def error do
+      Process.get(:fake_ss_error)
+    end
+
+    def profile_get(_issuer, _token) do
+      error() || {:ok, %{"data" => profile()}}
+    end
+
+    def profile do
+      Map.merge(@profile, Process.get(:fake_profile_overrides) || %{})
+    end
+
+    def profile_update(_issuer, _token, attrs) do
+      error() || {:ok, %{"data" => Map.merge(profile(), attrs)}}
+    end
+
+    def profile_change_password(_issuer, _token, current, new) do
+      cond do
+        error() ->
+          error()
+
+        current == "wrong-pass" ->
+          {:error, :unprocessable_entity,
+           %{"errors" => %{"current_password" => ["is incorrect"]}}}
+
+        byte_size(new) < 8 ->
+          {:error, :unprocessable_entity,
+           %{"errors" => %{"new_password" => ["must be at least 8 characters"]}}}
+
+        true ->
+          {:ok, %{"data" => %{"updated" => true}}}
+      end
+    end
+
+    def profile_email_request_codes(_issuer, _token, new_email) do
+      cond do
+        error() ->
+          error()
+
+        new_email == "alice@example.com" ->
+          {:error, :unprocessable_entity,
+           %{"error" => "same_email", "error_description" => "The new email must be different."}}
+
+        true ->
+          {:ok, %{"data" => %{"sent" => true}}}
+      end
+    end
+
+    def profile_email_change(_issuer, _token, _new_email, current_code, _new_code) do
+      cond do
+        error() ->
+          error()
+
+        current_code == "000000" ->
+          {:error, :unprocessable_entity,
+           %{"error" => "invalid_current_code", "error_description" => "incorrect"}}
+
+        true ->
+          {:ok, %{"data" => %{"email" => "new@example.com"}}}
+      end
+    end
+
+    def sessions_list(_issuer, _token) do
+      error() || {:ok, %{"data" => @sessions}}
+    end
+
+    def sessions_revoke(_issuer, _token, id) do
+      cond do
+        error() ->
+          error()
+
+        id == "missing" ->
+          {:error, :not_found, "not_found"}
+
+        true ->
+          {:ok, %{"data" => %{"revoked" => id}}}
+      end
+    end
+
+    def sessions_revoke_others(_issuer, _token) do
+      error() || {:ok, %{"data" => %{"revoked_count" => 3}}}
+    end
+
+    def tokens_list(_issuer, _token) do
+      error() || {:ok, %{"data" => @tokens}}
+    end
+
+    def tokens_create(_issuer, _token, name, expires_in) do
+      cond do
+        error() ->
+          error()
+
+        name == " " ->
+          {:error, :unprocessable_entity, %{"errors" => %{"name" => ["can't be blank"]}}}
+
+        true ->
+          expires_at = if expires_in == "never", do: nil, else: "2999-01-01T00:00:00Z"
+
+          {:ok,
+           %{
+             "data" => %{
+               "id" => "0192a1c0-0000-7000-8000-0000000000cc",
+               "name" => name,
+               "scope" => "openid profile email",
+               "expires_at" => expires_at,
+               "revoked_at" => nil,
+               "last_used_at" => nil,
+               "created_at" => "2026-09-09T00:00:00Z"
+             },
+             "token" => "9f3a-raw-token-once"
+           }}
+      end
+    end
+
+    def tokens_revoke(_issuer, _token, id) do
+      cond do
+        error() ->
+          error()
+
+        id == "missing" ->
+          {:error, :not_found, "not_found"}
+
+        true ->
+          {:ok, %{"data" => %{"revoked" => id}}}
+      end
+    end
+
+    def mfa_setup(_issuer, _token) do
+      error() ||
+        {:ok,
+         %{"data" => %{"secret" => "JBSWY3DPEHPK3PXP", "otpauth_uri" => "otpauth://totp/Bear:x"}}}
+    end
+
+    def mfa_setup_confirm(_issuer, _token, code) do
+      cond do
+        error() ->
+          error()
+
+        code == "000000" ->
+          {:error, :unprocessable_entity,
+           %{"error" => "invalid_code", "error_description" => "Invalid verification code."}}
+
+        true ->
+          {:ok, %{"data" => %{"enabled" => true, "recovery_codes" => ["rc-1", "rc-2"]}}}
+      end
+    end
+
+    def mfa_disable(_issuer, _token, code) do
+      cond do
+        error() ->
+          error()
+
+        code == "000000" ->
+          {:error, :unprocessable_entity,
+           %{
+             "error" => "invalid_code",
+             "error_description" => "Invalid code. MFA was not disabled."
+           }}
+
+        true ->
+          {:ok, %{"data" => %{"enabled" => false}}}
+      end
+    end
+
+    def mfa_recovery_codes(_issuer, _token, code) do
+      cond do
+        error() ->
+          error()
+
+        code == "000000" ->
+          {:error, :unprocessable_entity,
+           %{"error" => "invalid_code", "error_description" => "Invalid code."}}
+
+        true ->
+          {:ok, %{"data" => %{"recovery_codes" => ["new-rc-1", "new-rc-2"]}}}
+      end
+    end
+  end
+
+  # 互動輸入注入：依序回應佇列中的值；prompt 前綴不影響。
+  defmodule FakeIO do
+    def prompt_secret(_label) do
+      case Process.get(:fake_io_inputs) do
+        [] ->
+          :eof
+
+        [next | rest] ->
+          Process.put(:fake_io_inputs, rest)
+          {:ok, next}
+      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", "user-pat")
+    System.put_env("BEAR_CREDENTIALS", "/nonexistent/credentials.json")
+    :ok
+  end
+
+  defp run_out(argv, io_inputs \\ nil) do
+    if io_inputs, do: Process.put(:fake_io_inputs, io_inputs)
+
+    opts = [ss_api: FakeApi, io: FakeIO, tty?: true]
+
+    ExUnit.CaptureIO.with_io(fn ->
+      CLI.dispatch(CLI.parse(argv), opts)
+    end)
+  end
+
+  defp run_err(argv, io_inputs \\ nil) do
+    if io_inputs, do: Process.put(:fake_io_inputs, io_inputs)
+
+    opts = [ss_api: FakeApi, io: FakeIO, tty?: true]
+
+    ExUnit.CaptureIO.with_io(:stderr, "", fn ->
+      CLI.dispatch(CLI.parse(argv), opts)
+    end)
+  end
+
+  defp with_api_error(error) do
+    Process.put(:fake_ss_error, error)
+  end
+
+  defp restore(nil, key), do: System.delete_env(key)
+  defp restore(value, key), do: System.put_env(key, value)
+
+  # -- 解析：用法錯誤（退出碼 2）--
+
+  test "unknown self-service command exits 2" do
+    assert {:error, _msg, 2} = CLI.parse(["frobnicate"])
+  end
+
+  test "profile without verb exits 2" do
+    assert {:error, msg, 2} = CLI.parse(["profile"])
+    assert msg =~ "profile 缺少子指令"
+  end
+
+  test "profile unknown verb exits 2" do
+    assert {:error, msg, 2} = CLI.parse(["profile", "delete"])
+    assert msg =~ "未知的 profile 子指令"
+  end
+
+  test "profile show with positional exits 2" do
+    assert {:error, msg, 2} = CLI.parse(["profile", "show", "extra"])
+    assert msg =~ "不接受位置參數"
+  end
+
+  test "password unknown verb exits 2" do
+    assert {:error, msg, 2} = CLI.parse(["password", "reset"])
+    assert msg =~ "未知的 password 子指令"
+  end
+
+  test "password change rejects positional args" do
+    assert {:error, msg, 2} = CLI.parse(["password", "change", "secret"])
+    assert msg =~ "不接受參數"
+  end
+
+  test "email change missing --new exits 2 at runtime" do
+    {code, err} = run_err(["email", "change"])
+    assert code == 2
+    assert err =~ "缺少 --new"
+  end
+
+  test "sessions revoke missing id exits 2" do
+    assert {:error, msg, 2} = CLI.parse(["sessions", "revoke"])
+    assert msg =~ "缺少 <id>"
+  end
+
+  test "tokens create missing --name exits 2" do
+    assert {:error, msg, 2} = CLI.parse(["tokens", "create"])
+    assert msg =~ "缺少 --name"
+  end
+
+  test "tokens create invalid --expires-in exits 2" do
+    {code, err} = run_err(["tokens", "create", "--name", "x", "--expires-in", "-5"])
+    assert code == 2
+    assert err =~ "--expires-in"
+  end
+
+  test "mfa unknown verb exits 2" do
+    assert {:error, msg, 2} = CLI.parse(["mfa", "enable"])
+    assert msg =~ "未知的 mfa 子指令"
+  end
+
+  # -- profile --
+
+  test "profile show prints fields" do
+    {code, out} = run_out(["profile", "show"])
+    assert code == 0
+    assert out =~ "email"
+    assert out =~ "alice@example.com"
+    assert out =~ "mfa_enabled"
+  end
+
+  test "profile show --json outputs spec shape" do
+    {code, out} = run_out(["profile", "show", "--json"])
+    assert code == 0
+    assert {:ok, decoded} = Jason.decode(out)
+    assert decoded["ok"] == true
+    assert decoded["profile"]["email"] == "alice@example.com"
+  end
+
+  test "profile set sends only given fields" do
+    {code, out} = run_out(["profile", "set", "--name", "New Name", "--locale", "zh_TW"])
+    assert code == 0
+    assert out =~ "New Name"
+  end
+
+  test "profile set without fields exits 2" do
+    {code, err} = run_err(["profile", "set"])
+    assert code == 2
+    assert err =~ "未給任何欄位"
+  end
+
+  test "profile set invalid gender exits 2 without request" do
+    {code, err} = run_err(["profile", "set", "--gender", "robot"])
+    assert code == 2
+    assert err =~ "--gender"
+  end
+
+  test "profile set invalid url exits 2" do
+    {code, err} = run_err(["profile", "set", "--picture", "ftp://x"])
+    assert code == 2
+    assert err =~ "http(s)://"
+  end
+
+  # -- password --
+
+  test "password change happy path" do
+    {code, out} = run_out(["password", "change"], ["old-pass", "new-pass-9", "new-pass-9"])
+    assert code == 0
+    assert out =~ "密碼已變更"
+  end
+
+  test "password change mismatched confirmation exits 2 locally" do
+    {code, err} = run_err(["password", "change"], ["old", "new-pass-9", "different-9"])
+    assert code == 2
+    assert err =~ "不一致"
+  end
+
+  test "password change wrong current password maps to 422 exit 1" do
+    {code, err} = run_err(["password", "change"], ["wrong-pass", "new-pass-9", "new-pass-9"])
+    assert code == 1
+    assert err =~ "current_password"
+  end
+
+  test "password change in non-TTY exits 2" do
+    {code, _out} =
+      ExUnit.CaptureIO.with_io(fn ->
+        CLI.dispatch(
+          CLI.parse(["password", "change"]),
+          ss_api: FakeApi,
+          tty?: false
+        )
+      end)
+
+    assert code == 2
+  end
+
+  # -- email --
+
+  test "email change full flow" do
+    {code, out} =
+      run_out(["email", "change", "--new", "new@example.com"], ["111111", "222222"])
+
+    assert code == 0
+    assert out =~ "email 已更新：new@example.com"
+  end
+
+  test "email change same email maps 422 error to exit 1" do
+    {code, err} =
+      run_err(["email", "change", "--new", "alice@example.com"], ["111111", "222222"])
+
+    assert code == 1
+    assert err =~ "same_email"
+  end
+
+  test "email change invalid code maps to exit 1" do
+    {code, err} =
+      run_err(["email", "change", "--new", "new@example.com"], ["000000", "222222"])
+
+    assert code == 1
+    assert err =~ "invalid_current_code"
+  end
+
+  test "email change rate limited maps 429 to exit 1" do
+    with_api_error({:error, :too_many_requests, %{"error" => "rate_limited"}})
+
+    {code, err} = run_err(["email", "change", "--new", "new@example.com"], [])
+    assert code == 1
+    assert err =~ "429"
+  end
+
+  # -- sessions --
+
+  test "sessions list renders table" do
+    {code, out} = run_out(["sessions", "list"])
+    assert code == 0
+    assert out =~ "ID"
+    assert out =~ "203.0.113.10"
+    assert out =~ "Mozilla/5.0"
+  end
+
+  test "sessions list --json outputs spec shape" do
+    {code, out} = run_out(["sessions", "list", "--json"])
+    assert code == 0
+    assert {:ok, decoded} = Jason.decode(out)
+    assert decoded["ok"] == true
+    assert length(decoded["sessions"]) == 1
+    assert hd(decoded["sessions"])["user_agent"] =~ "Mozilla"
+  end
+
+  test "sessions revoke prints confirmation" do
+    {code, out} = run_out(["sessions", "revoke", "0192a1b0-0000"])
+    assert code == 0
+    assert out =~ "session 已撤銷"
+  end
+
+  test "sessions revoke missing id maps 404 to exit 1" do
+    {code, err} = run_err(["sessions", "revoke", "missing"])
+    assert code == 1
+    assert err =~ "404"
+  end
+
+  test "sessions revoke-others prints count" do
+    {code, out} = run_out(["sessions", "revoke-others"])
+    assert code == 0
+    assert out =~ "已撤銷 3 個其他 session"
+  end
+
+  # -- tokens --
+
+  test "tokens list renders table with status" do
+    {code, out} = run_out(["tokens", "list"])
+    assert code == 0
+    assert out =~ "ci-token"
+    assert out =~ "active"
+  end
+
+  test "tokens list --json outputs spec shape" do
+    {code, out} = run_out(["tokens", "list", "--json"])
+    assert code == 0
+    assert {:ok, decoded} = Jason.decode(out)
+    assert decoded["ok"] == true
+    assert hd(decoded["tokens"])["name"] == "ci-token"
+    # 明文絕不出現在 list
+    refute out =~ "9f3a-raw-token-once"
+  end
+
+  test "tokens create shows raw token exactly once" do
+    {code, out} = run_out(["tokens", "create", "--name", "ci-token"])
+    assert code == 0
+    assert out =~ "PAT 已建立：ci-token"
+    assert out =~ "9f3a-raw-token-once"
+    assert out =~ "只顯示這一次"
+  end
+
+  test "tokens create --json includes raw once" do
+    {code, out} = run_out(["tokens", "create", "--name", "ci", "--json"])
+    assert code == 0
+    assert {:ok, decoded} = Jason.decode(out)
+    assert decoded["raw"] == "9f3a-raw-token-once"
+  end
+
+  test "tokens create never expiry" do
+    {code, out} = run_out(["tokens", "create", "--name", "ci", "--expires-in", "never"])
+    assert code == 0
+    assert out =~ "無到期日"
+  end
+
+  test "tokens revoke prints confirmation" do
+    {code, out} = run_out(["tokens", "revoke", "0192a1c0-0000"])
+    assert code == 0
+    assert out =~ "PAT 已撤銷"
+  end
+
+  # -- mfa --
+
+  test "mfa status shows disabled" do
+    {code, out} = run_out(["mfa", "status"])
+    assert code == 0
+    assert out =~ "未啟用"
+  end
+
+  test "mfa status shows enabled when totp on" do
+    Process.put(:fake_profile_overrides, %{"mfa_enabled" => true})
+    {code, out} = run_out(["mfa", "status"])
+    assert code == 0
+    assert out =~ "已啟用"
+  after
+    Process.delete(:fake_profile_overrides)
+  end
+
+  test "mfa setup prints QR + secret then recovery codes" do
+    {code, out} = run_out(["mfa", "setup"], ["123456"])
+    assert code == 0
+    assert out =~ "otpauth://totp/Bear:x"
+    assert out =~ "JBSWY3DPEHPK3PXP"
+    # QR 為 ASCII 區塊字元
+    assert out =~ "█"
+    assert out =~ "recovery codes"
+    assert out =~ "rc-1"
+  end
+
+  test "mfa setup --json does not print QR block" do
+    {code, out} = run_out(["mfa", "setup", "--json"], ["123456"])
+    assert code == 0
+    assert {:ok, decoded} = Jason.decode(out)
+    assert decoded["recovery_codes"] == ["rc-1", "rc-2"]
+  end
+
+  test "mfa setup invalid code maps to exit 1" do
+    {code, err} = run_err(["mfa", "setup"], ["000000"])
+    assert code == 1
+    assert err =~ "invalid_code"
+  end
+
+  test "mfa setup already enabled maps 422 to exit 1" do
+    with_api_error(
+      {:error, :unprocessable_entity,
+       %{"error" => "already_enabled", "error_description" => "MFA is already enabled."}}
+    )
+
+    {code, err} = run_err(["mfa", "setup"], ["123456"])
+    assert code == 1
+    assert err =~ "already_enabled"
+  end
+
+  test "mfa disable happy path" do
+    {code, out} = run_out(["mfa", "disable"], ["123456"])
+    assert code == 0
+    assert out =~ "MFA 已停用"
+  end
+
+  test "mfa recovery-codes regenerates" do
+    {code, out} = run_out(["mfa", "recovery-codes"], ["123456"])
+    assert code == 0
+    assert out =~ "new-rc-1"
+    assert out =~ "只顯示這一次"
+  end
+
+  # -- 共通錯誤分流 --
+
+  test "401 maps to exit 3 with re-login hint" do
+    with_api_error({:error, :unauthorized, "invalid_token"})
+
+    {code, err} = run_err(["profile", "show"])
+    assert code == 3
+    assert err =~ "bear login"
+  end
+
+  test "403 maps to exit 8" do
+    with_api_error({:error, :forbidden, "forbidden"})
+
+    {code, err} = run_err(["profile", "show"])
+    assert code == 8
+    assert err =~ "403"
+  end
+
+  test "network error maps to exit 6" do
+    with_api_error({:error, :network, "econnrefused"})
+
+    {code, err} = run_err(["profile", "show"])
+    assert code == 6
+    assert err =~ "econnrefused"
+  end
+
+  test "server error maps to exit 6" do
+    with_api_error({:error, :server_error, 500})
+
+    {code, err} = run_err(["profile", "show"])
+    assert code == 6
+    assert err =~ "500"
+  end
+
+  test "not logged in exits 3" do
+    System.delete_env("BEAR_TOKEN")
+
+    {code, err} = run_err(["profile", "show"])
+    assert code == 3
+    assert err =~ "未登入"
+  end
+
+  # -- 直接模組層測試 --
+
+  test "SelfService.run/3 with injected api" do
+    {code, out} =
+      ExUnit.CaptureIO.with_io(fn ->
+        SelfService.run(:profile, :show,
+          ss_api: FakeApi,
+          issuer: "https://alterminal.com"
+        )
+      end)
+
+    assert code == 0
+    assert out =~ "alice@example.com"
+  end
+end
Author	SHA1	Message	Date
queena	34c549e77a	Merge branch 'merge-fix' into feat/admin-commands	2026-09-10 03:16:22 +08:00
queena	4d353ef5f4	merge: 吸納 main 的個人自助指令群（PR #15），衝突以管理端＋個人自助並存解算	2026-09-10 03:16:17 +08:00
queena	d70aa9e541	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）；基於含 PR #15 的最新 main	2026-09-10 03:15:53 +08:00
queena	9784e18c24	merge: rebase 到最新 main（吸納 PR #15 個人自助指令群）後新增管理端指令群 - main 已合併 PR #15（profile/password/email/sessions/tokens/mfa 與 eqrcode 依賴） - 保留 main 的 self_service 模組與 api.ex 個人自助端點，於其上重套管理端： jwks/accounts/audit-logs 指令、API 端點、CLI 接線、docs §3.8–§3.10、README 表格 - mix precommit 全綠（150 tests：admin 100 + self-service 50）	2026-09-10 03:15:11 +08:00
queena	464db21745	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）	2026-09-10 03:07:40 +08:00
queena	e23be309f8	Merge pull request 'feat: 實作個人自助指令群（issue #11）' (#15 ) from feat/self-service-commands into main	2026-09-10 01:08:17 +08:00
iris	62fd6b730e	feat: 實作個人自助指令群 profile/password/email/sessions/tokens/mfa（issue #11） - lib/bear_cli/self_service.ex：六個子群組（profile show/set、password change、 email change、sessions list/revoke/revoke-others、tokens list/create/revoke、 mfa status/setup/disable/recovery-codes），對接 alterminal/bear#38 的 /api/v1/profile* JSON API（PAT Bearer、任何有效帳號） - 敏感輸入（密碼／驗證碼）互動提示讀取，非 TTY → 退出碼 2；一次性明文（PAT 明文、recovery codes）僅於成功當下輸出 - mfa setup：otpauth URI 本地生成 ASCII QR（新增 eqrcode 依賴），確認走 /mfa/setup/confirm（依 #38 實作） - Api 模組新增 profile 系列端點與 429 分流；CLI 分派接上六個指令群組 - docs/commands.md §3.7 對齊 #38 實際 API（sessions 欄位、tokens create 無 --scope、mfa setup/confirm、email 需重帶 new_email）；§7／§8／§9 與 README 同步更新 - 測試 50 例（fake API 注入）：解析、輸出、退出碼、互動輸入、錯誤分流； mix precommit 全綠（114 passed）	2026-09-09 22:50:53 +08:00
ceo	a220f8c5e6	Merge pull request 'feat: 實作 bear apps 指令群（issue #10）' (#14 ) from feat/apps-commands into main	2026-09-08 21:28:27 +08:00
alex	2192d067ce	feat: 實作 bear apps 指令群 list/show/create/update/rotate-secret/toggle（issue #10） - Api：新增 /api/v1/apps 端點（apps_list/get/create/update/rotate_secret/toggle， 401/403/404/422/5xx/網路分流） - Apps：指令群實作——client_id → UUID 以 list 解析；一次性 client_secret 僅於 create/rotate-secret 成功當下輸出；--json 輸出符合 docs/commands.md §3.6； visibility/status 過濾由 CLI 本地套用 - CLI：apps 子指令解析（重複選項收集為清單）、本地用法驗證（缺參數/列舉值/ PKCE 未綁 --jwk-id → 退出碼 2）、help 更新 - 測試：注入 fake API 的單元測試 29 例（解析、輸出、退出碼、UUID 解析、 401/403/404/422 分流、PKCE rotate） - 文件：README.md 實作狀態、docs/commands.md §3.6/§9 更新	2026-09-08 20:58:54 +08:00
ceo	77c65ec299	Merge pull request 'docs: 規劃個人自助指令群介面規格（issue #11）' (#13 ) from docs/self-service-commands-spec into main	2026-09-08 20:25:28 +08:00