@follenfang/fupload 0.0.6 → 0.0.8

package/npm/lib/python.mjs

@@ -46,9 +46,13 @@ export function discoverPython({ platform = process.platform, minimumMinor = 9 }
 }
 
 export function runPython(python, script, args, options = {}) {
-  return spawnSync(python.command, [...python.args, script, ...args], {
+  const run = options.run || spawnSync;
+  const env = options.runtimeRoot
+    ? runtimeEnvironment(options.runtimeRoot, options.env || process.env)
+    : options.env || process.env;
+  return run(python.command, [...python.args, script, ...args], {
     cwd: options.cwd || process.cwd(),
-    env: options.env || process.env,
+    env,
     stdio: options.stdio || "inherit",
     encoding: options.encoding,
     shell: false,
@@ -82,45 +86,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 +218,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 +232,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 +253,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 +269,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.6",
-  "skill_version": "0.0.6",
-  "tree_sha256": "89170e9d93a44d9aa72a1c041f93d941609eb9d762375358090c5a96129405d9",
+  "package_version": "0.0.8",
+  "skill_version": "0.0.8",
+  "tree_sha256": "19b487eaba532263a849d4bfd48f4f40166edbf156f5317e5dbcc040fdc9819e",
   "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": "acf9b050750b58742981c5b9ae836149b89bb86daad01d18dd1948e71817d2c2"
+      "sha256": "7f13892a82918a297a8af731adf5b20a540dd3a873d089bf133225a0a642a840"
     },
     {
-      "path": "scripts/fupload_cli/blackbox_auth.py",
-      "bytes": 7211,
-      "sha256": "797ca228c57d2b845a7105f132891b71d3e494adcdb8f44027ce835125206177"
+      "path": "scripts/fupload_cli/blackbox_web.py",
+      "bytes": 19392,
+      "sha256": "4a849fb297f045b81d261f4456542c165a3c0d9a77f963dbfcbc1c9dad8fec65"
     },
     {
       "path": "scripts/fupload_cli/blackbox.py",
-      "bytes": 16666,
-      "sha256": "c6a793cacc7d9ceb8995cac62a076c1944345eaa113bed21068c75a05b1b0ee6"
+      "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": "af700f4e6eb924d955c8e5ae1205934c0bc08b425c85ce5f279eb0c630a0f77a"
+      "bytes": 23242,
+      "sha256": "ad3813733c9fd7aac62683f704bf1adc25982b6d45a14e4d749b6734a2bee3c3"
     }
   ]
 }

package/package.json

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

package/fupload/scripts/fupload_cli/blackbox_auth.py

@@ -1,159 +0,0 @@
-"""Authentication helpers for the Heybox desktop Workshop client."""
-from __future__ import annotations
-import hashlib, json, platform, secrets, sqlite3, time
-from pathlib import Path
-from urllib.parse import parse_qs, urlparse
-from .errors import FuploadError
-
-API_BASE = "https://workshopapi.xiaoheihe.cn"
-CLIENT_VERSION = "1.14.1"
-_CONFIG_AES_KEY = bytes.fromhex("5f1d7f11e6e90dbb5c2f0c1e614a6a8c4b9e16b50fa724e4c54d6f25b1208b93")
-_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 _decrypt_user_pkey(value: str) -> str:
-    """Decrypt the desktop config's ``iv:ciphertext`` AES-256-CBC value.
-
-    Older Chromium cookie databases contain the already decrypted pkey, so this
-    helper deliberately returns ordinary values unchanged and only attempts
-    crypto for the new config format.
-    """
-    if not isinstance(value, str) or ":" not in value:
-        return value
-    iv_hex, ciphertext_hex = value.split(":", 1)
-    try:
-        iv = bytes.fromhex(iv_hex)
-        ciphertext = bytes.fromhex(ciphertext_hex)
-        if len(iv) != 16 or not ciphertext or len(ciphertext) % 16:
-            return value
-    except ValueError:
-        return value
-    try:
-        from Crypto.Cipher import AES
-        plaintext = AES.new(_CONFIG_AES_KEY, AES.MODE_CBC, iv).decrypt(ciphertext)
-    except ImportError:
-        try:
-            from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
-            decryptor = Cipher(algorithms.AES(_CONFIG_AES_KEY), modes.CBC(iv)).decryptor()
-            plaintext = decryptor.update(ciphertext) + decryptor.finalize()
-        except ImportError as exc:
-            raise FuploadError(
-                "AES support is required to read the Heybox desktop session",
-                kind="environment_error",
-                details={"install": "Crypto or cryptography"},
-            ) from exc
-    if not plaintext:
-        return value
-    pad = plaintext[-1]
-    if not 1 <= pad <= 16 or plaintext[-pad:] != bytes([pad]) * pad:
-        raise FuploadError("Heybox desktop pkey could not be decrypted", kind="authentication_error")
-    try:
-        return plaintext[:-pad].decode("utf-8")
-    except UnicodeDecodeError as exc:
-        raise FuploadError("Heybox desktop pkey is invalid", kind="authentication_error") from exc
-
-
-def _read_json(path: Path) -> dict:
-    try:
-        data = json.loads(path.read_text(encoding="utf-8"))
-    except (OSError, UnicodeError, ValueError):
-        return {}
-    return data if isinstance(data, dict) else {}
-
-
-def _load_cookie_db(profile: Path) -> dict[str, str]:
-    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):
-        return {}
-    return {str(k): str(v) for k, v in rows if k in {"user_heybox_id", "user_pkey", "x_xhh_tokenid"} and v}
-
-
-def _read_sentry_identity(profile: Path) -> dict[str, str]:
-    identity: dict[str, str] = {}
-    scope = profile / "sentry/scope_v3.json"
-    try:
-        crumbs = _read_json(scope).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 = {
-                    "app", "client_type", "device_id", "exe_version", "heybox_id",
-                    "os_type", "os_version", "version", "web_version", "x_app",
-                    "x_client_type", "x_client_version", "x_os_type",
-                }
-                identity = {k: v[-1] for k, v in query.items() if k in allowed and v}
-                break
-    except (OSError, ValueError, TypeError):
-        pass
-    return identity
-
-
-def load_session(profile: Path | None = None):
-    """Load the current desktop session without exposing credential material.
-
-    Heybox 1.14 stores its authoritative session in ``config.json``.  The
-    Chromium database is retained as a compatibility fallback because older
-    installations and upgrade paths may not have written the new config yet.
-    """
-    profile = profile or Path.home() / "AppData/Roaming/heybox-pc-launcher"
-    config = _read_json(profile / "config.json")
-    db_cookies = _load_cookie_db(profile)
-    cookies: dict[str, str] = dict(db_cookies)
-    config_cookies = config.get("cookies")
-    if isinstance(config_cookies, list):
-        for item in config_cookies:
-            if not isinstance(item, dict):
-                continue
-            name, value = item.get("name"), item.get("value")
-            if isinstance(name, str) and isinstance(value, str) and value:
-                if name in {"user_heybox_id", "user_pkey", "x_xhh_tokenid"}:
-                    cookies[name] = value
-    acc_config = config.get("acc_config")
-    if isinstance(acc_config, dict) and acc_config.get("xhh_token_id"):
-        cookies["x_xhh_tokenid"] = str(acc_config["xhh_token_id"])
-    if cookies.get("user_pkey"):
-        cookies["user_pkey"] = _decrypt_user_pkey(cookies["user_pkey"])
-    account = config.get("account") if isinstance(config.get("account"), dict) else {}
-    if not cookies.get("user_heybox_id") and account.get("heybox_id"):
-        cookies["user_heybox_id"] = str(account["heybox_id"])
-    if not {"user_heybox_id", "user_pkey", "x_xhh_tokenid"} <= set(cookies):
-        raise FuploadError("Heybox desktop login state is incomplete", kind="authentication_error")
-
-    identity = _read_sentry_identity(profile)
-    version = identity.get("version") or CLIENT_VERSION
-    identity = {
-        "x_client_type": "pc",
-        "x_os_type": "Windows",
-        "x_app": "heybox_pc",
-        "version": version,
-        "exe_version": identity.get("exe_version") or version,
-        "os_version": identity.get("os_version") or platform.platform(aliased=True),
-        **identity,
-    }
-    identity["version"] = version
-    identity["exe_version"] = identity.get("exe_version") or version
-    identity["heybox_id"] = cookies["user_heybox_id"]
-    return cookies, identity