ChatECNU 0.2.2__tar.gz → 0.2.4__tar.gz

{chatecnu-0.2.2/src/ChatECNU.egg-info → chatecnu-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ChatECNU
-Version: 0.2.2
+Version: 0.2.4
 Summary: ChatArch ECNU campus portal automation CLI
 Author-email: ChatArch <1073853456@qq.com>
 License-Expression: MIT
@@ -15,7 +15,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: click>=8.0
 Requires-Dist: chatstyle<0.2.0,>=0.1.0
-Requires-Dist: chatenv<0.3.0,>=0.2.4
+Requires-Dist: chatenv<0.3.0,>=0.2.7
 Requires-Dist: ChatNet<0.3.0,>=0.2.0
 Requires-Dist: requests>=2.0
 Requires-Dist: pycryptodome>=3.0
@@ -99,6 +99,8 @@ ecnu home user
 ecnu home logout
 ```
 
+门户会话默认写入 ChatEnv runtime token-store：`~/.chatarch/tokens/ECNU/<profile>.json`；`ecnu home status --json` 只回读安全摘要，不输出原始 Cookie/CSRF。`chatenv token refresh ECNU <profile>` 可从同名 stable env profile 发起非交互 OCR 自动登录并由 ChatEnv 写入 runtime token-store；遇到短信验证码或验证码候选失败时会安全失败。
+
 校园网联网统一放在 `net` 下：
 
 ```bash

{chatecnu-0.2.2 → chatecnu-0.2.4}/README.md

@@ -63,6 +63,8 @@ ecnu home user
 ecnu home logout
 ```
 
+门户会话默认写入 ChatEnv runtime token-store：`~/.chatarch/tokens/ECNU/<profile>.json`；`ecnu home status --json` 只回读安全摘要，不输出原始 Cookie/CSRF。`chatenv token refresh ECNU <profile>` 可从同名 stable env profile 发起非交互 OCR 自动登录并由 ChatEnv 写入 runtime token-store；遇到短信验证码或验证码候选失败时会安全失败。
+
 校园网联网统一放在 `net` 下：
 
 ```bash

{chatecnu-0.2.2 → chatecnu-0.2.4}/pyproject.toml

@@ -12,7 +12,7 @@ license = "MIT"
 dependencies = [
     "click>=8.0",
     "chatstyle>=0.1.0,<0.2.0",
-    "chatenv>=0.2.4,<0.3.0",
+    "chatenv>=0.2.7,<0.3.0",
     "ChatNet>=0.2.0,<0.3.0",
     "requests>=2.0",
     "pycryptodome>=3.0",
@@ -31,6 +31,9 @@ chatecnu = "chatecnu.cli:main"
 [project.entry-points."chatenv.configs"]
 ecnu = "chatecnu.config"
 
+[project.entry-points."chatenv.token_refreshers"]
+ECNU = "chatecnu.ecnu.session_tokens:refresh_chatenv_token"
+
 [project.urls]
 Homepage = "https://github.com/ChatArch/ChatECNU"
 Repository = "https://github.com/ChatArch/ChatECNU"

{chatecnu-0.2.2 → chatecnu-0.2.4/src/ChatECNU.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ChatECNU
-Version: 0.2.2
+Version: 0.2.4
 Summary: ChatArch ECNU campus portal automation CLI
 Author-email: ChatArch <1073853456@qq.com>
 License-Expression: MIT
@@ -15,7 +15,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: click>=8.0
 Requires-Dist: chatstyle<0.2.0,>=0.1.0
-Requires-Dist: chatenv<0.3.0,>=0.2.4
+Requires-Dist: chatenv<0.3.0,>=0.2.7
 Requires-Dist: ChatNet<0.3.0,>=0.2.0
 Requires-Dist: requests>=2.0
 Requires-Dist: pycryptodome>=3.0
@@ -99,6 +99,8 @@ ecnu home user
 ecnu home logout
 ```
 
+门户会话默认写入 ChatEnv runtime token-store：`~/.chatarch/tokens/ECNU/<profile>.json`；`ecnu home status --json` 只回读安全摘要，不输出原始 Cookie/CSRF。`chatenv token refresh ECNU <profile>` 可从同名 stable env profile 发起非交互 OCR 自动登录并由 ChatEnv 写入 runtime token-store；遇到短信验证码或验证码候选失败时会安全失败。
+
 校园网联网统一放在 `net` 下：
 
 ```bash

{chatecnu-0.2.2 → chatecnu-0.2.4}/src/ChatECNU.egg-info/SOURCES.txt

@@ -17,6 +17,9 @@ src/chatecnu/ecnu/__init__.py
 src/chatecnu/ecnu/captcha.py
 src/chatecnu/ecnu/cli.py
 src/chatecnu/ecnu/portal.py
+src/chatecnu/ecnu/session_tokens.py
 tests/test_cli.py
+tests/test_docs_rendering.py
 tests/test_network_auth.py
+tests/test_token_store_sessions.py
 tests/test_version.py

{chatecnu-0.2.2 → chatecnu-0.2.4}/src/ChatECNU.egg-info/entry_points.txt

@@ -1,6 +1,9 @@
 [chatenv.configs]
 ecnu = chatecnu.config
 
+[chatenv.token_refreshers]
+ECNU = chatecnu.ecnu.session_tokens:refresh_chatenv_token
+
 [console_scripts]
 chatecnu = chatecnu.cli:main
 ecnu = chatecnu.cli:main

{chatecnu-0.2.2 → chatecnu-0.2.4}/src/ChatECNU.egg-info/requires.txt

@@ -1,6 +1,6 @@
 click>=8.0
 chatstyle<0.2.0,>=0.1.0
-chatenv<0.3.0,>=0.2.4
+chatenv<0.3.0,>=0.2.7
 ChatNet<0.3.0,>=0.2.0
 requests>=2.0
 pycryptodome>=3.0

{chatecnu-0.2.2 → chatecnu-0.2.4}/src/chatecnu/__init__.py

@@ -2,4 +2,4 @@
 
 __all__ = ["__version__"]
 
-__version__ = "0.2.2"
+__version__ = "0.2.4"

{chatecnu-0.2.2 → chatecnu-0.2.4}/src/chatecnu/config.py

@@ -14,7 +14,6 @@ class ECNUConfig(BaseEnvConfig):
 
     ECNU_USERNAME = EnvField("ECNU_USERNAME", desc="ECNU 用户名。")
     ECNU_PASSWORD = EnvField("ECNU_PASSWORD", desc="ECNU 密码。", is_sensitive=True)
-    ECNU_COOKIE = EnvField("ECNU_COOKIE", desc="ECNU 门户 Cookie。", is_sensitive=True)
     ECNU_BASE_URL = EnvField("ECNU_BASE_URL", default="https://login.ecnu.edu.cn:8800", desc="ECNU 门户地址。")
     ECNU_VISITOR_PASSWORD1 = EnvField("ECNU_VISITOR_PASSWORD1", desc="默认访客账号 m1 密码。", is_sensitive=True)
     ECNU_VISITOR_PASSWORD2 = EnvField("ECNU_VISITOR_PASSWORD2", desc="默认访客账号 m2 密码。", is_sensitive=True)
@@ -33,7 +32,6 @@ class ECNUConfig(BaseEnvConfig):
             return
         print(f"✅ Config loaded. Base URL: {base_url}")
         print(f"   Username configured: {bool(cls.ECNU_USERNAME.value)}")
-        print(f"   Cookie configured: {bool(cls.ECNU_COOKIE.value)}")
 
 
 __all__ = ["ECNUConfig"]

{chatecnu-0.2.2 → chatecnu-0.2.4}/src/chatecnu/ecnu/cli.py

@@ -9,6 +9,7 @@ from pathlib import Path
 from typing import Any, Callable
 
 import click
+from chatenv import TokenStore
 from chatstyle import CommandField, CommandSchema, add_interactive_option, resolve_command_inputs
 from chatenv.fields import BaseEnvConfig
 from chatenv.paths import get_paths
@@ -24,6 +25,7 @@ from chatecnu.network_auth import (
     resolve_auth_client_path,
 )
 from .portal import BASE_URL
+from .session_tokens import ECNU_SESSION_SERVICE, portal_session_profile
 
 
 LOGIN_SCHEMA = CommandSchema(
@@ -200,13 +202,13 @@ def _tree_callback(ctx: click.Context, param: click.Option, value: bool) -> None
     "--state-file",
     default=None,
     hidden=True,
-    help="Session state JSON file. Defaults to $CHATARCH_HOME/cache/chatecnu-session.json.",
+    help="Explicit legacy session state JSON file. Defaults to ChatEnv token-store tokens/ECNU/<profile>.json.",
 )
 @click.option(
     "--cookie",
     default=None,
     hidden=True,
-    help="Existing authenticated Cookie header. Defaults to chatenv ECNU_COOKIE.",
+    help="Explicit one-shot authenticated Cookie header override.",
 )
 @click.option("-e", "--env", "env_profile", default=None, help="ChatEnv 配置名。")
 @click.option("--env-file", default=None, hidden=True, help="Explicit env file override for ECNU values.")
@@ -224,10 +226,13 @@ def cli(
     """ECNU 门户工具。"""
 
     load_chatenv(env_profile=env_profile, env_file=env_file)
+    token_profile = portal_session_profile(env_profile)
     ctx.obj = {
         "base_url": base_url or ECNUConfig.ECNU_BASE_URL.value or BASE_URL,
-        "state_file": Path(state_file).expanduser() if state_file else default_state_file(),
-        "cookie": cookie or ECNUConfig.ECNU_COOKIE.value,
+        "state_file": Path(state_file).expanduser() if state_file else None,
+        "use_token_store": state_file is None,
+        "token_profile": token_profile,
+        "cookie": cookie,
         "timeout": timeout,
         "env_profile": env_profile,
         "env_file": env_file,
@@ -382,7 +387,7 @@ def session_info(ctx: click.Context, json_output: bool) -> None:
 def cookie_header(ctx: click.Context) -> None:
     """Print the current Cookie header from state/session."""
 
-    click.echo(make_client(ctx).cookie_header())
+    raise click.ClickException("Raw cookie output is disabled; use `ecnu home status --json` for redacted session metadata.")
 
 
 @home_group.command(name="logout")
@@ -929,11 +934,20 @@ def make_client(ctx: click.Context) -> Any:
     from .portal import PortalClient
 
     config = ctx.find_root().obj or ctx.obj or {}
+    token_store = TokenStore() if config.get("use_token_store") else None
+    token_profile = config.get("token_profile") or portal_session_profile(config.get("env_profile"))
+    state_file = config.get("state_file")
+    if token_store is not None:
+        state_file = token_store.token_path(ECNU_SESSION_SERVICE, token_profile)
+    elif state_file is None:
+        state_file = default_state_file()
     return PortalClient(
         base_url=config["base_url"],
-        state_file=config["state_file"],
+        state_file=Path(state_file),
         cookie_header=config.get("cookie"),
         timeout=config["timeout"],
+        token_store=token_store,
+        token_profile=token_profile,
     )
 
 
@@ -1105,6 +1119,12 @@ def format_status_summary(result: dict[str, Any]) -> str:
     else:
         lines.append("Authenticated at: not logged in")
     lines.append(f"Cookies saved: {len(cookies) if isinstance(cookies, dict) else 0}")
+    if result.get("session_storage") == "token_store":
+        lines.append(f"Session storage: token-store ({result.get('token_profile')})")
+        if result.get("token_file"):
+            lines.append(f"Token file: {result['token_file']}")
+    elif result.get("state_file"):
+        lines.append(f"Session storage: state-file ({result['state_file']})")
     if result.get("base_url"):
         lines.append(f"Base URL: {result['base_url']}")
     return "\n".join(lines)
@@ -1246,7 +1266,11 @@ def resolve_default_visitor_inputs(
 
 
 def session_status(ctx: click.Context) -> dict[str, Any]:
-    return redact_state(make_client(ctx).state)
+    client = make_client(ctx)
+    result = redact_state(client.state)
+    if hasattr(client, "session_storage_status"):
+        result.update(client.session_storage_status())
+    return result
 
 
 def ensure_default_visitors(

{chatecnu-0.2.2 → chatecnu-0.2.4}/src/chatecnu/ecnu/portal.py

@@ -23,6 +23,7 @@ from chatnet.portal import (
     find_table_with_headers,
     first_multirow_table,
     parse_detail_view_table,
+    parse_cookie_header,
     parse_tables,
     request_spec,
     require_value,
@@ -30,6 +31,14 @@ from chatnet.portal import (
     table_to_dicts,
 )
 
+from .session_tokens import (
+    ECNU_SESSION_SERVICE,
+    load_portal_session_state,
+    portal_session_profile,
+    portal_session_status,
+    save_portal_session_state,
+)
+
 BASE_URL = "https://login.ecnu.edu.cn:8800"
 LOGIN_PATH = "/login"
 VALIDATE_USER_PATH = "/site/validate-user"
@@ -113,6 +122,55 @@ class VisitorRow:
 
 
 class PortalClient(BrowserPortalClient):
+    def __init__(
+        self,
+        base_url: str,
+        state_file: Path,
+        cookie_header: str | None = None,
+        timeout: int = 20,
+        *,
+        token_store: Any | None = None,
+        token_profile: str | None = None,
+    ) -> None:
+        self._token_store = token_store
+        self._token_profile = portal_session_profile(token_profile)
+        super().__init__(base_url=base_url, state_file=state_file, cookie_header=None, timeout=timeout)
+        if self._token_store is not None:
+            self.state = load_portal_session_state(env_profile=self._token_profile, token_store=self._token_store)
+            self.session.cookies.clear()
+            state_cookies = self.state.get("cookies") or {}
+            if isinstance(state_cookies, dict) and state_cookies:
+                requests.utils.add_dict_to_cookiejar(self.session.cookies, state_cookies)
+        if cookie_header:
+            requests.utils.add_dict_to_cookiejar(self.session.cookies, parse_cookie_header(cookie_header))
+
+    def _save_state(self, extra: dict[str, Any] | None = None) -> None:
+        if self._token_store is None:
+            return super()._save_state(extra)
+        payload = dict(self.state)
+        payload["base_url"] = self.base_url
+        payload["cookies"] = requests.utils.dict_from_cookiejar(self.session.cookies)
+        if extra:
+            payload.update(extra)
+        save_portal_session_state(payload, env_profile=self._token_profile, token_store=self._token_store)
+        self.state = payload
+
+    def session_storage_status(self) -> dict[str, Any]:
+        if self._token_store is None:
+            return {
+                "session_storage": "state_file",
+                "state_file": str(self.state_file),
+            }
+        status = portal_session_status(env_profile=self._token_profile, token_store=self._token_store)
+        return {
+            "session_storage": "token_store",
+            "token_profile": status["profile"],
+            "token_file": status["token_file"],
+            "token_type": status["token_type"],
+            "token_present": status["token_present"],
+            "token_summary": status.get("summary") or {},
+        }
+
     def _authenticated_response(self, resp: requests.Response) -> requests.Response:
         resp.raise_for_status()
         if urlparse(resp.url).path == LOGIN_PATH:

chatecnu-0.2.4/src/chatecnu/ecnu/session_tokens.py

@@ -0,0 +1,200 @@
+"""ECNU portal session adapter for ChatEnv's generic token store."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from tempfile import TemporaryDirectory
+from typing import Any
+
+from chatenv import EnvStore, TokenRefreshResult, TokenStore, get_paths
+from chatenv.tokens import normalize_token_profile
+
+from chatecnu.config import ECNUConfig
+
+ECNU_SESSION_SERVICE = "ECNU"
+ECNU_PORTAL_TOKEN_TYPE = "portal_session"
+
+
+def portal_session_profile(env_profile: str | None = None) -> str:
+    """Return the token-store profile paired with the selected ChatEnv profile."""
+
+    return normalize_token_profile(env_profile)
+
+
+def portal_session_summary(state: dict[str, Any]) -> dict[str, Any]:
+    """Return safe metadata for a stored ECNU portal session."""
+
+    cookies = state.get("cookies") if isinstance(state, dict) else {}
+    cookie_count = len(cookies) if isinstance(cookies, dict) else 0
+    login_bootstrap = state.get("login_bootstrap") if isinstance(state, dict) else None
+    return {
+        "base_url": state.get("base_url") or "",
+        "username": state.get("username") or "",
+        "authenticated_at": state.get("authenticated_at") or "",
+        "cookie_count": cookie_count,
+        "has_login_bootstrap": isinstance(login_bootstrap, dict) and bool(login_bootstrap),
+    }
+
+
+def _store(token_store: TokenStore | None = None, *, home: str | Path | None = None) -> TokenStore:
+    return token_store or TokenStore(home=home)
+
+
+def _load_refresh_profile_values(
+    profile: str | None,
+    *,
+    home: str | Path | None = None,
+    env_store: EnvStore | None = None,
+) -> tuple[str, dict[str, str]]:
+    profile_name = normalize_token_profile(profile)
+    store = env_store or EnvStore(get_paths(home).envs_dir)
+    try:
+        profile_path = (
+            store.active_path(ECNUConfig)
+            if profile_name == "default"
+            else store.profile_path(ECNUConfig, profile_name)
+        )
+    except ValueError as exc:
+        raise ValueError(f"ECNU ChatEnv profile not found or invalid: {profile_name}") from exc
+    if not profile_path.exists():
+        raise ValueError(f"ECNU ChatEnv profile not found or invalid: {profile_name}")
+    try:
+        values = store.load_active(ECNUConfig) if profile_name == "default" else store.load_profile(ECNUConfig, profile_name)
+    except ValueError as exc:
+        raise ValueError(f"ECNU ChatEnv profile not found or invalid: {profile_name}") from exc
+    return profile_name, {str(key): str(value) for key, value in values.items() if value is not None}
+
+
+def _refresh_portal_client_class():
+    from .portal import PortalClient
+
+    return PortalClient
+
+
+def _default_base_url() -> str:
+    from .portal import BASE_URL
+
+    return BASE_URL
+
+
+def refresh_chatenv_token(
+    *,
+    service: str,
+    profile: str,
+    home: str | Path | None = None,
+    env_store: EnvStore | None = None,
+    token_store: TokenStore | None = None,
+) -> TokenRefreshResult:
+    """Refresh an ECNU portal session for ChatEnv's provider lifecycle.
+
+    The ECNU portal requires captcha OCR and can require SMS. This provider is
+    intentionally non-interactive: it runs the existing best-effort auto-login
+    path from a matching stable ChatEnv profile and fails closed if the portal
+    asks for SMS or rejects all captcha candidates. ChatEnv owns persistence
+    after this function returns, so the provider itself never writes the
+    token-store record.
+    """
+
+    del token_store  # ChatEnv persists the returned TokenRefreshResult.
+    if service != ECNU_SESSION_SERVICE:
+        raise ValueError(f"ChatECNU can refresh only {ECNU_SESSION_SERVICE} tokens")
+    profile_name, values = _load_refresh_profile_values(profile, home=home, env_store=env_store)
+    for key in ["ECNU_USERNAME", "ECNU_PASSWORD"]:
+        if not values.get(key):
+            raise ValueError(f"ECNU ChatEnv profile {profile_name} is missing {key}")
+
+    base_url = (values.get("ECNU_BASE_URL") or _default_base_url()).rstrip("/")
+    with TemporaryDirectory(prefix=f"chatecnu-refresh-{profile_name}-") as tmpdir:
+        tmp = Path(tmpdir)
+        client = _refresh_portal_client_class()(
+            base_url=base_url,
+            state_file=tmp / "ecnu-session.json",
+            cookie_header=None,
+            timeout=20,
+            token_store=None,
+            token_profile=profile_name,
+        )
+        result = client.login_auto(
+            values["ECNU_USERNAME"],
+            values["ECNU_PASSWORD"],
+            sms_code=None,
+            rounds=3,
+            topk=5,
+            captcha_path=tmp / "ecnu-login-captcha.png",
+        )
+        state = dict(getattr(client, "state", {}) or {})
+
+    if result.get("requires_sms"):
+        raise ValueError("ECNU portal refresh requires SMS verification and cannot run non-interactively")
+    if not result.get("success"):
+        raise ValueError("ECNU portal automatic refresh failed")
+    cookies = state.get("cookies")
+    if not isinstance(cookies, dict) or not cookies:
+        raise ValueError("ECNU portal refresh completed without cookies")
+    state.setdefault("base_url", base_url)
+    state.setdefault("username", values["ECNU_USERNAME"])
+    return TokenRefreshResult(
+        values=state,
+        token_type=ECNU_PORTAL_TOKEN_TYPE,
+        summary=portal_session_summary(state),
+    )
+
+
+def save_portal_session_state(
+    state: dict[str, Any],
+    *,
+    env_profile: str | None = None,
+    token_store: TokenStore | None = None,
+    home: str | Path | None = None,
+    source: str = "refresh",
+) -> dict[str, Any]:
+    """Persist opaque ECNU portal runtime state in ChatEnv's token store."""
+
+    values = dict(state)
+    return _store(token_store, home=home).write(
+        ECNU_SESSION_SERVICE,
+        portal_session_profile(env_profile),
+        values=values,
+        token_type=ECNU_PORTAL_TOKEN_TYPE,
+        summary=portal_session_summary(values),
+        source=source,
+    )
+
+
+def load_portal_session_state(
+    *,
+    env_profile: str | None = None,
+    token_store: TokenStore | None = None,
+    home: str | Path | None = None,
+) -> dict[str, Any]:
+    """Load opaque ECNU portal runtime state from ChatEnv's token store."""
+
+    payload = _store(token_store, home=home).read(ECNU_SESSION_SERVICE, portal_session_profile(env_profile))
+    values = payload.get("values") if isinstance(payload, dict) else None
+    return dict(values) if isinstance(values, dict) else {}
+
+
+def portal_session_status(
+    *,
+    env_profile: str | None = None,
+    token_store: TokenStore | None = None,
+    home: str | Path | None = None,
+) -> dict[str, Any]:
+    """Return safe token-store metadata for the ECNU portal session."""
+
+    status = _store(token_store, home=home).status(ECNU_SESSION_SERVICE, portal_session_profile(env_profile))
+    if not status.get("token_file_exists"):
+        status["token_type"] = ECNU_PORTAL_TOKEN_TYPE
+    return status
+
+
+__all__ = [
+    "ECNU_PORTAL_TOKEN_TYPE",
+    "ECNU_SESSION_SERVICE",
+    "load_portal_session_state",
+    "portal_session_profile",
+    "portal_session_status",
+    "portal_session_summary",
+    "refresh_chatenv_token",
+    "save_portal_session_state",
+]

chatecnu-0.2.4/tests/test_docs_rendering.py

@@ -0,0 +1,35 @@
+from __future__ import annotations
+
+import subprocess
+import sys
+from pathlib import Path
+
+
+def test_quickstart_uses_active_ecnu_env_profile() -> None:
+    repo = Path(__file__).resolve().parents[1]
+    for relative in ("docs/quickstart.md", "docs/quickstart.en.md"):
+        text = (repo / relative).read_text(encoding="utf-8")
+        assert "chatenv init -t ecnu -I" in text
+        assert "chatenv new default -t ecnu -I --yes" not in text
+
+
+def test_mkdocs_material_icons_render_without_literal_tokens(tmp_path: Path) -> None:
+    site_dir = tmp_path / "site"
+    result = subprocess.run(
+        [sys.executable, "-m", "mkdocs", "build", "--strict", "--site-dir", str(site_dir)],
+        cwd=Path(__file__).resolve().parents[1],
+        text=True,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.STDOUT,
+        check=False,
+    )
+
+    assert result.returncode == 0, result.stdout
+    checked = {
+        "zh_home": site_dir / "index.html",
+        "en_home": site_dir / "en" / "index.html",
+    }
+    for name, page in checked.items():
+        html = page.read_text(encoding="utf-8")
+        assert ":material-" not in html, name
+        assert "twemoji" in html or "md-icon" in html, name

chatecnu-0.2.4/tests/test_token_store_sessions.py

@@ -0,0 +1,317 @@
+import json
+
+import pytest
+from click.testing import CliRunner
+from chatenv import EnvStore, TokenRefreshResult, TokenStore
+import chatenv.token_refreshers as chatenv_refreshers
+from chatenv.token_refreshers import refresh_token
+
+from chatecnu.cli import main
+from chatecnu.config import ECNUConfig
+
+
+def test_ecnu_config_does_not_persist_portal_cookie_in_stable_env_schema():
+    assert not hasattr(ECNUConfig, "ECNU_COOKIE")
+
+
+def test_portal_session_state_roundtrips_through_chatenv_token_store(tmp_path):
+    from chatecnu.ecnu.session_tokens import (
+        ECNU_PORTAL_TOKEN_TYPE,
+        load_portal_session_state,
+        portal_session_status,
+        save_portal_session_state,
+    )
+
+    store = TokenStore(tokens_dir=tmp_path / "tokens")
+    state = {
+        "base_url": "https://login.ecnu.edu.cn:8800",
+        "username": "student001",
+        "authenticated_at": "2026-08-11T12:34:56",
+        "cookies": {"PHPSESSID_8800": "secret-cookie"},
+        "login_bootstrap": {"csrf_param": "_csrf-8800", "csrf_token": "secret-csrf"},
+    }
+
+    written = save_portal_session_state(
+        state,
+        env_profile="RexWzh",
+        token_store=store,
+        source="login",
+    )
+
+    assert written["service"] == "ECNU"
+    assert written["profile"] == "RexWzh"
+    assert written["token_type"] == ECNU_PORTAL_TOKEN_TYPE
+    assert written["token_present"] is True
+    assert written["summary"] == {
+        "base_url": "https://login.ecnu.edu.cn:8800",
+        "username": "student001",
+        "authenticated_at": "2026-08-11T12:34:56",
+        "cookie_count": 1,
+        "has_login_bootstrap": True,
+    }
+    assert "secret-cookie" not in json.dumps(written)
+    assert "secret-csrf" not in json.dumps(written)
+
+    assert load_portal_session_state(env_profile="RexWzh", token_store=store) == state
+    status = portal_session_status(env_profile="RexWzh", token_store=store)
+    assert status["token_file"].endswith("tokens/ECNU/RexWzh.json")
+    assert status["summary"]["cookie_count"] == 1
+
+
+def test_home_status_reads_profile_token_store_and_redacts_session_values(tmp_path, monkeypatch):
+    chatarch_home = tmp_path / "chatarch"
+    monkeypatch.setenv("CHATARCH_HOME", str(chatarch_home))
+    env_file = chatarch_home / "envs" / "ECNU" / "RexWzh.env"
+    env_file.parent.mkdir(parents=True)
+    env_file.write_text("ECNU_BASE_URL='https://login.ecnu.edu.cn:8800'\n", encoding="utf-8")
+    TokenStore(home=chatarch_home).write(
+        "ECNU",
+        "RexWzh",
+        values={
+            "base_url": "https://login.ecnu.edu.cn:8800",
+            "username": "student001",
+            "authenticated_at": "2026-08-11T12:34:56",
+            "cookies": {"PHPSESSID_8800": "secret-cookie"},
+            "login_bootstrap": {"csrf_param": "_csrf-8800", "csrf_token": "secret-csrf"},
+        },
+        token_type="portal_session",
+        summary={
+            "base_url": "https://login.ecnu.edu.cn:8800",
+            "username": "student001",
+            "authenticated_at": "2026-08-11T12:34:56",
+            "cookie_count": 1,
+            "has_login_bootstrap": True,
+        },
+        source="test",
+    )
+
+    result = CliRunner().invoke(main, ["-e", "RexWzh", "home", "status", "--json"])
+
+    assert result.exit_code == 0, result.output
+    data = json.loads(result.output)
+    assert data["username"] == "student001"
+    assert data["cookies"] == {"PHPSESSID_8800": "***"}
+    assert data["token_profile"] == "RexWzh"
+    assert data["token_type"] == "portal_session"
+    assert data["token_file"].endswith("tokens/ECNU/RexWzh.json")
+    assert "secret-cookie" not in result.output
+    assert "secret-csrf" not in result.output
+
+
+def test_cookie_header_command_is_disabled_instead_of_printing_raw_cookie(tmp_path):
+    state_file = tmp_path / "legacy-session.json"
+    state_file.write_text(
+        json.dumps({"cookies": {"PHPSESSID_8800": "secret-cookie"}}),
+        encoding="utf-8",
+    )
+
+    result = CliRunner().invoke(main, ["--state-file", str(state_file), "home", "cookie-header"])
+
+    assert result.exit_code != 0
+    assert "secret-cookie" not in result.output
+    assert "disabled" in result.output.lower()
+
+
+def _save_ecnu_profile(env_store: EnvStore, name: str = "RexWzh") -> None:
+    env_store.save_profile(
+        ECNUConfig,
+        name,
+        {
+            "ECNU_BASE_URL": "https://login.ecnu.edu.cn:8800",
+            "ECNU_USERNAME": "student001",
+            "ECNU_PASSWORD": "secret-password-fixture",
+        },
+    )
+
+
+def _save_active_ecnu_profile(env_store: EnvStore) -> None:
+    env_store.save_active(
+        ECNUConfig,
+        {
+            "ECNU_BASE_URL": "https://login.ecnu.edu.cn:8800",
+            "ECNU_USERNAME": "active-student",
+            "ECNU_PASSWORD": "active-secret-password-fixture",
+        },
+    )
+
+
+def test_refresh_chatenv_token_uses_matching_stable_profile_without_writing_store(tmp_path, monkeypatch):
+    from chatecnu.ecnu import session_tokens
+
+    home = tmp_path / "chatarch"
+    env_store = EnvStore(home / "envs")
+    _save_ecnu_profile(env_store)
+    captured: dict[str, object] = {}
+
+    class FakePortalClient:
+        def __init__(self, *, base_url, state_file, cookie_header=None, timeout=20, token_store=None, token_profile=None):
+            captured.update(
+                {
+                    "base_url": base_url,
+                    "state_file": str(state_file),
+                    "cookie_header": cookie_header,
+                    "timeout": timeout,
+                    "token_store": token_store,
+                    "token_profile": token_profile,
+                }
+            )
+            self.state: dict[str, object] = {}
+
+        def login_auto(self, username, password, sms_code, rounds, topk, captcha_path):
+            captured.update(
+                {
+                    "username": username,
+                    "password": password,
+                    "sms_code": sms_code,
+                    "rounds": rounds,
+                    "topk": topk,
+                    "captcha_path": str(captcha_path),
+                }
+            )
+            self.state = {
+                "base_url": "https://login.ecnu.edu.cn:8800",
+                "username": username,
+                "authenticated_at": "2026-08-11T12:34:56",
+                "cookies": {"PHPSESSID_8800": "secret-cookie"},
+                "login_bootstrap": {"csrf_param": "_csrf-8800", "csrf_token": "secret-csrf"},
+            }
+            return {"success": True, "requires_sms": False}
+
+    monkeypatch.setattr(session_tokens, "_refresh_portal_client_class", lambda: FakePortalClient)
+
+    result = session_tokens.refresh_chatenv_token(
+        service="ECNU",
+        profile="RexWzh",
+        home=home,
+        env_store=env_store,
+    )
+
+    assert result.token_type == "portal_session"
+    assert result.values["cookies"] == {"PHPSESSID_8800": "secret-cookie"}
+    assert result.summary == {
+        "base_url": "https://login.ecnu.edu.cn:8800",
+        "username": "student001",
+        "authenticated_at": "2026-08-11T12:34:56",
+        "cookie_count": 1,
+        "has_login_bootstrap": True,
+    }
+    assert "secret-cookie" not in json.dumps(result.summary)
+    assert "secret-csrf" not in json.dumps(result.summary)
+    assert captured["token_store"] is None
+    assert captured["token_profile"] == "RexWzh"
+    assert captured["password"] == "secret-password-fixture"
+    assert captured["rounds"] == 3
+    assert captured["topk"] == 5
+    assert not TokenStore(home=home).token_path("ECNU", "RexWzh").exists()
+
+
+def test_refresh_chatenv_token_default_uses_active_env_profile(tmp_path, monkeypatch):
+    from chatecnu.ecnu import session_tokens
+
+    home = tmp_path / "chatarch"
+    env_store = EnvStore(home / "envs")
+    _save_active_ecnu_profile(env_store)
+    captured: dict[str, object] = {}
+
+    class ActivePortalClient:
+        def __init__(self, **kwargs):
+            captured.update(kwargs)
+            self.state: dict[str, object] = {}
+
+        def login_auto(self, username, password, sms_code, rounds, topk, captcha_path):
+            captured.update({"username": username, "password": password})
+            self.state = {
+                "base_url": "https://login.ecnu.edu.cn:8800",
+                "username": username,
+                "authenticated_at": "2026-08-11T13:00:00",
+                "cookies": {"PHPSESSID_8800": "active-secret-cookie"},
+            }
+            return {"success": True, "requires_sms": False}
+
+    monkeypatch.setattr(session_tokens, "_refresh_portal_client_class", lambda: ActivePortalClient)
+
+    result = session_tokens.refresh_chatenv_token(
+        service="ECNU",
+        profile="default",
+        home=home,
+        env_store=env_store,
+    )
+
+    assert result.token_type == "portal_session"
+    assert result.summary["username"] == "active-student"
+    assert captured["token_profile"] == "default"
+    assert captured["username"] == "active-student"
+    assert captured["password"] == "active-secret-password-fixture"
+    assert not TokenStore(home=home).token_path("ECNU", "default").exists()
+
+
+def test_refresh_chatenv_token_fails_without_matching_stable_profile(tmp_path):
+    from chatecnu.ecnu.session_tokens import refresh_chatenv_token
+
+    home = tmp_path / "chatarch"
+    env_store = EnvStore(home / "envs")
+
+    with pytest.raises(ValueError, match="profile not found"):
+        refresh_chatenv_token(service="ECNU", profile="RexWzh", home=home, env_store=env_store)
+
+
+def test_refresh_chatenv_token_fails_closed_when_auto_login_requires_sms(tmp_path, monkeypatch):
+    from chatecnu.ecnu import session_tokens
+
+    home = tmp_path / "chatarch"
+    env_store = EnvStore(home / "envs")
+    _save_ecnu_profile(env_store)
+
+    class SmsPortalClient:
+        def __init__(self, **kwargs):
+            self.state = {"cookies": {"PHPSESSID_8800": "secret-cookie"}}
+
+        def login_auto(self, username, password, sms_code, rounds, topk, captcha_path):
+            return {"success": False, "requires_sms": True, "message": "SMS verification is required"}
+
+    monkeypatch.setattr(session_tokens, "_refresh_portal_client_class", lambda: SmsPortalClient)
+
+    with pytest.raises(ValueError, match="requires SMS") as exc_info:
+        session_tokens.refresh_chatenv_token(service="ECNU", profile="RexWzh", home=home, env_store=env_store)
+    assert "secret-cookie" not in str(exc_info.value)
+
+
+def test_chat_env_refresh_writes_ecnu_provider_result(tmp_path, monkeypatch):
+    home = tmp_path / "chatarch"
+    env_store = EnvStore(home / "envs")
+    _save_ecnu_profile(env_store)
+
+    def fake_provider(**kwargs):
+        return TokenRefreshResult(
+            values={
+                "base_url": "https://login.ecnu.edu.cn:8800",
+                "username": "student001",
+                "authenticated_at": "2026-08-11T12:34:56",
+                "cookies": {"PHPSESSID_8800": "secret-cookie"},
+                "login_bootstrap": {"csrf_token": "secret-csrf"},
+            },
+            token_type="portal_session",
+            summary={
+                "base_url": "https://login.ecnu.edu.cn:8800",
+                "username": "student001",
+                "authenticated_at": "2026-08-11T12:34:56",
+                "cookie_count": 1,
+                "has_login_bootstrap": True,
+            },
+        )
+
+    chatenv_refreshers.clear_token_refreshers()
+    monkeypatch.setitem(chatenv_refreshers._token_refreshers, "ecnu", fake_provider)
+    monkeypatch.setattr(chatenv_refreshers, "_loaded", True)
+
+    status = refresh_token("ECNU", "RexWzh", home=home, env_store=env_store)
+
+    assert status["service"] == "ECNU"
+    assert status["profile"] == "RexWzh"
+    assert status["token_type"] == "portal_session"
+    assert status["token_present"] is True
+    assert status["source"] == "refresh"
+    assert status["summary"]["cookie_count"] == 1
+    dumped = json.dumps(status)
+    assert "secret-cookie" not in dumped
+    assert "secret-csrf" not in dumped

chatecnu-0.2.4/tests/test_version.py

@@ -0,0 +1,26 @@
+from chatecnu import __version__
+
+
+def test_version_present():
+    assert __version__ == "0.2.4"
+
+
+def test_cli_version_option():
+    from click.testing import CliRunner
+    from chatecnu.cli import main
+
+    result = CliRunner().invoke(main, ["--version"])
+
+    assert result.exit_code == 0
+    assert "0.2.4" in result.output
+
+
+def test_chatenv_dependency_and_refresh_provider_entry_point_declared():
+    from pathlib import Path
+
+    pyproject = (Path(__file__).resolve().parents[1] / "pyproject.toml").read_text(
+        encoding="utf-8"
+    )
+    assert '"chatenv>=0.2.7,<0.3.0"' in pyproject
+    assert '[project.entry-points."chatenv.token_refreshers"]' in pyproject
+    assert 'ECNU = "chatecnu.ecnu.session_tokens:refresh_chatenv_token"' in pyproject

chatecnu-0.2.2/tests/test_version.py

@@ -1,15 +0,0 @@
-from chatecnu import __version__
-
-
-def test_version_present():
-    assert __version__ == "0.2.2"
-
-
-def test_cli_version_option():
-    from click.testing import CliRunner
-    from chatecnu.cli import main
-
-    result = CliRunner().invoke(main, ["--version"])
-
-    assert result.exit_code == 0
-    assert "0.2.2" in result.output