@follenfang/fupload 0.0.10 → 0.0.12

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.12"
 ---
 
 # Fupload

package/fupload/references/modus.md

@@ -19,6 +19,11 @@ game/data/config/detail` with a JSON `{"keys": [...]}` body. Repeat `--key`
 to request selected server-defined configuration keys; at least one key is
 required because the service rejects an empty list.
 
+Main-client form choices are available through `modus options config-tags`,
+`modus options wa-tags`, and `modus options wa-support-addons`. These commands
+read the official ModUs static client-data origin without sending the local
+login token.
+
 ## Project writes
 
 `modus project create|edit|delete` uses versioned JSON through `--input`.
@@ -27,10 +32,43 @@ 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` | nullable positive integer input | omitted means no tier | service `subscription-tiers` enum; current result is `[]`; BigFoot requires no tier | omitted from the wire for no tier |
+| `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.
-When BigFoot is selected, `required_tier_id` must be null. Category ID 998 is
+When BigFoot is selected, `required_tier_id` must be null or omitted. Category ID 998 is
 BigFoot-exclusive and forces BigFoot as the only platform. `categories` contains
 one to five positive integer IDs.
 
@@ -51,8 +89,9 @@ local form state, not project update keys.
 `project_state` is a resumable `choose_game` -> `basic_info` -> `license` ->
 `complete` snapshot and is required for both create and edit; incomplete or
 missing snapshots are rejected before dry-run or network access. Each step preserves
-its state on validation failure. `required_tier_id` is null for the explicit
-no-tier branch or a positive dropdown ID.
+its state on validation failure. `required_tier_id` is null or omitted for the
+no-tier branch and is omitted from the HTTP payload; a selected tier is a
+positive dropdown ID.
 The write document also accepts `confirm` for destructive operations.
 Deletion requires `confirm: "DELETE"`.
 
@@ -64,7 +103,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`,
@@ -75,3 +117,78 @@ never substituted for the binary upload. Release deletion requires
 
 All write commands support `--dry-run`, which validates the versioned JSON and
 local files without constructing an authenticated provider or making a request.
+
+## Main ModUs client: configuration shares
+
+The installed main client stores its Chromium session under `%APPDATA%\modus\Local Storage\leveldb`.
+Fupload reads the persisted `token`/`deviceId` pair and calls the fixed
+`https://app.modus.cool/api` origin with the raw `Authorization` value and
+`X-Device-Id`; values are never printed. The Creator DPAPI store remains a
+separate authentication source for `project` and `plugin` commands.
+
+The configuration surface uses:
+
+* `GET /system/user/backup/list`, `GET /system/user/backup/detail/{id}`
+* `POST /system/user/backup/update`, `DELETE /system/user/backup/delete/{id}`
+* `POST /system/user/share/list`, `POST /system/user/share/detail`
+* `POST /system/user/share/create`, `PUT /system/user/share/update`,
+  `DELETE /system/user/share/delete/{id}`
+
+Share write fields are `share_id`, `addons_id`, `account_name`, `backup_id`,
+`content`, `content_text`, `image_url`, `is_paid`, `is_public`, `price`,
+`share_type`, `tags`, `title`, `exclude_wtf`, `role_name`,
+`required_tier_id`, `sub_type`, optional low-level `platform` /
+`synchronization_type`, and
+`server_type`. `exclude_wtf` is a binary state: when it is `1`, account and
+role are empty; when it is `0`, an account is required and a selected role is
+optional. `sub_type=0` is the normal subscription mode; `sub_type=1` is the
+season mode. Both modes allow the "none" tier represented by null or omitted
+`required_tier_id`; Fupload omits `requiredTierId` from the wire in that branch.
+A selected tier must be a positive ID returned by the service. The official
+configuration form's submit object omits `platform` and `synchronizationType`.
+Fupload's low-level API surface nevertheless exposes the backend fields: list
+defaults `platform=0`, create defaults `platform=1` and
+`synchronizationType=1`, and explicit low-level values are passed through.
+`backup_id`, content, cover, title, and tags are required for create;
+update is presence-aware and uses `share_id`. `addons_id` must be non-empty,
+the trimmed title must contain at least 6 characters, tags contain 1 to 3
+comma-delimited IDs, and plain `content_text` must contain more than 20
+characters.
+
+Backup rename uses `backup_id`, `backup_name`, and `server_type`; backup
+deletion uses `backup_id`, `confirm`, and `server_type`.
+
+## Main ModUs client: strings
+
+String articles use:
+
+* `POST /system/user/import/list`, `POST /system/user/import/detail`
+* `POST /system/user/import/create`, `POST /system/user/import/update`
+* `DELETE /system/user/import/delete/{id}`
+* `POST /system/user/import/version/publish`
+* `DELETE /system/user/import/version/delete?versionId={id}`
+
+String fields are `import_id`, `code_text`, `content`, `addons_id`,
+`content_text`, `file_path`, `image_url`, `is_paid`, `is_public`, `price`,
+`share_type`, `support_addon`, `tags`, `title`, `version`, `required_tier_id`,
+`sub_type`, and `server_type`. The client requires a supported addon,
+non-empty rendered/plain article content, cover, title, tags, and version.
+`sub_type` and `required_tier_id` follow the same normal/season state machine.
+The current account uses the no-tier branch, so `requiredTierId` is absent from
+the wire. The official string form's submit object omits `platform` and
+`synchronizationType`; Fupload's low-level API surface defaults list
+`platform=0` and create/update `platform=1` / `synchronizationType=1`, while
+preserving explicit values.
+The trimmed title must contain at least 6 characters, tags contain 1 to 3
+comma-delimited IDs, plain `content_text` must contain more than 20 characters,
+and `file_path` is the client's fixed empty string. Version history is separate
+from article metadata:
+`version-publish` takes `import_id`, `version`, `code_text`, and optional
+`changelog`; `version-delete` takes `version_id` and `confirm: "DELETE"`.
+
+Both main-client modules support explicit `confirm: "DELETE"` on destructive
+commands. List operations send only server fields (`pageNum`, `pageSize`,
+`keyword`, status/filter values), not the local CLI envelope or `server_type`.
+### Main-client resource IDs and deletion
+
+Configuration-share and string/import IDs are opaque decimal strings (for example, 16-digit IDs), not the numeric backup/project IDs. Fupload preserves them as strings. ModUs delete is a soft-delete: a successful `DELETE` returns code `200`, and a subsequent detail may return the record with `status=4` and `isPublic=0`; regression treats that state as deleted.

package/fupload/scripts/fupload_cli/__init__.py

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

package/fupload/scripts/fupload_cli/cli.py

@@ -30,11 +30,11 @@ schema exposes them. The calling Skill must show the complete plan and obtain co
 """
 
 
-def _modus_provider(*, authenticate: bool = True) -> Any:
+def _modus_provider(*, authenticate: bool = True, main_session: bool = False) -> Any:
     # Keep ModUs optional at import time so existing platform commands remain
     # usable while the provider is installed or upgraded independently.
     from .modus import Modus
-    return Modus(authenticate=authenticate)
+    return Modus(authenticate=authenticate, main_session=main_session)
 
 
 def _parser(**kwargs: Any) -> argparse.ArgumentParser:
@@ -88,6 +88,19 @@ def _read_leaf(parent: argparse._SubParsersAction, name: str, summary: str, **de
     return leaf
 
 
+def _modus_server_flag(parser: argparse.ArgumentParser) -> None:
+    """Select the WoW Build sent as ``server`` and ``X-Server-Type``.
+
+    ``None`` deliberately means "use the main client's current Build". Build
+    zero is valid, so this is an integer flag rather than ``_positive``.
+    ``--build`` is a concise alias; both names write the same input field.
+    """
+    parser.add_argument(
+        "--server-type", "--build", dest="server_type", type=int, default=None,
+        metavar="BUILD_ID", help="WoW Build id; omitted follows the local ModUs current Build (0-4).",
+    )
+
+
 def _newbee_relationship_tree(parent: argparse.ArgumentParser, resource: str, label: str) -> None:
     authors = parent.add_parser("co-author", help="Search, list, or replace %s co-authors" % label).add_subparsers(dest="author_action", required=True)
     leaf = _read_leaf(authors, "search", "Search current co-author candidates.", platform="newbee", resource=resource, action="co-author-search"); leaf.add_argument("--keyword", required=True)
@@ -236,6 +249,7 @@ def _modus_tree(platforms: argparse._SubParsersAction) -> None:
     groups = root.add_subparsers(dest="resource_command", required=True)
     session = groups.add_parser("session", help="Local authentication diagnostics").add_subparsers(dest="action_command", required=True)
     _read_leaf(session, "doctor", "Check the local ModUs.Creator token store, DPAPI decryption, and authenticated API readiness without exposing credentials.", platform="modus", resource="session", action="doctor")
+    _read_leaf(groups, "builds", "List the fixed ModUs WoW Build ids, codes, names, and the locally selected current Build.", platform="modus", resource="builds", action="list")
 
     account = groups.add_parser("account", help="ModUs author account and statistics").add_subparsers(dest="action_command", required=True)
     _read_leaf(account, "info", "Read the current ModUs account capability flags.", platform="modus", resource="account", action="info")
@@ -245,13 +259,13 @@ def _modus_tree(platforms: argparse._SubParsersAction) -> None:
     addon = groups.add_parser("addon", help="ModUs addon discovery and history APIs").add_subparsers(dest="action_command", required=True)
     leaf = _read_leaf(addon, "info", "Resolve addon directories to project records.", platform="modus", resource="addon", action="info")
     leaf.add_argument("--directory", dest="directories", action="append", required=True)
-    leaf.add_argument("--server-type", type=int, default=1)
+    _modus_server_flag(leaf)
     leaf = _read_leaf(addon, "project-info", "Resolve addon project IDs to names.", platform="modus", resource="addon", action="project-info")
     leaf.add_argument("--project-id", dest="project_ids", action="append", type=_positive, required=True)
-    leaf.add_argument("--server-type", type=int, default=1)
+    _modus_server_flag(leaf)
     leaf = _read_leaf(addon, "history", "Read addon project version history.", platform="modus", resource="addon", action="history")
     leaf.add_argument("--project-id", type=_positive, required=True)
-    leaf.add_argument("--server-type", type=int, default=1)
+    _modus_server_flag(leaf)
     _page_flags(leaf)
 
     options = groups.add_parser("options", help="Read ModUs dynamic choices").add_subparsers(dest="option_action", required=True)
@@ -259,6 +273,9 @@ def _modus_tree(platforms: argparse._SubParsersAction) -> None:
     game_versions = _read_leaf(options, "game-versions", "List supported ModUs game versions.", platform="modus", resource="options", action="game-versions")
     game_versions.add_argument("--key", dest="keys", action="append", required=True, help="Request one game config key; repeatable.")
     _read_leaf(options, "subscription-tiers", "List author subscription tiers returned by ModUs.", platform="modus", resource="options", action="subscription-tiers")
+    _read_leaf(options, "config-tags", "List configuration-share tag choices from the official ModUs client data.", platform="modus", resource="options", action="config-tags")
+    _read_leaf(options, "wa-tags", "List string tag choices from the official ModUs client data.", platform="modus", resource="options", action="wa-tags")
+    _read_leaf(options, "wa-support-addons", "List applicable-addon choices from the official ModUs client data.", platform="modus", resource="options", action="wa-support-addons")
 
     project = groups.add_parser("project", help="ModUs plugin project records").add_subparsers(dest="action_command", required=True)
     for action, text in (
@@ -282,9 +299,23 @@ def _modus_tree(platforms: argparse._SubParsersAction) -> None:
         ("delete", "Delete one explicitly confirmed ModUs plugin release."),
     ):
         _write_leaf(plugin, "modus", "plugin", action, text)
-    leaf = _read_leaf(plugin, "list", "List releases for one ModUs plugin project.", platform="modus", resource="plugin", action="list"); leaf.add_argument("--project-id", type=_positive, required=True); _page_flags(leaf)
-    leaf = _read_leaf(plugin, "get", "Read one ModUs plugin release detail.", platform="modus", resource="plugin", action="get"); leaf.add_argument("--project-id", type=_positive, required=True); leaf.add_argument("--file-id", type=_positive, required=True)
-    leaf = _read_leaf(plugin, "versions", "List releases for one ModUs plugin project.", platform="modus", resource="plugin", action="versions"); leaf.add_argument("--project-id", type=_positive, required=True); _page_flags(leaf)
+    leaf = _read_leaf(plugin, "list", "List releases for one ModUs plugin project.", platform="modus", resource="plugin", action="list"); leaf.add_argument("--project-id", type=_positive, required=True); _modus_server_flag(leaf); _page_flags(leaf)
+    leaf = _read_leaf(plugin, "get", "Read one ModUs plugin release detail.", platform="modus", resource="plugin", action="get"); leaf.add_argument("--project-id", type=_positive, required=True); leaf.add_argument("--file-id", type=_positive, required=True); _modus_server_flag(leaf)
+    leaf = _read_leaf(plugin, "versions", "List releases for one ModUs plugin project.", platform="modus", resource="plugin", action="versions"); leaf.add_argument("--project-id", type=_positive, required=True); _modus_server_flag(leaf); _page_flags(leaf)
+
+    config = groups.add_parser("config", help="ModUs main-client configuration shares and backups").add_subparsers(dest="action_command", required=True)
+    for action, text in (("create", "Create a configuration share from an existing ModUs cloud backup."), ("update", "Update a configuration share."), ("edit", "Edit a configuration share."), ("delete", "Delete one explicitly confirmed configuration share."), ("backup-edit", "Rename an existing ModUs cloud backup."), ("backup-delete", "Delete one explicitly confirmed ModUs cloud backup.")):
+        _write_leaf(config, "modus", "config", action, text)
+    leaf = _read_leaf(config, "list", "List ModUs configuration shares.", platform="modus", resource="config", action="list"); _modus_server_flag(leaf); leaf.add_argument("--page-num", type=int); leaf.add_argument("--page-size", type=int); leaf.add_argument("--keyword"); leaf.add_argument("--status", type=int); leaf.add_argument("--share-type", type=int); leaf.add_argument("--order-by"); leaf.add_argument("--mine", action=argparse.BooleanOptionalAction); leaf.add_argument("--is-public", type=int, choices=(0, 1)); leaf.add_argument("--is-paid", type=int, choices=(0, 1)); leaf.add_argument("--tags")
+    leaf = _read_leaf(config, "get", "Read a ModUs configuration share detail.", platform="modus", resource="config", action="get"); leaf.add_argument("--share-id", required=True); _modus_server_flag(leaf)
+    leaf = _read_leaf(config, "backups", "List existing ModUs cloud backups.", platform="modus", resource="config", action="backups"); _modus_server_flag(leaf)
+    leaf = _read_leaf(config, "backup-get", "Read one ModUs cloud backup detail.", platform="modus", resource="config", action="backup-get"); leaf.add_argument("--backup-id", type=_positive, required=True); _modus_server_flag(leaf)
+
+    wa = groups.add_parser("wa", help="ModUs main-client string articles").add_subparsers(dest="action_command", required=True)
+    for action, text in (("create", "Create a ModUs string article."), ("update", "Update a ModUs string article."), ("edit", "Edit a ModUs string article."), ("delete", "Delete one explicitly confirmed string article."), ("version-publish", "Publish a new string article version."), ("version-delete", "Delete one explicitly confirmed historical string version.")):
+        _write_leaf(wa, "modus", "wa", action, text)
+    leaf = _read_leaf(wa, "list", "List ModUs string articles.", platform="modus", resource="wa", action="list"); _modus_server_flag(leaf); leaf.add_argument("--page-num", type=int); leaf.add_argument("--page-size", type=int); leaf.add_argument("--keyword"); leaf.add_argument("--status", type=int); leaf.add_argument("--order-by"); leaf.add_argument("--mine", action=argparse.BooleanOptionalAction); leaf.add_argument("--support-addon"); leaf.add_argument("--tags"); leaf.add_argument("--is-paid", type=int, choices=(0, 1))
+    leaf = _read_leaf(wa, "get", "Read one ModUs string article detail.", platform="modus", resource="wa", action="get"); leaf.add_argument("--import-id", required=True); _modus_server_flag(leaf)
 
 
 def build_parser() -> argparse.ArgumentParser:
@@ -347,7 +378,7 @@ def main(argv: Optional[Sequence[str]] = None) -> int:
             if args.dry_run:
                 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 == "curseforge" else _modus_provider())))
+            provider = NewBee() if platform == "newbee" else (DD() if platform == "dd" else (Blackbox() if platform == "blackbox" else (CurseForge() if platform == "curseforge" else _modus_provider(main_session=resource in ("config", "wa")))))
             try:
                 if platform == "dd":
                     data = provider.execute_write(resource, action, doc, getattr(args, "session", None))
@@ -360,10 +391,15 @@ def main(argv: Optional[Sequence[str]] = None) -> int:
             write_output(platform, operation, data)
             return 0
         modus_doctor = platform == "modus" and resource == "session" and action == "doctor"
-        provider = NewBee() if platform == "newbee" else (DD() if platform == "dd" else (Blackbox() if platform == "blackbox" else (CurseForge() if platform == "curseforge" else _modus_provider(authenticate=not modus_doctor))))
+        provider = NewBee() if platform == "newbee" else (DD() if platform == "dd" else (Blackbox() if platform == "blackbox" else (CurseForge() if platform == "curseforge" else _modus_provider(authenticate=not modus_doctor, main_session=resource in ("addon", "plugin", "config", "wa", "builds")))))
         try:
             if platform == "dd":
                 data = provider.execute_read(resource, action, args, getattr(args, "session", None))
+            elif platform == "modus" and resource == "builds" and action == "list":
+                # Build discovery is local and deterministic; it must not
+                # accidentally hit a platform endpoint or confuse platform
+                # selection with the Build id sent on CRUD requests.
+                data = provider.builds()
             else:
                 data = provider.execute_read(resource, action, args)
         finally:

package/fupload/scripts/fupload_cli/modus.py

@@ -25,12 +25,22 @@ from typing import Any, Dict, Mapping, Optional
 from .errors import FuploadError, ValidationError, redact
 from .state_machine import COMPLETE, ProjectStateMachine
 from .modus_zip import parse_modus_zip
+from .transport import json_request
 
 
 API_BASE = "https://app.modus.cool/api/"
+STATIC_API_BASE = "https://cdn.modus.cool/modus/client_static_api/"
 TOKEN_PATH = Path(os.environ.get("LOCALAPPDATA", Path.home() / "AppData/Local")) / "ModUs.Creator" / "auth" / "token.dat"
 TOKEN_ENTROPY = b"ModUs.Creator.TokenStore.v1"
+MODUS_APPDATA = Path(os.environ.get("APPDATA", Path.home() / "AppData/Roaming")) / "modus"
 MAX_PACKAGE_BYTES = 200 * 1024 * 1024
+MODUS_BUILDS = (
+    {"id": 0, "code": "retail", "name": "至暗之夜", "label": "正式服-至暗之夜"},
+    {"id": 1, "code": "classic_era", "name": "经典旧世", "label": "怀旧服-经典旧世"},
+    {"id": 2, "code": "classic", "name": "熊猫人之谜", "label": "怀旧服-熊猫人之谜"},
+    {"id": 3, "code": "classic_titan", "name": "泰坦重铸", "label": "时光服-泰坦重铸"},
+    {"id": 4, "code": "anniversary", "name": "燃烧的远征", "label": "周年服-燃烧的远征"},
+)
 _SECRET_KEYS = {"token", "access_token", "authorization", "cookie", "signedurl", "signed_url", "upload_url"}
 _WIRE_NAMES = {
     "project_id": "projectId", "file_id": "fileId", "alt_name": "altName",
@@ -158,6 +168,16 @@ def _positive_id(value: Any, *, field: str) -> int:
     return result
 
 
+def _resource_id(value: Any, *, field: str) -> str:
+    """ModUs share/import IDs are opaque positive decimal strings."""
+    if isinstance(value, bool) or value is None:
+        raise ValidationError("%s must be a non-empty identifier" % field, path=field)
+    text = str(value).strip()
+    if not text or (text.isdigit() and int(text) <= 0):
+        raise ValidationError("%s must be a non-empty identifier" % field, path=field)
+    return text
+
+
 def _supported_game_versions(value: Any) -> list[Dict[str, str]]:
     """Map CLI aliases to Creator's anonymous {gameVersion, server} objects.
 
@@ -407,6 +427,94 @@ def load_token(path: Optional[Path] = None) -> str:
     return token
 
 
+def load_main_session(root: Optional[Path] = None) -> Dict[str, str]:
+    """Recover the main ModUs renderer session from Chromium local storage.
+
+    Chromium LevelDB values are length-prefixed and may be locked by the
+    running client.  We therefore scan shared-read bytes for JSON fragments,
+    accepting only the known persisted token/device keys and never returning
+    unrelated storage values.
+    """
+    base = root or MODUS_APPDATA
+    leveldb = base / "Local Storage" / "leveldb"
+    if not leveldb.is_dir():
+        raise FuploadError("ModUs main-client local storage was not found", kind="authentication_error")
+    token = ""
+    device = ""
+    for path in sorted(leveldb.iterdir()):
+        if not path.is_file() or path.name in {"LOCK", "LOG", "LOG.old", "CURRENT", "MANIFEST-000001"}:
+            continue
+        try:
+            with path.open("rb", buffering=0) as handle:
+                raw = handle.read()
+        except OSError:
+            continue
+        text = raw.decode("utf-8", errors="ignore")
+        # Pinia persistence is JSON, but the LevelDB record can contain a
+        # prefix/suffix.  Try JSON objects first, then bounded key/value pairs.
+        candidates = [text]
+        # Persisted Pinia user JSON contains nested wallet objects, so a
+        # shallow-brace regex is insufficient. Extract only scalar credential
+        # fields from the record instead of attempting to parse the whole log.
+        import re
+        token_match = re.search(r'"(?:token|accessToken|access_token)"\s*:\s*"([^"\\]*(?:\\.[^"\\]*)*)"', text)
+        device_match = re.search(r'"(?:deviceId|device_id)"\s*:\s*"([^"\\]*)"', text)
+        if token_match and not token:
+            token = bytes(token_match.group(1), "utf-8").decode("unicode_escape")
+        if device_match and not device:
+            device = device_match.group(1)
+        for candidate in candidates:
+            try:
+                parsed = json.loads(candidate)
+            except (TypeError, ValueError):
+                continue
+            stack = [parsed]
+            while stack:
+                item = stack.pop()
+                if isinstance(item, Mapping):
+                    for key, value in item.items():
+                        normalized = str(key).lower()
+                        if isinstance(value, str) and value.strip():
+                            if normalized in {"token", "accesstoken", "access_token"} and not token:
+                                token = value.strip()
+                            elif normalized in {"deviceid", "device_id"} and not device:
+                                device = value.strip()
+                        elif isinstance(value, (Mapping, list)):
+                            stack.append(value)
+                elif isinstance(item, list):
+                    stack.extend(item)
+        if token and device:
+            break
+    if not token:
+        raise FuploadError("ModUs main-client login token was not found", kind="authentication_error")
+    return {"token": token, **({"device_id": device} if device else {})}
+
+
+def load_current_build(root: Optional[Path] = None) -> Optional[int]:
+    """Read the persisted main-client currentGameWow id when available."""
+    base = root or MODUS_APPDATA
+    leveldb = base / "Local Storage" / "leveldb"
+    if not leveldb.is_dir():
+        return None
+    import re
+    for path in sorted(leveldb.iterdir()):
+        if not path.is_file() or path.name in {"LOCK", "LOG", "LOG.old", "CURRENT", "MANIFEST-000001"}:
+            continue
+        try:
+            with path.open("rb", buffering=0) as handle:
+                text = handle.read().decode("utf-8", errors="ignore")
+        except OSError:
+            continue
+        # Pinia persistence may be split across records; accept only the scalar id.
+        for pattern in (r'currentGameWow[^{}]{0,120}?"id"\s*:\s*(\d+)', r'"currentGameWowId"\s*:\s*(\d+)'):
+            match = re.search(pattern, text)
+            if match:
+                value = int(match.group(1))
+                if 0 <= value <= 4:
+                    return value
+    return None
+
+
 def _unwrap(payload: Any) -> Any:
     if isinstance(payload, Mapping) and "data" in payload:
         return payload["data"]
@@ -423,12 +531,28 @@ class ModUs:
         base_url: str = API_BASE,
         timeout: int = 60,
         token_path: Optional[Path] = None,
+        device_id: Optional[str] = None,
+        main_session: bool = False,
         authenticate: bool = True,
     ) -> None:
         self.base_url = base_url.rstrip("/") + "/"
         self.timeout = timeout
         self.token_path = token_path or TOKEN_PATH
-        self.token = token if token is not None else (load_token(self.token_path) if authenticate else "")
+        self.device_id = device_id
+        self.main_session = main_session
+        self.current_build = load_current_build() if main_session else None
+        self.authorization_scheme = ""
+        if token is not None:
+            self.token = token
+        elif authenticate:
+            if main_session:
+                session = load_main_session()
+                self.token, self.device_id = session["token"], session.get("device_id")
+                self.authorization_scheme = ""
+            else:
+                self.token = load_token(self.token_path)
+        else:
+            self.token = ""
 
     def _url(self, path: str) -> str:
         return urllib.parse.urljoin(self.base_url, path.lstrip("/"))
@@ -454,7 +578,10 @@ class ModUs:
     def _request(self, method: str, path: str, body: Any = None, *, headers: Optional[Mapping[str, str]] = None) -> Any:
         url = self._url(path)
         stage = self._request_stage(method, path)
-        request_headers = {"Accept": "application/json", "Authorization": "Bearer " + self.token}
+        authorization = self.token if self.authorization_scheme == "" else self.authorization_scheme + self.token
+        request_headers = {"Accept": "application/json", "Authorization": authorization}
+        if self.device_id:
+            request_headers["X-Device-Id"] = self.device_id
         if headers:
             request_headers.update(headers)
         data = None
@@ -576,31 +703,57 @@ class ModUs:
     def user_info(self) -> Any:
         return _safe(_unwrap(self._request("GET", "system/user/getInfo")))
 
+    def builds(self) -> Any:
+        """Return the fixed WoW Build choices used by the ModUs main client."""
+        current = self.current_build
+        return {"current": current, "builds": [dict(item) for item in MODUS_BUILDS]}
+
+    def _build(self, value: Optional[int]) -> int:
+        selected = self.current_build if value is None else value
+        if selected is None:
+            # The desktop wrapper uses getCurrentWow?.id || 0.
+            selected = 0
+        selected = int(selected)
+        if selected < 0 or selected > 4:
+            raise ValidationError("server_type must be a known ModUs Build id", path="server_type")
+        return selected
+
     def active_subscription_count(self) -> Any:
         return _safe(_unwrap(self._request("GET", "user/author/subscription/active/count")))
 
     def project_statistics(self) -> Any:
         return _safe(_unwrap(self._request("GET", "game/data/author/project/statistics")))
 
-    def addon_info(self, directories: Any, *, server_type: int = 1) -> Any:
+    def addon_info(self, directories: Any, *, server_type: Optional[int] = None) -> Any:
         values = directories if isinstance(directories, (list, tuple)) else [directories]
         body = {"pluginList": [str(value) for value in values]}
-        return _safe(_unwrap(self._request("POST", "plugin/list/info", body, headers={"X-Server-Type": str(int(server_type))})))
+        return _safe(_unwrap(self._request("POST", "plugin/list/info", body, headers={"X-Server-Type": str(self._build(server_type))})))
 
-    def addon_project_info(self, project_ids: Any, *, server_type: int = 1) -> Any:
+    def addon_project_info(self, project_ids: Any, *, server_type: Optional[int] = None) -> Any:
         values = project_ids if isinstance(project_ids, (list, tuple)) else [project_ids]
         body = {"projectIds": [int(value) for value in values]}
-        return _safe(_unwrap(self._request("POST", "plugin/list/detail", body, headers={"X-Server-Type": str(int(server_type))})))
+        return _safe(_unwrap(self._request("POST", "plugin/list/detail", body, headers={"X-Server-Type": str(self._build(server_type))})))
 
-    def addon_history(self, project_id: int, *, page_num: int = 1, page_size: int = 5, server_type: int = 1) -> Any:
+    def addon_history(self, project_id: int, *, page_num: int = 1, page_size: int = 5, server_type: Optional[int] = None) -> Any:
         body = {"projectIds": [int(project_id)], "pageNum": int(page_num), "pageSize": int(page_size)}
-        return _safe(_unwrap(self._request("POST", "plugin/project/history", body, headers={"X-Server-Type": str(int(server_type))})))
+        return _safe(_unwrap(self._request("POST", "plugin/project/history", body, headers={"X-Server-Type": str(self._build(server_type))})))
 
     def project_dependencies(self, query: Any) -> Any:
         body = _dependency_query_wire(query)
         return _safe(_unwrap(self._request("POST", "game/data/author/project/dependency/query", body)))
 
     def options(self, action: str, *, keys: Optional[Any] = None) -> Any:
+        static_files = {
+            "config-tags": "share_tags.json",
+            "wa-tags": "imports_tags.json",
+            "wa-support-addons": "imports_support_addons.json",
+        }
+        if action in static_files:
+            url = urllib.parse.urljoin(STATIC_API_BASE, static_files[action])
+            payload = json_request(url)
+            if isinstance(payload, Mapping) and "rows" in payload:
+                payload = payload["rows"]
+            return _safe(_unwrap(payload))
         routes = {
             # These paths are the routes used by ModUs.Creator's ApiService.
             "categories": "plugin/list/Categories",
@@ -618,6 +771,123 @@ class ModUs:
             raise ValidationError("unsupported ModUs options operation")
         return _safe(_unwrap(self._request("GET", routes[action])))
 
+    # Main ModUs client: configuration shares and string articles.
+    def cloud_backups(self, *, server_type: Optional[int] = None) -> Any:
+        return _safe(_unwrap(self._request("GET", "system/user/backup/list", headers={"X-Server-Type": str(self._build(server_type))})))
+
+    def cloud_backup_detail(self, backup_id: int, *, server_type: Optional[int] = None) -> Any:
+        return _safe(_unwrap(self._request("GET", "system/user/backup/detail/%s" % _positive_id(backup_id, field="backup_id"), headers={"X-Server-Type": str(self._build(server_type))})))
+
+    def cloud_backup_update(self, doc: Mapping[str, Any], *, server_type: Optional[int] = None) -> Any:
+        body = {"id": _positive_id(doc["backup_id"], field="backup_id"), "backupName": doc["backup_name"]}
+        return _safe(_unwrap(self._request("POST", "system/user/backup/update", body, headers={"X-Server-Type": str(self._build(server_type))})))
+
+    def cloud_backup_delete(self, backup_id: int, *, server_type: Optional[int] = None) -> Any:
+        return _safe(_unwrap(self._request("DELETE", "system/user/backup/delete/%s" % _positive_id(backup_id, field="backup_id"), headers={"X-Server-Type": str(self._build(server_type))})))
+
+    @staticmethod
+    def _share_wire(doc: Mapping[str, Any]) -> Dict[str, Any]:
+        aliases = {"share_id": "id", "addons_id": "addonsId", "backup_id": "backupId", "account_name": "accountName", "content_text": "contentText", "image_url": "imageUrl", "is_paid": "isPaid", "is_public": "isPublic", "share_type": "shareType", "exclude_wtf": "excludeWtf", "role_name": "roleName", "required_tier_id": "requiredTierId", "sub_type": "subType", "synchronization_type": "synchronizationType"}
+        allowed = {"id", "addonsId", "backupId", "accountName", "content", "contentText", "imageUrl", "isPaid", "isPublic", "price", "shareType", "tags", "title", "excludeWtf", "roleName", "requiredTierId", "subType", "platform", "synchronizationType"}
+        result = {}
+        for key, value in doc.items():
+            wire = aliases.get(key, key)
+            if wire in allowed and value is not None:
+                result[wire] = value
+        result.setdefault("platform", 1)
+        exclude = result.get("excludeWtf", 0)
+        result["excludeWtf"] = 1 if str(exclude).strip().lower() in {"1", "true"} else 0
+        return result
+
+    def share_list(self, body: Optional[Mapping[str, Any]] = None, *, server_type: Optional[int] = None) -> Any:
+        source = body or {}
+        selected_build = self._build(source.get("server", server_type))
+        mine = source.get("mine")
+        share_type = source.get("share_type")
+        wire = {
+            "pageNum": int(source.get("page_num") or 1),
+            "pageSize": int(source.get("page_size") or 20),
+            "server": selected_build,
+            "mine": False if mine is None else bool(mine),
+            "shareType": 0 if share_type is None else share_type,
+        }
+        platform = source.get("platform")
+        wire["platform"] = int(platform) if isinstance(platform, (int, float)) and not isinstance(platform, bool) else 0
+        for key in ("keyword", "status", "tags", "order_by", "is_public", "is_paid"):
+            if key in source and source[key] is not None:
+                wire[{"order_by": "orderBy", "is_public": "isPublic", "is_paid": "isPaid"}.get(key, key)] = source[key]
+        return _safe(_unwrap(self._request("POST", "system/user/share/list", wire, headers={"X-Server-Type": str(selected_build)})))
+
+    def share_detail(self, share_ids: Any, *, server_type: Optional[int] = None) -> Any:
+        ids = share_ids if isinstance(share_ids, list) else [share_ids]
+        return _safe(_unwrap(self._request("POST", "system/user/share/detail", {"shareIds": [_resource_id(x, field="share_id") for x in ids]}, headers={"X-Server-Type": str(self._build(server_type))})))
+
+    def share_create(self, doc: Mapping[str, Any], *, server_type: Optional[int] = None) -> Any:
+        wire = self._share_wire(doc)
+        wire.setdefault("synchronizationType", 3 if wire["platform"] == 3 else 1)
+        return _safe(_unwrap(self._request("POST", "system/user/share/create", wire, headers={"X-Server-Type": str(self._build(server_type))})))
+
+    def share_update(self, doc: Mapping[str, Any], *, server_type: Optional[int] = None) -> Any:
+        return _safe(_unwrap(self._request("PUT", "system/user/share/update", self._share_wire(doc), headers={"X-Server-Type": str(self._build(server_type))})))
+
+    def share_delete(self, share_id: Any, *, server_type: Optional[int] = None) -> Any:
+        return _safe(_unwrap(self._request("DELETE", "system/user/share/delete/%s" % urllib.parse.quote(_resource_id(share_id, field="share_id"), safe=""), headers={"X-Server-Type": str(self._build(server_type))})))
+
+    @staticmethod
+    def _import_wire(doc: Mapping[str, Any]) -> Dict[str, Any]:
+        aliases = {"import_id": "id", "code_text": "codeText", "addons_id": "addonsId", "content_text": "contentText", "file_path": "filePath", "image_url": "imageUrl", "is_paid": "isPaid", "is_public": "isPublic", "share_type": "shareType", "support_addon": "supportAddon", "required_tier_id": "requiredTierId", "sub_type": "subType", "synchronization_type": "synchronizationType"}
+        allowed = {"id", "codeText", "content", "addonsId", "contentText", "filePath", "imageUrl", "isPaid", "isPublic", "price", "shareType", "supportAddon", "tags", "title", "version", "requiredTierId", "subType", "platform", "synchronizationType"}
+        result = {aliases.get(key, key): value for key, value in doc.items() if aliases.get(key, key) in allowed and value is not None}
+        result.setdefault("platform", 1)
+        result.setdefault("synchronizationType", 3 if result["platform"] == 3 else 1)
+        return result
+
+    def import_list(self, body: Optional[Mapping[str, Any]] = None, *, server_type: Optional[int] = None) -> Any:
+        source = body or {}
+        selected_build = self._build(source.get("server", server_type))
+        mine = source.get("mine")
+        status = source.get("status")
+        wire = {
+            "pageNum": int(source.get("page_num") or 1),
+            "pageSize": int(source.get("page_size") or 10),
+            "server": selected_build,
+            "mine": False if mine is None else bool(mine),
+            "status": 1 if status is None else status,
+        }
+        platform = source.get("platform")
+        wire["platform"] = int(platform) if isinstance(platform, (int, float)) and not isinstance(platform, bool) else 0
+        for key in ("keyword", "support_addon", "tags", "is_paid", "order_by"):
+            if key in source and source[key] is not None:
+                wire[{"support_addon": "supportAddon", "is_paid": "isPaid", "order_by": "orderBy"}.get(key, key)] = source[key]
+        return _safe(_unwrap(self._request("POST", "system/user/import/list", wire, headers={"X-Server-Type": str(selected_build)})))
+
+    def import_detail(self, import_ids: Any, *, server_type: Optional[int] = None) -> Any:
+        ids = import_ids if isinstance(import_ids, list) else [import_ids]
+        return _safe(_unwrap(self._request("POST", "system/user/import/detail", {"importIds": [_resource_id(x, field="import_id") for x in ids]}, headers={"X-Server-Type": str(self._build(server_type))})))
+
+    def import_create(self, doc: Mapping[str, Any], *, server_type: Optional[int] = None) -> Any:
+        return _safe(_unwrap(self._request("POST", "system/user/import/create", self._import_wire(doc), headers={"X-Server-Type": str(self._build(server_type))})))
+
+    def import_update(self, doc: Mapping[str, Any], *, server_type: Optional[int] = None) -> Any:
+        return _safe(_unwrap(self._request("POST", "system/user/import/update", self._import_wire(doc), headers={"X-Server-Type": str(self._build(server_type))})))
+
+    def import_delete(self, import_id: Any, *, server_type: Optional[int] = None) -> Any:
+        return _safe(_unwrap(self._request("DELETE", "system/user/import/delete/%s" % urllib.parse.quote(_resource_id(import_id, field="import_id"), safe=""), headers={"X-Server-Type": str(self._build(server_type))})))
+
+    def import_version_publish(self, doc: Mapping[str, Any], *, server_type: Optional[int] = None) -> Any:
+        body = {
+            "importId": _resource_id(doc["import_id"], field="import_id"),
+            "version": str(doc["version"]).strip(),
+            "codeText": str(doc["code_text"]).strip(),
+        }
+        changelog = str(doc.get("changelog") or "").strip()
+        if changelog:
+            body["changelog"] = changelog
+        return _safe(_unwrap(self._request("POST", "system/user/import/version/publish", body, headers={"X-Server-Type": str(self._build(server_type))})))
+
+    def import_version_delete(self, version_id: Any, *, server_type: Optional[int] = None) -> Any:
+        return _safe(_unwrap(self._request("DELETE", "system/user/import/version/delete?versionId=%s" % urllib.parse.quote(str(version_id), safe=""), headers={"X-Server-Type": str(self._build(server_type))})))
+
     def release_signature(self, project_id: int, file_id: int) -> str:
         result = _unwrap(self._request("GET", "game/data/author/project/file/upload/signature/%s/%s" % (_positive_id(project_id, field="project_id"), _positive_id(file_id, field="file_id"))))
         url = result.get("signedUrl") if isinstance(result, Mapping) else result
@@ -633,12 +903,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 +929,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 +963,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:
+            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:
-            transaction["stages"].append("release_metadata_update" if update else "release_metadata")
+            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,18 +1072,40 @@ 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()
+        if resource == "options" and action == "builds": return self.builds()
+        if resource == "builds" and action == "list": return self.builds()
         doc = vars(args) if args is not None and hasattr(args, "__dict__") else (args or {})
         if resource == "account" and action == "info": return self.user_info()
         if resource == "account" and action == "subscription-count": return self.active_subscription_count()
         if resource == "account" and action == "statistics": return self.project_statistics()
-        if resource == "addon" and action == "info": return self.addon_info(doc.get("directories", []), server_type=doc.get("server_type", 1))
-        if resource == "addon" and action == "project-info": return self.addon_project_info(doc.get("project_ids", []), server_type=doc.get("server_type", 1))
-        if resource == "addon" and action == "history": return self.addon_history(doc["project_id"], page_num=doc.get("page_num", 1), page_size=doc.get("page_size", 5), server_type=doc.get("server_type", 1))
+        if resource == "addon" and action == "info": return self.addon_info(doc.get("directories", []), server_type=doc.get("server_type"))
+        if resource == "addon" and action == "project-info": return self.addon_project_info(doc.get("project_ids", []), server_type=doc.get("server_type"))
+        if resource == "addon" and action == "history": return self.addon_history(doc["project_id"], page_num=doc.get("page_num", 1), page_size=doc.get("page_size", 5), server_type=doc.get("server_type"))
         if resource == "project" and action == "dependencies": return self.project_dependencies(doc.get("query") or doc.get("project_ids") or doc.get("project_id"))
         if resource == "options": return self.options(action, keys=doc.get("keys"))
+        if resource == "config" and action == "backups": return self.cloud_backups(server_type=doc.get("server_type"))
+        if resource == "config" and action == "backup-get": return self.cloud_backup_detail(doc["backup_id"], server_type=doc.get("server_type"))
+        if resource == "config" and action == "list": return self.share_list(doc, server_type=doc.get("server_type"))
+        if resource == "config" and action == "get": return self.share_detail(doc["share_id"], server_type=doc.get("server_type"))
+        if resource == "wa" and action == "list": return self.import_list(doc, server_type=doc.get("server_type"))
+        if resource == "wa" and action == "get": return self.import_detail(doc["import_id"], server_type=doc.get("server_type"))
         if resource == "project" and action == "list": return self.project_list(**doc)
         if resource == "project" and action in ("get", "detail"): return self.project_detail(doc["project_id"])
         if resource in ("plugin", "release") and action in ("list", "versions"): return self.release_list(doc["project_id"], page_num=doc.get("page_num", 1), page_size=doc.get("page_size", 50))
@@ -756,6 +1113,16 @@ class ModUs:
         raise ValidationError("unsupported ModUs read operation")
 
     def execute_write(self, resource: str, action: str, doc: Mapping[str, Any]) -> Any:
+        if resource == "config" and action == "create": return self.share_create(doc, server_type=doc.get("server_type"))
+        if resource == "config" and action in ("update", "edit"): return self.share_update(doc, server_type=doc.get("server_type"))
+        if resource == "config" and action == "delete": return self.share_delete(doc["share_id"], server_type=doc.get("server_type"))
+        if resource == "config" and action == "backup-edit": return self.cloud_backup_update(doc, server_type=doc.get("server_type"))
+        if resource == "config" and action == "backup-delete": return self.cloud_backup_delete(doc["backup_id"], server_type=doc.get("server_type"))
+        if resource == "wa" and action == "create": return self.import_create(doc, server_type=doc.get("server_type"))
+        if resource == "wa" and action in ("update", "edit"): return self.import_update(doc, server_type=doc.get("server_type"))
+        if resource == "wa" and action == "delete": return self.import_delete(doc["import_id"], server_type=doc.get("server_type"))
+        if resource == "wa" and action == "version-publish": return self.import_version_publish(doc, server_type=doc.get("server_type"))
+        if resource == "wa" and action == "version-delete": return self.import_version_delete(doc["version_id"], server_type=doc.get("server_type"))
         if resource == "project" and action in ("create", "release"): return self.project_create(doc)
         if resource == "project" and action in ("update", "edit"): return self.project_update(doc)
         if resource == "project" and action == "delete": return self.project_delete(int(doc["project_id"]))

package/fupload/scripts/fupload_cli/schema.py

@@ -17,6 +17,7 @@ JSON_TYPES = {
     "boolean": (bool,),
     "array": (list,),
     "object": (dict,),
+    "identifier": (int, str),
 }
 
 
@@ -98,6 +99,21 @@ class Schema:
         return checked
 
     def _validate_conditionals(self, value: Dict[str, Any]) -> None:
+        if self.name.startswith("fupload.v1.modus.config"):
+            exclude = value.get("exclude_wtf")
+            if exclude == 1 and (value.get("account_name") or value.get("role_name")):
+                raise ValidationError("account_name and role_name must be empty when exclude_wtf=1", path="$.account_name")
+            if exclude == 0 and not str(value.get("account_name") or "").strip():
+                raise ValidationError("account_name is required when exclude_wtf=0", path="$.account_name")
+        if self.name.startswith(("fupload.v1.modus.config", "fupload.v1.modus.wa")):
+            if "title" in value and len(str(value["title"]).strip()) < 6:
+                raise ValidationError("must contain at least 6 characters", path="$.title")
+            if "content_text" in value and len(str(value["content_text"]).strip()) <= 20:
+                raise ValidationError("must contain more than 20 characters", path="$.content_text")
+            if "tags" in value:
+                tags = [item.strip() for item in str(value["tags"]).split(",")]
+                if any(not item for item in tags) or not 1 <= len(tags) <= 3:
+                    raise ValidationError("must contain 1 to 3 comma-delimited tag IDs", path="$.tags")
         if self.name in ("fupload.v1.modus.project.create", "fupload.v1.modus.project.edit"):
             snapshot = value.get("project_state")
             if snapshot is None:
@@ -693,6 +709,31 @@ MODUS_RELEASE = {
     "file": f("string", local_file=True),
     "transaction_log": f("string", max_length=1000),
 }
+MODUS_BUILD_ID = f("integer", minimum=0, maximum=4)
+MODUS_SHARE = {
+    "share_id": f("identifier", nonempty=True), "addons_id": f("string", nonempty=True, max_length=10000),
+    "account_name": f("string", nullable=True, max_length=120), "backup_id": f("integer", minimum=1),
+    "content": f("string", nonempty=True), "content_text": f("string", nonempty=True),
+    "image_url": f("string", nonempty=True, max_length=1000), "is_paid": f("integer", choices=(0, 1)),
+    "is_public": f("integer", choices=(0, 1)), "price": f("number", minimum=0),
+    "share_type": f("integer", minimum=0), "tags": f("string", nonempty=True, max_length=1000),
+    "title": f("string", nonempty=True, max_length=120), "exclude_wtf": f("integer", choices=(0, 1)),
+    "role_name": f("string", nullable=True, max_length=120), "required_tier_id": f("integer", nullable=True, minimum=1),
+    "sub_type": f("integer", choices=(0, 1)), "platform": f("integer", choices=(1, 3)),
+    "synchronization_type": f("integer", choices=(1, 3)), "server_type": MODUS_BUILD_ID,
+}
+MODUS_IMPORT = {
+    "import_id": f("identifier", nonempty=True), "code_text": f("string", nonempty=True),
+    "content": f("string", nonempty=True), "addons_id": f("string", nonempty=True, max_length=10000),
+    "content_text": f("string", nonempty=True), "file_path": f("string", choices=("",)),
+    "image_url": f("string", nonempty=True, max_length=1000), "is_paid": f("integer", choices=(0, 1)),
+    "is_public": f("integer", choices=(0, 1)), "price": f("number", minimum=0),
+    "share_type": f("integer", minimum=0), "support_addon": f("string", nonempty=True, max_length=120),
+    "tags": f("string", nonempty=True, max_length=1000), "title": f("string", nonempty=True, max_length=120),
+    "version": f("string", nonempty=True, max_length=120), "required_tier_id": f("integer", nullable=True, minimum=1),
+    "sub_type": f("integer", choices=(0, 1)), "platform": f("integer", choices=(1, 3)),
+    "synchronization_type": f("integer", choices=(1, 3)), "server_type": MODUS_BUILD_ID,
+}
 register("modus", "project", "create", required(MODUS_PROJECT_CREATE, ("project_state",)))
 register("modus", "project", "edit", required(with_id(MODUS_PROJECT_EDIT, "project_id"), ("project_id", "project_state")))
 register("modus", "project", "delete", required({"project_id": f("integer", minimum=1), "confirm": f("string", choices=("DELETE",))}, ("project_id", "confirm")))
@@ -701,7 +742,18 @@ register("modus", "plugin", "upload", required(MODUS_RELEASE, ("project_id", "fi
 register("modus", "plugin", "update", required(MODUS_RELEASE, ("project_id", "file_id")))
 register("modus", "plugin", "edit", required(MODUS_RELEASE, ("project_id", "file_id")))
 register("modus", "plugin", "delete", required({"project_id": f("integer", minimum=1), "file_id": f("integer", minimum=1), "confirm": f("string", choices=("DELETE",))}, ("project_id", "file_id", "confirm")))
-
+register("modus", "config", "create", required(MODUS_SHARE, ("addons_id", "backup_id", "content", "content_text", "image_url", "tags", "title", "exclude_wtf")))
+register("modus", "config", "update", required(MODUS_SHARE, ("share_id",)))
+register("modus", "config", "edit", required(MODUS_SHARE, ("share_id",)))
+register("modus", "config", "delete", required({"share_id": f("identifier", nonempty=True), "confirm": f("string", choices=("DELETE",)), "server_type": MODUS_BUILD_ID}, ("share_id", "confirm")))
+register("modus", "config", "backup-edit", required({"backup_id": f("integer", minimum=1), "backup_name": f("string", nonempty=True, max_length=200), "server_type": MODUS_BUILD_ID}, ("backup_id", "backup_name")))
+register("modus", "config", "backup-delete", required({"backup_id": f("integer", minimum=1), "confirm": f("string", choices=("DELETE",)), "server_type": MODUS_BUILD_ID}, ("backup_id", "confirm")))
+register("modus", "wa", "create", required(MODUS_IMPORT, ("code_text", "content", "addons_id", "content_text", "image_url", "support_addon", "tags", "title", "version")))
+register("modus", "wa", "update", required(MODUS_IMPORT, ("import_id",)))
+register("modus", "wa", "edit", required(MODUS_IMPORT, ("import_id",)))
+register("modus", "wa", "delete", required({"import_id": f("identifier", nonempty=True), "confirm": f("string", choices=("DELETE",)), "server_type": MODUS_BUILD_ID}, ("import_id", "confirm")))
+register("modus", "wa", "version-publish", required({"import_id": f("identifier", nonempty=True), "version": f("string", nonempty=True, max_length=120), "code_text": f("string", nonempty=True), "changelog": f("string", max_length=10000), "server_type": MODUS_BUILD_ID}, ("import_id", "version", "code_text")))
+register("modus", "wa", "version-delete", required({"version_id": f("identifier", nonempty=True), "confirm": f("string", choices=("DELETE",)), "server_type": MODUS_BUILD_ID}, ("version_id", "confirm")))
 register("blackbox", "plugin", "edit", required({
     "id": f("integer"), "name": f("string"), "logo_url": f("string"), "category_ids": f("array"),
     "type": f("integer", choices=(1, 9)), "desc": f("string"), "official": f("string"),

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.12",
+  "skill_version": "0.0.12",
+  "tree_sha256": "f1e559aef665537c4b2b24f15dab01b9e4140378bd3a70a00331d56358d2071a",
   "files": [
     {
       "path": "agents/openai.yaml",
@@ -92,8 +92,8 @@
     },
     {
       "path": "references/modus.md",
-      "bytes": 4492,
-      "sha256": "0b9cf6c4b3bc7aa37a3649ec6ccb6c8b8aa3d077c8febc2635548546150df356"
+      "bytes": 13492,
+      "sha256": "919b8b097fd1ec14d38583e84f4d33a5320d24af03703dc1c06a072dbab33e68"
     },
     {
       "path": "references/newbee-official-cli.md",
@@ -113,7 +113,7 @@
     {
       "path": "scripts/fupload_cli/__init__.py",
       "bytes": 50,
-      "sha256": "3f1afb95137eaedc622bb437c9c8a01bdaa729b911f3749e400a429d24abaaa2"
+      "sha256": "cad1ed5cd2ed3020e1fc98c2036d22b47e1138772e9829f5dd61c39cc3bd810f"
     },
     {
       "path": "scripts/fupload_cli/blackbox_web.py",
@@ -127,8 +127,8 @@
     },
     {
       "path": "scripts/fupload_cli/cli.py",
-      "bytes": 31958,
-      "sha256": "897c2e7a7fea00125023d7fc977aaa6e3b7729b50a468e7deadfacc04d89f9b8"
+      "bytes": 36811,
+      "sha256": "bdd159c7d86c009685417e7b4a25194d98a49547e036606b920ff44090b1619e"
     },
     {
       "path": "scripts/fupload_cli/curseforge.py",
@@ -167,8 +167,8 @@
     },
     {
       "path": "scripts/fupload_cli/modus.py",
-      "bytes": 38821,
-      "sha256": "f5edb6898ce515a7e34f0fcab3dc022c2c5185f548644eabf5291e38b22dae22"
+      "bytes": 60792,
+      "sha256": "9cf3d8127e2b7583f1760a74f88512b81ab272ea116bf9ca185c7531eba960d2"
     },
     {
       "path": "scripts/fupload_cli/newbee_auth.py",
@@ -182,13 +182,13 @@
     },
     {
       "path": "scripts/fupload_cli/schema.py",
-      "bytes": 46291,
-      "sha256": "025d6f4af1e8adda87aed14a075028c370e78bf0def6738ab303e2f1798aefd8"
+      "bytes": 51541,
+      "sha256": "aca30dc7997f47645b3da154fa3656fefa1179733e1d61e7ff0de326734f2575"
     },
     {
       "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": "fe14cba8f02167dce36034ce8b73784793c92ed3de37dda1ab982a5a8a9cc8de"
     }
   ]
 }

package/package.json

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