| 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180 |
- """DingTalk Device Flow authorization."""
- from __future__ import annotations
- import contextlib
- import os
- import sys
- import time
- from typing import Optional, Tuple
- import requests
- REGISTRATION_BASE_URL = os.environ.get("DINGTALK_REGISTRATION_BASE_URL", "https://oapi.dingtalk.com").rstrip("/")
- REGISTRATION_SOURCE = os.environ.get("DINGTALK_REGISTRATION_SOURCE", "openClaw")
- _POLL_STATUSES = {"WAITING", "SUCCESS", "FAIL", "EXPIRED"}
- _RETRY_WINDOW = 120 # seconds of transient errors / non-success statuses tolerated before giving up
- class RegistrationError(Exception):
- """Raised when a DingTalk registration API call fails."""
- def _api_post(path: str, payload: dict) -> dict:
- """POST to the registration API and return the parsed JSON body."""
- url = f"{REGISTRATION_BASE_URL}{path}"
- try:
- resp = requests.post(url, json=payload, timeout=15)
- resp.raise_for_status()
- data = resp.json()
- except requests.RequestException as exc:
- raise RegistrationError(f"Network error calling {url}: {exc}") from exc
- errcode = data.get("errcode", -1)
- if errcode != 0:
- raise RegistrationError(f"API error [{path}]: {data.get('errmsg', 'unknown error')} (errcode={errcode})")
- return data
- def begin_registration() -> dict:
- """Start a device-flow registration: init → nonce, begin → device_code + verification URL."""
- nonce = str(_api_post("/app/registration/init", {"source": REGISTRATION_SOURCE}).get("nonce", "")).strip()
- if not nonce:
- raise RegistrationError("init response missing nonce")
- begin_data = _api_post("/app/registration/begin", {"nonce": nonce})
- reg = {key: str(begin_data.get(key, "")).strip() for key in ("device_code", "verification_uri_complete")}
- for key, value in reg.items():
- if not value:
- raise RegistrationError(f"begin response missing {key}")
- reg["expires_in"] = int(begin_data.get("expires_in", 7200))
- reg["interval"] = max(int(begin_data.get("interval", 3)), 2)
- return reg
- def poll_registration(device_code: str) -> dict:
- """Poll the registration status once."""
- data = _api_post("/app/registration/poll", {"device_code": device_code})
- status_raw = str(data.get("status", "")).strip().upper()
- result = {"status": status_raw if status_raw in _POLL_STATUSES else "UNKNOWN"}
- result.update({key: str(data.get(key, "")).strip() or None for key in ("client_id", "client_secret", "fail_reason")})
- return result
- def wait_for_registration_success(
- device_code: str, interval: int = 3, expires_in: int = 7200, on_waiting: Optional[callable] = None,
- ) -> tuple[str, str]:
- """Block until the registration succeeds or times out.
- Transient errors and FAIL/EXPIRED/UNKNOWN statuses are retried for ``_RETRY_WINDOW`` seconds
- before being raised; a WAITING status resets that window.
- """
- deadline = time.monotonic() + expires_in
- retry_start = 0.0
- def _within_retry_window() -> bool:
- nonlocal retry_start
- if retry_start == 0:
- retry_start = time.monotonic()
- return time.monotonic() - retry_start < _RETRY_WINDOW
- while time.monotonic() < deadline:
- time.sleep(interval)
- try:
- result = poll_registration(device_code)
- except RegistrationError:
- if _within_retry_window():
- continue
- raise
- status = result["status"]
- if status == "WAITING":
- retry_start = 0
- if on_waiting:
- on_waiting()
- elif status == "SUCCESS":
- cid, csecret = result["client_id"], result["client_secret"]
- if not cid or not csecret:
- raise RegistrationError("authorization succeeded but credentials are missing")
- return cid, csecret
- elif not _within_retry_window():
- raise RegistrationError(f"authorization failed: {result.get('fail_reason') or status}")
- raise RegistrationError("authorization timed out, please retry")
- def _ensure_qrcode_installed() -> bool:
- """Enable DingTalk dependencies; only render QR codes importable in this process."""
- with contextlib.suppress(ImportError):
- import qrcode
- return True
- import pm
- with contextlib.suppress(pm.InstallError, OSError, ValueError):
- pm.sync_venv(["dingtalk"], explicit=True)
- # PM selects a new generation for the next launch, never this process.
- # The authorization link works without qrcode, so no restart is required here.
- return False
- def render_qr_to_terminal(url: str) -> bool:
- """Render *url* as a compact QR code (half-block glyphs, 2 rows per character) in the terminal."""
- try:
- import qrcode
- except ImportError:
- return False
- qr = qrcode.QRCode(version=1, error_correction=qrcode.constants.ERROR_CORRECT_L, box_size=1, border=1)
- qr.add_data(url)
- qr.make(fit=True)
- matrix = qr.get_matrix()
- glyph = {(True, True): "\u2588", (True, False): "\u2580", (False, True): "\u2584", (False, False): " "} # █ ▀ ▄ space
- lines = []
- for r in range(0, len(matrix), 2):
- bottom_row = matrix[r + 1] if r + 1 < len(matrix) else [False] * len(matrix[r])
- lines.append(" " + "".join(glyph[(bool(top), bool(bottom))] for top, bottom in zip(matrix[r], bottom_row)))
- print("\n".join(lines))
- return True
- def dingtalk_qr_auth() -> Optional[tuple[str, str]]:
- """Run the interactive QR-code device-flow authorization (setup wizard entry point)."""
- from hermes_cli.setup import print_info, print_success, print_warning, print_error
- print()
- print_info(" Initializing DingTalk device authorization...")
- print_info(" Note: the scan page is branded 'OpenClaw' — DingTalk's")
- print_info(" ecosystem onboarding bridge. Safe to use.")
- try:
- reg = begin_registration()
- except RegistrationError as exc:
- print_error(f" Authorization init failed: {exc}")
- return None
- url = reg["verification_uri_complete"]
- if not _ensure_qrcode_installed():
- print_warning(" QR rendering is unavailable in this process; using the authorization link.")
- print()
- print_info(" Please scan the QR code below with DingTalk to authorize:")
- print()
- if not render_qr_to_terminal(url):
- print_warning(" QR code render failed, please open the link below to authorize:")
- print()
- print_info(f" Or open this link manually: {url}")
- print()
- print_info(" Waiting for QR scan authorization... (timeout: 2 hours)")
- dot_count = 0
- def _on_waiting():
- nonlocal dot_count
- dot_count += 1
- if dot_count % 10 == 0:
- sys.stdout.write(".")
- sys.stdout.flush()
- try:
- client_id, client_secret = wait_for_registration_success(
- device_code=reg["device_code"], interval=reg["interval"], expires_in=reg["expires_in"],
- on_waiting=_on_waiting,
- )
- except RegistrationError as exc:
- print()
- print_error(f" Authorization failed: {exc}")
- return None
- print()
- print_success(" QR scan authorization successful!")
- print_success(f" Client ID: {client_id}")
- print_success(f" Client Secret: {client_secret[:8]}{'*' * (len(client_secret) - 8)}")
- return client_id, client_secret
|