hipowork-cli 0.1.0__py3-none-any.whl

hipowork_cli/__init__.py

@@ -0,0 +1,116 @@
+"""HiPo Work CLI — 面向求职者和招聘方的命令行工具集。
+
+安装后提供 `hipo` 命令（等价于仓库根目录时代的 hipo.py）：
+
+    hipo authorize --role candidate
+    hipo match-jobs
+    hipo publish-job --json examples/job.example.json
+
+scripts/ 下 16 个子命令模块通过 hipo CLI 统一调度。
+"""
+from __future__ import annotations
+
+import os
+import subprocess
+import sys
+from pathlib import Path
+
+__version__ = "0.1.0"
+
+SCRIPTS_DIR = Path(__file__).resolve().parent / "scripts"
+
+# 命令名 → 对应脚本文件（不含 .py）
+COMMANDS = {
+    "authorize": "hipo_authorize",
+    "status": "hipo_token_status",
+    "refresh": "hipo_token_refresh",
+    "token-sync": "hipo_token_sync",
+    "accounts": "hipo_accounts",
+    "match-jobs": "hipo_match_jobs",
+    "publish-job": "hipo_publish_job",
+    "search": "hipo_search_candidates",
+    "match-candidates": "hipo_match_candidates",
+    "market": "hipo_market",
+    "stats": "hipo_stats",
+    "resume-extract": "hipo_resume_extract",
+    "resume-validate": "hipo_resume_validate",
+    "resume-import": "hipo_resume_import",
+    "healthcheck": "hipo_healthcheck",
+    "e2e": "hipo_e2e",
+}
+
+# 各命令的一句话说明（help 输出用）
+HELP = {
+    "authorize": "OAuth 授权（打开浏览器完成邮箱验证码登录）",
+    "status": "查看 token 状态（角色/scope/过期）",
+    "refresh": "强制刷新 token",
+    "token-sync": "导出 token 到浏览器 localStorage（4 个 base64）",
+    "accounts": "多账户管理（list/switch/delete）",
+    "match-jobs": "求职者：匹配岗位",
+    "publish-job": "招聘方：发布岗位",
+    "search": "招聘方：自然语言搜索候选人",
+    "match-candidates": "招聘方：结构化/自然语言匹配候选人",
+    "market": "招聘方：人才市场分析",
+    "stats": "平台统计",
+    "resume-extract": "简历文本提取（PDF/DOCX/TXT）",
+    "resume-validate": "简历 JSON 结构校验",
+    "resume-import": "简历导入（校验 + 写入）",
+    "healthcheck": "服务连通性检查（API/MCP/Embedding）",
+    "e2e": "端到端冒烟测试",
+}
+
+# 需要前置授权的命令（帮助提示用）
+AUTH_REQUIRED = {
+    "status", "refresh", "token-sync", "accounts", "match-jobs", "publish-job",
+    "search", "match-candidates", "market", "stats", "resume-import", "e2e",
+}
+
+
+def _print_help() -> None:
+    print("HiPo Work CLI — 统一入口")
+    print("用法: hipo <command> [args...]\n")
+    print("认证与令牌:")
+    for k in ("authorize", "status", "refresh", "token-sync", "accounts"):
+        print(f"  {k:<16} {HELP[k]}")
+    print("\n招聘方:")
+    for k in ("publish-job", "search", "match-candidates", "market", "stats"):
+        print(f"  {k:<16} {HELP[k]}")
+    print("\n求职者:")
+    for k in ("match-jobs", "resume-extract", "resume-validate", "resume-import"):
+        print(f"  {k:<16} {HELP[k]}")
+    print("\n运维:")
+    for k in ("healthcheck", "e2e"):
+        print(f"  {k:<16} {HELP[k]}")
+    print("\n任何命令都可用 --help 查看详细参数，例如:")
+    print("  hipo publish-job --help")
+    print("\n也可以直接运行 src/hipowork_cli/scripts/ 下的独立脚本（等价）。")
+
+
+def main() -> int:
+    # 允许从任意目录运行：把 scripts/ 加进 PYTHONPATH
+    env = dict(os.environ)
+    pythonpath = env.get("PYTHONPATH", "")
+    env["PYTHONPATH"] = str(SCRIPTS_DIR) + (os.pathsep + pythonpath if pythonpath else "")
+
+    args = sys.argv[1:]
+    if not args or args[0] in ("-h", "--help", "help"):
+        _print_help()
+        return 0
+
+    cmd = args[0]
+    if cmd not in COMMANDS:
+        print(f"❌ 未知命令: {cmd}\n", file=sys.stderr)
+        _print_help()
+        return 2
+
+    script = SCRIPTS_DIR / f"{COMMANDS[cmd]}.py"
+    if not script.exists():
+        print(f"❌ 脚本缺失: {script}", file=sys.stderr)
+        return 2
+
+    # 转发剩余参数；子进程继承 PYTHONPATH，保证 scripts 内部互相 import 正常
+    return subprocess.call([sys.executable, str(script), *args[1:]], env=env)
+
+
+if __name__ == "__main__":
+    sys.exit(main())

hipowork_cli/examples/job.example.json

@@ -0,0 +1,24 @@
+{
+  "title": "Python/FastAPI 后端工程师",
+  "raw_text": "成都 Python/FastAPI 后端开发，3 年以上经验，要求高并发系统经验，熟悉 PostgreSQL，有区块链经验优先",
+  "required": [
+    {"field": "location", "operator": "eq", "value": "成都"},
+    {"field": "experience_years", "operator": "gte", "value": 3}
+  ],
+  "preferred": {
+    "semantic_query": "高并发系统设计，FastAPI 后端，区块链 Web3",
+    "skills": [
+      {"name": "FastAPI", "min_years": 2, "weight": 1.0},
+      {"name": "PostgreSQL", "min_years": 2, "weight": 1.0},
+      {"name": "Python", "min_years": 3, "weight": 1.0}
+    ],
+    "keywords": [
+      {"text": "高并发", "weight": 1.0},
+      {"text": "智能合约", "weight": 0.8}
+    ]
+  },
+  "salary_min": 20,
+  "salary_max": 35,
+  "salary_unit": "monthly",
+  "benefits": ["五险一金", "弹性工作", "远程办公", "年终奖"]
+}

hipowork_cli/examples/resume.example.json

@@ -0,0 +1,63 @@
+{
+  "basic_info": {
+    "name": "张三",
+    "location": "成都",
+    "headline": "区块链全栈工程师",
+    "summary": "5 年全栈开发经验，专注区块链与 Web3，熟悉 Solidity 智能合约、Python/FastAPI 后端和 React 前端，主导过多个 DeFi 项目从 0 到 1。",
+    "industry": "tech"
+  },
+  "work_experiences": [
+    {
+      "company": "某科技公司",
+      "role": "高级全栈工程师",
+      "start_date": "2022-03",
+      "end_date": "2026-08",
+      "duration_months": 53,
+      "industry": "tech",
+      "responsibilities": ["负责核心后端服务设计与开发", "主导智能合约安全审计流程"],
+      "achievements": ["支撑百万级用户的高并发系统，QPS 提升 40%"],
+      "tech_stack": ["Python", "FastAPI", "PostgreSQL", "Redis", "Solidity"],
+      "team_size": 8,
+      "ai_summary": "5 年全栈经验，主导多个区块链项目"
+    }
+  ],
+  "projects": [
+    {
+      "name": "DeFi 借贷协议",
+      "role": "核心开发者",
+      "start_date": "2023-01",
+      "end_date": "2024-06",
+      "description": "基于 Solidity 的链上借贷协议，支持多币种抵押借贷与清算",
+      "responsibilities": ["设计智能合约架构", "实现清算机器人"],
+      "achievements": ["TVL 峰值 5000 万美元", "通过第三方安全审计"],
+      "tech_stack": ["Solidity", "Hardhat", "Web3.js"],
+      "project_url": "https://github.com/example/defi-lending",
+      "ai_summary": "链上借贷协议，TVL 峰值 5000 万美元"
+    }
+  ],
+  "education": [
+    {
+      "school": "某大学",
+      "degree": "本科",
+      "major": "计算机科学与技术",
+      "start_year": 2015,
+      "end_year": 2019,
+      "gpa": 3.6,
+      "school_type": "211",
+      "ai_summary": "计算机本科，GPA 3.6"
+    }
+  ],
+  "skills": [
+    {"name": "Python", "category": "programming_language", "level": 5, "years": 5, "context": "后端开发，AI 服务"},
+    {"name": "Solidity", "category": "programming_language", "level": 4, "years": 3, "context": "智能合约开发"},
+    {"name": "FastAPI", "category": "framework", "level": 4, "years": 3, "context": "后端 API 服务"},
+    {"name": "PostgreSQL", "category": "tool", "level": 4, "years": 4, "context": "数据存储，pgvector 向量检索"}
+  ],
+  "certificates": [
+    {"name": "区块链工程师认证", "issuer": "某机构", "year": 2023}
+  ],
+  "languages": [
+    {"language": "中文", "level": "native"},
+    {"language": "英语", "level": "business"}
+  ]
+}

hipowork_cli/scripts/hipo_accounts.py

@@ -0,0 +1,116 @@
+"""HiPo Work 多账户管理。
+
+token 仓库（~/.hipo_mcp_tokens.json）按多账户设计：每个邮箱/角色一条，
+可列出、切换默认账户、删除账户。
+
+用法：
+  python3 hipo_accounts.py list
+  python3 hipo_accounts.py current
+  python3 hipo_accounts.py switch <account_id>
+  python3 hipo_accounts.py delete <account_id>
+  python3 hipo_accounts.py --file /path/to/tokens.json list
+"""
+from __future__ import annotations
+
+import argparse
+import sys
+from pathlib import Path
+
+from hipo_auth import TokenStore, require_py310
+
+
+def _short_id(account_id: str) -> str:
+    return account_id if len(account_id) <= 40 else account_id[:40] + "…"
+
+
+def cmd_list(store: TokenStore) -> int:
+    accounts = store.accounts()
+    default = store.default_account()
+    if not accounts:
+        print("（空）暂无账户。请先运行 hipo_authorize.py / hipo.py authorize 完成授权。")
+        return 0
+    print(f"token 仓库: {store.path}")
+    print(f"默认账户: {default or '（未设置）'}\n")
+    print(f"{'账户':<44} {'角色':<10} {'邮箱'}")
+    print("-" * 88)
+    for aid, acc in accounts.items():
+        marker = "→" if aid == default else " "
+        role = acc.get("role") or "?"
+        email = acc.get("email") or "?"
+        print(f"{marker} {_short_id(aid):<42} {role:<10} {email}")
+    print("\n提示: 用 `switch <account_id>` 切换默认账户；用 `delete <account_id>` 删除。")
+    return 0
+
+
+def cmd_current(store: TokenStore) -> int:
+    default = store.default_account()
+    if not default:
+        print("（未设置默认账户）")
+        return 1
+    acc = store.get_account()
+    if not acc:
+        print(f"默认账户 {default} 不存在于仓库。")
+        return 1
+    print(f"默认账户: {default}")
+    print(f"  邮箱: {acc.get('email') or '?'}")
+    print(f"  角色: {acc.get('role') or '?'}")
+    tokens = acc.get("tokens") or {}
+    print(f"  access_token: {'有' if tokens.get('access_token') else '无'}")
+    print(f"  refresh_token: {'有' if tokens.get('refresh_token') else '无'}")
+    return 0
+
+
+def cmd_switch(store: TokenStore, account_id: str) -> int:
+    if account_id not in store.accounts():
+        print(f"❌ 账户 {account_id} 不存在。可运行 `list` 查看现有账户。")
+        return 1
+    store.set_account(account_id, store.accounts()[account_id], make_default=True)
+    print(f"✅ 默认账户已切换为 {account_id}")
+    return 0
+
+
+def cmd_delete(store: TokenStore, account_id: str) -> int:
+    if account_id not in store.accounts():
+        print(f"❌ 账户 {account_id} 不存在。")
+        return 1
+    acc = store.accounts()[account_id]
+    if input(f"确认删除账户 {account_id}（{acc.get('email') or '?'}）？[y/N] ").strip().lower() != "y":
+        print("已取消。")
+        return 0
+    del store._data["accounts"][account_id]  # noqa: SLF001
+    if store.default_account() == account_id:
+        rest = list(store.accounts().keys())
+        store._data["default_account"] = rest[0] if rest else ""  # noqa: SLF001
+    store._save()
+    print(f"✅ 已删除账户 {account_id}")
+    return 0
+
+
+def main() -> int:
+    require_py310()
+    parser = argparse.ArgumentParser(description="HiPo Work 多账户管理")
+    parser.add_argument("--file", default=None, help="token 仓库文件路径（默认 ~/.hipo_mcp_tokens.json）")
+    sub = parser.add_subparsers(dest="action", required=True)
+    sub.add_parser("list", help="列出所有账户")
+    sub.add_parser("current", help="显示当前默认账户")
+    p_switch = sub.add_parser("switch", help="切换默认账户")
+    p_switch.add_argument("account_id", help="目标账户 ID（可为邮箱）")
+    p_delete = sub.add_parser("delete", help="删除账户")
+    p_delete.add_argument("account_id", help="要删除的账户 ID")
+    args = parser.parse_args()
+
+    store = TokenStore(args.file)
+    if args.action == "list":
+        return cmd_list(store)
+    if args.action == "current":
+        return cmd_current(store)
+    if args.action == "switch":
+        return cmd_switch(store, args.account_id)
+    if args.action == "delete":
+        return cmd_delete(store, args.account_id)
+    parser.print_help()
+    return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

hipowork_cli/scripts/hipo_auth.py

@@ -0,0 +1,289 @@
+"""HiPo Work 共享认证库：token 仓库读写 / 过期判断 / 刷新 / 多账户预留。
+
+所有 CLI 脚本都通过本模块管理令牌，避免重复实现。
+数据结构（~/.hipo_mcp_tokens.json，多账户预留）：
+
+{
+  "default_account": "sexylin2010+eng2@gmail.com",
+  "accounts": {
+    "<account_id>": {
+      "email": "...", "role": "candidate" | "employer",
+      "client_info": { "client_id": "...", "client_name": "..." },
+      "tokens": { "access_token": "...", "refresh_token": "...", "scope": "...", "expires_in": 3600 }
+    }
+  }
+}
+
+第一版只维护单账户（default_account），但存储结构已按多账户设计，
+后续扩展只需在 accounts 下新增条目即可。
+"""
+from __future__ import annotations
+
+import base64
+import json
+import sys
+import time
+import urllib.error
+import urllib.parse
+import urllib.request
+from pathlib import Path
+
+# ---- 默认配置（可用 config.yaml 或环境变量覆盖）----
+DEFAULT_TOKEN_FILE = Path.home() / ".hipo_mcp_tokens.json"
+DEFAULT_TOKEN_ENDPOINT = "https://mcp.hipowork.com/token"
+DEFAULT_MCP_URL = "https://mcp.hipowork.com/mcp"
+DEFAULT_API_BASE = "https://api.hipowork.com/api/v1"
+DEFAULT_CALLBACK_PORT = 8765
+
+
+# ============ Token 仓库 ============
+
+class TokenStore:
+    """极简 JSON 文件 token 仓库（线程安全 + 原子写）。"""
+
+    def __init__(self, path: str | Path | None = None):
+        self.path = Path(path or DEFAULT_TOKEN_FILE)
+        self._data = self._load()
+
+    def _load(self) -> dict:
+        try:
+            data = json.loads(self.path.read_text(encoding="utf-8"))
+        except (FileNotFoundError, json.JSONDecodeError):
+            return {}
+        if not isinstance(data, dict):
+            return {}
+        # 兼容旧版平铺结构 {client_info, tokens} → 自动迁移为多账户结构
+        if "tokens" in data and "accounts" not in data:
+            data = self._migrate_flat(data)
+        return data
+
+    def _migrate_flat(self, data: dict) -> dict:
+        """旧版平铺 token 文件 → 多账户结构（account_id 取 email，缺省用 default）。"""
+        account_id = str(data.get("email") or "default")
+        account = {}
+        if data.get("tokens"):
+            account["tokens"] = data["tokens"]
+        if data.get("client_info"):
+            account["client_info"] = data["client_info"]
+        if data.get("email"):
+            account["email"] = data["email"]
+        if data.get("role"):
+            account["role"] = data["role"]
+        migrated = {"default_account": account_id, "accounts": {account_id: account}}
+        # 迁移即写回，保证下次 save 直接落盘多账户结构
+        tmp = self.path.with_suffix(".tmp")
+        tmp.write_text(json.dumps(migrated, indent=2, ensure_ascii=False), encoding="utf-8")
+        tmp.replace(self.path)
+        return migrated
+
+    def _save(self) -> None:
+        self.path.parent.mkdir(parents=True, exist_ok=True)
+        # 原子写：先写临时文件再 rename，避免中断导致仓库损坏
+        tmp = self.path.with_suffix(".tmp")
+        tmp.write_text(json.dumps(self._data, indent=2, ensure_ascii=False), encoding="utf-8")
+        tmp.replace(self.path)
+        try:
+            self.path.chmod(0o600)  # 仅 owner 可读写
+        except OSError:
+            pass
+
+    # ---- 账户级 API ----
+
+    def default_account(self) -> str:
+        return self._data.get("default_account", "")
+
+    def accounts(self) -> dict:
+        return self._data.get("accounts", {})
+
+    def get_account(self, account_id: str | None = None) -> dict | None:
+        account_id = account_id or self.default_account()
+        if not account_id:
+            return None
+        return self.accounts().get(account_id)
+
+    def set_account(self, account_id: str, payload: dict, make_default: bool = True) -> None:
+        self._data.setdefault("accounts", {})[account_id] = payload
+        if make_default:
+            self._data["default_account"] = account_id
+        self._save()
+
+    def save_tokens(self, tokens: dict, client_info: dict | None = None,
+                    account_id: str | None = None, email: str = "", role: str = "") -> None:
+        account_id = account_id or email or self.default_account() or "default"
+        acc = self.get_account(account_id) or {}
+        acc.setdefault("tokens", {}).update(tokens)
+        if client_info:
+            acc["client_info"] = client_info
+        if email:
+            acc["email"] = email
+        if role:
+            acc["role"] = role
+        self.set_account(account_id, acc, make_default=True)
+
+    # ---- 便捷访问 ----
+
+    def tokens(self, account_id: str | None = None) -> dict:
+        acc = self.get_account(account_id)
+        return (acc or {}).get("tokens", {})
+
+    def client_info(self, account_id: str | None = None) -> dict:
+        acc = self.get_account(account_id)
+        return (acc or {}).get("client_info", {})
+
+    def email(self, account_id: str | None = None) -> str:
+        acc = self.get_account(account_id)
+        return (acc or {}).get("email", "")
+
+    def role(self, account_id: str | None = None) -> str:
+        acc = self.get_account(account_id)
+        return (acc or {}).get("role", "")
+
+    def exists(self) -> bool:
+        return self.path.exists() and bool(self.tokens().get("access_token"))
+
+
+# ============ Token 工具 ============
+
+def decode_jwt_payload(token: str) -> dict:
+    """解析 JWT 的 payload（不校验签名，仅用于读取 exp/scope/role）。"""
+    try:
+        payload = token.split(".")[1]
+        payload += "=" * (-len(payload) % 4)
+        return json.loads(base64.urlsafe_b64decode(payload))
+    except Exception:
+        return {}
+
+
+def is_expired(token: str, margin: int = 120) -> bool:
+    """判断 access_token 是否在 margin 秒内过期。解析失败视为过期。"""
+    exp = decode_jwt_payload(token).get("exp", 0)
+    return exp - margin <= time.time()
+
+
+def refresh_tokens(tokens: dict, client_info: dict, endpoint: str = DEFAULT_TOKEN_ENDPOINT) -> dict:
+    """用 refresh_token 轮换出一对新 token。失败抛异常，由调用方决定如何处理。"""
+    if not tokens.get("refresh_token"):
+        raise ValueError("仓库中没有 refresh_token，需要重新走 OAuth 授权")
+    if not client_info.get("client_id"):
+        raise ValueError("仓库中没有 client_info.client_id，需要重新走 OAuth 授权")
+
+    body = urllib.parse.urlencode({
+        "grant_type": "refresh_token",
+        "refresh_token": tokens["refresh_token"],
+        "client_id": client_info["client_id"],
+    }).encode()
+    req = urllib.request.Request(
+        endpoint, data=body,
+        headers={"Content-Type": "application/x-www-form-urlencoded"},
+    )
+    try:
+        with urllib.request.urlopen(req, timeout=30) as resp:
+            new = json.loads(resp.read())
+    except urllib.error.HTTPError as exc:
+        detail = exc.read().decode()[:300]
+        if exc.code in (400, 401):
+            raise ValueError(f"refresh_token 已失效（HTTP {exc.code}），需要重新授权: {detail}")
+        raise RuntimeError(f"刷新失败 HTTP {exc.code}: {detail}")
+    except Exception as exc:
+        raise RuntimeError(f"网络错误: {exc}")
+
+    if "access_token" not in new:
+        raise ValueError(f"刷新响应缺少 access_token: {new}")
+
+    tokens["access_token"] = new["access_token"]
+    if new.get("refresh_token"):
+        tokens["refresh_token"] = new["refresh_token"]
+    if new.get("scope"):
+        tokens["scope"] = new["scope"]
+    tokens["expires_in"] = new.get("expires_in", tokens.get("expires_in", 3600))
+    return tokens
+
+
+def ensure_valid_token(store: TokenStore, account_id: str | None = None,
+                       force: bool = False) -> dict:
+    """确保拿到未过期的 access_token。过期则自动刷新；刷新失败抛异常。
+
+    返回 tokens dict（可能已刷新）。
+    """
+    tokens = store.tokens(account_id)
+    client_info = store.client_info(account_id)
+    if not tokens.get("access_token"):
+        raise ValueError("未找到 access_token，请先运行 hipo_authorize.py 完成授权")
+
+    if force or is_expired(tokens["access_token"]):
+        refreshed = refresh_tokens(tokens, client_info)
+        store.save_tokens(refreshed, client_info, account_id=account_id)
+        return refreshed
+    return tokens
+
+
+# ============ MCP / API 客户端入口 ============
+
+def build_authorizer(store: TokenStore, account_id: str | None = None):
+    """构造 mcp SDK 的 OAuthClientProvider，复用仓库中的 token。
+
+    若仓库已有有效 token，SDK 会直接使用而不再弹授权。
+    依赖 mcp SDK；未安装时抛 ImportError。
+    """
+    try:
+        from mcp.client.auth import OAuthClientProvider
+    except ImportError as exc:  # pragma: no cover
+        raise ImportError("需要 mcp SDK：pip install -r requirements.txt") from exc
+    raise NotImplementedError("多账户/复用式 authorizer 在 v1.1 提供；v1.0 请直接用 hipo_mcp_client.py")
+
+
+def api_request(method: str, path: str, token: str | None = None, body: dict | None = None,
+                api_base: str = DEFAULT_API_BASE, timeout: int = 30):
+    """对后端 REST API 发请求（/api/v1 之下），返回解析后的 JSON。
+
+    path 示例："/candidate/matches"、"/candidate/profile"。
+    token 传 None 时（公开接口，如发送验证码）不携带 Authorization 头。
+    """
+    url = f"{api_base}{path}"
+    headers = {
+        "Content-Type": "application/json",
+    }
+    if token:
+        headers["Authorization"] = f"Bearer {token}"
+    data = json.dumps(body).encode() if body is not None else None
+    req = urllib.request.Request(url, data=data, headers=headers, method=method)
+    try:
+        with urllib.request.urlopen(req, timeout=timeout) as resp:
+            return json.loads(resp.read())
+    except urllib.error.HTTPError as exc:
+        detail = exc.read().decode()[:500]
+        raise RuntimeError(f"API {method} {path} 失败 HTTP {exc.code}: {detail}")
+
+
+# ============ CLI 公共工具 ============
+
+def require_py310() -> None:
+    """Python 版本检查：最低 3.10（PEP 604 联合类型）。"""
+    if sys.version_info < (3, 10):
+        sys.stderr.write(
+            f"需要 Python 3.10+（当前 {sys.version_info.major}.{sys.version_info.minor}）。\n"
+            "请升级 Python 后重试。\n"
+        )
+        sys.exit(1)
+
+
+def print_token_summary(store: TokenStore, account_id: str | None = None) -> None:
+    """打印当前账户的 token 状态摘要（不打印 token 本身）。"""
+    tokens = store.tokens(account_id)
+    client_info = store.client_info(account_id)
+    email = store.email(account_id) or "?"
+    role = store.role(account_id) or "?"
+    if not tokens.get("access_token"):
+        print(f"  账户: {email}（{role}）— 未授权")
+        return
+
+    claims = decode_jwt_payload(tokens["access_token"])
+    exp = claims.get("exp", 0)
+    now = time.time()
+    expires_in_min = max(0, int((exp - now) // 60)) if exp else -1
+    status = "有效" if exp - 120 > now else ("已过期" if exp and exp <= now else "即将过期")
+    print(f"  账户: {email}（{role}）")
+    print(f"  scope: {tokens.get('scope', '?')}")
+    print(f"  access_token: {status}（{expires_in_min} 分钟后过期）")
+    print(f"  refresh_token: {'有' if tokens.get('refresh_token') else '无'}")
+    print(f"  client_id: {client_info.get('client_id', '?')[:12]}..." if client_info.get("client_id") else "  client_id: 无")