@follenfang/fupload 0.0.5 → 0.0.7

package/fupload/SKILL.md

@@ -1,8 +1,8 @@
 ---
 name: fupload
-description: Explicit author-publishing workflow for World of Warcraft plugins, configuration shares, and WA/strings on NewBeeBox, NetEase DD, CurseForge, and Heybox Workshop, including CurseForge author project lookup, plugin ZIP upload, and Heybox client-session version management. Use only when the user explicitly invokes `$fupload`, explicitly asks to use the Fupload Skill, or loads this Skill by path. Do not trigger from ordinary mentions of publishing, NewBeeBox, DD, CurseForge, Heybox, plugins, configurations, or WA.
+description: Explicit author-publishing workflow for World of Warcraft plugins, configuration shares, and WA/strings on NewBeeBox, NetEase DD, CurseForge, and Heybox Workshop, including CurseForge author project lookup, plugin ZIP upload, and Heybox web-session version management. Use only when the user explicitly invokes `$fupload`, explicitly asks to use the Fupload Skill, or loads this Skill by path. Do not trigger from ordinary mentions of publishing, NewBeeBox, DD, CurseForge, Heybox, plugins, configurations, or WA.
 metadata:
-  version: "0.0.5"
+  version: "0.0.7"
 ---
 
 # Fupload
@@ -69,7 +69,7 @@ For npm package maintenance, use `fupload update` to update the CLI, managed Pyt
 - Read [references/newbee.md](references/newbee.md) only when the user explicitly selected the third-party Python NewBeeBox channel.
 - Read [references/dd.md](references/dd.md) only for DD.
 - Read [references/curseforge.md](references/curseforge.md) for every CurseForge lookup or upload.
-- Read [references/blackbox.md](references/blackbox.md) for Heybox Workshop plugin list/detail, metadata edit, version upload/edit/delete, and client-session authentication.
+- Read [references/blackbox.md](references/blackbox.md) for Heybox Workshop plugin list/detail, metadata edit, version upload/edit/delete, and managed web-session authentication.
 - For Python, run the exact leaf command with `--help` before creating its input. Treat help as the executable schema contract.
 
 ## Investigate
@@ -88,7 +88,7 @@ For DD, use the one active task session to read game types/builds and the resour
 
 For every existing DD update or edit, GET the detail first and rebuild the official full form before preparing the write. If a legacy record lacks a field now required by the official submit validator, such as `creation_statement`, stop before upload and collect that value. When the missing field belongs to a different action allowlist, plan and confirm the prerequisite edit first, read it back, then run the content update. Do not send `null`, create defaults, or guessed values to bypass the missing field.
 
-For Heybox Workshop, use the signed-in desktop client's local session automatically. `blackbox plugin list`, `get`, and `versions` are read-only; `plugin edit` preserves omitted module fields by reading the complete module first; `plugin update` and `version-edit` upload or reuse a ZIP URL and verify the version readback; `version-delete` waits for asynchronous soft deletion and retries once when the audit state temporarily returns active. Do not accept or print cookies, tokens, signatures, or temporary COS credentials, and do not delete a whole module.
+For Heybox Workshop, use Fuploader's managed Chromium web profile. If the profile is missing or the creator API reports an expired session, Fuploader opens the Workshop login page visibly for the user to complete login, then reuses the same profile headlessly for signed protocol requests. Never read the desktop client config or import another browser profile, and never accept a caller-supplied profile, cookie, token, signature, or endpoint. `blackbox plugin list`, `get`, and `versions` are read-only; `plugin edit` preserves omitted module fields by reading the complete module first; `plugin update` and `version-edit` upload or reuse a ZIP URL and verify the version readback; `version-delete` waits for asynchronous soft deletion and retries once when the audit state temporarily returns active. Do not print cookies, tokens, signatures, or temporary COS credentials, and do not delete a whole module.
 
 For DD WA create, collect user choices before generating JSON, then let the Python CLI supply only the official create defaults for omitted form values: seven-day share and purchase lifetimes, `need_buy=false`, category `ui_original`, `Interface/Addons`, empty VIP levels, and version `0`. Submit category IDs as strings even when a discovery response represents them numerically. WA create/update versions contain digits only; update must be numerically greater than the current remote value. Every `!WA:2!` create/update/edit is reparsed by the installed official `WowUIInterface.parseWa` chain, including unchanged edit content. Do not carry create defaults into WA update/edit; omitted existing fields preserve their remote value.
 

package/fupload/references/blackbox.md

@@ -1,6 +1,8 @@
 # Heybox Workshop
 
-The blackbox provider reuses the signed-in Heybox desktop client's local login state. It never accepts credentials, cookies, tokens, signatures, or COS temporary credentials as input.
+The blackbox provider uses a Fuploader-managed persistent Chromium profile for the Workshop web session. It probes that profile headlessly. If the profile is missing or expired, it opens the Workshop login page visibly and waits for the user to finish login, then resumes through the same profile in headless mode.
+
+The Chromium profile lives under Fuploader's product state directory and is managed with the package's private Python venv. Fuploader does not read the Heybox desktop config or import Chrome, Edge, Electron, or another Playwright profile, and never accepts credentials, profile paths, cookies, tokens, signatures, endpoints, or COS temporary credentials as input. API calls use a fixed allowlisted web protocol and redact authentication and signed-upload material from output.
 
 The npm installer manages Tencent's official COS SDK in a Fuploader-only Python venv. `fupload update` synchronizes it, the launcher repairs a missing or stale runtime before executing the Python CLI, and `fupload uninstall` removes it. No system-wide `pip install` is required.
 

package/fupload/scripts/fupload_cli/__init__.py

@@ -1,3 +1,3 @@
 """Fupload Python CLI."""
 
-__version__ = "0.0.5"
+__version__ = "0.0.7"

package/fupload/scripts/fupload_cli/blackbox.py

@@ -1,29 +1,43 @@
 """Heybox Workshop plugin provider."""
 from __future__ import annotations
-import hashlib, json, secrets, time
+import hashlib, json, time, zipfile
 from pathlib import Path
-from urllib.parse import urlencode
-from urllib.request import Request, urlopen
+from urllib.parse import urlsplit, urlunsplit
 from typing import Any, Mapping
 from .errors import FuploadError, ValidationError
-from .blackbox_auth import API_BASE, hkey, load_session
+from .blackbox_web import API_ORIGIN, BlackboxWebSession
+
+API_MISC_BASE = "https://api.xiaoheihe.cn"
+API_BASE = API_ORIGIN
 
 class Blackbox:
-    def __init__(self, config: Mapping[str, Any] | None = None, transport=None):
+    def __init__(self, config: Mapping[str, Any] | None = None, transport=None, *, web_session=None, web_session_factory=None):
         self.config = dict(config or {})
-        self.profile = Path(self.config.get("client_profile") or Path.home() / "AppData/Roaming/heybox-pc-launcher")
         self._transport = transport
-    def _request(self, method, path, body=None, query=None):
-        if self._transport: return self._transport(method, path, body or {}, query or {})
-        cookies, identity = load_session(self.profile); ts=int(time.time()); nonce=hashlib.md5((str(ts)+secrets.token_hex(16)).encode()).hexdigest().upper()
-        params={**identity,"version":identity.get("version","1.12.0"),"hkey":hkey(path,ts,nonce),"_time":ts,"_chat_time":int(time.time()*1000),"nonce":nonce,**(query or {})}
-        headers={"User-Agent":"HeyboxApp/1.12.0","x_xhh_tokenid":cookies["x_xhh_tokenid"],"Cookie":"; ".join(f"{k}={v}" for k,v in cookies.items()),"Content-Type":"application/x-www-form-urlencoded"}
-        url=API_BASE+path+"?"+urlencode(params); data=urlencode(body or {},doseq=True).encode() if method=="POST" else None
-        try:
-            with urlopen(Request(url,data=data,headers=headers,method=method),timeout=60) as r: result=json.loads(r.read().decode())
-        except Exception as exc: raise FuploadError("Workshop API request failed", endpoint=path, verification_required=method=="POST") from exc
-        if not isinstance(result,dict) or result.get("status")!="ok": raise FuploadError("Workshop API rejected request", endpoint=path, details={"status":result.get("status") if isinstance(result,dict) else None})
-        return result
+        self._web_session = web_session
+        self._web_session_factory = web_session_factory or BlackboxWebSession
+
+    def close(self):
+        if self._web_session is not None:
+            self._web_session.close()
+            self._web_session = None
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *args):
+        self.close()
+
+    def _request(self, method, path, body=None, query=None, *, base=API_BASE):
+        if self._transport:
+            if base != API_BASE:
+                raise ValidationError("API origin is fixed to Workshop web protocol", path="$.base")
+            return self._transport(method, path, body or {}, query or {})
+        if base != API_BASE:
+            raise ValidationError("API origin is fixed to Workshop web protocol", path="$.base")
+        if self._web_session is None:
+            self._web_session = self._web_session_factory()
+        return self._web_session.request(method, path, body=body, query=query)
     @staticmethod
     def _result(payload): return payload.get("result") or {}
     def execute_read(self, resource: str, action: str, args: Any):
@@ -44,15 +58,18 @@ class Blackbox:
         rows=self._result(self._request("GET","/wow/open_platform/module/list/")).get("moduleList") or []
         return {"total_count":len(rows),"plugins":[self._redact(x) for x in rows if isinstance(x,dict)]}
     def plugin_get(self,module_id:int):
+        detail=self._module_detail(module_id)
+        return {"module":self._redact(detail),"versions":[self._redact(x) for x in self._version_rows(module_id)]}
+    def _module_detail(self,module_id:int):
         detail=self._result(self._request("GET","/wow/open_platform/module/detail/",query={"moduleId":module_id}))
-        versions=self._result(self._request("GET","/wow/open_platform/module_version/list/",query={"moduleId":module_id,"offset":0,"limit":100}))
-        return {"module":self._redact(detail.get("module") or detail),"versions":[self._redact(x) for x in (versions.get("versionList") or [])]}
+        module=detail.get("module") or detail
+        return module if isinstance(module,dict) else {}
     def module_edit(self,doc):
         aliases={"module_id":"id","logo_url":"logoUrl","category_ids":"categoryIds","official_url":"officialUrl","core_folders":"coreFolders"}
         normalized={aliases.get(k,k):v for k,v in doc.items() if k not in {"schema","dry_run"}}
         if "id" not in normalized: raise ValidationError("id is required",path="$.id")
         module_id = int(normalized["id"])
-        current = self.plugin_get(module_id)["module"]
+        current = self._module_detail(module_id)
         # The web client sends a complete module object; preserve omitted fields.
         defaults = {"name":"", "logoUrl":"", "id":module_id, "categoryIds":[],
                     "type":1, "desc":"", "official":"", "officialUrl":"", "coreFolders":""}
@@ -61,37 +78,42 @@ class Blackbox:
         fields["id"] = module_id
         if isinstance(fields.get("coreFolders"),list): fields["coreFolders"]=",".join(map(str,fields["coreFolders"]))
         response=self._request("POST","/wow/open_platform/module/update/",body=fields)
-        actual=self.plugin_get(module_id)["module"]
-        mismatches=[]
-        for key,wanted in ((aliases.get(key,key), value) for key,value in normalized.items() if key in aliases or key in fields):
-            observed=actual.get(key)
-            if key=="coreFolders" and isinstance(observed,list): wanted=[x for x in str(wanted).split(",") if x]
-            if observed != wanted: mismatches.append(key)
-        if mismatches: raise FuploadError("module update readback mismatch",kind="verification_required",verification_required=True,details={"fields":mismatches})
+        expected={aliases.get(key,key):value for key,value in normalized.items() if key in aliases or key in fields}
+        self._wait_module(module_id,expected)
         return {"accepted":True,"verified":True,"module_id":module_id,"response":self._redact(response)}
     def version_upsert(self,doc):
         aliases={"module_id":"moduleId","version_id":"versionId","game_versions":"gameVersions","file_url":"fileUrl"}
         normalized={aliases.get(k,k):v for k,v in doc.items() if k not in {"schema","dry_run"}}
-        if "file" in normalized and "fileUrl" not in normalized:
-            normalized["fileUrl"]=self.upload_zip(int(normalized["moduleId"]),str(normalized["file"]))["url"]
+        upload_result = None
+        if "file" in normalized:
+            upload_result=self.upload_zip(int(normalized["moduleId"]),str(normalized["file"]))
+            normalized["fileUrl"]=upload_result["url"]
         if "fileUrl" not in normalized and "versionId" in normalized:
             existing = self._find_version(int(normalized["moduleId"]), int(normalized["versionId"]))
-            if existing and existing.get("fileUrlHeybox"):
-                normalized["fileUrl"] = existing["fileUrlHeybox"]
+            current_url=self._archive_url(existing or {})
+            if current_url: normalized["fileUrl"]=current_url
         required=("moduleId","name","type","gameVersions","fileUrl")
         missing=[k for k in required if k not in normalized]
         if missing: raise ValidationError("missing field(s): %s"%", ".join(missing))
         games=normalized["gameVersions"] if isinstance(normalized["gameVersions"],list) else [x for x in str(normalized["gameVersions"]).split(",") if x]
         body={"moduleId":int(normalized["moduleId"]),"name":normalized["name"],"type":int(normalized["type"]),"gameVersions":",".join(map(str,games)),"fileUrl":normalized["fileUrl"]}
         if "versionId" in normalized: body["versionId"]=int(normalized["versionId"])
+        existing_ids={self._id_value(row.get("id")) for row in self._version_rows(body["moduleId"])} if "versionId" not in body else set()
         response=self._request("POST","/wow/open_platform/module_version/upsert/",body=body)
-        found=self._wait_version(body["moduleId"],body.get("versionId"),body["name"],
-                                 expected={"name":body["name"],"type":body["type"],"gameVersions":list(map(str,games))})
-        mismatches=[key for key,wanted in {"name":body["name"],"type":body["type"],"gameVersions":list(map(str,games))}.items() if found.get(key)!=wanted]
-        if not found.get("fileUrlHeybox"):
+        response_result=self._result(response)
+        response_id=(response_result.get("versionId") or response_result.get("id")) if isinstance(response_result,dict) else None
+        target_id=body.get("versionId") or (self._id_value(response_id) if response_id is not None else None)
+        expected = {"name":body["name"],"type":body["type"],"gameVersions":list(map(str,games))}
+        found=self._wait_version(body["moduleId"],target_id,body["name"],excluded_ids=existing_ids,
+                                 expected=expected,expected_archive=body["fileUrl"])
+        mismatches=[key for key,wanted in {"name":body["name"],"type":body["type"],"gameVersions":list(map(str,games))}.items() if self._comparable(key,found.get(key))!=self._comparable(key,wanted)]
+        if self._comparable("fileUrl", self._archive_url(found)) != self._comparable("fileUrl", body["fileUrl"]):
             mismatches.append("fileUrl")
         if mismatches: raise FuploadError("version upsert readback mismatch",kind="verification_required",verification_required=True,details={"fields":mismatches})
-        return {"accepted":True,"verified":True,"module_id":body["moduleId"],"version_id":found.get("id"),"readback":self._redact(found),"response":self._redact(response)}
+        result={"accepted":True,"verified":True,"module_id":body["moduleId"],"version_id":found.get("id"),"readback":self._redact(found),"response":self._redact(response)}
+        if upload_result:
+            result["upload"]={key:upload_result[key] for key in ("protocol","bytes","sha256") if key in upload_result}
+        return result
     def version_delete(self,doc):
         version_id=doc.get("versionId",doc.get("version_id")); module_id=doc.get("moduleId",doc.get("module_id"))
         if version_id is None or module_id is None: raise ValidationError("versionId and moduleId are required")
@@ -106,33 +128,107 @@ class Blackbox:
                 retry = True
                 response = self._request("POST","/wow/open_platform/module_version/delete/",body={"versionId":int(version_id),"moduleId":int(module_id)})
                 found = self._wait_version(int(module_id),int(version_id),None,deleted=True)
+                time.sleep(settle)
+                current = self._find_version(int(module_id), int(version_id))
+                if current is not None and current.get("auditState") != 4:
+                    raise FuploadError("version delete did not remain stable",kind="verification_required",verification_required=True)
         return {"accepted":True,"verified":True,"module_id":int(module_id),"version_id":int(version_id),"audit_state":found.get("auditState") if found else None,"retry":retry,"response":self._redact(response)}
     def _version_rows(self,module_id):
-        return self._result(self._request("GET","/wow/open_platform/module_version/list/",query={"moduleId":module_id,"offset":0,"limit":100})).get("versionList") or []
+        limit = int(self.config.get("version_page_size", 100))
+        max_pages = int(self.config.get("version_max_pages", 100))
+        rows = []
+        page_fingerprints = set()
+        for page_index in range(max_pages):
+            offset = page_index * limit
+            result = self._result(self._request(
+                "GET", "/wow/open_platform/module_version/list/",
+                query={"moduleId":module_id,"offset":offset,"limit":limit},
+            ))
+            page = result.get("versionList") or []
+            if not isinstance(page, list):
+                raise FuploadError("version list response is invalid", kind="verification_required", verification_required=True)
+            fingerprint = tuple(self._id_value(item.get("id")) for item in page if isinstance(item, Mapping))
+            if page and fingerprint in page_fingerprints:
+                raise FuploadError("version list pagination did not advance", kind="verification_required", verification_required=True)
+            page_fingerprints.add(fingerprint)
+            rows.extend(item for item in page if isinstance(item, dict))
+            total = next((result.get(key) for key in ("totalCount", "total_count", "total", "count") if isinstance(result.get(key), int)), None)
+            if not page or len(page) < limit or (total is not None and len(rows) >= total):
+                return rows
+        raise FuploadError("version list pagination exceeded the supported limit", kind="verification_required", verification_required=True)
 
     def _find_version(self, module_id, version_id):
-        return next((x for x in self._version_rows(module_id) if x.get("id") == version_id), None)
-    def _wait_version(self,module_id,version_id,name,deleted=False,expected=None):
-        for attempt in range(int(self.config.get("verify_attempts",20))):
+        wanted=self._id_value(version_id)
+        return next((x for x in self._version_rows(module_id) if self._id_value(x.get("id"))==wanted),None)
+    def _wait_module(self,module_id,expected):
+        attempts=int(self.config.get("verify_attempts",30))
+        mismatches=list(expected)
+        for attempt in range(attempts):
+            actual=self._module_detail(module_id)
+            mismatches=[key for key,wanted in expected.items() if self._comparable(key,actual.get(key))!=self._comparable(key,wanted)]
+            if not mismatches: return actual
+            if attempt+1<attempts: time.sleep(float(self.config.get("verify_interval",2)))
+        raise FuploadError("module update readback mismatch",kind="verification_required",verification_required=True,details={"fields":mismatches})
+    def _wait_version(self,module_id,version_id,name,deleted=False,expected=None,excluded_ids=None,expected_archive=None):
+        excluded_ids=excluded_ids or set()
+        for attempt in range(int(self.config.get("verify_attempts",30))):
             rows=self._version_rows(module_id)
-            found=next((x for x in rows if (version_id is not None and x.get("id")==version_id) or (version_id is None and x.get("name")==name)),None)
+            if version_id is not None:
+                candidates=[x for x in rows if self._id_value(x.get("id"))==self._id_value(version_id)]
+            else:
+                candidates=[x for x in rows if x.get("name")==name and self._id_value(x.get("id")) not in excluded_ids]
+            if len(candidates)>1: raise FuploadError("version write readback is ambiguous",kind="verification_required",verification_required=True)
+            found=candidates[0] if candidates else None
             matches_expected = found and all(
-                (list(map(str, found.get(key) or [])) if key == "gameVersions" else found.get(key)) == wanted
+                self._comparable(key,found.get(key))==self._comparable(key,wanted)
                 for key, wanted in (expected or {}).items()
             )
+            if matches_expected and expected_archive is not None:
+                matches_expected = self._comparable("fileUrl", self._archive_url(found)) == self._comparable("fileUrl", expected_archive)
             if (deleted and (found is None or found.get("auditState")==4)) or (not deleted and found and matches_expected): return found or {}
-            if attempt+1<int(self.config.get("verify_attempts",20)): time.sleep(float(self.config.get("verify_interval",2)))
+            if attempt+1<int(self.config.get("verify_attempts",30)): time.sleep(float(self.config.get("verify_interval",2)))
         raise FuploadError("version write was not confirmed by readback",kind="verification_required",verification_required=True)
     @staticmethod
     def _redact(value):
-        if isinstance(value,dict): return {k:("<redacted>" if any(s in k.lower() for s in ("token","secret","cookie","nonce","hkey")) else Blackbox._redact(v)) for k,v in value.items()}
-        if isinstance(value,list): return [Blackbox._redact(v) for v in value]
+        if isinstance(value,dict):
+            markers=("token","secret","cookie","nonce","hkey","pkey","credential","signature","authorization","authentication","device_id","signed_url","upload_url","presigned")
+            return {k:("<redacted>" if any(s in str(k).lower() for s in markers) else Blackbox._redact(v)) for k,v in value.items()}
+        if isinstance(value,(list,tuple)): return [Blackbox._redact(v) for v in value]
+        if isinstance(value,str):
+            parsed=urlsplit(value)
+            if parsed.scheme in {"http","https"} and parsed.netloc and parsed.query:
+                return urlunsplit((parsed.scheme,parsed.netloc,parsed.path,"<redacted>",parsed.fragment))
+        return value
+
+    @staticmethod
+    def _id_value(value):
+        try: return int(value)
+        except (TypeError,ValueError): return value
+    @staticmethod
+    def _archive_url(row): return row.get("fileUrlHeybox") or row.get("fileUrl") or row.get("file_url")
+    @staticmethod
+    def _comparable(key,value):
+        if key in {"categoryIds","gameVersions","coreFolders"}:
+            if isinstance(value,str): items=[item for item in value.split(",") if item]
+            elif isinstance(value,(list,tuple,set)): items=list(value)
+            else: items=[] if value is None else [value]
+            normalized=[]
+            for item in items:
+                if isinstance(item,Mapping): item=item.get("id",item.get("value"))
+                if item not in (None, ""):
+                    normalized.append(str(item))
+            return tuple(sorted(normalized))
+        if key in {"id","type"}: return Blackbox._id_value(value)
         return value
 
     def upload_zip(self, module_id: int, file_path: str, *, dry_run=False):
         path=Path(file_path)
         if not path.is_file(): raise ValidationError("file does not exist",path="$.file")
+        if not zipfile.is_zipfile(path): raise ValidationError("file must be a valid ZIP archive",path="$.file")
         if dry_run: return {"dry_run":True,"bytes":path.stat().st_size,"sha256":hashlib.sha256(path.read_bytes()).hexdigest()}
+        return self._upload_zip_legacy(path)
+
+    def _upload_zip_legacy(self, path: Path):
         size_mb=path.stat().st_size/1024/1024
         token=self._result(self._request("POST","/wow/cos/upload/token/",body={"jsonData":json.dumps({"upload_infos":[{"filename":path.name,"file_size":size_mb,"type":"module"}]},separators=(",",":"))}))
         info=token["info"]; f=token["files"][0]; creds=info["Credentials"].get("Credentials",info["Credentials"])
@@ -148,4 +244,4 @@ class Blackbox:
             cos=CosS3Client(CosConfig(Region=info.get("region") or "ap-shanghai",SecretId=creds["TmpSecretID"],SecretKey=creds["TmpSecretKey"],Token=creds["Token"],Scheme="https"))
             with path.open("rb") as stream: cos.put_object(Bucket=info["bucket"],Key=f["key"],Body=stream)
         except Exception as exc: raise FuploadError("COS upload failed",verification_required=True) from exc
-        return {"url":"https://%s/%s"%(info["host"],f["key"]),"bytes":path.stat().st_size,"sha256":hashlib.sha256(path.read_bytes()).hexdigest()}
+        return {"url":"https://%s/%s"%(info["host"],f["key"]),"bytes":path.stat().st_size,"sha256":hashlib.sha256(path.read_bytes()).hexdigest(),"protocol":"legacy"}

package/fupload/scripts/fupload_cli/blackbox_web.py

@@ -0,0 +1,522 @@
+"""Persistent browser session and protocol for Heybox Workshop."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import secrets
+import sys
+import time
+from enum import Enum
+from pathlib import Path
+from typing import Any, Callable, Mapping
+from urllib.parse import parse_qs, urlencode, urlsplit
+
+from .errors import FuploadError, redact
+
+
+WORKSHOP_URL = "https://open.xiaoheihe.cn/zh_cn/workshop"
+LOGIN_ORIGIN = "https://login.xiaoheihe.cn"
+API_ORIGIN = "https://workshopapi.xiaoheihe.cn"
+API_ROUTES = frozenset({
+    ("GET", "/wow/open_platform/module/list/"),
+    ("GET", "/wow/open_platform/module/detail/"),
+    ("POST", "/wow/open_platform/module/update/"),
+    ("GET", "/wow/open_platform/module_version/list/"),
+    ("POST", "/wow/open_platform/module_version/upsert/"),
+    ("POST", "/wow/open_platform/module_version/delete/"),
+    ("POST", "/wow/cos/upload/token/"),
+})
+API_PATHS = frozenset(path for _method, path in API_ROUTES)
+WEB_QUERY_KEYS = frozenset({
+    "_time", "app", "device_id", "heybox_id", "hkey", "nonce", "os_type",
+    "version", "web_version", "x_app", "x_client_type", "x_os_type",
+    "x_xhh_tokenid",
+})
+_ALPHABET = "AB45STUVWZEFGJ6CH01D237IXYPQRKLMN89"
+_INTERACTIVE_STATUSES = frozenset({
+    "lack_token", "show_captcha", "name_verify", "need_alipay_verify",
+    "need_bind_phone", "need_phone_code",
+})
+_SECRET_MARKERS = (
+    "token", "secret", "cookie", "nonce", "hkey", "pkey", "credential",
+    "signature", "authorization", "authentication", "password", "device_id",
+    "signed_url", "upload_url", "presigned",
+)
+
+
+class WebSessionState(str, Enum):
+    HEADLESS_PROBE = "headless_probe"
+    HEADED_LOGIN = "headed_login"
+    READY = "ready"
+    EXPIRED = "expired"
+    FAILED = "failed"
+
+
+def managed_profile_path() -> Path:
+    """Return the private browser profile owned by Fuploader."""
+    if os.name == "nt":
+        base = Path(os.environ.get("LOCALAPPDATA") or (Path.home() / "AppData/Local"))
+        return base / "Fuploader" / "blackbox-chromium"
+    return Path.home() / ".fupload" / "blackbox-chromium"
+
+
+def managed_state_path() -> Path:
+    return managed_profile_path().parent / "blackbox-web-state.json"
+
+
+def _n8(value: str, limit: int) -> str:
+    table = _ALPHABET[:limit]
+    return "".join(table[ord(char) % len(table)] for char in value)
+
+
+def _i8(value: str) -> str:
+    return "".join(_ALPHABET[ord(char) % len(_ALPHABET)] for char in value)
+
+
+def _interleave(parts: list[str]) -> str:
+    width = max(map(len, parts))
+    return "".join(part[index] for index in range(width) for part in parts if index < len(part))
+
+
+def _mix(values: list[int]) -> list[int]:
+    def p(value: int) -> int:
+        return ((value << 1) ^ 27) & 255 if value & 128 else (value << 1) & 255
+
+    def hm(value: int) -> int:
+        return p(value) ^ value
+
+    def qg(value: int) -> int:
+        return hm(p(value))
+
+    def dx(value: int) -> int:
+        return qg(hm(p(value)))
+
+    def mw(value: int) -> int:
+        return dx(value) ^ qg(value) ^ hm(value)
+
+    a, b, c, d, *rest = values
+    return [
+        mw(a) ^ dx(b) ^ qg(c) ^ hm(d),
+        hm(a) ^ mw(b) ^ dx(c) ^ qg(d),
+        qg(a) ^ hm(b) ^ mw(c) ^ dx(d),
+        dx(a) ^ qg(b) ^ hm(c) ^ mw(d),
+        *rest,
+    ]
+
+
+def web_hkey(path: str, timestamp: int, nonce: str) -> str:
+    normalized = "/" + "/".join(part for part in path.split("/") if part) + "/"
+    source = _interleave([_n8(str(timestamp), -2), _i8(normalized), _i8(nonce)])
+    digest = hashlib.md5(source.encode()).hexdigest()
+    return _n8(digest[:5], -4) + f"{sum(_mix([ord(char) for char in digest[-6:]])) % 100:02d}"
+
+
+def redact_recursive(value: Any) -> Any:
+    """Remove browser credentials and signed query strings from diagnostics."""
+    if isinstance(value, Mapping):
+        result = {}
+        for key, item in value.items():
+            if any(marker in str(key).lower() for marker in _SECRET_MARKERS):
+                result[key] = "<redacted>"
+            else:
+                result[key] = redact_recursive(item)
+        return result
+    if isinstance(value, (list, tuple, set)):
+        return [redact_recursive(item) for item in value]
+    if isinstance(value, str):
+        parsed = urlsplit(value)
+        if parsed.scheme in {"http", "https"} and parsed.netloc and parsed.query:
+            return f"{parsed.scheme}://{parsed.netloc}{parsed.path}?<redacted>"
+        return redact(value)
+    return value
+
+
+class BlackboxWebSession:
+    """Own a persistent Chromium profile and expose the Workshop protocol."""
+
+    def __init__(
+        self,
+        *,
+        login_timeout: float = 300,
+        poll_interval: float = 1,
+        browser_launcher: Callable[[bool, Path], Any] | None = None,
+        sleep: Callable[[float], None] = time.sleep,
+        monotonic: Callable[[], float] = time.monotonic,
+    ) -> None:
+        self.state = WebSessionState.HEADLESS_PROBE
+        self.login_timeout = max(0.0, float(login_timeout))
+        self.poll_interval = max(0.0, float(poll_interval))
+        self._browser_launcher = browser_launcher
+        self._sleep = sleep
+        self._monotonic = monotonic
+        self._context = None
+        self._playwright = None
+
+    @property
+    def profile_path(self) -> Path:
+        return managed_profile_path()
+
+    def close(self) -> None:
+        self._close_context()
+
+    def __enter__(self) -> "BlackboxWebSession":
+        return self
+
+    def __exit__(self, *args: Any) -> None:
+        self.close()
+
+    def ensure_ready(self) -> None:
+        if self.state == WebSessionState.READY and self._context is not None:
+            return
+        self._close_context()
+        self._set_state(WebSessionState.HEADLESS_PROBE)
+        try:
+            self._context = self._launch(headless=True)
+            self._open_workshop(self._context)
+            if self._probe(self._context):
+                self._set_state(WebSessionState.READY)
+                return
+            self._set_state(WebSessionState.EXPIRED, "web session requires login")
+            self._login()
+        except FuploadError:
+            if self.state not in {WebSessionState.EXPIRED, WebSessionState.HEADED_LOGIN}:
+                self._set_state(WebSessionState.FAILED, "browser session failed")
+            raise
+        except Exception as exc:
+            self._set_state(WebSessionState.FAILED, "browser session failed")
+            raise self._error("Workshop browser session failed", exc) from exc
+
+    def request(
+        self,
+        method: str,
+        path: str,
+        body: Mapping[str, Any] | None = None,
+        query: Mapping[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        method, path = self._validate_request(method, path)
+        self.ensure_ready()
+        payload, response = self._protocol(self._context, method, path, body, query)
+        if self._authenticated(payload, response):
+            return payload
+        if not self._needs_interaction(payload, response):
+            raise self._response_error(path, payload, response, verification_required=method == "POST")
+
+        self._set_state(WebSessionState.EXPIRED, "web session expired")
+        if method == "POST":
+            raise self._response_error(path, payload, response, verification_required=True)
+        self._login()
+        payload, response = self._protocol(self._context, method, path, body, query)
+        if self._authenticated(payload, response):
+            return payload
+        if self._needs_interaction(payload, response):
+            self._set_state(WebSessionState.EXPIRED, "web session remained expired")
+        raise self._response_error(path, payload, response)
+
+    def _login(self) -> None:
+        self._close_context()
+        self._set_state(WebSessionState.HEADED_LOGIN)
+        try:
+            context = self._launch(headless=False)
+            self._context = context
+            self._open_workshop(context)
+            deadline = self._monotonic() + self.login_timeout
+            while True:
+                if self._headed_window_closed(context):
+                    self._set_state(WebSessionState.EXPIRED, "headed login window closed")
+                    raise FuploadError(
+                        "Workshop login window was closed",
+                        kind="authentication_error",
+                        stage="headed_login",
+                    )
+                try:
+                    ready = self._probe(context)
+                except FuploadError as exc:
+                    if exc.business_code != "network_error":
+                        raise
+                    ready = False
+                if ready:
+                    break
+                if self._monotonic() >= deadline:
+                    self._set_state(WebSessionState.EXPIRED, "headed login timed out")
+                    raise FuploadError(
+                        "Workshop web login timed out",
+                        kind="authentication_error",
+                        stage="headed_login",
+                    )
+                self._sleep(self.poll_interval)
+
+            self._close_context()
+            self._set_state(WebSessionState.HEADLESS_PROBE)
+            self._context = self._launch(headless=True)
+            self._open_workshop(self._context)
+            if not self._probe(self._context):
+                self._set_state(WebSessionState.EXPIRED, "web login did not persist")
+                raise FuploadError(
+                    "Workshop web login did not persist",
+                    kind="authentication_error",
+                    stage="headless_probe",
+                )
+            self._set_state(WebSessionState.READY)
+        except FuploadError:
+            self._close_context()
+            raise
+        except Exception as exc:
+            self._set_state(WebSessionState.FAILED, "headed login failed")
+            self._close_context()
+            raise self._error("Workshop headed login failed", exc) from exc
+
+    def _launch(self, *, headless: bool) -> Any:
+        profile = self.profile_path
+        profile.mkdir(parents=True, exist_ok=True)
+        if self._browser_launcher is not None:
+            return self._browser_launcher(headless, profile)
+        try:
+            from playwright.sync_api import sync_playwright
+        except ImportError as exc:
+            raise FuploadError(
+                "Playwright is required for Workshop web login",
+                kind="environment_error",
+                stage="browser_launch",
+                details={"dependency": "playwright"},
+            ) from exc
+        try:
+            self._playwright = sync_playwright().start()
+            return self._playwright.chromium.launch_persistent_context(
+                user_data_dir=str(profile),
+                headless=headless,
+            )
+        except Exception:
+            if self._playwright is not None:
+                self._playwright.stop()
+                self._playwright = None
+            raise
+
+    @staticmethod
+    def _open_workshop(context: Any) -> None:
+        page = context.pages[0] if getattr(context, "pages", None) else context.new_page()
+        page.goto(WORKSHOP_URL, wait_until="domcontentloaded")
+        current = str(getattr(page, "url", "") or "")
+        if current and not BlackboxWebSession._allowed_navigation(current):
+            raise FuploadError(
+                "Workshop browser navigated outside the fixed login flow",
+                kind="authentication_error",
+                stage="browser_navigation",
+            )
+
+    def _probe(self, context: Any) -> bool:
+        payload, response = self._protocol(
+            context, "GET", "/wow/open_platform/module/list/", None, None,
+        )
+        if self._authenticated(payload, response):
+            modules = (payload.get("result") or {}).get("moduleList")
+            if isinstance(modules, list):
+                return True
+            raise self._response_error(
+                "/wow/open_platform/module/list/", payload, response,
+                message="Workshop readiness response is invalid",
+            )
+        if self._needs_interaction(payload, response):
+            return False
+        raise self._response_error("/wow/open_platform/module/list/", payload, response)
+
+    @staticmethod
+    def _protocol(
+        context: Any,
+        method: str,
+        path: str,
+        body: Mapping[str, Any] | None,
+        query: Mapping[str, Any] | None,
+    ) -> tuple[dict[str, Any], Any]:
+        caller_query = dict(query or {})
+        reserved = sorted(WEB_QUERY_KEYS.intersection(caller_query))
+        if reserved:
+            raise FuploadError(
+                "Workshop query overrides a managed protocol field",
+                kind="validation_error",
+                stage="protocol_validation",
+                details={"fields": reserved},
+            )
+        cookie_rows = context.cookies([WORKSHOP_URL, API_ORIGIN])
+        cookies = {str(item.get("name")): str(item.get("value") or "") for item in cookie_rows}
+        heybox_id = cookies.get("user_heybox_id") or cookies.get("heybox_id") or ""
+        risk_token = cookies.get("x_xhh_tokenid") or ""
+        timestamp = int(time.time())
+        nonce = hashlib.md5(
+            f"{timestamp}{time.time_ns()}{secrets.token_hex(8)}".encode(),
+        ).hexdigest().upper()
+        params = {
+            "app": "heybox",
+            "heybox_id": heybox_id,
+            "os_type": "web",
+            "x_app": "heybox_website",
+            "x_client_type": "weboutapp",
+            "x_os_type": BlackboxWebSession._platform_name(),
+            "web_version": "",
+            "device_id": risk_token,
+            "version": "999.0.4",
+            "hkey": web_hkey(path, timestamp + 1, nonce),
+            "_time": timestamp,
+            "nonce": nonce,
+            "x_xhh_tokenid": risk_token,
+            **caller_query,
+        }
+        url = API_ORIGIN + path
+        headers = {"Referer": WORKSHOP_URL}
+        try:
+            if method == "GET":
+                response = context.request.get(url, params=params, headers=headers)
+            else:
+                response = context.request.post(
+                    url,
+                    params=params,
+                    data=urlencode(dict(body or {}), doseq=True),
+                    headers={
+                        **headers,
+                        "Content-Type": "application/x-www-form-urlencoded;charset=UTF-8",
+                    },
+                )
+        except Exception as exc:
+            raise FuploadError(
+                "Workshop web request failed",
+                kind="operation_failed",
+                stage="web_protocol",
+                endpoint=path,
+                business_code="network_error",
+                verification_required=method == "POST",
+                details=redact_recursive({"error": str(exc)}),
+            ) from exc
+        try:
+            payload = response.json()
+        except Exception:
+            payload = {"status": "network_error"}
+        return (payload if isinstance(payload, dict) else {}), response
+
+    @staticmethod
+    def _authenticated(payload: Mapping[str, Any], response: Any) -> bool:
+        return bool(getattr(response, "ok", False)) and payload.get("status") == "ok"
+
+    @staticmethod
+    def _needs_interaction(payload: Mapping[str, Any], response: Any) -> bool:
+        return (
+            payload.get("status") in {"login", "relogin", "unauthorized", *_INTERACTIVE_STATUSES}
+            or getattr(response, "status", 0) in {401, 403}
+        )
+
+    @staticmethod
+    def _validate_request(method: str, path: str) -> tuple[str, str]:
+        normalized_method = str(method).upper()
+        if not isinstance(path, str) or (normalized_method, path) not in API_ROUTES:
+            raise FuploadError(
+                "Workshop protocol route is not allowed",
+                kind="validation_error",
+                stage="protocol_validation",
+            )
+        return normalized_method, path
+
+    @staticmethod
+    def _allowed_navigation(url: str) -> bool:
+        parsed = urlsplit(url)
+        origin = f"{parsed.scheme}://{parsed.netloc}"
+        if origin == "https://open.xiaoheihe.cn":
+            return parsed.path in {"/zh_cn/workshop", "/zh_cn/workshop/"}
+        if origin != LOGIN_ORIGIN or parsed.path != "/":
+            return False
+        query = parse_qs(parsed.query)
+        return (
+            query.get("origin") == ["heybox_open"]
+            and query.get("redirect_url") in ([WORKSHOP_URL], [WORKSHOP_URL + "/"])
+        )
+
+    @staticmethod
+    def _headed_window_closed(context: Any) -> bool:
+        pages = getattr(context, "pages", None)
+        if pages is None:
+            return False
+        if not pages:
+            return True
+        return all(callable(getattr(page, "is_closed", None)) and page.is_closed() for page in pages)
+
+    @staticmethod
+    def _platform_name() -> str:
+        if os.name == "nt":
+            return "Windows"
+        if sys.platform == "darwin":
+            return "macOS"
+        return "Linux"
+
+    def _set_state(self, state: WebSessionState, reason: str | None = None) -> None:
+        self.state = state
+        path = managed_state_path()
+        path.parent.mkdir(parents=True, exist_ok=True)
+        payload = {
+            "schema": "fupload.blackbox.web-state.v1",
+            "state": state.value,
+            "updated_at": int(time.time()),
+        }
+        if reason:
+            payload["reason"] = redact(reason)
+        temporary = path.with_suffix(path.suffix + ".tmp")
+        temporary.write_text(json.dumps(payload, sort_keys=True) + "\n", encoding="utf-8")
+        temporary.replace(path)
+
+    def _close_context(self) -> None:
+        context, self._context = self._context, None
+        if context is not None:
+            try:
+                context.close()
+            except Exception:
+                pass
+        playwright, self._playwright = self._playwright, None
+        if playwright is not None:
+            try:
+                playwright.stop()
+            except Exception:
+                pass
+
+    @staticmethod
+    def _response_error(
+        path: str,
+        payload: Mapping[str, Any],
+        response: Any,
+        *,
+        message: str = "Workshop web request was rejected",
+        verification_required: bool = False,
+    ) -> FuploadError:
+        status = payload.get("status")
+        is_auth = BlackboxWebSession._needs_interaction(payload, response)
+        return FuploadError(
+            message,
+            kind="authentication_error" if is_auth else "operation_failed",
+            stage="web_protocol",
+            endpoint=path,
+            http_status=getattr(response, "status", None),
+            business_code=status,
+            verification_required=verification_required,
+            details=redact_recursive({"response": payload}),
+        )
+
+    @staticmethod
+    def _error(message: str, exc: Exception) -> FuploadError:
+        return FuploadError(
+            message,
+            kind="environment_error",
+            stage="browser_session",
+            details=redact_recursive({"error": str(exc)}),
+        )
+
+
+__all__ = [
+    "API_ORIGIN",
+    "API_PATHS",
+    "API_ROUTES",
+    "WEB_QUERY_KEYS",
+    "WORKSHOP_URL",
+    "BlackboxWebSession",
+    "WebSessionState",
+    "managed_profile_path",
+    "managed_state_path",
+    "redact_recursive",
+    "web_hkey",
+]

package/fupload/scripts/fupload_cli/cli.py

@@ -206,7 +206,7 @@ def _blackbox_tree(platforms: argparse._SubParsersAction) -> None:
     root = platforms.add_parser(
         "blackbox",
         help="Heybox Workshop plugin management",
-        description="Reuse the signed-in Heybox desktop client login state; no credential input is accepted.",
+        description="Use a managed Heybox Workshop web session; an interactive browser opens when login is required.",
     )
     groups = root.add_subparsers(dest="resource_command", required=True)
     plugin = groups.add_parser("plugin", help="Heybox Workshop plugin metadata and versions").add_subparsers(dest="action_command", required=True)
@@ -281,17 +281,27 @@ def main(argv: Optional[Sequence[str]] = None) -> int:
                 write_output(platform, operation, _dry_run_data(doc, schema.name), dry_run=True)
                 return 0
             provider = NewBee() if platform == "newbee" else (DD() if platform == "dd" else (Blackbox() if platform == "blackbox" else CurseForge()))
-            if platform == "dd":
-                data = provider.execute_write(resource, action, doc, getattr(args, "session", None))
-            else:
-                data = provider.execute_write(resource, action, doc)
+            try:
+                if platform == "dd":
+                    data = provider.execute_write(resource, action, doc, getattr(args, "session", None))
+                else:
+                    data = provider.execute_write(resource, action, doc)
+            finally:
+                close = getattr(provider, "close", None)
+                if close:
+                    close()
             write_output(platform, operation, data)
             return 0
         provider = NewBee() if platform == "newbee" else (DD() if platform == "dd" else (Blackbox() if platform == "blackbox" else CurseForge()))
-        if platform == "dd":
-            data = provider.execute_read(resource, action, args, getattr(args, "session", None))
-        else:
-            data = provider.execute_read(resource, action, args)
+        try:
+            if platform == "dd":
+                data = provider.execute_read(resource, action, args, getattr(args, "session", None))
+            else:
+                data = provider.execute_read(resource, action, args)
+        finally:
+            close = getattr(provider, "close", None)
+            if close:
+                close()
         write_output(platform, operation, data)
         return 0
     except (FuploadError, OSError, ValueError) as exc:

package/fupload/scripts/fupload_cli/schema.py

@@ -93,7 +93,7 @@ class Schema:
         return checked
 
     def _validate_conditionals(self, value: Dict[str, Any]) -> None:
-        for name in ("id", "mod_id", "file_id", "content_id", "source_id", "module_id", "game_version_id", "cloud_id"):
+        for name in ("id", "mod_id", "file_id", "content_id", "source_id", "module_id", "version_id", "game_version_id", "cloud_id"):
             if name in value and isinstance(value[name], int) and value[name] <= 0:
                 raise ValidationError("must be greater than zero", path="$.%s" % name)
         if value.get("public") is True and value.get("submit_for_review") is not True:
@@ -340,6 +340,17 @@ class Schema:
                 for field_name in ("game_versions", "game_version_names"):
                     if field_name in value:
                         raise ValidationError("must be omitted when parent_file_id is set", path="$.%s" % field_name)
+        if self.name.startswith("fupload.v1.blackbox"):
+            scalar_array("game_versions", (str,), "array must contain nonempty game-version strings")
+            if "game_versions" in value and any(not item.strip() for item in value["game_versions"]):
+                raise ValidationError("array must contain nonempty game-version strings", path="$.game_versions")
+            if "category_ids" in value and any(isinstance(item, bool) or not isinstance(item, int) or item <= 0 for item in value["category_ids"]):
+                raise ValidationError("array must contain positive integer IDs", path="$.category_ids")
+            scalar_array("core_folders", (str,), "array must contain nonempty folder names")
+            if "core_folders" in value and any(not item.strip() for item in value["core_folders"]):
+                raise ValidationError("array must contain nonempty folder names", path="$.core_folders")
+            if "file" in value and not zipfile.is_zipfile(value["file"]):
+                raise ValidationError("file must be a valid ZIP archive", path="$.file")
 
 
 def f(type_name: str, **kwargs: Any) -> Field:
@@ -559,12 +570,12 @@ register("blackbox", "plugin", "edit", required({
 }, ("id",)))
 register("blackbox", "plugin", "update", required({
     "module_id": f("integer"), "name": f("string", nonempty=True), "type": f("integer", choices=(1, 2, 3)),
-    "game_versions": f("array", nonempty=True), "file": f("string", local_file=True), "file_url": f("string"),
+    "game_versions": f("array", nonempty=True), "file": f("string", local_file=True), "file_url": f("string", nonempty=True),
 }, ("module_id", "name", "type", "game_versions", "file")))
 register("blackbox", "version", "edit", required({
     "version_id": f("integer"), "module_id": f("integer"), "name": f("string", nonempty=True),
     "type": f("integer", choices=(1, 2, 3)), "game_versions": f("array", nonempty=True),
-    "file": f("string", local_file=True), "file_url": f("string"),
+    "file": f("string", local_file=True), "file_url": f("string", nonempty=True),
 }, ("version_id", "module_id", "name", "type", "game_versions")))
 register("blackbox", "version", "delete", required({
     "version_id": f("integer"), "module_id": f("integer"),

package/npm/lib/python-requirements.txt

@@ -1 +1,2 @@
 cos-python-sdk-v5==1.9.44
+playwright==1.62.0

package/npm/lib/python.mjs

@@ -82,45 +82,68 @@ function readMarker(root) {
   }
 }
 
-function probeRuntime(executable, run = spawnSync) {
+function runtimeEnvironment(root, env) {
+  return {
+    ...env,
+    PLAYWRIGHT_BROWSERS_PATH: path.join(root, "browsers"),
+  };
+}
+
+function probeRuntime(executable, root, env, run = spawnSync) {
   if (!fs.existsSync(executable)) {
     return null;
   }
   const result = run(executable, [
     "-c",
-    "import importlib.metadata,sys; import qcloud_cos; print('.'.join(map(str,sys.version_info[:3]))); print(importlib.metadata.version('cos-python-sdk-v5'))",
-  ], { encoding: "utf8", shell: false, windowsHide: true });
+    "import importlib.metadata,json,pathlib,sys; import qcloud_cos; from playwright.sync_api import sync_playwright; p=sync_playwright().start(); executable=p.chromium.executable_path; p.stop(); print(json.dumps({'python_version': '.'.join(map(str,sys.version_info[:3])), 'cos_version': importlib.metadata.version('cos-python-sdk-v5'), 'playwright_version': importlib.metadata.version('playwright'), 'chromium_executable': executable})); sys.exit(0 if pathlib.Path(executable).is_file() else 1)",
+  ], {
+    encoding: "utf8",
+    env: runtimeEnvironment(root, env),
+    shell: false,
+    windowsHide: true,
+  });
   if (result.status !== 0) {
     return null;
   }
-  const [pythonVersion, dependencyVersion] = result.stdout.trim().split(/\r?\n/);
-  const match = pythonVersion?.match(/^(\d+)\.(\d+)\.(\d+)$/);
-  if (!match || !dependencyVersion) {
+  let details;
+  try {
+    details = JSON.parse(result.stdout.trim());
+  } catch {
     return null;
   }
-  return { version: match.slice(1).map(Number), dependencyVersion };
+  const match = details.python_version?.match(/^(\d+)\.(\d+)\.(\d+)$/);
+  if (!match || !details.cos_version || !details.playwright_version || !details.chromium_executable) {
+    return null;
+  }
+  return {
+    version: match.slice(1).map(Number),
+    dependencyVersion: details.cos_version,
+    playwrightVersion: details.playwright_version,
+    chromiumExecutable: details.chromium_executable,
+  };
 }
 
-function inspectRuntime({ root, platform, requirementsHash, run }) {
+function inspectRuntime({ root, platform, requirementsHash, env, run }) {
   const marker = readMarker(root);
   if (marker?.schema !== PYTHON_RUNTIME_SCHEMA || marker.requirements_sha256 !== requirementsHash) {
     return null;
   }
   const command = pythonRuntimeExecutable(root, platform);
-  const probe = probeRuntime(command, run);
+  const probe = probeRuntime(command, root, env, run);
   if (!probe || probe.version[0] !== 3 || probe.version[1] < 9) {
     return null;
   }
-  return { command, args: [], version: probe.version, dependencyVersion: probe.dependencyVersion };
+  return { command, args: [], ...probe };
 }
 
 function bounded(value) {
   return String(value || "").trim().slice(0, 4000);
 }
 
-function runChecked(run, command, args, message) {
+function runChecked(run, command, args, message, options = {}) {
   const result = run(command, args, {
     encoding: "utf8",
+    ...options,
     shell: false,
     windowsHide: true,
   });
@@ -191,7 +214,7 @@ export function ensurePythonRuntime({
   const parent = path.dirname(root);
   const lock = acquireRuntimeLock(root);
   try {
-    const current = inspectRuntime({ root, platform, requirementsHash, run });
+    const current = inspectRuntime({ root, platform, requirementsHash, env, run });
     if (current) {
       return { status: "current", root, requirements, python: current };
     }
@@ -205,13 +228,19 @@ export function ensurePythonRuntime({
     const backup = path.join(parent, `.python-backup-${nonce}`);
     fs.mkdirSync(parent, { recursive: true });
     let movedOld = false;
+    let created;
     try {
       runChecked(run, base.command, [...base.args, "-m", "venv", staging], "Could not create the Fuploader Python runtime");
       const stagingPython = pythonRuntimeExecutable(staging, platform);
       runChecked(run, stagingPython, [
         "-m", "pip", "install", "--disable-pip-version-check", "--no-input", "--requirement", requirements,
       ], "Could not install Fuploader Python dependencies");
-      const installed = probeRuntime(stagingPython, run);
+      runChecked(run, stagingPython, [
+        "-m", "playwright", "install", "chromium",
+      ], "Could not install Fuploader Chromium", {
+        env: runtimeEnvironment(staging, env),
+      });
+      const installed = probeRuntime(stagingPython, staging, env, run);
       if (!installed) {
         throw new Error("The Fuploader Python runtime did not pass its dependency probe.");
       }
@@ -220,6 +249,8 @@ export function ensurePythonRuntime({
         requirements_sha256: requirementsHash,
         python_version: installed.version.join("."),
         dependency_version: installed.dependencyVersion,
+        playwright_version: installed.playwrightVersion,
+        chromium_executable: path.relative(staging, installed.chromiumExecutable),
       });
       if (fs.existsSync(root)) {
         fs.renameSync(root, backup);
@@ -234,16 +265,21 @@ export function ensurePythonRuntime({
         }
         throw error;
       }
+      created = inspectRuntime({ root, platform, requirementsHash, env, run });
+      if (!created) {
+        fs.rmSync(root, { recursive: true, force: true });
+        if (movedOld) {
+          fs.renameSync(backup, root);
+          movedOld = false;
+        }
+        throw new Error("The installed Fuploader Python runtime failed final validation.");
+      }
       if (movedOld) {
         fs.rmSync(backup, { recursive: true, force: true });
       }
     } finally {
       fs.rmSync(staging, { recursive: true, force: true });
     }
-    const created = inspectRuntime({ root, platform, requirementsHash, run });
-    if (!created) {
-      throw new Error("The installed Fuploader Python runtime failed final validation.");
-    }
     return { status: "installed", root, requirements, python: created };
   } finally {
     lock.release();

package/npm/skill-manifest.json

@@ -1,9 +1,9 @@
 {
   "schema": "fupload.npm-skill-manifest.v1",
   "package_name": "@follenfang/fupload",
-  "package_version": "0.0.5",
-  "skill_version": "0.0.5",
-  "tree_sha256": "0a6d0f91197fbaaff3266c7b78f6f894eb8eac38bdf899581909344393d79afd",
+  "package_version": "0.0.7",
+  "skill_version": "0.0.7",
+  "tree_sha256": "f2693bc26ecd3f9bab3ed691a2f372c5702b6ac5f72f52880fc6cee40ca90314",
   "files": [
     {
       "path": "agents/openai.yaml",
@@ -77,8 +77,8 @@
     },
     {
       "path": "references/blackbox.md",
-      "bytes": 2357,
-      "sha256": "022563a7611a5877761df71074ed347ef51fd27f735da7926cbb96d3b781dcc6"
+      "bytes": 2966,
+      "sha256": "ea95e8826af8e54c82343c404f9c97a611ab8ec3fb0282b561907c50169e4307"
     },
     {
       "path": "references/curseforge.md",
@@ -108,22 +108,22 @@
     {
       "path": "scripts/fupload_cli/__init__.py",
       "bytes": 49,
-      "sha256": "219d361d9b7f13dc9ff7f9eab399b0696fd3de9adcd6ecae755f5724262f12e6"
+      "sha256": "b44c52f9e6b2989921c93580a400ddcd3dd3e5c1cc787e9984baf0dabdfd93e7"
     },
     {
-      "path": "scripts/fupload_cli/blackbox_auth.py",
-      "bytes": 2874,
-      "sha256": "e018a33dce4babd1dc739af68c58499412474c7e1f1e3c0640dc53dbe46fce29"
+      "path": "scripts/fupload_cli/blackbox_web.py",
+      "bytes": 19392,
+      "sha256": "4a849fb297f045b81d261f4456542c165a3c0d9a77f963dbfcbc1c9dad8fec65"
     },
     {
       "path": "scripts/fupload_cli/blackbox.py",
-      "bytes": 12499,
-      "sha256": "5b46c38f8c5f8a352f261f2c3751b51f16827f62410d2124e0147073e8308350"
+      "bytes": 17089,
+      "sha256": "4487141898ba6a080d2120c1df9ad83c290528e9b462acb22d6c0f89dbbd117c"
     },
     {
       "path": "scripts/fupload_cli/cli.py",
-      "bytes": 25664,
-      "sha256": "d1327783aa0e4e27fcc1f71a80cd090f661feaf2e226688b2efa6a36b9645073"
+      "bytes": 25982,
+      "sha256": "79c5de939e3a7e7d0ed49d79fcce6c22e78c1a5abcf8eae5422dbd78f7c7bf2d"
     },
     {
       "path": "scripts/fupload_cli/curseforge.py",
@@ -167,8 +167,8 @@
     },
     {
       "path": "scripts/fupload_cli/schema.py",
-      "bytes": 36268,
-      "sha256": "db788d2422c0f6b50ce2795a3df75d5bf1e23934ba4211a64198de06931492a5"
+      "bytes": 37399,
+      "sha256": "5538eaf099bf9e7cae5f8142faecf827d41da698ae574b5597d17756da23e331"
     },
     {
       "path": "scripts/fupload_cli/transport.py",
@@ -187,8 +187,8 @@
     },
     {
       "path": "SKILL.md",
-      "bytes": 22890,
-      "sha256": "937bbee45d18e8ef257a8071f63951aede681628bb951e40793de81d763f85f3"
+      "bytes": 23242,
+      "sha256": "941f2c5f615dded9fcfe086516a9bf903f54db52351815c38d26c2691f71793b"
     }
   ]
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@follenfang/fupload",
-  "version": "0.0.5",
+  "version": "0.0.7",
   "description": "Install and run the Fuploader Agent Skill and Python CLI.",
   "type": "module",
   "bin": {

package/fupload/scripts/fupload_cli/blackbox_auth.py

@@ -1,54 +0,0 @@
-"""Authentication helpers for the Heybox desktop Workshop client."""
-from __future__ import annotations
-import hashlib, json, secrets, sqlite3, time
-from pathlib import Path
-from urllib.parse import parse_qs, urlparse
-from .errors import FuploadError
-
-API_BASE = "https://workshopapi.xiaoheihe.cn"
-_ALPHABET = "AB45STUVWZEFGJ6CH01D237IXYPQRKLMN89"
-
-def _n8(value: str, limit: int) -> str:
-    table = _ALPHABET[:limit]
-    return "".join(table[ord(ch) % len(table)] for ch in value)
-def _i8(value: str) -> str:
-    return "".join(_ALPHABET[ord(ch) % len(_ALPHABET)] for ch in value)
-def _interleave(parts):
-    return "".join(part[i] for i in range(max(map(len, parts))) for part in parts if i < len(part))
-def _mix(values):
-    def p(x): return ((x << 1) ^ 27) & 255 if x & 128 else (x << 1) & 255
-    def hm(x): return p(x) ^ x
-    def qg(x): return hm(p(x))
-    def dx(x): return qg(hm(p(x)))
-    def mw(x): return dx(x) ^ qg(x) ^ hm(x)
-    a,b,c,d,*rest=values
-    return [mw(a)^dx(b)^qg(c)^hm(d), hm(a)^mw(b)^dx(c)^qg(d), qg(a)^hm(b)^mw(c)^dx(d), dx(a)^qg(b)^hm(c)^mw(d), *rest]
-def hkey(path: str, timestamp: int, nonce: str) -> str:
-    normalized = "/" + "/".join(x for x in path.split("/") if x) + "/"
-    digest = hashlib.md5(_interleave([_n8(str(timestamp), -2), _i8(normalized), _i8(nonce)]).encode()).hexdigest()
-    return _n8(digest[:5], -4) + "%02d" % (sum(_mix([ord(x) for x in digest[-6:]])) % 100)
-
-def load_session(profile: Path | None = None):
-    profile = profile or Path.home() / "AppData/Roaming/heybox-pc-launcher"
-    db = profile / "Network/Cookies"
-    try:
-        with sqlite3.connect("file:%s?mode=ro" % db, uri=True) as con:
-            rows = con.execute("select name,value from cookies where host_key like '%xiaoheihe.cn'").fetchall()
-    except (OSError, sqlite3.Error) as exc:
-        raise FuploadError("Heybox desktop Cookie DB is missing", kind="authentication_error") from exc
-    cookies = {str(k): str(v) for k,v in rows if k in {"user_heybox_id","user_pkey","x_xhh_tokenid"} and v}
-    if not {"user_heybox_id","user_pkey","x_xhh_tokenid"} <= set(cookies):
-        raise FuploadError("Heybox desktop login state is incomplete", kind="authentication_error")
-    identity = {}
-    scope = profile / "sentry/scope_v3.json"
-    try:
-        crumbs = json.loads(scope.read_text(encoding="utf-8")).get("scope",{}).get("breadcrumbs",[])
-        for crumb in reversed(crumbs):
-            raw = crumb.get("data",{}).get("url","")
-            if "x_app=heybox_pc" in raw:
-                query = parse_qs(urlparse(raw).query)
-                allowed = {"x_client_type","x_os_type","x_app","version","exe_version","os_version","device_id","channel","heybox_id"}
-                identity = {k:v[-1] for k,v in query.items() if k in allowed and v}; break
-    except (OSError, ValueError, TypeError):
-        pass
-    return cookies, identity