@follenfang/fupload 0.0.11 → 0.0.15

package/fupload/scripts/fupload_cli/modus.py

@@ -25,12 +25,23 @@ from typing import Any, Dict, Mapping, Optional
 from .errors import FuploadError, ValidationError, redact
 from .state_machine import COMPLETE, ProjectStateMachine
 from .modus_zip import parse_modus_zip
+from .transport import json_request, multipart_request
 
 
 API_BASE = "https://app.modus.cool/api/"
+STATIC_API_BASE = "https://cdn.modus.cool/modus/client_static_api/"
+RESOURCE_BASE = "https://cdn.modus.cool/"
 TOKEN_PATH = Path(os.environ.get("LOCALAPPDATA", Path.home() / "AppData/Local")) / "ModUs.Creator" / "auth" / "token.dat"
 TOKEN_ENTROPY = b"ModUs.Creator.TokenStore.v1"
+MODUS_APPDATA = Path(os.environ.get("APPDATA", Path.home() / "AppData/Roaming")) / "modus"
 MAX_PACKAGE_BYTES = 200 * 1024 * 1024
+MODUS_BUILDS = (
+    {"id": 0, "code": "retail", "name": "至暗之夜", "label": "正式服-至暗之夜"},
+    {"id": 1, "code": "classic_era", "name": "经典旧世", "label": "怀旧服-经典旧世"},
+    {"id": 2, "code": "classic", "name": "熊猫人之谜", "label": "怀旧服-熊猫人之谜"},
+    {"id": 3, "code": "classic_titan", "name": "泰坦重铸", "label": "时光服-泰坦重铸"},
+    {"id": 4, "code": "anniversary", "name": "燃烧的远征", "label": "周年服-燃烧的远征"},
+)
 _SECRET_KEYS = {"token", "access_token", "authorization", "cookie", "signedurl", "signed_url", "upload_url"}
 _WIRE_NAMES = {
     "project_id": "projectId", "file_id": "fileId", "alt_name": "altName",
@@ -100,6 +111,14 @@ def _category_ids(value: Any) -> Any:
     return output
 
 
+def _tag_filter(value: Any) -> list[str]:
+    values = value if isinstance(value, (list, tuple, set)) else str(value).split(",")
+    result = [str(item).strip() for item in values if str(item).strip()]
+    if not result:
+        raise ValidationError("tag filter must contain at least one ID", path="tags")
+    return result
+
+
 def _sync_type(value: Any) -> Any:
     if value is None:
         return 0
@@ -124,13 +143,22 @@ def _image_ops(value: Any) -> list[Dict[str, str]]:
         path = "image_ops[%d]" % index
         if not isinstance(item, Mapping):
             raise ValidationError("image operation must be an object", path=path)
-        unknown = sorted(set(item) - {"op", "name", "base64"})
+        op = item.get("op")
+        if op not in ("upload", "delete", "rename"):
+            raise ValidationError("image operation must be upload, delete, or rename", path=path + ".op")
+        allowed = {"op", "from", "to"} if op == "rename" else {"op", "name", "base64"}
+        unknown = sorted(set(item) - allowed)
         if unknown:
             raise ValidationError("unknown image operation field(s): %s" % ", ".join(unknown), path=path + "." + unknown[0])
-        op = item.get("op")
+        if op == "rename":
+            source, target = item.get("from"), item.get("to")
+            if not isinstance(source, str) or not source.strip():
+                raise ValidationError("rename image operation requires from", path=path + ".from")
+            if not isinstance(target, str) or not target.strip():
+                raise ValidationError("rename image operation requires to", path=path + ".to")
+            result.append({"op": op, "from": source.strip(), "to": target.strip()})
+            continue
         name = item.get("name")
-        if op not in ("upload", "delete"):
-            raise ValidationError("image operation must be upload or delete", path=path + ".op")
         if not isinstance(name, str) or not name.strip():
             raise ValidationError("image operation name must be non-empty", path=path + ".name")
         operation = {"op": op, "name": name.strip()}
@@ -158,6 +186,16 @@ def _positive_id(value: Any, *, field: str) -> int:
     return result
 
 
+def _resource_id(value: Any, *, field: str) -> str:
+    """ModUs share/import IDs are opaque positive decimal strings."""
+    if isinstance(value, bool) or value is None:
+        raise ValidationError("%s must be a non-empty identifier" % field, path=field)
+    text = str(value).strip()
+    if not text or (text.isdigit() and int(text) <= 0):
+        raise ValidationError("%s must be a non-empty identifier" % field, path=field)
+    return text
+
+
 def _supported_game_versions(value: Any) -> list[Dict[str, str]]:
     """Map CLI aliases to Creator's anonymous {gameVersion, server} objects.
 
@@ -274,7 +312,7 @@ def _project_wire(value: Mapping[str, Any], *, create: bool = False) -> Dict[str
     """Project project create/update fields to Creator's request shape."""
     result: Dict[str, Any] = {}
     for key in ("name", "alt_name", "summary", "repo_url"):
-        if key in value and value[key] is not None:
+        if key in value and (value[key] is not None or not create):
             wire_name = _WIRE_NAMES.get(key, key)
             if create:
                 if key == "repo_url" and not str(value[key]).strip():
@@ -343,13 +381,56 @@ def _business_code(payload: Mapping[str, Any]) -> Optional[int]:
         return None
 
 
+def _image_upload_record(payload: Any) -> Dict[str, str]:
+    """Extract the reusable key and display URL used by the main client."""
+    data = _unwrap(payload)
+    if not isinstance(data, Mapping):
+        raise FuploadError(
+            "ModUs image upload returned no media record",
+            kind="platform_data_error",
+            stage="media_upload",
+        )
+
+    download_url = data.get("downloadUrl") or data.get("url") or data.get("fileUrl")
+    reference = data.get("cosStoreKey") or data.get("cosStoreUrl") or data.get("key")
+    if not reference and isinstance(download_url, str) and download_url.strip():
+        parsed = urllib.parse.urlsplit(download_url.strip())
+        reference = urllib.parse.unquote(parsed.path.lstrip("/"))
+    if not isinstance(reference, str) or not reference.strip():
+        raise FuploadError(
+            "ModUs image upload omitted its object key",
+            kind="platform_data_error",
+            stage="media_upload",
+        )
+
+    reference = reference.strip()
+    if isinstance(download_url, str) and download_url.strip():
+        display_url = download_url.strip()
+    elif reference.startswith(("https://", "http://")):
+        display_url = reference
+    else:
+        display_url = urllib.parse.urljoin(RESOURCE_BASE, reference.lstrip("/"))
+    return {"key": reference, "url": display_url, "reference": reference}
+
+
 def _safe(value: Any) -> Any:
     """Recursively redact credentials and presigned URLs in API results."""
     if isinstance(value, Mapping):
         result = {}
         for key, item in value.items():
             normalized = str(key).replace("-", "_").lower()
-            result[str(key)] = "[REDACTED]" if normalized in _SECRET_KEYS else _safe(item)
+            if normalized in _SECRET_KEYS:
+                result[str(key)] = "[REDACTED]"
+            elif normalized in {
+                "content", "contenttext", "codetext", "changelog",
+                "description", "licensecontent",
+            }:
+                # write_output() hashes these fields before serializing JSON.
+                # Preserve the original here so the digest represents the
+                # service value instead of a generic redaction placeholder.
+                result[str(key)] = item
+            else:
+                result[str(key)] = _safe(item)
         return result
     if isinstance(value, list):
         return [_safe(item) for item in value]
@@ -407,6 +488,94 @@ def load_token(path: Optional[Path] = None) -> str:
     return token
 
 
+def load_main_session(root: Optional[Path] = None) -> Dict[str, str]:
+    """Recover the main ModUs renderer session from Chromium local storage.
+
+    Chromium LevelDB values are length-prefixed and may be locked by the
+    running client.  We therefore scan shared-read bytes for JSON fragments,
+    accepting only the known persisted token/device keys and never returning
+    unrelated storage values.
+    """
+    base = root or MODUS_APPDATA
+    leveldb = base / "Local Storage" / "leveldb"
+    if not leveldb.is_dir():
+        raise FuploadError("ModUs main-client local storage was not found", kind="authentication_error")
+    token = ""
+    device = ""
+    for path in sorted(leveldb.iterdir()):
+        if not path.is_file() or path.name in {"LOCK", "LOG", "LOG.old", "CURRENT", "MANIFEST-000001"}:
+            continue
+        try:
+            with path.open("rb", buffering=0) as handle:
+                raw = handle.read()
+        except OSError:
+            continue
+        text = raw.decode("utf-8", errors="ignore")
+        # Pinia persistence is JSON, but the LevelDB record can contain a
+        # prefix/suffix.  Try JSON objects first, then bounded key/value pairs.
+        candidates = [text]
+        # Persisted Pinia user JSON contains nested wallet objects, so a
+        # shallow-brace regex is insufficient. Extract only scalar credential
+        # fields from the record instead of attempting to parse the whole log.
+        import re
+        token_match = re.search(r'"(?:token|accessToken|access_token)"\s*:\s*"([^"\\]*(?:\\.[^"\\]*)*)"', text)
+        device_match = re.search(r'"(?:deviceId|device_id)"\s*:\s*"([^"\\]*)"', text)
+        if token_match and not token:
+            token = bytes(token_match.group(1), "utf-8").decode("unicode_escape")
+        if device_match and not device:
+            device = device_match.group(1)
+        for candidate in candidates:
+            try:
+                parsed = json.loads(candidate)
+            except (TypeError, ValueError):
+                continue
+            stack = [parsed]
+            while stack:
+                item = stack.pop()
+                if isinstance(item, Mapping):
+                    for key, value in item.items():
+                        normalized = str(key).lower()
+                        if isinstance(value, str) and value.strip():
+                            if normalized in {"token", "accesstoken", "access_token"} and not token:
+                                token = value.strip()
+                            elif normalized in {"deviceid", "device_id"} and not device:
+                                device = value.strip()
+                        elif isinstance(value, (Mapping, list)):
+                            stack.append(value)
+                elif isinstance(item, list):
+                    stack.extend(item)
+        if token and device:
+            break
+    if not token:
+        raise FuploadError("ModUs main-client login token was not found", kind="authentication_error")
+    return {"token": token, **({"device_id": device} if device else {})}
+
+
+def load_current_build(root: Optional[Path] = None) -> Optional[int]:
+    """Read the persisted main-client currentGameWow id when available."""
+    base = root or MODUS_APPDATA
+    leveldb = base / "Local Storage" / "leveldb"
+    if not leveldb.is_dir():
+        return None
+    import re
+    for path in sorted(leveldb.iterdir()):
+        if not path.is_file() or path.name in {"LOCK", "LOG", "LOG.old", "CURRENT", "MANIFEST-000001"}:
+            continue
+        try:
+            with path.open("rb", buffering=0) as handle:
+                text = handle.read().decode("utf-8", errors="ignore")
+        except OSError:
+            continue
+        # Pinia persistence may be split across records; accept only the scalar id.
+        for pattern in (r'currentGameWow[^{}]{0,120}?"id"\s*:\s*(\d+)', r'"currentGameWowId"\s*:\s*(\d+)'):
+            match = re.search(pattern, text)
+            if match:
+                value = int(match.group(1))
+                if 0 <= value <= 4:
+                    return value
+    return None
+
+
 def _unwrap(payload: Any) -> Any:
     if isinstance(payload, Mapping) and "data" in payload:
         return payload["data"]
@@ -423,12 +592,28 @@ class ModUs:
         base_url: str = API_BASE,
         timeout: int = 60,
         token_path: Optional[Path] = None,
+        device_id: Optional[str] = None,
+        main_session: bool = False,
         authenticate: bool = True,
     ) -> None:
         self.base_url = base_url.rstrip("/") + "/"
         self.timeout = timeout
         self.token_path = token_path or TOKEN_PATH
-        self.token = token if token is not None else (load_token(self.token_path) if authenticate else "")
+        self.device_id = device_id
+        self.main_session = main_session
+        self.current_build = load_current_build() if main_session else None
+        self.authorization_scheme = ""
+        if token is not None:
+            self.token = token
+        elif authenticate:
+            if main_session:
+                session = load_main_session()
+                self.token, self.device_id = session["token"], session.get("device_id")
+                self.authorization_scheme = ""
+            else:
+                self.token = load_token(self.token_path)
+        else:
+            self.token = ""
 
     def _url(self, path: str) -> str:
         return urllib.parse.urljoin(self.base_url, path.lstrip("/"))
@@ -454,7 +639,10 @@ class ModUs:
     def _request(self, method: str, path: str, body: Any = None, *, headers: Optional[Mapping[str, str]] = None) -> Any:
         url = self._url(path)
         stage = self._request_stage(method, path)
-        request_headers = {"Accept": "application/json", "Authorization": "Bearer " + self.token}
+        authorization = self.token if self.authorization_scheme == "" else self.authorization_scheme + self.token
+        request_headers = {"Accept": "application/json", "Authorization": authorization}
+        if self.device_id:
+            request_headers["X-Device-Id"] = self.device_id
         if headers:
             request_headers.update(headers)
         data = None
@@ -472,7 +660,7 @@ class ModUs:
             except Exception:
                 detail = "HTTP %d" % exc.code
             raise FuploadError(redact(str(detail)), endpoint=url, http_status=exc.code, kind="platform_error", stage=stage) from exc
-        except (OSError, urllib.error.URLError) as exc:
+        except (OSError, urllib.error.URLError, http.client.IncompleteRead) as exc:
             raise FuploadError("ModUs request failed: %s" % exc, endpoint=url, verification_required=method != "GET", stage=stage) from exc
         if status < 200 or status >= 300:
             raise FuploadError("ModUs returned HTTP %d" % status, endpoint=url, http_status=status, stage=stage)
@@ -494,6 +682,32 @@ class ModUs:
         return payload
 
     def doctor(self) -> Dict[str, Any]:
+        if self.main_session:
+            result = {
+                "token_present": False,
+                "token_decrypted": False,
+                "token_nonempty": False,
+                "api_ready": False,
+            }
+            try:
+                session = load_main_session()
+                token = str(session.get("token") or "").strip()
+                result["token_present"] = bool(token)
+                result["token_decrypted"] = bool(token)
+                result["token_nonempty"] = bool(token)
+                if not token:
+                    return result
+                previous_token, previous_device = self.token, self.device_id
+                self.token = token
+                self.device_id = session.get("device_id")
+                try:
+                    self.user_info()
+                    result["api_ready"] = True
+                finally:
+                    self.token, self.device_id = previous_token, previous_device
+            except (FuploadError, OSError, UnicodeError, ValueError, TypeError):
+                pass
+            return result
         selected = self.token_path
         if not selected.is_file() and selected.with_name("token.json").is_file():
             selected = selected.with_name("token.json")
@@ -576,31 +790,57 @@ class ModUs:
     def user_info(self) -> Any:
         return _safe(_unwrap(self._request("GET", "system/user/getInfo")))
 
+    def builds(self) -> Any:
+        """Return the fixed WoW Build choices used by the ModUs main client."""
+        current = self.current_build
+        return {"current": current, "builds": [dict(item) for item in MODUS_BUILDS]}
+
+    def _build(self, value: Optional[int]) -> int:
+        selected = self.current_build if value is None else value
+        if selected is None:
+            # The desktop wrapper uses getCurrentWow?.id || 0.
+            selected = 0
+        selected = int(selected)
+        if selected < 0 or selected > 4:
+            raise ValidationError("server_type must be a known ModUs Build id", path="server_type")
+        return selected
+
     def active_subscription_count(self) -> Any:
         return _safe(_unwrap(self._request("GET", "user/author/subscription/active/count")))
 
     def project_statistics(self) -> Any:
         return _safe(_unwrap(self._request("GET", "game/data/author/project/statistics")))
 
-    def addon_info(self, directories: Any, *, server_type: int = 1) -> Any:
+    def addon_info(self, directories: Any, *, server_type: Optional[int] = None) -> Any:
         values = directories if isinstance(directories, (list, tuple)) else [directories]
         body = {"pluginList": [str(value) for value in values]}
-        return _safe(_unwrap(self._request("POST", "plugin/list/info", body, headers={"X-Server-Type": str(int(server_type))})))
+        return _safe(_unwrap(self._request("POST", "plugin/list/info", body, headers={"X-Server-Type": str(self._build(server_type))})))
 
-    def addon_project_info(self, project_ids: Any, *, server_type: int = 1) -> Any:
+    def addon_project_info(self, project_ids: Any, *, server_type: Optional[int] = None) -> Any:
         values = project_ids if isinstance(project_ids, (list, tuple)) else [project_ids]
         body = {"projectIds": [int(value) for value in values]}
-        return _safe(_unwrap(self._request("POST", "plugin/list/detail", body, headers={"X-Server-Type": str(int(server_type))})))
+        return _safe(_unwrap(self._request("POST", "plugin/list/detail", body, headers={"X-Server-Type": str(self._build(server_type))})))
 
-    def addon_history(self, project_id: int, *, page_num: int = 1, page_size: int = 5, server_type: int = 1) -> Any:
+    def addon_history(self, project_id: int, *, page_num: int = 1, page_size: int = 5, server_type: Optional[int] = None) -> Any:
         body = {"projectIds": [int(project_id)], "pageNum": int(page_num), "pageSize": int(page_size)}
-        return _safe(_unwrap(self._request("POST", "plugin/project/history", body, headers={"X-Server-Type": str(int(server_type))})))
+        return _safe(_unwrap(self._request("POST", "plugin/project/history", body, headers={"X-Server-Type": str(self._build(server_type))})))
 
     def project_dependencies(self, query: Any) -> Any:
         body = _dependency_query_wire(query)
         return _safe(_unwrap(self._request("POST", "game/data/author/project/dependency/query", body)))
 
     def options(self, action: str, *, keys: Optional[Any] = None) -> Any:
+        static_files = {
+            "config-tags": "share_tags.json",
+            "wa-tags": "imports_tags.json",
+            "wa-support-addons": "imports_support_addons.json",
+        }
+        if action in static_files:
+            url = urllib.parse.urljoin(STATIC_API_BASE, static_files[action])
+            payload = json_request(url)
+            if isinstance(payload, Mapping) and "rows" in payload:
+                payload = payload["rows"]
+            return _safe(_unwrap(payload))
         routes = {
             # These paths are the routes used by ModUs.Creator's ApiService.
             "categories": "plugin/list/Categories",
@@ -618,6 +858,298 @@ class ModUs:
             raise ValidationError("unsupported ModUs options operation")
         return _safe(_unwrap(self._request("GET", routes[action])))
 
+    @staticmethod
+    def _option_rows(value: Any) -> list[Mapping[str, Any]]:
+        if isinstance(value, Mapping):
+            value = value.get("rows", value.get("data", []))
+        return [item for item in value if isinstance(item, Mapping)] if isinstance(value, list) else []
+
+    @classmethod
+    def _nested_option_rows(cls, value: Any) -> list[Mapping[str, Any]]:
+        rows: list[Mapping[str, Any]] = []
+        pending = list(cls._option_rows(value))
+        while pending:
+            item = pending.pop(0)
+            rows.append(item)
+            pending.extend(cls._option_rows(item.get("children", [])))
+        return rows
+
+    @staticmethod
+    def _csv_values(value: Any) -> list[str]:
+        return [item.strip() for item in str(value or "").split(",") if item.strip()]
+
+    @staticmethod
+    def _account_rows(backup: Mapping[str, Any]) -> list[Mapping[str, Any]]:
+        value = backup.get("wtfAccounts") or []
+        if isinstance(value, str):
+            try:
+                value = json.loads(value)
+            except (TypeError, ValueError):
+                value = []
+        return [item for item in value if isinstance(item, Mapping)] if isinstance(value, list) else []
+
+    @staticmethod
+    def _backup_addons_id(backup: Mapping[str, Any]) -> Optional[str]:
+        value = backup.get("knownAddons")
+        if not isinstance(value, str) or not value.strip():
+            return None
+        try:
+            parsed = json.loads(value)
+        except (TypeError, ValueError):
+            return None
+        project_ids = parsed.get("projectids") if isinstance(parsed, Mapping) else None
+        return None if project_ids is None else str(project_ids)
+
+    def _validate_project_write(self, action: str, doc: Mapping[str, Any]) -> None:
+        if action not in {"create", "release", "update", "edit"}:
+            return
+        document = _project_document(doc)
+        allowed_categories = {
+            int(item["id"])
+            for item in self._nested_option_rows(self.options("categories"))
+            if item.get("id") is not None
+        }
+        unknown = [item for item in document.get("categories", []) if item not in allowed_categories]
+        if unknown:
+            raise ValidationError(
+                "category is not present in current Creator options",
+                path="$.project_state.basic_info.categories",
+            )
+
+    def _validate_main_write(self, resource: str, action: str, doc: Mapping[str, Any]) -> None:
+        if resource not in {"config", "wa"} or action not in {"create", "update", "edit"}:
+            return
+
+        if "tags" in doc:
+            option_name = "config-tags" if resource == "config" else "wa-tags"
+            allowed_tags = {str(item.get("id")) for item in self._option_rows(self.options(option_name)) if item.get("id") is not None}
+            unknown = [item for item in self._csv_values(doc.get("tags")) if item not in allowed_tags]
+            if unknown:
+                raise ValidationError("tag is not present in current %s options" % option_name, path="$.tags")
+
+        tier_id = doc.get("required_tier_id")
+        if tier_id is not None:
+            tiers = self._option_rows(self.options("subscription-tiers"))
+            allowed_tiers = {
+                str(item.get("id"))
+                for item in tiers
+                if item.get("id") is not None and item.get("isEnabled", item.get("is_enabled", 1)) not in (0, False)
+            }
+            if str(tier_id) not in allowed_tiers:
+                raise ValidationError("required_tier_id is not present in current tier options", path="$.required_tier_id")
+
+        if resource == "wa" and ("support_addon" in doc or "addons_id" in doc):
+            selected_doc = dict(doc)
+            if action in {"update", "edit"} and (
+                "support_addon" not in selected_doc or "addons_id" not in selected_doc
+            ):
+                current = self.import_detail(doc["import_id"], server_type=doc.get("server_type"))
+                current = current[0] if isinstance(current, list) and current else current
+                if isinstance(current, Mapping):
+                    selected_doc.setdefault("support_addon", current.get("supportAddon"))
+                    selected_doc.setdefault("addons_id", current.get("addonsId"))
+            support_rows = self._option_rows(self.options("wa-support-addons"))
+            selected = next((item for item in support_rows if str(item.get("name")) == str(selected_doc.get("support_addon"))), None)
+            if selected is None or str(selected.get("id")) != str(selected_doc.get("addons_id")):
+                raise ValidationError("support_addon and addons_id must match current options", path="$.support_addon")
+            return
+
+        if resource != "config":
+            return
+        linkage_fields = {"backup_id", "addons_id", "account_name", "role_name", "exclude_wtf"}
+        if not linkage_fields.intersection(doc):
+            return
+        merged = dict(doc)
+        if action in {"update", "edit"} and "backup_id" not in merged:
+            current = self.share_detail(doc["share_id"], server_type=doc.get("server_type"))
+            current = current[0] if isinstance(current, list) and current else current
+            if isinstance(current, Mapping):
+                aliases = {
+                    "backupId": "backup_id", "addonsId": "addons_id", "accountName": "account_name",
+                    "roleName": "role_name", "excludeWtf": "exclude_wtf",
+                }
+                for wire, local in aliases.items():
+                    if local not in merged and wire in current:
+                        merged[local] = current[wire]
+        backup_id = merged.get("backup_id")
+        backups = self._option_rows(self.cloud_backups(server_type=merged.get("server_type")))
+        backup = next((item for item in backups if str(item.get("id")) == str(backup_id)), None)
+        if backup is None:
+            raise ValidationError("backup_id is not present in the selected Build", path="$.backup_id")
+        expected_addons = self._backup_addons_id(backup)
+        if expected_addons is not None and "addons_id" in merged and str(merged.get("addons_id")) != expected_addons:
+            raise ValidationError("addons_id does not match selected backup knownAddons.projectids", path="$.addons_id")
+        if int(merged.get("exclude_wtf") or 0) == 1:
+            return
+        account_name = str(merged.get("account_name") or "")
+        account = next((item for item in self._account_rows(backup) if account_name in {
+            str(item.get("id") or ""), str(item.get("accountId") or ""),
+            str(item.get("name") or ""), str(item.get("characterName") or ""),
+        }), None)
+        if account is None:
+            raise ValidationError("account_name is not present in selected backup", path="$.account_name")
+        roles = [str(item) for item in account.get("roles") or [] if str(item)]
+        role_name = str(merged.get("role_name") or "")
+        if roles and not role_name:
+            raise ValidationError("role_name is required for selected account", path="$.role_name")
+        if role_name and role_name not in roles:
+            raise ValidationError("role_name is not present in selected account", path="$.role_name")
+
+    # Main ModUs client: configuration shares and string articles.
+    def cloud_backups(self, *, server_type: Optional[int] = None) -> Any:
+        return _safe(_unwrap(self._request("GET", "system/user/backup/list", headers={"X-Server-Type": str(self._build(server_type))})))
+
+    def cloud_backup_detail(self, backup_id: int, *, server_type: Optional[int] = None) -> Any:
+        return _safe(_unwrap(self._request("GET", "system/user/backup/detail/%s" % _positive_id(backup_id, field="backup_id"), headers={"X-Server-Type": str(self._build(server_type))})))
+
+    def cloud_backup_update(self, doc: Mapping[str, Any], *, server_type: Optional[int] = None) -> Any:
+        body = {"id": _positive_id(doc["backup_id"], field="backup_id"), "backupName": doc["backup_name"]}
+        return _safe(_unwrap(self._request("POST", "system/user/backup/update", body, headers={"X-Server-Type": str(self._build(server_type))})))
+
+    def cloud_backup_delete(self, backup_id: int, *, server_type: Optional[int] = None) -> Any:
+        return _safe(_unwrap(self._request("DELETE", "system/user/backup/delete/%s" % _positive_id(backup_id, field="backup_id"), headers={"X-Server-Type": str(self._build(server_type))})))
+
+    def image_upload(self, file_path: str) -> Dict[str, Any]:
+        """Upload an image through the exact ModUs main-client multipart API."""
+        path = Path(file_path)
+        if not path.is_file():
+            raise ValidationError("image file does not exist", path="$.file")
+        authorization = self.token if self.authorization_scheme == "" else self.authorization_scheme + self.token
+        headers = {"Accept": "application/json", "Authorization": authorization}
+        if self.device_id:
+            headers["X-Device-Id"] = self.device_id
+        payload = multipart_request(
+            self._url("game/data/file/upload/file/image"),
+            str(path),
+            file_field="file",
+            headers=headers,
+            timeout=max(self.timeout, 600),
+        )
+        if isinstance(payload, Mapping):
+            business_code = _business_code(payload)
+            if payload.get("success") is False or (business_code is not None and business_code != 200):
+                raise FuploadError(
+                    str(payload.get("msg") or payload.get("message") or "ModUs image upload was rejected"),
+                    endpoint=self._url("game/data/file/upload/file/image"),
+                    business_code=business_code,
+                    kind="platform_error",
+                    stage="media_upload",
+                )
+        record = _image_upload_record(payload)
+        content = path.read_bytes()
+        return {
+            **record,
+            "bytes": len(content),
+            "sha256": hashlib.sha256(content).hexdigest(),
+        }
+
+    @staticmethod
+    def _share_wire(doc: Mapping[str, Any]) -> Dict[str, Any]:
+        aliases = {"share_id": "id", "addons_id": "addonsId", "backup_id": "backupId", "account_name": "accountName", "content_text": "contentText", "image_url": "imageUrl", "is_paid": "isPaid", "is_public": "isPublic", "share_type": "shareType", "exclude_wtf": "excludeWtf", "role_name": "roleName", "required_tier_id": "requiredTierId", "sub_type": "subType", "synchronization_type": "synchronizationType"}
+        allowed = {"id", "addonsId", "backupId", "accountName", "content", "contentText", "imageUrl", "isPaid", "isPublic", "price", "shareType", "tags", "title", "excludeWtf", "roleName", "requiredTierId", "subType", "platform", "synchronizationType"}
+        result = {}
+        for key, value in doc.items():
+            wire = aliases.get(key, key)
+            if wire in allowed and value is not None:
+                result[wire] = str(value) if wire == "addonsId" else value
+        result.setdefault("platform", 1)
+        exclude = result.get("excludeWtf", 0)
+        result["excludeWtf"] = 1 if str(exclude).strip().lower() in {"1", "true"} else 0
+        return result
+
+    def share_list(self, body: Optional[Mapping[str, Any]] = None, *, server_type: Optional[int] = None) -> Any:
+        source = body or {}
+        selected_build = self._build(source.get("server", server_type))
+        mine = source.get("mine")
+        share_type = source.get("share_type")
+        wire = {
+            "pageNum": int(source.get("page_num") or 1),
+            "pageSize": int(source.get("page_size") or 20),
+            "server": selected_build,
+            "mine": False if mine is None else bool(mine),
+            "shareType": 0 if share_type is None else share_type,
+        }
+        platform = source.get("platform")
+        wire["platform"] = int(platform) if isinstance(platform, (int, float)) and not isinstance(platform, bool) else 0
+        for key in ("keyword", "status", "tags", "order_by", "is_public", "is_paid"):
+            if key in source and source[key] is not None:
+                wire[{"order_by": "orderBy", "is_public": "isPublic", "is_paid": "isPaid"}.get(key, key)] = (
+                    _tag_filter(source[key]) if key == "tags" else source[key]
+                )
+        return _safe(_unwrap(self._request("POST", "system/user/share/list", wire, headers={"X-Server-Type": str(selected_build)})))
+
+    def share_detail(self, share_ids: Any, *, server_type: Optional[int] = None) -> Any:
+        ids = share_ids if isinstance(share_ids, list) else [share_ids]
+        return _safe(_unwrap(self._request("POST", "system/user/share/detail", {"shareIds": [_resource_id(x, field="share_id") for x in ids]}, headers={"X-Server-Type": str(self._build(server_type))})))
+
+    def share_create(self, doc: Mapping[str, Any], *, server_type: Optional[int] = None) -> Any:
+        return _safe(_unwrap(self._request("POST", "system/user/share/create", self._share_wire(doc), headers={"X-Server-Type": str(self._build(server_type))})))
+
+    def share_update(self, doc: Mapping[str, Any], *, server_type: Optional[int] = None) -> Any:
+        return _safe(_unwrap(self._request("PUT", "system/user/share/update", self._share_wire(doc), headers={"X-Server-Type": str(self._build(server_type))})))
+
+    def share_delete(self, share_id: Any, *, server_type: Optional[int] = None) -> Any:
+        return _safe(_unwrap(self._request("DELETE", "system/user/share/delete/%s" % urllib.parse.quote(_resource_id(share_id, field="share_id"), safe=""), headers={"X-Server-Type": str(self._build(server_type))})))
+
+    @staticmethod
+    def _import_wire(doc: Mapping[str, Any]) -> Dict[str, Any]:
+        aliases = {"import_id": "id", "code_text": "codeText", "addons_id": "addonsId", "content_text": "contentText", "file_path": "filePath", "image_url": "imageUrl", "is_paid": "isPaid", "is_public": "isPublic", "share_type": "shareType", "support_addon": "supportAddon", "required_tier_id": "requiredTierId", "sub_type": "subType", "synchronization_type": "synchronizationType"}
+        allowed = {"id", "codeText", "content", "addonsId", "contentText", "filePath", "imageUrl", "isPaid", "isPublic", "price", "shareType", "supportAddon", "tags", "title", "version", "requiredTierId", "subType", "platform", "synchronizationType"}
+        result = {aliases.get(key, key): value for key, value in doc.items() if aliases.get(key, key) in allowed and value is not None}
+        if "addonsId" in result:
+            result["addonsId"] = str(result["addonsId"])
+        result.setdefault("platform", 1)
+        result.setdefault("synchronizationType", 3 if result["platform"] == 3 else 1)
+        return result
+
+    def import_list(self, body: Optional[Mapping[str, Any]] = None, *, server_type: Optional[int] = None) -> Any:
+        source = body or {}
+        selected_build = self._build(source.get("server", server_type))
+        mine = source.get("mine")
+        status = source.get("status")
+        wire = {
+            "pageNum": int(source.get("page_num") or 1),
+            "pageSize": int(source.get("page_size") or 10),
+            "server": selected_build,
+            "mine": False if mine is None else bool(mine),
+            "status": 1 if status is None else status,
+        }
+        platform = source.get("platform")
+        wire["platform"] = int(platform) if isinstance(platform, (int, float)) and not isinstance(platform, bool) else 0
+        for key in ("keyword", "support_addon", "tags", "is_paid", "order_by"):
+            if key in source and source[key] is not None:
+                wire[{"support_addon": "supportAddon", "is_paid": "isPaid", "order_by": "orderBy"}.get(key, key)] = (
+                    _tag_filter(source[key]) if key == "tags" else source[key]
+                )
+        return _safe(_unwrap(self._request("POST", "system/user/import/list", wire, headers={"X-Server-Type": str(selected_build)})))
+
+    def import_detail(self, import_ids: Any, *, server_type: Optional[int] = None) -> Any:
+        ids = import_ids if isinstance(import_ids, list) else [import_ids]
+        return _safe(_unwrap(self._request("POST", "system/user/import/detail", {"importIds": [_resource_id(x, field="import_id") for x in ids]}, headers={"X-Server-Type": str(self._build(server_type))})))
+
+    def import_create(self, doc: Mapping[str, Any], *, server_type: Optional[int] = None) -> Any:
+        return _safe(_unwrap(self._request("POST", "system/user/import/create", self._import_wire(doc), headers={"X-Server-Type": str(self._build(server_type))})))
+
+    def import_update(self, doc: Mapping[str, Any], *, server_type: Optional[int] = None) -> Any:
+        return _safe(_unwrap(self._request("POST", "system/user/import/update", self._import_wire(doc), headers={"X-Server-Type": str(self._build(server_type))})))
+
+    def import_delete(self, import_id: Any, *, server_type: Optional[int] = None) -> Any:
+        return _safe(_unwrap(self._request("DELETE", "system/user/import/delete/%s" % urllib.parse.quote(_resource_id(import_id, field="import_id"), safe=""), headers={"X-Server-Type": str(self._build(server_type))})))
+
+    def import_version_publish(self, doc: Mapping[str, Any], *, server_type: Optional[int] = None) -> Any:
+        body = {
+            "importId": _resource_id(doc["import_id"], field="import_id"),
+            "version": str(doc["version"]).strip(),
+            "codeText": str(doc["code_text"]).strip(),
+        }
+        changelog = str(doc.get("changelog") or "").strip()
+        if changelog:
+            body["changelog"] = changelog
+        return _safe(_unwrap(self._request("POST", "system/user/import/version/publish", body, headers={"X-Server-Type": str(self._build(server_type))})))
+
+    def import_version_delete(self, version_id: Any, *, server_type: Optional[int] = None) -> Any:
+        return _safe(_unwrap(self._request("DELETE", "system/user/import/version/delete?versionId=%s" % urllib.parse.quote(str(version_id), safe=""), headers={"X-Server-Type": str(self._build(server_type))})))
+
     def release_signature(self, project_id: int, file_id: int) -> str:
         result = _unwrap(self._request("GET", "game/data/author/project/file/upload/signature/%s/%s" % (_positive_id(project_id, field="project_id"), _positive_id(file_id, field="file_id"))))
         url = result.get("signedUrl") if isinstance(result, Mapping) else result
@@ -819,15 +1351,23 @@ class ModUs:
 
     def execute_read(self, resource: str, action: str, args: Any = None) -> Any:
         if resource == "session" and action == "doctor": return self.doctor()
+        if resource == "options" and action == "builds": return self.builds()
+        if resource == "builds" and action == "list": return self.builds()
         doc = vars(args) if args is not None and hasattr(args, "__dict__") else (args or {})
         if resource == "account" and action == "info": return self.user_info()
         if resource == "account" and action == "subscription-count": return self.active_subscription_count()
         if resource == "account" and action == "statistics": return self.project_statistics()
-        if resource == "addon" and action == "info": return self.addon_info(doc.get("directories", []), server_type=doc.get("server_type", 1))
-        if resource == "addon" and action == "project-info": return self.addon_project_info(doc.get("project_ids", []), server_type=doc.get("server_type", 1))
-        if resource == "addon" and action == "history": return self.addon_history(doc["project_id"], page_num=doc.get("page_num", 1), page_size=doc.get("page_size", 5), server_type=doc.get("server_type", 1))
+        if resource == "addon" and action == "info": return self.addon_info(doc.get("directories", []), server_type=doc.get("server_type"))
+        if resource == "addon" and action == "project-info": return self.addon_project_info(doc.get("project_ids", []), server_type=doc.get("server_type"))
+        if resource == "addon" and action == "history": return self.addon_history(doc["project_id"], page_num=doc.get("page_num", 1), page_size=doc.get("page_size", 5), server_type=doc.get("server_type"))
         if resource == "project" and action == "dependencies": return self.project_dependencies(doc.get("query") or doc.get("project_ids") or doc.get("project_id"))
         if resource == "options": return self.options(action, keys=doc.get("keys"))
+        if resource == "config" and action == "backups": return self.cloud_backups(server_type=doc.get("server_type"))
+        if resource == "config" and action == "backup-get": return self.cloud_backup_detail(doc["backup_id"], server_type=doc.get("server_type"))
+        if resource == "config" and action == "list": return self.share_list(doc, server_type=doc.get("server_type"))
+        if resource == "config" and action == "get": return self.share_detail(doc["share_id"], server_type=doc.get("server_type"))
+        if resource == "wa" and action == "list": return self.import_list(doc, server_type=doc.get("server_type"))
+        if resource == "wa" and action == "get": return self.import_detail(doc["import_id"], server_type=doc.get("server_type"))
         if resource == "project" and action == "list": return self.project_list(**doc)
         if resource == "project" and action in ("get", "detail"): return self.project_detail(doc["project_id"])
         if resource in ("plugin", "release") and action in ("list", "versions"): return self.release_list(doc["project_id"], page_num=doc.get("page_num", 1), page_size=doc.get("page_size", 50))
@@ -835,6 +1375,19 @@ class ModUs:
         raise ValidationError("unsupported ModUs read operation")
 
     def execute_write(self, resource: str, action: str, doc: Mapping[str, Any]) -> Any:
+        if resource == "media" and action == "upload": return self.image_upload(str(doc["file"]))
+        if resource == "project": self._validate_project_write(action, doc)
+        self._validate_main_write(resource, action, doc)
+        if resource == "config" and action == "create": return self.share_create(doc, server_type=doc.get("server_type"))
+        if resource == "config" and action in ("update", "edit"): return self.share_update(doc, server_type=doc.get("server_type"))
+        if resource == "config" and action == "delete": return self.share_delete(doc["share_id"], server_type=doc.get("server_type"))
+        if resource == "config" and action == "backup-edit": return self.cloud_backup_update(doc, server_type=doc.get("server_type"))
+        if resource == "config" and action == "backup-delete": return self.cloud_backup_delete(doc["backup_id"], server_type=doc.get("server_type"))
+        if resource == "wa" and action == "create": return self.import_create(doc, server_type=doc.get("server_type"))
+        if resource == "wa" and action in ("update", "edit"): return self.import_update(doc, server_type=doc.get("server_type"))
+        if resource == "wa" and action == "delete": return self.import_delete(doc["import_id"], server_type=doc.get("server_type"))
+        if resource == "wa" and action == "version-publish": return self.import_version_publish(doc, server_type=doc.get("server_type"))
+        if resource == "wa" and action == "version-delete": return self.import_version_delete(doc["version_id"], server_type=doc.get("server_type"))
         if resource == "project" and action in ("create", "release"): return self.project_create(doc)
         if resource == "project" and action in ("update", "edit"): return self.project_update(doc)
         if resource == "project" and action == "delete": return self.project_delete(int(doc["project_id"]))