@follenfang/fupload 0.0.10 → 0.0.11

package/fupload/SKILL.md

@@ -2,7 +2,7 @@
 name: fupload
 description: Explicit author-publishing workflow for World of Warcraft plugins, configuration shares, and WA/strings on NewBeeBox, NetEase DD, CurseForge, Heybox Workshop, and ModUs.Creator, including local Creator login reuse and plugin ZIP publishing. 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, ModUs, plugins, configurations, or WA.
 metadata:
-  version: "0.0.10"
+  version: "0.0.11"
 ---
 
 # Fupload

package/fupload/references/modus.md

@@ -27,6 +27,39 @@ The complete project model includes `project_id`, `name`, `alt_name`, `summary`,
 `required_tier_id`, `required_dependencies`, `cf_url`, returned `logo`, `status`,
 `game`, and `description`. Write inputs use `project_state`, `publish_platforms`,
 `logo_base64`, the compatibility `screenshot_base64s`, and edit-only `image_ops`.
+
+### Project field contract
+
+| CLI/state field | Creator wire/readback | JSON type | Required/default | Source and state dependency | Successful readback |
+| --- | --- | --- | --- | --- | --- |
+| `schema` | none | string | required by every write document | versioned CLI envelope | not sent |
+| `project_id` | `projectId` | positive integer | edit/delete required; create assigned by server | outer write document, not form state | `projectId` |
+| `game` | none confirmed | object or non-empty string | required; no default | `choose_game`; object needs a stable ID/key | preserved in state snapshot |
+| `name` | `name` | non-empty string | required; no default | `basic_info` | `name` |
+| `alt_name` | `altName` | string/null | optional; omitted preserves value | `basic_info`; edit clear uses `<null>` | `altName` |
+| `summary` | `summary` | non-empty string | required; no default | `basic_info` | `summary` |
+| `categories` | comma-delimited `categories` | 1-5 positive integer IDs | required; no default | service `categories` enum; `basic_info`; ID 998 requires BigFoot only | comma-delimited `categories` |
+| `publish_platforms` | derived `synchronizationType` | non-empty unique enum array | required; no default | `basic_info`; values `modus`, `bigfoot`, or both | integer `1`, `2`, or `3` |
+| `synchronization_type` | `synchronizationType` | integer | derived; caller value is replaced | derived from platform toggles in `basic_info` | `synchronizationType` |
+| `required_tier_id` | `requiredTierId` | null for this account | defaults to null | service `subscription-tiers` enum; current result is `[]`; BigFoot requires null | `requiredTierId: null` |
+| `repo_url` | `repoUrl` | string/null | optional; omitted preserves value | `basic_info`; create empty is omitted; edit clear uses `<null>` | `repoUrl` |
+| `logo_base64` | `screenshotBase64sReqs.screenshotBase64s` | base64 string | optional; default empty string | create-only `basic_info`; sent as `logo.webp` | server-managed `logo` path |
+| `screenshot_base64s` | same create logo payload | string array | compatibility alias; default empty array | create-only `basic_info`; first value is used when `logo_base64` is absent | server-managed `logo` path |
+| `license.type` | `license` JSON string `type` | non-empty string | required; no default | separate `license` step | parsed `license` |
+| `license.holder/year/content` | fields inside `license` JSON string | non-empty strings | optional except custom content | separate `license` step; custom requires content | parsed `license` |
+| `description` | `description` | string/null | edit-only; omitted preserves value | edit `basic_info`; clear uses `<null>` | `description` |
+| `required_dependencies` | `requiredDependencies` | string/null | edit-only; omitted preserves value | edit `basic_info`; clear uses `<null>`; dependency query is dynamic | `requiredDependencies` |
+| `images` | `images` | non-negative integer | edit-only; required with `image_ops` | edit `basic_info` | `images` count |
+| `image_ops` | `imagesOps` | operation array | edit-only; no default | edit `basic_info`; upload requires base64, delete forbids it | `images` count |
+| `cf_url` | `cfUrl` | string/null | read-only | known detail field may be preserved in a snapshot but is never sent | `cfUrl` |
+| `logo` | `logo` | string/object/null | read-only | server-managed detail field; create uses `logo_base64` instead | `logo` |
+| `status` | `status` | integer/null | read-only | server-managed detail field | `status` |
+| `project_state` | none | object | required and must be `complete` | wraps `choose_game -> basic_info -> license`; unknown nested fields are rejected | local resumable snapshot |
+
+Create-only, edit-only, and read-only fields may be preserved in a resumable
+snapshot, but `_project_wire` sends only fields supported by the selected API
+operation. The state machine rejects unknown `basic_info` and `license` fields
+before changing state.
 `publish_platforms` is a non-empty array containing `modus`,
 `bigfoot`, or both; the two values are not mutually exclusive. Creator derives
 wire `synchronizationType` as 1 for ModUs, 2 for BigFoot, and 3 for both.
@@ -64,7 +97,10 @@ Deletion requires `confirm: "DELETE"`.
 `transaction_log` optionally selects the redacted transaction record path.
 Successful records include the completed `file_id`, metadata, signature, and
 binary upload stages that ran; failed records include `failed_stage`, a redacted
-error, and whether the ZIP was retained. The provider parses every ZIP `.toc`
+error, and whether the ZIP was retained. The transaction record is established
+before file-ID allocation and ZIP preflight, so those early failures are also
+durable. Binary-upload errors expose only a query-free endpoint identifier,
+status when available, and a bounded redacted response summary. The provider parses every ZIP `.toc`
 `Interface` value to derive
 `toc_version` and `supported_game_versions`; explicit caller values must match.
 The provider validates the ZIP, computes `md5`, `zip_size`, and `unzip_size`,

package/fupload/scripts/fupload_cli/__init__.py

@@ -1,3 +1,3 @@
 """Fupload Python CLI."""
 
-__version__ = "0.0.10"
+__version__ = "0.0.11"

package/fupload/scripts/fupload_cli/modus.py

@@ -633,12 +633,21 @@ class ModUs:
         if size > MAX_PACKAGE_BYTES:
             raise ValidationError("release ZIP exceeds the 200 MB upload limit", path=file_path)
         parsed = urllib.parse.urlsplit(signed_url)
+        if parsed.scheme not in ("http", "https") or not parsed.hostname:
+            raise ValidationError("release upload URL must be HTTP(S)", path="signed_url")
+        # The query carries the object-store signature.  Keep a useful endpoint
+        # in errors without ever persisting that credential material.
+        endpoint_host = parsed.hostname
+        if parsed.port is not None:
+            endpoint_host = "%s:%d" % (endpoint_host, parsed.port)
+        endpoint = urllib.parse.urlunsplit((parsed.scheme, endpoint_host, parsed.path or "/", "", ""))
         conn_cls = http.client.HTTPSConnection if parsed.scheme == "https" else http.client.HTTPConnection
-        if parsed.scheme == "https":
-            conn = conn_cls(parsed.hostname, parsed.port, timeout=max(self.timeout, 600), context=ssl.create_default_context())
-        else:
-            conn = conn_cls(parsed.hostname, parsed.port, timeout=max(self.timeout, 600))
+        conn = None
         try:
+            if parsed.scheme == "https":
+                conn = conn_cls(parsed.hostname, parsed.port, timeout=max(self.timeout, 600), context=ssl.create_default_context())
+            else:
+                conn = conn_cls(parsed.hostname, parsed.port, timeout=max(self.timeout, 600))
             conn.putrequest("PUT", urllib.parse.urlunsplit(("", "", parsed.path or "/", parsed.query, "")))
             conn.putheader("Content-Type", "application/zip")
             conn.putheader("Content-Length", str(size))
@@ -650,15 +659,33 @@ class ModUs:
                         break
                     conn.send(chunk)
             response = conn.getresponse()
-            response.read()
+            raw = response.read(4096)
             if response.status < 200 or response.status >= 300:
-                raise FuploadError("ModUs binary upload returned HTTP %d" % response.status, http_status=response.status, verification_required=True, stage="binary_upload")
+                summary = redact(raw.decode("utf-8", errors="replace")) if raw else "<empty>"
+                raise FuploadError(
+                    "ModUs binary upload returned HTTP %d" % response.status,
+                    endpoint=endpoint,
+                    http_status=response.status,
+                    verification_required=True,
+                    stage="binary_upload",
+                    details={"response_summary": summary},
+                )
         except FuploadError:
             raise
-        except OSError as exc:
-            raise FuploadError("ModUs binary upload failed: %s" % exc, verification_required=True, stage="binary_upload") from exc
+        except (OSError, http.client.HTTPException) as exc:
+            raise FuploadError(
+                "ModUs binary upload failed",
+                endpoint=endpoint,
+                verification_required=True,
+                stage="binary_upload",
+                details={"response_summary": redact(str(exc)) or exc.__class__.__name__},
+            ) from exc
         finally:
-            conn.close()
+            if conn is not None:
+                try:
+                    conn.close()
+                except OSError:
+                    pass
         return {"status": "uploaded", "archive": path.name, "bytes": size}
 
     def release_delete(self, project_id: int, file_id: int) -> Any:
@@ -666,70 +693,108 @@ class ModUs:
 
     def publish(self, doc: Mapping[str, Any], *, update: bool = False) -> Dict[str, Any]:
         project_id = _positive_id(doc["project_id"], field="project_id")
-        allocated_file_id = not bool(doc.get("file_id"))
-        file_id = _positive_id(doc.get("file_id") or self.release_file_id(project_id), field="file_id")
-        metadata = {k: doc[k] for k in ("project_id", "version", "type", "supported_game_versions", "toc_version", "changelog", "path") if k in doc}
-        metadata["file_id"] = file_id
         file_path = doc.get("file")
-        if file_path is None and not update:
-            raise ValidationError("release ZIP file is required", path="file")
         archive = Path(str(file_path)) if file_path is not None else None
-        if archive is not None:
-            if not archive.is_file():
-                raise ValidationError("release ZIP file does not exist", path=str(file_path))
-            size = archive.stat().st_size
-            if size > MAX_PACKAGE_BYTES:
-                raise ValidationError("release ZIP exceeds the 200 MB upload limit", path=str(file_path))
-            md5 = hashlib.md5(archive.read_bytes()).hexdigest()
-            try:
-                unzip_size = sum(info.file_size for info in zipfile.ZipFile(str(archive)).infolist())
-            except (OSError, zipfile.BadZipFile) as exc:
-                raise ValidationError("release file is not a valid ZIP", path=str(file_path)) from exc
-            derived = parse_modus_zip(archive)
-            supplied_toc = doc.get("toc_version")
-            supplied_games = doc.get("supported_game_versions")
-            if supplied_toc is not None and str(supplied_toc) != derived["toc_version"]:
-                raise ValidationError("toc_version does not match the ZIP Interface field", path="$.toc_version")
-            if supplied_games is not None and _supported_game_versions(supplied_games) != derived["supported_game_versions"]:
-                raise ValidationError("supported_game_versions does not match the ZIP Interface field", path="$.supported_game_versions")
-            metadata.update({
-                "md5": md5,
-                "zip_size": size,
-                "unzip_size": unzip_size,
-                "toc_version": derived["toc_version"],
-                "supported_game_versions": derived["supported_game_versions"],
-                "path": doc.get("path") or archive.name,
-            })
+        supplied_file_id = doc.get("file_id")
         transaction: Dict[str, Any] = {
             "schema": "fupload.v1.modus.upload-transaction",
             "created_at": int(time.time()),
             "project_id": project_id,
-            "file_id": file_id,
+            "file_id": None,
             "update": bool(update),
             "archive": str(archive) if archive is not None else None,
-            "stages": ["file_id"] if allocated_file_id else [],
+            "stages": [],
         }
         transaction_path = Path(str(doc.get("transaction_log") or ((str(archive) + ".modus-transaction.json") if archive else "modus-transaction.json")))
 
         def save_transaction() -> None:
             transaction_path.write_text(json.dumps(transaction, ensure_ascii=False, indent=2), encoding="utf-8")
 
+        # Establish the audit record before reserving a file ID or validating
+        # the archive so every publish failure has a durable transaction.
         try:
-            transaction["stages"].append("release_metadata_update" if update else "release_metadata")
+            save_transaction()
+        except OSError as exc:
+            raise FuploadError(
+                "ModUs upload transaction could not be written",
+                stage="transaction_log",
+                details={"path": str(transaction_path)},
+            ) from exc
+
+        current_stage = "prepare"
+        try:
+            allocated_file_id = not bool(supplied_file_id)
+            current_stage = "file_id"
+            transaction["active_stage"] = current_stage
+            save_transaction()
+            if allocated_file_id:
+                transaction["stages"].append("file_id")
+                file_id = _positive_id(self.release_file_id(project_id), field="file_id")
+            else:
+                file_id = _positive_id(supplied_file_id, field="file_id")
+            transaction["file_id"] = file_id
+
+            metadata = {k: doc[k] for k in ("project_id", "version", "type", "supported_game_versions", "toc_version", "changelog", "path") if k in doc}
+            metadata["file_id"] = file_id
+            current_stage = "zip_preflight"
+            transaction["active_stage"] = current_stage
+            save_transaction()
+            if archive is None and not update:
+                raise ValidationError("release ZIP file is required", path="file")
+            if archive is not None:
+                if not archive.is_file():
+                    raise ValidationError("release ZIP file does not exist", path=str(file_path))
+                size = archive.stat().st_size
+                if size > MAX_PACKAGE_BYTES:
+                    raise ValidationError("release ZIP exceeds the 200 MB upload limit", path=str(file_path))
+                md5 = hashlib.md5(archive.read_bytes()).hexdigest()
+                try:
+                    unzip_size = sum(info.file_size for info in zipfile.ZipFile(str(archive)).infolist())
+                except (OSError, zipfile.BadZipFile) as exc:
+                    raise ValidationError("release file is not a valid ZIP", path=str(file_path)) from exc
+                derived = parse_modus_zip(archive)
+                supplied_toc = doc.get("toc_version")
+                supplied_games = doc.get("supported_game_versions")
+                if supplied_toc is not None and str(supplied_toc) != derived["toc_version"]:
+                    raise ValidationError("toc_version does not match the ZIP Interface field", path="$.toc_version")
+                if supplied_games is not None and _supported_game_versions(supplied_games) != derived["supported_game_versions"]:
+                    raise ValidationError("supported_game_versions does not match the ZIP Interface field", path="$.supported_game_versions")
+                metadata.update({
+                    "md5": md5,
+                    "zip_size": size,
+                    "unzip_size": unzip_size,
+                    "toc_version": derived["toc_version"],
+                    "supported_game_versions": derived["supported_game_versions"],
+                    "path": doc.get("path") or archive.name,
+                })
+            current_stage = "release_metadata_update" if update else "release_metadata"
+            transaction["stages"].append(current_stage)
+            transaction["active_stage"] = current_stage
+            save_transaction()
             result = self.release_metadata(metadata, update=update)
             if archive is None:
+                transaction.pop("active_stage", None)
                 transaction.update({"completed": True, "upload": None})
                 save_transaction()
                 return {"project_id": project_id, "file_id": file_id, "metadata": result, "upload": None, "transaction": _safe(transaction)}
-            transaction["stages"].append("signature")
+            current_stage = "signature"
+            transaction["stages"].append(current_stage)
+            transaction["active_stage"] = current_stage
+            save_transaction()
             signed = self.release_signature(project_id, file_id)
-            transaction["stages"].append("binary_upload")
+            current_stage = "binary_upload"
+            transaction["stages"].append(current_stage)
+            transaction["active_stage"] = current_stage
+            save_transaction()
             uploaded = self.upload_zip(signed, str(archive))
+            transaction.pop("active_stage", None)
             transaction.update({"completed": True, "upload": uploaded})
             save_transaction()
             return {"project_id": project_id, "file_id": file_id, "metadata": result, "upload": uploaded, "transaction": _safe(transaction)}
         except FuploadError as exc:
-            transaction["failed_stage"] = exc.stage or transaction["stages"][-1] if transaction["stages"] else "prepare"
+            if exc.stage in (None, "dependency_get"):
+                exc.stage = current_stage
+            transaction["failed_stage"] = exc.stage or current_stage
             transaction["error"] = exc.as_dict()
             transaction["retained_archive"] = bool(archive and archive.is_file())
             try:
@@ -737,6 +802,20 @@ class ModUs:
             except OSError:
                 pass
             raise
+        except OSError as exc:
+            wrapped = FuploadError(
+                "ModUs upload preparation failed",
+                stage=current_stage,
+                details={"response_summary": redact(str(exc)) or exc.__class__.__name__},
+            )
+            transaction["failed_stage"] = current_stage
+            transaction["error"] = wrapped.as_dict()
+            transaction["retained_archive"] = bool(archive and archive.is_file())
+            try:
+                save_transaction()
+            except OSError:
+                pass
+            raise wrapped from exc
 
     def execute_read(self, resource: str, action: str, args: Any = None) -> Any:
         if resource == "session" and action == "doctor": return self.doctor()

package/fupload/scripts/fupload_cli/state_machine.py

@@ -41,6 +41,17 @@ COMPLETE = ProjectStep.COMPLETE.value
 _SCHEMA = "fupload.v1.modus.project-state"
 _PLATFORMS = ("modus", "bigfoot")
 _BIGFOOT_EXCLUSIVE_CATEGORY_ID = 998
+_BASIC_INFO_KEYS = {
+    # Shared create/edit form fields.
+    "schema", "name", "project_name", "alt_name", "summary", "categories",
+    "synchronization_type", "publish_platforms", "publishPlatforms",
+    "required_tier_id", "requiredTierId", "repo_url",
+    # Create-only image fields and edit-only detail/image fields.
+    "logo_base64", "screenshot_base64s", "description",
+    "required_dependencies", "images", "image_ops",
+    # Known project-detail readback fields preserved in resumable snapshots.
+    "cf_url", "logo", "status",
+}
 _LICENSE_KEYS = {
     "type", "template", "license_template", "licenseTemplate",
     "holder", "copyright_holder", "copyrightHolder",
@@ -49,6 +60,15 @@ _LICENSE_KEYS = {
 }
 
 
+def _basic_info_fields(value: Mapping[str, Any]) -> None:
+    unknown = sorted(set(value) - _BASIC_INFO_KEYS)
+    if unknown:
+        raise ValidationError(
+            "unknown basic_info field(s): %s" % ", ".join(unknown),
+            path="$.basic_info.%s" % unknown[0],
+        )
+
+
 def _nonempty_text(value: Any, *, path: str) -> str:
     if not isinstance(value, str) or not value.strip():
         raise ValidationError("value must be a non-empty string", path=path)
@@ -194,6 +214,7 @@ class ProjectStateMachine:
         self._require(ProjectStep.BASIC_INFO)
         value: Dict[str, Any] = dict(info or {})
         value.update(fields)
+        _basic_info_fields(value)
         name = value.get("name", value.get("project_name"))
         summary = value.get("summary")
         _nonempty_text(name, path="$.basic_info.name")
@@ -288,26 +309,33 @@ class ProjectStateMachine:
         game = snapshot.get("game")
         basic = snapshot.get("basic_info") or {}
         lic = snapshot.get("license") or {}
+        restored_game: Any = None
+        restored_basic: Dict[str, Any] = {}
+        restored_license: Dict[str, Any] = {}
         if state != CHOOSE_GAME:
-            self._game = _game(game)
+            restored_game = _game(game)
         if state in {LICENSE, COMPLETE}:
             if not isinstance(basic, Mapping):
                 raise ValidationError("basic_info must be an object", path="$.basic_info")
-            self._basic_info = dict(basic)
-            _nonempty_text(self._basic_info.get("name"), path="$.basic_info.name")
-            _nonempty_text(self._basic_info.get("summary"), path="$.basic_info.summary")
-            self._basic_info["publish_platforms"] = _platforms(self._basic_info.get("publish_platforms"))
-            self._basic_info["categories"] = _categories(self._basic_info.get("categories"))
-            self._basic_info["required_tier_id"] = _required_tier(self._basic_info.get("required_tier_id"))
-            if _BIGFOOT_EXCLUSIVE_CATEGORY_ID in self._basic_info["categories"] and self._basic_info["publish_platforms"] != ["bigfoot"]:
+            restored_basic = dict(basic)
+            _basic_info_fields(restored_basic)
+            _nonempty_text(restored_basic.get("name"), path="$.basic_info.name")
+            _nonempty_text(restored_basic.get("summary"), path="$.basic_info.summary")
+            restored_basic["publish_platforms"] = _platforms(restored_basic.get("publish_platforms"))
+            restored_basic["categories"] = _categories(restored_basic.get("categories"))
+            restored_basic["required_tier_id"] = _required_tier(restored_basic.get("required_tier_id"))
+            if _BIGFOOT_EXCLUSIVE_CATEGORY_ID in restored_basic["categories"] and restored_basic["publish_platforms"] != ["bigfoot"]:
                 raise ValidationError("category 998 requires bigfoot as the only publish platform", path="$.basic_info.publish_platforms")
-            if "bigfoot" in self._basic_info["publish_platforms"] and self._basic_info["required_tier_id"] is not None:
+            if "bigfoot" in restored_basic["publish_platforms"] and restored_basic["required_tier_id"] is not None:
                 raise ValidationError("required_tier_id must be null when bigfoot is selected", path="$.basic_info.required_tier_id")
-            derived_sync_type = (1 if "modus" in self._basic_info["publish_platforms"] else 0) | (2 if "bigfoot" in self._basic_info["publish_platforms"] else 0)
-            if self._basic_info.get("synchronization_type") != derived_sync_type:
+            derived_sync_type = (1 if "modus" in restored_basic["publish_platforms"] else 0) | (2 if "bigfoot" in restored_basic["publish_platforms"] else 0)
+            if restored_basic.get("synchronization_type") != derived_sync_type:
                 raise ValidationError("synchronization_type must match publish_platforms", path="$.basic_info.synchronization_type")
         if state == COMPLETE:
-            self._license = _license(lic)
+            restored_license = _license(lic)
+        self._game = restored_game
+        self._basic_info = restored_basic
+        self._license = restored_license
         self._step = str(state)
 
     def save(self, path: Union[str, os.PathLike[str]]) -> Path:

package/npm/skill-manifest.json

@@ -1,9 +1,9 @@
 {
   "schema": "fupload.npm-skill-manifest.v1",
   "package_name": "@follenfang/fupload",
-  "package_version": "0.0.10",
-  "skill_version": "0.0.10",
-  "tree_sha256": "38621aa4709de68a1cc298c8183fe0a5647c8291b870defdbbb5f54d184fa94a",
+  "package_version": "0.0.11",
+  "skill_version": "0.0.11",
+  "tree_sha256": "a0d589cb5d67c7bfbd34862ee4c3109e88068662ae3b7430c0635e71ace9a8d9",
   "files": [
     {
       "path": "agents/openai.yaml",
@@ -92,8 +92,8 @@
     },
     {
       "path": "references/modus.md",
-      "bytes": 4492,
-      "sha256": "0b9cf6c4b3bc7aa37a3649ec6ccb6c8b8aa3d077c8febc2635548546150df356"
+      "bytes": 8705,
+      "sha256": "10c2db10ade101c6738d9007865db68da54892da59fc1cc0fc1a422296a4bf07"
     },
     {
       "path": "references/newbee-official-cli.md",
@@ -113,7 +113,7 @@
     {
       "path": "scripts/fupload_cli/__init__.py",
       "bytes": 50,
-      "sha256": "3f1afb95137eaedc622bb437c9c8a01bdaa729b911f3749e400a429d24abaaa2"
+      "sha256": "c7d5308bddd21b0e8042689cdeaba91ba45170a998f42844d42f88b7248fc057"
     },
     {
       "path": "scripts/fupload_cli/blackbox_web.py",
@@ -167,8 +167,8 @@
     },
     {
       "path": "scripts/fupload_cli/modus.py",
-      "bytes": 38821,
-      "sha256": "f5edb6898ce515a7e34f0fcab3dc022c2c5185f548644eabf5291e38b22dae22"
+      "bytes": 42241,
+      "sha256": "ee298b064f4b3c4a25081f76e93d48b18f1b810f647437e78d78a4a20ab5bd5c"
     },
     {
       "path": "scripts/fupload_cli/newbee_auth.py",
@@ -187,8 +187,8 @@
     },
     {
       "path": "scripts/fupload_cli/state_machine.py",
-      "bytes": 15325,
-      "sha256": "02f37b745bbb70860c09563b6778014bd1c69ca06ba28777415ad7ce84d02610"
+      "bytes": 16450,
+      "sha256": "da26b63be4e085b9b39aea4d13a2c58206836d98fa46400b243113ce4b1ff4a9"
     },
     {
       "path": "scripts/fupload_cli/transport.py",
@@ -208,7 +208,7 @@
     {
       "path": "SKILL.md",
       "bytes": 25720,
-      "sha256": "2e20b91ded57f4d91dbb658abf6fedc636785cc1b3ada23f985c9241c53cd3e6"
+      "sha256": "cfc3ce770c3594c5a787b25da03cb2e92e0f6ea6fbd162f26f4b6b3c44295a89"
     }
   ]
 }

package/package.json

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