hap-cli 0.9.5__tar.gz → 0.9.6__tar.gz

{hap_cli-0.9.5 → hap_cli-0.9.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hap-cli
-Version: 0.9.5
+Version: 0.9.6
 Summary: CLI harness for Mingdao HAP - Enterprise no-code platform
 Author: hap-cli
 License: Apache-2.0
@@ -339,6 +339,7 @@ discover every subcommand.
 | `config completion [bash\|zsh\|fish] [--install]` | Enable `<Tab>` completion |
 | `config language [LANG]` | Switch UI language (`en` / `zh-Hans`, or `auto` to follow the account language) |
 | `config update [auto\|notify\|off]` | Self-upgrade mode; `notify` only reports, `off` never checks |
+| `config auto-login [on\|off]` | Renew an expired login in the browser (one click on Authorize) and carry on; `off` stops with "not logged in" |
 | `config log on / off / status` | Toggle and inspect API logging |
 | `config log level LEVEL` | `DEBUG / INFO / WARNING / ERROR / CRITICAL` |
 | `config log view [--lines N] [--no-follow]` | Tail the log file |

{hap_cli-0.9.5/hap_cli → hap_cli-0.9.6}/README.md

@@ -310,6 +310,7 @@ discover every subcommand.
 | `config completion [bash\|zsh\|fish] [--install]` | Enable `<Tab>` completion |
 | `config language [LANG]` | Switch UI language (`en` / `zh-Hans`, or `auto` to follow the account language) |
 | `config update [auto\|notify\|off]` | Self-upgrade mode; `notify` only reports, `off` never checks |
+| `config auto-login [on\|off]` | Renew an expired login in the browser (one click on Authorize) and carry on; `off` stops with "not logged in" |
 | `config log on / off / status` | Toggle and inspect API logging |
 | `config log level LEVEL` | `DEBUG / INFO / WARNING / ERROR / CRITICAL` |
 | `config log view [--lines N] [--no-follow]` | Tail the log file |

{hap_cli-0.9.5 → hap_cli-0.9.6/hap_cli}/README.md

@@ -310,6 +310,7 @@ discover every subcommand.
 | `config completion [bash\|zsh\|fish] [--install]` | Enable `<Tab>` completion |
 | `config language [LANG]` | Switch UI language (`en` / `zh-Hans`, or `auto` to follow the account language) |
 | `config update [auto\|notify\|off]` | Self-upgrade mode; `notify` only reports, `off` never checks |
+| `config auto-login [on\|off]` | Renew an expired login in the browser (one click on Authorize) and carry on; `off` stops with "not logged in" |
 | `config log on / off / status` | Toggle and inspect API logging |
 | `config log level LEVEL` | `DEBUG / INFO / WARNING / ERROR / CRITICAL` |
 | `config log view [--lines N] [--no-follow]` | Tail the log file |

{hap_cli-0.9.5 → hap_cli-0.9.6}/hap_cli/README_CN.md

@@ -289,6 +289,7 @@ hap --json worksheet record list WORKSHEET_ID
 | `config completion [bash\|zsh\|fish] [--install]` | 启用 `<Tab>` 补全 |
 | `config language [LANG]` | 切换显示语言（`en` / `zh-Hans`；`auto` 跟随登录账号的语言） |
 | `config update [auto\|notify\|off]` | 自动升级开关；`notify` 只提示不安装，`off` 不检查 |
+| `config auto-login [on\|off]` | 登录过期时自动打开浏览器授权页，点一下「授权」命令继续执行；`off` 则直接报未登录 |
 | `config log on / off / status` | 日志开关与状态 |
 | `config log level LEVEL` | 设置日志级别（`DEBUG/INFO/WARNING/ERROR/CRITICAL`） |
 | `config log view [--lines N] [--no-follow]` | 跟踪日志文件 |

{hap_cli-0.9.5 → hap_cli-0.9.6}/hap_cli/__init__.py

@@ -3,7 +3,7 @@
 import sys as _sys
 import types as _types
 
-__version__ = "0.9.5"
+__version__ = "0.9.6"
 
 # The command tree used to live in hap_cli/hap_cli.py. A module named
 # after the package it sits in shadows that package: run python with the

{hap_cli-0.9.5 → hap_cli-0.9.6}/hap_cli/commands/config_cmd.py

@@ -126,6 +126,7 @@ def config_completion(shell, install):
 @pass_context
 def config_show(ctx):
     """Display current harness configuration."""
+    from hap_cli.core.relogin import get_mode as get_auto_login_mode
     from hap_cli.core.update import get_update_mode
 
     log_cfg = load_logging_config()
@@ -136,6 +137,7 @@ def config_show(ctx):
             "file": str(resolve_log_path(log_cfg)),
         },
         "update": get_update_mode(),
+        "auto_login": get_auto_login_mode(),
     }
 
     def _human(d):
@@ -144,6 +146,7 @@ def config_show(ctx):
         click.echo(f"  level   : {d['logging']['level']}")
         click.echo(f"  file    : {d['logging']['file']}")
         click.echo(f"update    : {d['update']}")
+        click.echo(f"auto-login: {d['auto_login']}")
 
     ctx.output(data, _human)
 
@@ -253,6 +256,45 @@ def config_update(ctx, mode):
         click.echo(f"Self-update set to: {mode}")
 
 
+# ── `hap config auto-login` ───────────────────────────────────────────────
+
+
+@config.command("auto-login")
+@click.argument("mode", required=False, type=click.Choice(["on", "off"]))
+@pass_context
+def config_auto_login(ctx, mode):
+    """Control whether an expired login is renewed in the browser.
+
+    \b
+      on   when a command finds your login expired, open the browser
+           authorization page, wait for you to click Authorize, then
+           carry on (default)
+      off  stop with a "not logged in" error instead
+
+    Without an argument, shows the current setting. It never applies over
+    SSH, in CI, or where no browser can be shown. Setting the environment
+    variable HAP_AUTO_LOGIN=0 turns it off for one shell.
+    """
+    from hap_cli.core.relogin import CONFIG_KEY, get_mode
+    from hap_cli.core.session import save_config
+
+    if mode is None:
+        current = get_mode()
+        if ctx.json_mode:
+            from hap_cli.utils.formatting import output_json
+            output_json({"auto_login": current})
+        else:
+            click.echo(f"Auto-login: {current}")
+        return
+
+    save_config({CONFIG_KEY: mode})
+    if ctx.json_mode:
+        from hap_cli.utils.formatting import output_json
+        output_json({"status": "ok", "auto_login": mode})
+    else:
+        click.echo(f"Auto-login set to: {mode}")
+
+
 # ── `hap config language` ─────────────────────────────────────────────────
 
 

{hap_cli-0.9.5 → hap_cli-0.9.6}/hap_cli/context.py

@@ -20,6 +20,27 @@ NOT_LOGGED_IN_HINT = (
 )
 
 
+def _relogin_notice(login_url: str, timeout: int) -> None:
+    """Tell the user an authorization page is waiting for one click.
+
+    Written to stderr so ``--json`` output on stdout stays parseable; the
+    desktop notification is for callers (AI agents) whose terminal output
+    the user only sees after the command ends.
+    """
+    from hap_cli.core.relogin import desktop_notify
+    from hap_cli.i18n import t
+
+    click.echo(
+        t("Your HAP login has expired. A browser page is open — click "
+          "Authorize (授权) to continue (waiting up to {seconds}s).").format(
+            seconds=timeout),
+        err=True,
+    )
+    click.echo(f"  {login_url}", err=True)
+    desktop_notify(t("Login expired — click Authorize (授权) in the browser "
+                     "to let the command continue."))
+
+
 class Context:
     """Shared CLI context."""
 
@@ -43,6 +64,7 @@ class Context:
         """
         if self.session is None:
             self.session = Session.load(self.profile)
+            self.session.relogin_notice = _relogin_notice
             # One-time migration for sessions logged in before account_id
             # was persisted. Some HAP controllers (notably
             # Invitation/InviteUser) silently degrade when the AccountId
@@ -55,7 +77,10 @@ class Context:
             ):
                 self.session._lazy_resolve_account_id()
         if require_auth and not self.session.auth_token:
-            raise SessionError("Not logged in. Run 'hap auth login' first.")
+            # A saved environment without a token: authorize it again in
+            # the browser rather than stopping the command.
+            if not (self.session.login_url and self.session.recover_auth()):
+                raise SessionError("Not logged in. Run 'hap auth login' first.")
         return self.session
 
     def output(self, data, table_fn=None):

{hap_cli-0.9.5 → hap_cli-0.9.6}/hap_cli/core/chat.py

@@ -48,26 +48,43 @@ def _chatmq_get(
     # mirror the other transport hooks.
     from hap_cli.core import cli_access
 
+    from hap_cli.core.session import AuthenticationError
+
     cli_access.ensure_before_request(session, url)
-    headers = {
-        "Authorization": f"md_pss_id {session.auth_token}",
-        "X-Requested-With": "XMLHttpRequest",
-        "User-Agent": hap_user_agent(),
-    }
-    auth_for_log = redact_authorization(headers["Authorization"])
-    logger.info(
-        "HAP GET %s params=%s Authorization=%s",
-        url,
-        format_body_for_log(params) or "{}",
-        auth_for_log,
-    )
-    response = requests.get(url, params=params, headers=headers, timeout=timeout)
-    logger.info(
-        "HAP GET %s -> %d %s",
-        url,
-        response.status_code,
-        format_response_for_log(getattr(response, "text", "") or ""),
-    )
+
+    def _send():
+        headers = {
+            "Authorization": f"md_pss_id {session.auth_token}",
+            "X-Requested-With": "XMLHttpRequest",
+            "User-Agent": hap_user_agent(),
+        }
+        auth_for_log = redact_authorization(headers["Authorization"])
+        logger.info(
+            "HAP GET %s params=%s Authorization=%s",
+            url,
+            format_body_for_log(params) or "{}",
+            auth_for_log,
+        )
+        response = requests.get(url, params=params, headers=headers, timeout=timeout)
+        logger.info(
+            "HAP GET %s -> %d %s",
+            url,
+            response.status_code,
+            format_response_for_log(getattr(response, "text", "") or ""),
+        )
+        return response
+
+    response = _send()
+    # An expired login gets the same one-shot browser re-authorization as
+    # the main transport (Session._post); the read is then resent once.
+    if response.status_code == 401:
+        if not session.recover_auth():
+            raise AuthenticationError(
+                "Authentication failed (HTTP 401). "
+                "Your session token is missing, invalid, or expired.",
+                status_code=401,
+            )
+        response = _send()
     response.raise_for_status()
     return response.json()
 

hap_cli-0.9.6/hap_cli/core/relogin.py

@@ -0,0 +1,255 @@
+"""Recover from an expired login by re-running the browser authorization.
+
+The CLI token is the web session token (``md_pss_id``) handed over by the
+``/cliauth`` page, so it dies with the web session: after 24 hours without
+activity every request starts failing with 401. Most callers are AI agents
+running one command at a time, for whom a dead token means the whole task
+stops until a human runs ``hap auth login``. Instead, the transport calls
+:func:`recover` when the server rejects the token: it opens the same
+authorization page (the user clicks 授权 once), waits a bounded time, saves
+the new token to the same profile, and tells the caller to retry the
+request once.
+
+Guard rails, all deliberate:
+
+- Only when a desktop browser can plausibly be shown (no SSH session, no
+  CI, a display on Linux) and the user has not turned it off
+  (``hap config auto-login off`` / ``HAP_AUTO_LOGIN=0``).
+- Only for a session loaded from a saved profile with a login address —
+  a bare ``Session()`` (tests, library use) never opens a browser.
+- At most once per process. A second rejection after a fresh login is a
+  real permission problem, not an expiry.
+- A 401/403 is first confirmed against ``Global/GetGlobalMeta``: if the
+  current token still identifies the user, the rejection was about
+  permissions and no browser is opened.
+- The browser may be signed in as somebody else; a token for a different
+  account is discarded rather than silently switching identities.
+- Parallel commands share one login through a file lock; the ones that
+  waited pick up the token the first one saved.
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+import subprocess
+import sys
+import time
+from contextlib import contextmanager
+from pathlib import Path
+from typing import Any, Callable, Optional
+
+logger = logging.getLogger("hap_cli.relogin")
+
+# Seconds to wait for the user to click 授权. AI tool runners commonly
+# kill a command after 120s, so this stays well inside that budget.
+DEFAULT_TIMEOUT_SECONDS = 90
+
+CONFIG_KEY = "auto_login"
+ENV_SWITCH = "HAP_AUTO_LOGIN"
+ENV_TIMEOUT = "HAP_AUTO_LOGIN_TIMEOUT"
+
+_OFF_VALUES = {"0", "off", "false", "no"}
+
+# Signals that tell us nobody is sitting in front of a browser.
+_HEADLESS_ENV = ("CI", "SSH_CONNECTION", "SSH_TTY")
+
+
+class ReloginTimeout(Exception):
+    """The browser authorization page was opened but not completed."""
+
+
+def get_mode() -> str:
+    """``"on"`` or ``"off"`` as stored by ``hap config auto-login``."""
+    from hap_cli.core.session import load_config
+
+    value = str((load_config() or {}).get(CONFIG_KEY) or "on").lower()
+    return "off" if value in _OFF_VALUES else "on"
+
+
+def timeout_seconds() -> int:
+    raw = os.environ.get(ENV_TIMEOUT)
+    if raw:
+        try:
+            value = int(raw)
+            if value > 0:
+                return value
+        except ValueError:
+            logger.warning("Ignoring non-integer %s=%r", ENV_TIMEOUT, raw)
+    return DEFAULT_TIMEOUT_SECONDS
+
+
+def can_open_browser() -> bool:
+    """Best guess whether a browser window would reach a person."""
+    for name in _HEADLESS_ENV:
+        if os.environ.get(name):
+            logger.info("Auto-login skipped: %s is set", name)
+            return False
+    if sys.platform.startswith("linux"):
+        if not (os.environ.get("DISPLAY") or os.environ.get("WAYLAND_DISPLAY")):
+            logger.info("Auto-login skipped: no DISPLAY / WAYLAND_DISPLAY")
+            return False
+    return True
+
+
+def enabled(session: Any) -> bool:
+    switch = os.environ.get(ENV_SWITCH)
+    if switch is not None and switch.strip().lower() in _OFF_VALUES:
+        return False
+    if get_mode() == "off":
+        return False
+    if not getattr(session, "_profile_name", "") or not getattr(session, "login_url", ""):
+        return False
+    if getattr(session, "_relogin_attempted", False):
+        return False
+    return can_open_browser()
+
+
+def token_still_valid(login_url: str, token: str) -> bool:
+    """True when ``token`` still identifies a user.
+
+    Network or shape trouble counts as "cannot tell" and returns True, so
+    a flaky connection never pops a browser window.
+    """
+    from hap_cli.core import auth as auth_mod
+    from hap_cli.core.session import AuthenticationError
+
+    if not token:
+        return False
+    try:
+        auth_mod.user_info_from_meta(auth_mod.fetch_global_meta(login_url, token))
+        return True
+    except AuthenticationError:
+        return False
+    except Exception as exc:
+        logger.warning("Could not confirm whether the token expired: %s", exc)
+        return True
+
+
+def _lock_path() -> Path:
+    from hap_cli.core.session import CONFIG_DIR
+
+    return Path(CONFIG_DIR) / "relogin.lock"
+
+
+@contextmanager
+def _login_lock():
+    """Serialise logins across processes. No-op where fcntl is missing."""
+    try:
+        import fcntl
+    except ImportError:  # Windows
+        yield
+        return
+    path = _lock_path()
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with open(path, "a+") as handle:
+        fcntl.flock(handle.fileno(), fcntl.LOCK_EX)
+        try:
+            yield
+        finally:
+            fcntl.flock(handle.fileno(), fcntl.LOCK_UN)
+
+
+def desktop_notify(message: str) -> None:
+    """Raise an OS notification so the user notices the browser tab."""
+    try:
+        if sys.platform == "darwin":
+            script = 'display notification {} with title "hap-cli"'.format(
+                _applescript_quote(message)
+            )
+            subprocess.run(["osascript", "-e", script], timeout=5,
+                           capture_output=True, check=False)
+        elif sys.platform.startswith("linux"):
+            subprocess.run(["notify-send", "hap-cli", message], timeout=5,
+                           capture_output=True, check=False)
+    except Exception as exc:
+        logger.warning("Desktop notification failed: %s", exc)
+
+
+def _applescript_quote(text: str) -> str:
+    return '"' + text.replace("\\", "\\\\").replace('"', '\\"') + '"'
+
+
+def _adopt_saved_token(session: Any) -> bool:
+    """Pick up a token another process saved while we waited for the lock."""
+    from hap_cli.core.session import Session
+
+    # Session.load, not load_profile: the token is encrypted at rest.
+    token = Session.load(session._profile_name).auth_token or ""
+    if token and token != session.auth_token and token_still_valid(session.login_url, token):
+        logger.info("Auto-login: reusing token refreshed by another command")
+        session.auth_token = token
+        session._global_meta_cache = None
+        return True
+    return False
+
+
+def _apply_login(session: Any, token: str, meta: dict, user_info: dict) -> None:
+    from hap_cli.core import global_meta as gm
+    from hap_cli.core.session import AuthenticationError
+
+    new_account = str(user_info.get("id") or "")
+    if session.account_id and new_account and new_account != session.account_id:
+        raise AuthenticationError(
+            "The browser is signed in to a different account "
+            f"({user_info.get('name') or new_account}); the saved login was "
+            "not changed. Sign in to the right account in the browser, or run "
+            "'hap auth login' to switch."
+        )
+    session.auth_token = token
+    if new_account:
+        session.account_id = new_account
+    endpoints = gm.extract_service_endpoints(meta)
+    if endpoints:
+        session.service_endpoints = endpoints
+    session._global_meta_cache = None
+    session.save(profile=session._profile_name)
+    logger.info("Auto-login: saved refreshed token to profile %s", session._profile_name)
+
+
+def recover(
+    session: Any,
+    *,
+    login: Optional[Callable[..., tuple]] = None,
+    notify: Optional[Callable[[str, int], None]] = None,
+) -> bool:
+    """Try to replace an expired token. True means "retry the request".
+
+    Raises :class:`ReloginTimeout` when the authorization page was opened
+    but nobody clicked through in time, and ``AuthenticationError`` when
+    the browser handed back a different account. Every other way out is
+    ``False`` — the caller then raises its original error.
+    """
+    if not enabled(session):
+        return False
+    session._relogin_attempted = True
+
+    if token_still_valid(session.login_url, session.auth_token):
+        logger.info("Auto-login skipped: token is still valid, rejection is "
+                    "not an expiry")
+        return False
+
+    from hap_cli.core import auth as auth_mod
+
+    login = login or auth_mod.login
+    notify = notify or getattr(session, "relogin_notice", None)
+    seconds = timeout_seconds()
+
+    with _login_lock():
+        if _adopt_saved_token(session):
+            return True
+        logger.info("Auto-login: opening browser authorization for %s "
+                    "(timeout %ss)", session.login_url, seconds)
+        if notify:
+            try:
+                notify(session.login_url, seconds)
+            except Exception as exc:
+                logger.warning("Auto-login notice failed: %s", exc)
+        started = time.monotonic()
+        try:
+            token, _webui, user_info, meta = login(session.login_url, timeout=seconds)
+        except TimeoutError as exc:
+            logger.info("Auto-login timed out after %.0fs", time.monotonic() - started)
+            raise ReloginTimeout(str(exc)) from exc
+        _apply_login(session, token, meta, user_info)
+    return True

{hap_cli-0.9.5 → hap_cli-0.9.6}/hap_cli/core/session.py

@@ -30,7 +30,7 @@ import logging
 import os
 import re
 from pathlib import Path
-from typing import Any, Optional
+from typing import Any, Callable, Optional
 from urllib.parse import urlparse
 
 import requests
@@ -256,6 +256,11 @@ class Session:
         # status request goes through ``_post`` and must not re-trigger
         # the gate. Managed by ``hap_cli.core.cli_access``.
         self._cli_access_check_in_progress = False
+        # Expired-login recovery (hap_cli.core.relogin): runs at most once
+        # per process; ``relogin_notice(login_url, timeout)`` is set by the
+        # CLI layer to tell the user a browser page is waiting for them.
+        self._relogin_attempted = False
+        self.relogin_notice: Optional[Callable[[str, int], None]] = None
         self.default_app_id = ""
         self.default_project_id = ""
         self.default_project_name = ""
@@ -403,6 +408,50 @@ class Session:
         *,
         extra_headers: Optional[dict[str, str]] = None,
         query: Optional[dict] = None,
+    ) -> dict[str, Any]:
+        """Send a request; on an expired login, re-authorize and retry once.
+
+        A rejected token means the server never ran the request, so
+        resending it after a fresh login cannot apply a write twice.
+        """
+        try:
+            return self._send(url, data, timeout, method,
+                              extra_headers=extra_headers, query=query)
+        except AuthenticationError:
+            if not self.recover_auth():
+                raise
+        logger.info("Retrying %s %s with the refreshed login", method.upper(), url)
+        return self._send(url, data, timeout, method,
+                          extra_headers=extra_headers, query=query)
+
+    def recover_auth(self) -> bool:
+        """Re-run the browser login after the server rejected the token.
+
+        True means a fresh token is in place and the caller should resend
+        once. See :mod:`hap_cli.core.relogin` for when this declines.
+        """
+        from hap_cli.core import relogin
+
+        try:
+            return relogin.recover(self)
+        except relogin.ReloginTimeout:
+            raise AuthenticationError(
+                "Your login has expired. A browser authorization page was "
+                f"opened for {self.login_url} but was not confirmed within "
+                f"{relogin.timeout_seconds()}s. Run the command again and "
+                "click Authorize (授权) in the browser, or run 'hap auth login'.",
+                status_code=None,
+            ) from None
+
+    def _send(
+        self,
+        url: str,
+        data: Optional[dict],
+        timeout: int,
+        method: str = "POST",
+        *,
+        extra_headers: Optional[dict[str, str]] = None,
+        query: Optional[dict] = None,
     ) -> dict[str, Any]:
         """Execute an HTTP request with standard HAP headers.
 

{hap_cli-0.9.5 → hap_cli-0.9.6}/hap_cli/locale/messages.json

@@ -326,6 +326,14 @@
     "✗ Publish failed: a workflow this one runs was not published, so this one was left alone.": {
       "en": "✗ Publish failed: a workflow this one runs was not published, so this one was left alone.",
       "zh-Hans": "✗ 发布失败：它调用的某条流程没有发布，所以这条也没有发布。"
+    },
+    "Your HAP login has expired. A browser page is open — click Authorize (授权) to continue (waiting up to {seconds}s).": {
+      "en": "Your HAP login has expired. A browser page is open — click Authorize (授权) to continue (waiting up to {seconds}s).",
+      "zh-Hans": "HAP 登录已过期，已在浏览器打开授权页——点击「授权」后命令会继续执行（最多等待 {seconds} 秒）。"
+    },
+    "Login expired — click Authorize (授权) in the browser to let the command continue.": {
+      "en": "Login expired — click Authorize (授权) in the browser to let the command continue.",
+      "zh-Hans": "登录已过期——请在浏览器中点击「授权」，命令即可继续。"
     }
   },
   "v3": {
@@ -3627,6 +3635,14 @@
       "en": "Output in JSON format",
       "zh-Hans": "以 JSON 格式输出"
     },
+    "config auto-login": {
+      "en": "Control whether an expired login is renewed in the browser.\n\n\b\n  on   when a command finds your login expired, open the browser\n       authorization page, wait for you to click Authorize, then\n       carry on (default)\n  off  stop with a \"not logged in\" error instead\n\nWithout an argument, shows the current setting. It never applies over\nSSH, in CI, or where no browser can be shown. Setting the environment\nvariable HAP_AUTO_LOGIN=0 turns it off for one shell.",
+      "zh-Hans": "控制登录过期时是否在浏览器里自动续期。\n\n\b\n  on   命令发现登录已过期时，打开浏览器授权页，等你点击「授权」后\n       继续执行（默认）\n  off  直接报「未登录」错误\n\n不带参数时显示当前设置。通过 SSH、在 CI 里或无法显示浏览器时不会生效。设置环境变量 HAP_AUTO_LOGIN=0 可在当前 shell 里关闭。"
+    },
+    "config auto-login --json": {
+      "en": "Output in JSON format",
+      "zh-Hans": "以 JSON 格式输出"
+    },
     "config completion": {
       "en": "Enable <Tab> completion for hap commands and options.\n\n\b\n    hap config completion              # show instructions for your shell\n    hap config completion bash         # show bash setup\n    hap config completion zsh          # show zsh setup\n    hap config completion fish         # show fish setup\n    hap config completion --install    # append the init line to your rc file",
       "zh-Hans": "为 hap 命令和选项启用 <Tab> 补全。\n\n\b\n    hap config completion              # 显示适用于当前 Shell 的说明\n    hap config completion bash         # 显示 bash 配置\n    hap config completion zsh          # 显示 zsh 配置\n    hap config completion fish         # 显示 fish 配置\n    hap config completion --install    # 将初始化行追加到 rc 文件"

{hap_cli-0.9.5 → hap_cli-0.9.6}/hap_cli/tests/conftest.py

@@ -101,6 +101,18 @@ def _disable_cli_access_gate(request, monkeypatch):
     cli_access._memo.clear()
 
 
+@pytest.fixture(autouse=True)
+def _disable_auto_login(monkeypatch):
+    """Never open a browser from a test.
+
+    A mocked 401 would otherwise send ``Session._post`` into the
+    expired-login recovery (``hap_cli.core.relogin``) and pop the
+    authorization page. ``test_relogin.py`` lifts this where it tests the
+    recovery itself.
+    """
+    monkeypatch.setenv("HAP_AUTO_LOGIN", "0")
+
+
 @pytest.fixture(autouse=True)
 def _forget_worksheet_rules():
     """Start every test with a cold business-rule cache.