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）

lib/bear_cli/accounts.ex

@@ -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

lib/bear_cli/admin.ex

@@ -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

lib/bear_cli/api.ex

@@ -61,12 +61,12 @@ defmodule BearCli.Api do
   成功回 `{:ok, %{"data" => [apps], "page" => n, "per_page" => n, "total" => n}}`。
   """
   def apps_list(issuer, token, params \\ []) do
-    apps_request(issuer, token, :get, "/api/v1/apps", params: params)
+    api_request(issuer, token, :get, "/api/v1/apps", params: params)
   end
 
   @doc "`GET /api/v1/apps/{id}`：單一 App（`client_secret` 永不回傳）。"
   def apps_get(issuer, token, id) do
-    apps_request(issuer, token, :get, "/api/v1/apps/" <> URI.encode(id))
+    api_request(issuer, token, :get, "/api/v1/apps/" <> URI.encode(id))
   end
 
   @doc """
@@ -75,12 +75,12 @@ defmodule BearCli.Api do
   （`%{"data" => app, "client_secret" => secret}`）。
   """
   def apps_create(issuer, token, attrs) do
-    apps_request(issuer, token, :post, "/api/v1/apps", json: attrs)
+    api_request(issuer, token, :post, "/api/v1/apps", json: attrs)
   end
 
   @doc "`PUT /api/v1/apps/{id}`：部分更新（只送有給的欄位）。"
   def apps_update(issuer, token, id, attrs) do
-    apps_request(issuer, token, :put, "/api/v1/apps/" <> URI.encode(id), json: attrs)
+    api_request(issuer, token, :put, "/api/v1/apps/" <> URI.encode(id), json: attrs)
   end
 
   @doc """
@@ -88,21 +88,21 @@ defmodule BearCli.Api do
   一次性明文。PKCE App 回 422 `%{"error" => "pkce_app"}`。
   """
   def apps_rotate_secret(issuer, token, id) do
-    apps_request(issuer, token, :post, "/api/v1/apps/" <> URI.encode(id) <> "/rotate-secret",
+    api_request(issuer, token, :post, "/api/v1/apps/" <> URI.encode(id) <> "/rotate-secret",
       json: %{}
     )
   end
 
   @doc "`POST /api/v1/apps/{id}/toggle`：切換 active ↔ inactive。"
   def apps_toggle(issuer, token, id) do
-    apps_request(issuer, token, :post, "/api/v1/apps/" <> URI.encode(id) <> "/toggle", json: %{})
+    api_request(issuer, token, :post, "/api/v1/apps/" <> URI.encode(id) <> "/toggle", json: %{})
   end
 
   # App 管理 API 共用請求。回傳：
   #   {:ok, body} | {:error, :unauthorized, desc} | {:error, :forbidden, desc}
   #   | {:error, :not_found, desc} | {:error, :unprocessable_entity, body}
   #   | {:error, :server_error, status} | {:error, :network, reason}
-  defp apps_request(issuer, token, method, path, extra \\ []) do
+  defp api_request(issuer, token, method, path, extra \\ []) do
     url = String.trim_trailing(issuer, "/") <> path
 
     opts =
@@ -136,4 +136,85 @@ defmodule BearCli.Api do
         {: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

lib/bear_cli/audit_logs.ex

@@ -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

lib/bear_cli/cli.ex

@@ -8,7 +8,7 @@ defmodule BearCli.CLI do
   優先使用該值，不讀寫本機憑證檔。
   """
 
-  alias BearCli.{Api, Apps, Config, Credentials}
+  alias BearCli.{Accounts, Admin, Api, Apps, AuditLogs, Config, Credentials, Jwks}
 
   @global_switches [
     issuer: :string,
@@ -177,6 +177,14 @@ defmodule BearCli.CLI do
     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
@@ -345,6 +353,19 @@ defmodule BearCli.CLI do
         apps_api = cmd_opts[:apps_api] || opts[:apps_api] || Api
         Apps.run(verb, Map.put(cmd_opts, :apps_api, apps_api))
 
+      # 管理端指令群（jwks/accounts/audit-logs；各自注入對應的 api 模組）
+      {:ok, {Jwks, verb}, cmd_opts} when is_atom(verb) ->
+        jwks_api = cmd_opts[:jwks_api] || opts[:jwks_api] || Api
+        Jwks.run(verb, Map.put(cmd_opts, :jwks_api, jwks_api))
+
+      {:ok, {Accounts, verb}, cmd_opts} when is_atom(verb) ->
+        accounts_api = cmd_opts[:accounts_api] || opts[:accounts_api] || Api
+        Accounts.run(verb, Map.put(cmd_opts, :accounts_api, accounts_api))
+
+      {:ok, {AuditLogs, verb}, cmd_opts} when is_atom(verb) ->
+        audit_logs_api = cmd_opts[:audit_logs_api] || opts[:audit_logs_api] || Api
+        AuditLogs.run(verb, Map.put(cmd_opts, :audit_logs_api, audit_logs_api))
+
       {:ok, command, cmd_opts} ->
         cond do
           cmd_opts[:version] ->
@@ -653,6 +674,9 @@ defmodule BearCli.CLI do
       logout                登出（清除本機憑證）
       status                顯示登入狀態
       apps <動詞>            App 管理（admin；bear apps --help 查看）
+      jwks <動詞>            簽章金鑰管理（admin）
+      accounts <動詞>        帳號管理（admin）
+      audit-logs list        稽核日誌（admin）
 
     apps 指令群（需 admin 權限的 PAT）：
       apps list [--visibility public|internal] [--status active|inactive]

lib/bear_cli/jwks.ex

@@ -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