@follenfang/fupload 0.0.12 → 0.0.16

package/fupload/scripts/fupload_cli/dd_broker.py

@@ -282,6 +282,31 @@ def _load_live_state() -> Optional[Dict[str, Any]]:
     return value
 
 
+def _remove_session_state(path: Path, session_id: str, timeout: float = 5) -> bool:
+    deadline = time.monotonic() + timeout
+    while True:
+        try:
+            current = _read_json(path)
+        except FuploadError as exc:
+            if isinstance(exc.__cause__, FileNotFoundError):
+                return True
+            if not isinstance(exc.__cause__, OSError):
+                return False
+        else:
+            if current.get("session_id") != session_id:
+                return False
+            try:
+                path.unlink()
+                return True
+            except FileNotFoundError:
+                return True
+            except OSError:
+                pass
+        if time.monotonic() >= deadline:
+            return False
+        time.sleep(0.05)
+
+
 def doctor() -> Dict[str, Any]:
     dd_dir, signature = _dd_module().discover_dd_info()
     processes = running_dd_processes()
@@ -390,6 +415,10 @@ def start(confirm_close_gui: bool) -> Dict[str, Any]:
             "running": True,
             "reused": True,
             "login_count": active.get("login_count", 1),
+            "broker_count": active.get("broker_count", 1),
+            "sidecar_count": active.get("sidecar_count", 1),
+            "native_login_count": active.get("native_login_count", 1),
+            "credential_kind": active.get("credential_kind"),
         }
     processes = running_dd_processes()
     if processes and not confirm_close_gui:
@@ -427,6 +456,10 @@ def start(confirm_close_gui: bool) -> Dict[str, Any]:
                 "running": True,
                 "reused": False,
                 "login_count": 1,
+                "broker_count": state.get("broker_count", 1),
+                "sidecar_count": state.get("sidecar_count", 1),
+                "native_login_count": state.get("native_login_count", 1),
+                "credential_kind": state.get("credential_kind"),
                 "closed_gui_processes": len(processes),
             }
         if startup.exists():
@@ -471,15 +504,23 @@ def status(session_id: Optional[str] = None) -> Dict[str, Any]:
 
 def stop(session_id: str) -> Dict[str, Any]:
     data = _send({"session_id": session_id, "command": "stop"}, timeout=30)
-    deadline = time.time() + 30
-    while time.time() < deadline and _load_live_state():
+    deadline = time.monotonic() + 30
+    while True:
+        try:
+            state = _load_live_state()
+        except FuploadError as exc:
+            if exc.kind != "session_error" or not isinstance(exc.__cause__, OSError):
+                raise
+        else:
+            if not state:
+                break
+        if time.monotonic() >= deadline:
+            raise FuploadError(
+                "DD task session acknowledged stop but did not finish cleanup",
+                kind="session_stop_failed",
+                stage="session",
+            )
         time.sleep(0.05)
-    if _load_live_state():
-        raise FuploadError(
-            "DD task session acknowledged stop but did not finish cleanup",
-            kind="session_stop_failed",
-            stage="session",
-        )
     result = dict(data or {})
     result["cleanup_complete"] = True
     return result
@@ -542,6 +583,10 @@ def _serve(startup_id: str) -> int:
         sidecar = _dd_module().Sidecar().__enter__()
         state["dd_dir"] = str(sidecar.dd_dir)
         state["signature"] = sidecar.signature
+        state["credential_kind"] = sidecar.credential_kind
+        state["broker_count"] = 1
+        state["sidecar_count"] = 1
+        state["native_login_count"] = 1
         _atomic_json(state_path, state)
         try:
             startup_path.unlink()
@@ -570,6 +615,10 @@ def _serve(startup_id: str) -> int:
                             "started_at": started_at,
                             "last_activity": last_activity,
                             "login_count": 1,
+                            "broker_count": state.get("broker_count", 1),
+                            "sidecar_count": state.get("sidecar_count", 1),
+                            "native_login_count": state.get("native_login_count", 1),
+                            "credential_kind": state.get("credential_kind"),
                             "dd_dir": state.get("dd_dir"),
                             "signature": state.get("signature"),
                         }
@@ -615,12 +664,7 @@ def _serve(startup_id: str) -> int:
         listener.close()
         if sidecar is not None:
             sidecar.__exit__(None, None, None)
-        try:
-            current = _read_json(state_path)
-            if current.get("session_id") == session_id:
-                state_path.unlink()
-        except (FuploadError, OSError):
-            pass
+        _remove_session_state(state_path, session_id)
 
 
 def main(argv: Optional[List[str]] = None) -> int:

package/fupload/scripts/fupload_cli/dd_sidecar.py

@@ -551,10 +551,52 @@ def wait_until(qt, predicate, timeout):
     return bool(predicate())
 
 
+def _enum_name(value):
+    name = getattr(value, "name", None)
+    return name if isinstance(name, str) else None
+
+
+def _create_relogin_flow(
+    account, credential, controller, sdk, cgi, netconfig,
+    urs_flow_class, mobile_flow_class,
+):
+    method = _enum_name(getattr(account, "method", None))
+    credential_type = _enum_name(getattr(credential, "type", None))
+    modifier = _enum_name(getattr(credential, "modifier", None))
+
+    if (method, credential_type, modifier) == ("urs", "urs_token", "normal"):
+        return urs_flow_class(controller, sdk, credential.value, account.name)
+    if (
+        method == "mobile"
+        and credential_type == "urs_mobile_token"
+        and modifier in ("mobile_password", "mobile_uplink")
+    ):
+        return mobile_flow_class(
+            controller, sdk, cgi, netconfig, credential.value,
+            modifier == "mobile_password", account.name,
+        )
+    raise RuntimeError("DD persisted login state uses an unsupported credential combination")
+
+
+def _credential_kind(account, credential):
+    method = _enum_name(getattr(account, "method", None))
+    credential_type = _enum_name(getattr(credential, "type", None))
+    modifier = _enum_name(getattr(credential, "modifier", None))
+    if (method, credential_type, modifier) == ("urs", "urs_token", "normal"):
+        return "email"
+    if (
+        method == "mobile"
+        and credential_type == "urs_mobile_token"
+        and modifier in ("mobile_password", "mobile_uplink")
+    ):
+        return "mobile"
+    raise RuntimeError("DD persisted login state uses an unsupported credential combination")
+
+
 def open_session(timeout=45):
     from cli_anything.ccvoicehub.core.container import ContainerManager
     from cli_anything.ccvoicehub.core.qt_runtime import QtRuntime
-    from components.login.flow import MobileReLoginFlow
+    from components.login.flow import MobileReLoginFlow, UrsReLoginFlow
     import components.login.login_controller as login_controller_module
     import logger.cclogger as cclogger
 
@@ -562,7 +604,7 @@ def open_session(timeout=45):
     container = ContainerManager.get_container()
     storage = container.get_instance("AccountCredStorage")
     account = storage.getAutoAccount()
-    credential = storage.getCred(account)
+    credential = storage.getCred(account) if account else None
     if not account or not credential:
         raise RuntimeError("DD has no persisted credential; sign in with the desktop client first")
     cclogger.renameLogAfterLogin = lambda *_args, **_kwargs: None
@@ -581,11 +623,12 @@ def open_session(timeout=45):
         state["jwt"] = True
 
     jwt_helper.sigJwtUpdated.connect(jwt_result)
-    flow = MobileReLoginFlow(
-        controller, container.get_instance("UrsSDK"), container.get_instance("CgiHelper"),
-        container.get_instance("NetConfig"), credential.value,
-        credential.modifier.name == "mobile_password", account.name,
+    flow = _create_relogin_flow(
+        account, credential, controller,
+        container.get_instance("UrsSDK"), container.get_instance("CgiHelper"),
+        container.get_instance("NetConfig"), UrsReLoginFlow, MobileReLoginFlow,
     )
+    flow._fupload_credential_kind = _credential_kind(account, credential)
     flow.sigResult.connect(login_result)
     flow.start()
     if not wait_until(qt, lambda: state["done"], timeout) or not state["ok"]:
@@ -610,6 +653,12 @@ def api_result(payload):
     return payload.get("result") if isinstance(payload, dict) else None
 
 
+def _retryable_get_signature_rejection(payload):
+    if not isinstance(payload, dict) or payload.get("code") != 409:
+        return False
+    return str(payload.get("msg") or payload.get("message") or "").strip() == "签名无效"
+
+
 def _native_json(value):
     to_json = getattr(value, "toJson", None)
     if callable(to_json):
@@ -673,7 +722,13 @@ def run_command(session, command):
             method = command.get("method", "GET").upper()
             path = command["path"]
             params = command.get("payload") or {}
-            response_payload = client.get(path, params) if method == "GET" else client.post(path, params)
+            if method == "GET":
+                response_payload = client.get(path, params)
+                if _retryable_get_signature_rejection(response_payload):
+                    client._fupload_last_response_error = None
+                    response_payload = client.get(path, params)
+            else:
+                response_payload = client.post(path, params)
             if isinstance(response_payload, dict) and response_payload.get("code") not in (None, 0):
                 rejected_payload = response_payload
                 response_probe = getattr(client, "_fupload_last_response_error", None)
@@ -831,7 +886,11 @@ def main():
     session = None
     try:
         session = open_session()
-        output({"ready": True, "device_state_created": created})
+        output({
+            "ready": True,
+            "device_state_created": created,
+            "credential_kind": getattr(session[2], "_fupload_credential_kind", None),
+        })
         for line in sys.stdin:
             if not line.strip():
                 continue

package/fupload/scripts/fupload_cli/io.py

@@ -2,6 +2,8 @@
 
 from __future__ import annotations
 
+import base64
+import binascii
 import hashlib
 import json
 import sys
@@ -22,8 +24,10 @@ _SENSITIVE_KEYS = {
 }
 _RAW_CONTENT_KEYS = {
     "content", "wa_str", "t_wa_str", "raw_wtf", "wtf_zip", "download_url",
-    "import_string",
+    "import_string", "content_text", "contenttext", "code_text", "codetext",
+    "description", "changelog", "license_content", "licensecontent",
 }
+_BASE64_CONTENT_KEYS = {"base64", "logo_base64", "screenshot_base64s"}
 
 
 class _DuplicateKey(ValueError):
@@ -89,7 +93,9 @@ def sanitize_output(value: Any) -> Any:
         result: Dict[str, Any] = {}
         for key, item in value.items():
             normalized = str(key).replace("-", "_").lower()
-            if normalized in {"token_present", "token_decrypted", "token_nonempty", "api_ready"} and isinstance(item, bool):
+            if normalized == "credential_kind" and item in {"email", "mobile"}:
+                result[key] = item
+            elif normalized in {"token_present", "token_decrypted", "token_nonempty", "api_ready"} and isinstance(item, bool):
                 result[key] = item
             elif normalized in _SENSITIVE_KEYS or any(
                 marker in normalized
@@ -102,6 +108,18 @@ def sanitize_output(value: Any) -> Any:
                     "bytes": len(text),
                     "sha256": hashlib.sha256(text).hexdigest(),
                 }
+            elif normalized in _BASE64_CONTENT_KEYS and isinstance(item, str):
+                try:
+                    content = base64.b64decode(item, validate=True)
+                    encoding = "base64"
+                except (binascii.Error, ValueError):
+                    content = item.encode("utf-8")
+                    encoding = "utf-8"
+                result[str(key) + "_summary"] = {
+                    "bytes": len(content),
+                    "sha256": hashlib.sha256(content).hexdigest(),
+                    "source_encoding": encoding,
+                }
             else:
                 result[key] = sanitize_output(item)
         return result