@miravia_test/miravia-publish-skill 0.1.8 → 0.1.9

package/dist/SKILL.md

@@ -117,6 +117,7 @@ description: Miravia 商品发布 AI Skill。仅负责商品创建（手动一
 | `need_compliance` | 制造商/EU 负责人匹配失败 | 按返回候选选择或补充信息后重跑 |
 | `compliance_missing_suggest_draft` | 合规字段缺失（制造商/欧代/Safety Warning内容/合规文档） | 补充合规字段或加 `--draft` 发布为草稿 |
 | `gpsr_missing_suggest_draft` | GPSR 字段缺失（制造商和/或欧盟负责人为空） | 补充 GPSR 字段或加 `--draft` 发布为草稿 |
+| `need_safety_warning_confirm` | AI/Excel 源检测到安全相关内容，但卖家未显式设置「该产品是否有安全警告」；系统**不会**静默默认为 No | 展示 `detected_safety_content` 证据与当前值，让卖家确认：确有则加 `--safety-warning yes`（必要时 `--safety-warning-content`）重跑；确无则加 `--safety-warning no` 确认；或在 Excel 补齐该列后重跑 |
 | `post_to_inactive_missing_suggest_draft` | 类目必填字段缺失（EAN） | 补充字段或加 `--draft` 发布为草稿 |
 | `special_category_block` | 特殊类目规则阻断（PPU 值无效 / 图书类目 ISBN 缺失） | 修正错误后重跑，不可转 Draft |
 | `special_category_suggest_draft` | 特殊类目字段缺失（PPU 缺失 / 食品属性缺失） | 补充字段或加 `--draft` 发布为草稿 |

package/dist/VERSION

@@ -1 +1 @@
-0.1.8
+0.1.9

package/dist/scripts/config.py

@@ -220,6 +220,31 @@ def require_business_credentials() -> None:
             pass
 
 
+def has_valid_business_credentials() -> bool:
+    """Return True when credentials are present and not expired.
+
+    Non-raising companion to ``require_business_credentials``. The publish
+    flow uses this to decide whether the seller is already authorized: when
+    valid credentials exist (they can only exist after a successful
+    ``auth_cli.py login``, which grants the read-profile / access-products /
+    update-products scopes), the skill must not re-prompt the three-item
+    authorization consent on every run. Returns False for missing or expired
+    credentials so the caller falls back to asking the seller.
+    """
+    if not (APP_KEY and APP_SECRET and ACCESS_TOKEN):
+        return False
+
+    if TOKEN_EXPIRES_AT:
+        try:
+            expires_at_ms = int(TOKEN_EXPIRES_AT)
+            if expires_at_ms > 0 and int(time.time() * 1000) > expires_at_ms - 60_000:
+                return False
+        except ValueError:
+            pass
+
+    return True
+
+
 def mask_token(token: str) -> str:
     if not token:
         return "<empty>"

package/dist/scripts/i18n.py

@@ -218,6 +218,11 @@ TRANSLATIONS: Dict[str, Dict[str, str]] = {
         "pub_compliance_manufacturer_eurp_both_empty": "Manufacturer and EU Responsible Person are both empty. Non-EU manufacturers require an EU Responsible Person.",
         "pub_compliance_eurp_missing_with_manufacturer": "Manufacturer is filled but EU Responsible Person is empty. Non-EU manufacturers require an EU Responsible Person.",
         "pub_safety_warning_content_missing": "Safety Warning is set to Yes but the warning content is empty. Please provide the safety warning content.",
+        "pub_safety_confirm_title": "Safety warning needs your confirmation",
+        "pub_safety_confirm_message": "We detected safety-related content in your source ({evidence}), but the 'Does this product have a safety warning' flag was not set explicitly. We will NOT silently default it to 'No'. Please confirm the correct value, or complete the field in your Excel and rerun.",
+        "pub_safety_confirm_next_yes": "If the product does have a safety warning, rerun with --safety-warning yes (add --safety-warning-content if needed).",
+        "pub_safety_confirm_next_no": "If it genuinely has no safety warning, rerun with --safety-warning no to confirm.",
+        "pub_safety_confirm_next_excel": "Your Excel fields may be incomplete; you can fill the safety column there and rerun.",
         "pub_compliance_docs_missing": "Compliance documents are required for this category but not provided.",
         "pub_compliance_missing_message": "Some compliance fields are missing. You can fill them or publish to Draft.",
         "pub_compliance_fill_or_draft": "Fill the missing compliance fields, or publish as Draft to complete them later.",
@@ -887,6 +892,11 @@ TRANSLATIONS: Dict[str, Dict[str, str]] = {
         "pub_compliance_manufacturer_eurp_both_empty": "制造商和欧盟负责人均为空。非欧盟制造商必须填写欧盟负责人。",
         "pub_compliance_eurp_missing_with_manufacturer": "已填写制造商但欧盟负责人为空。非欧盟制造商必须填写欧盟负责人。",
         "pub_safety_warning_content_missing": "安全警告已设为 Yes 但未填写警告内容。请补充安全警告内容。",
+        "pub_safety_confirm_title": "安全警告需要你确认",
+        "pub_safety_confirm_message": "我们从你的源文件中检测到安全相关内容（{evidence}），但“该产品是否有安全警告”这一项没有被显式设置。我们不会把它静默默认为 No。请确认应取的值，或先在 Excel 中补全该项后重新运行。",
+        "pub_safety_confirm_next_yes": "如果该商品确实有安全警告，请加 --safety-warning yes 重新运行（必要时再加 --safety-warning-content）。",
+        "pub_safety_confirm_next_no": "如果确实没有安全警告，请加 --safety-warning no 确认。",
+        "pub_safety_confirm_next_excel": "Excel 字段可能不完整，你可以在其中补上安全警告列后重新运行。",
         "pub_compliance_docs_missing": "该类目要求上传合规文档但未提供。",
         "pub_compliance_missing_message": "部分合规字段缺失。您可以补充完整或发布为草稿。",
         "pub_compliance_fill_or_draft": "补充缺失的合规字段，或发布为草稿（Draft）稍后在 Seller Center 中完善。",

package/dist/scripts/product_client.py

@@ -360,15 +360,14 @@ class ProductClient:
 
         # GPSR compliance fields are injected at SKU level (see below).
 
-        # Delivery method -> Miravia create field ``Attributes.deliverySof``
-        # ("DBM" or "DBS"). Only written when the seller explicitly chose one;
+        # Delivery method -> Miravia create field ``Attributes.delivery_option_sof``,
+        # which is a YES/NO flag: "Yes" = DBS (seller-fulfilled), "No" = DBM
+        # (platform-fulfilled). Only written when the seller explicitly chose one;
         # when absent, publish_module._check_dbm_limits applies the default
-        # (DBM generally, DBS if the seller has DBS permission).
+        # (No/DBM generally, Yes/DBS if the seller has DBS permission).
         _dm = str(data.get("delivery_method") or "").strip().upper()
-        if "DBS" in _dm:
-            attributes["deliverySof"] = "DBS"
-        elif "DBM" in _dm:
-            attributes["deliverySof"] = "DBM"
+        if _dm in ("DBM", "DBS"):
+            attributes["delivery_option_sof"] = "Yes" if _dm == "DBS" else "No"
 
         product_payload: Dict[str, Any] = {
             "PrimaryCategory": category_id,
@@ -407,13 +406,14 @@ class ProductClient:
         if draft:
             product_payload["Status"] = "inactive"
 
-        # Country-specific prices (best-effort mapping)
-        country_prices = data.get("country_general_prices", {})
-        if country_prices:
-            product_payload["CountryPrice"] = [
-                {"country": c, "price": str(p)}
-                for c, p in country_prices.items()
-            ]
+        # Country-specific prices are NOT injected here at the product level.
+        # Verified against the authoritative /product/create contract: each
+        # country override lives INSIDE the SKU as
+        # ``CountryPrice: [{"CountryCode":"ES","Price":"1.9","SalePrice":"1.8"}]``
+        # (capitalised keys). A product-level ``CountryPrice`` list with the
+        # old ``{"country","price"}`` shape is silently ignored by the API.
+        # This is built per SKU in
+        # ``PublishModule._build_sku_list_from_schema``.
 
         # Standard unit type / count
         if data.get("standard_unit_type"):

package/dist/scripts/product_skill.py

@@ -815,7 +815,8 @@ def main() -> None:
             print(json.dumps(auth_payload, indent=2, ensure_ascii=False))
         return
 
-    if not skip_credential_check and args.scenario and not getattr(args, "authorized", False):
+    already_authorized = getattr(args, "authorized", False) or config.has_valid_business_credentials()
+    if not skip_credential_check and args.scenario and not already_authorized:
         auth_payload = {
             "status": "need_authorization",
             "title": i18n._("pub_authorization_title"),

package/dist/scripts/publish_module.py

@@ -801,32 +801,55 @@ class PublishModule:
         *,
         has_dbs_permission: bool = False,
     ) -> Optional[Dict[str, Any]]:
-        """Resolve ``Attributes.deliverySof`` and enforce DBM package limits.
-
-        Miravia ``/product/create`` expects ``Attributes.deliverySof`` to be
-        ``"DBM"`` or ``"DBS"``. When the seller did not choose one it is
-        defaulted here: generally DBM, but DBS when the seller has DBS
-        permission. If the effective method is DBM but the package exceeds the
-        DBM limits (weight <= 40KG, L+W+H <= 300cm, volumetric weight
-        L*W*H/6000 <= 40), it is switched to DBS when permitted, otherwise the
-        caller blocks. Returns a result dict, or None when nothing to do.
+        """Resolve ``Attributes.delivery_option_sof`` and enforce DBM package limits.
+
+        Miravia ``/product/create`` expects ``Attributes.delivery_option_sof`` to be
+        a YES/NO flag: ``"Yes"`` = DBS (seller-fulfilled), ``"No"`` = DBM
+        (platform-fulfilled). The legacy ``deliverySof="DBM"/"DBS"`` literal is
+        silently ignored by the platform. Internally we normalise to ``"DBM"``/
+        ``"DBS"`` for the package-limit logic and always write the flag back as
+        Yes/No. When the seller did not choose one it is defaulted here: generally
+        DBM (No), but DBS (Yes) when the seller has DBS permission. If the
+        effective method is DBM but the package exceeds the DBM limits (weight
+        <= 40KG, L+W+H <= 300cm, volumetric weight L*W*H/6000 <= 40), it is
+        switched to DBS when permitted, otherwise the caller blocks. Returns a
+        result dict, or None when nothing to do.
         """
         attrs = product_payload.setdefault("Attributes", {})
-        delivery_method = str(attrs.get("deliverySof") or "").strip().upper()
+
+        def _write_flag(method: str) -> None:
+            # Canonical wire flag the platform actually honours; replaces the
+            # legacy deliverySof value so no stale key lingers.
+            attrs["delivery_option_sof"] = "Yes" if method == "DBS" else "No"
+            attrs.pop("deliverySof", None)
+
+        _raw = str(
+            attrs.get("delivery_option_sof") or attrs.get("deliverySof") or ""
+        ).strip().upper()
+        # Accept the wire flag (Yes/No) as well as legacy DBM/DBS codes.
+        if _raw in ("YES", "DBS"):
+            delivery_method = "DBS"
+        elif _raw in ("NO", "DBM"):
+            delivery_method = "DBM"
+        else:
+            delivery_method = ""
         downgraded_from_dbs = False
 
         if delivery_method not in ("DBM", "DBS"):
             # No explicit entry: default to DBS when the seller is permitted,
             # otherwise DBM.
             delivery_method = "DBS" if has_dbs_permission else "DBM"
-            attrs["deliverySof"] = delivery_method
+            _write_flag(delivery_method)
         elif delivery_method == "DBS" and not has_dbs_permission:
             # Seller explicitly chose DBS but the account has no DBS permission:
             # never grant DBS without permission — fall back to DBM and still
             # enforce the DBM package limits below.
             delivery_method = "DBM"
-            attrs["deliverySof"] = "DBM"
+            _write_flag(delivery_method)
             downgraded_from_dbs = True
+        else:
+            # Normalise an explicit/legacy value to the canonical Yes/No flag.
+            _write_flag(delivery_method)
 
         # Only DBM carries package limits.
         if delivery_method != "DBM":
@@ -874,7 +897,7 @@ class PublishModule:
         # Exceeded DBM limits — check DBS permission
         if has_dbs_permission:
             # Auto-switch to DBS
-            attrs["deliverySof"] = "DBS"
+            _write_flag("DBS")
             return {
                 "switched_to_dbs": True,
                 "reasons": exceeded,
@@ -915,7 +938,9 @@ class PublishModule:
         seller_sku_required = self._field_is_required(
             "SellerSku", category_attributes or []
         )
-        _validate_create_payload(product_payload, seller_sku_required=seller_sku_required)
+        _validate_create_payload(
+            product_payload, seller_sku_required=seller_sku_required, draft=draft
+        )
 
         # Check DBM limits — auto-switch to DBS if exceeded (requires DBS permission)
         has_dbs = self.product.get_shipping_permission()
@@ -1377,6 +1402,40 @@ class PublishModule:
         if mapping_check:
             return mapping_check
 
+        # Safety warning: honor an explicit --safety-warning in the source flow.
+        # build_create_product_payload defaults the flag to "No" and manual mode
+        # applies the CLI flags at build time, but the Excel/source flow never did
+        # — so --safety-warning was silently ignored here. Apply it now so the
+        # seller's explicit choice is never overwritten by the default.
+        self._apply_safety_cli_override(product_payload)
+
+        # Safety guidance gate: never silently ship an inferred "No". If the seller
+        # has not chosen a value but the source carries real safety content, pause
+        # and ask them to confirm yes/no (or complete the Excel). The flag can only
+        # be auto-populated once the seller answers, per the "surface assumed
+        # values, do not silently replace" rule.
+        if getattr(self.args, "safety_warning", None) is None:
+            safety_evidence = self._detect_safety_content(product_payload, schema)
+            if safety_evidence:
+                current_flag = (product_payload.get("Attributes") or {}).get(
+                    "Does_this_product_have_a_safety_warning"
+                )
+                return {
+                    "status": "need_safety_warning_confirm",
+                    "title": i18n._("pub_safety_confirm_title"),
+                    "message": i18n._(
+                        "pub_safety_confirm_message",
+                        evidence=", ".join(safety_evidence),
+                    ),
+                    "detected_safety_content": safety_evidence,
+                    "current_value": current_flag,
+                    "next_actions": [
+                        i18n._("pub_safety_confirm_next_yes"),
+                        i18n._("pub_safety_confirm_next_no"),
+                        i18n._("pub_safety_confirm_next_excel"),
+                    ],
+                }
+
         # Stage 3b: unified compliance check (GPSR + Safety Warning + compliance docs)
         draft_issues: list = []
         compliance_check = self._check_compliance_fields(
@@ -1537,8 +1596,8 @@ class PublishModule:
 
     # Structural fields Miravia always requires for any product (not category
     # attributes, so the API never governs them) — always blocking. NOTE:
-    # delivery method (Attributes.deliverySof) is intentionally NOT here — it is
-    # auto-defaulted (DBM, or DBS when the seller has DBS permission) rather
+    # delivery method (Attributes.delivery_option_sof) is intentionally NOT here — it is
+    # auto-defaulted (DBM=No, or DBS=Yes when the seller has DBS permission) rather
     # than hard-collected; see _check_dbm_limits.
     _CORE_MANDATORY_KEYS = frozenset(
         {
@@ -2048,8 +2107,8 @@ class PublishModule:
         # jeans, so an empty EAN must NOT be flagged as missing.
         api_optional: List[str] = []
 
-        # Delivery method (Attributes.deliverySof) is NOT a hard-collect field:
-        # Miravia defaults it when absent (DBM, or DBS if the seller has DBS
+        # Delivery method (Attributes.delivery_option_sof) is NOT a hard-collect field:
+        # Miravia defaults it when absent (DBM=No, or DBS=Yes if the seller has DBS
         # permission — see _check_dbm_limits), so an empty value shows as
         # "Optional" here and never blocks.
         if not (getattr(schema, "delivery_method", None) or "").strip():
@@ -2844,7 +2903,8 @@ class PublishModule:
             )
             # Do NOT hard-require SellerSku here. Its mandatory-ness comes from
             # the category attribute API and is enforced in _validate_create_payload
-            # (not relaxed by draft). Omit empty values so create can auto-generate.
+            # (draft-aware: a live publish blocks an interface-mandatory empty value;
+            # a draft defers it). Omit empty values so create can auto-generate.
             if seller_sku:
                 sku["SellerSku"] = seller_sku
 
@@ -2892,6 +2952,25 @@ class PublishModule:
             if sku_images:
                 sku["Images"] = {"Image": sku_images}
 
+            # Country-specific prices live INSIDE each SKU (per the
+            # authoritative /product/create contract), with capitalised keys
+            # ``CountryCode`` / ``Price`` / ``SalePrice``. ``country_general_prices``
+            # supplies the per-country Price and ``country_discounted_prices``
+            # the per-country SalePrice. A product-level list or the old
+            # lowercase ``{"country","price"}`` shape is silently ignored.
+            _cgp = schema.country_general_prices or {}
+            _cdp = schema.country_discounted_prices or {}
+            _country_price = []
+            for _cc in sorted(set(_cgp) | set(_cdp)):
+                _entry: Dict[str, Any] = {"CountryCode": _cc}
+                if _cgp.get(_cc) not in (None, ""):
+                    _entry["Price"] = str(_cgp[_cc])
+                if _cdp.get(_cc) not in (None, ""):
+                    _entry["SalePrice"] = str(_cdp[_cc])
+                _country_price.append(_entry)
+            if _country_price:
+                sku["CountryPrice"] = _country_price
+
             skus.append(sku)
 
         if len(skus) > _MAX_SKUS_PER_PRODUCT:
@@ -2900,6 +2979,84 @@ class PublishModule:
             )
         return skus
 
+    # Boilerplate default warning text — must NOT be treated as real safety content.
+    _SAFETY_CONTENT_DEFAULT = "no specific safety warnings apply to this product"
+
+    def _apply_safety_cli_override(self, product_payload: Dict[str, Any]) -> None:
+        """Honor ``--safety-warning`` / ``--safety-warning-content`` in the source flow.
+
+        ``build_create_product_payload`` defaults ``Does_this_product_have_a_safety_warning``
+        to "No" when ``schema.safety_warning`` is falsy, and manual mode applies the CLI
+        flags at build time (see the manual path). The Excel/source flow never applied
+        them, so ``--safety-warning`` was silently ignored there. Write the seller's
+        explicit choice here using the same "Yes"/"No" casing the client already emits,
+        so the platform contract is unchanged and only the previously-ignored flag is
+        now respected.
+        """
+        safety_arg = getattr(self.args, "safety_warning", None)
+        if safety_arg is None:
+            return
+        is_yes = str(safety_arg).strip().lower() in ("yes", "1", "true", "y")
+        attributes = product_payload.setdefault("Attributes", {})
+        value = "Yes" if is_yes else "No"
+        attributes["Does this product have a safety warning"] = value
+        attributes["Does_this_product_have_a_safety_warning"] = value
+        content = getattr(self.args, "safety_warning_content", None)
+        if is_yes and content:
+            attributes["Safety_warning_content"] = content
+
+    def _detect_safety_content(
+        self, product_payload: Dict[str, Any], schema: MiraviaListingSchema
+    ) -> List[str]:
+        """Return human-readable evidence that the product has safety info.
+
+        Used to decide whether the auto-defaulted safety flag should be surfaced
+        to the seller instead of shipped silently. Ignores the boilerplate default
+        warning text and a plain "No" flag so we do not raise false prompts. Counts
+        real safety artifacts that came from the source: safety documents
+        (Safety_Date_Sheet / CPSR / CPNP URLs), an affirmative Hazmat flag, a
+        non-default ``Safety_warning_content`` already present, or an explicit
+        ``Does_this_product_have_a_safety_warning=Yes``.
+        """
+        attributes = product_payload.get("Attributes") or {}
+        evidence: List[str] = []
+        for key, val in attributes.items():
+            if not isinstance(val, str) or not val.strip():
+                continue
+            low = key.lower()
+            # Skip the yes/no flag itself (handled explicitly below).
+            if low in (
+                "does this product have a safety warning",
+                "does_this_product_have_a_safety_warning",
+            ):
+                if val.strip().lower() == "yes":
+                    evidence.append(f"{key}=Yes")
+                continue
+            if not any(tok in low for tok in ("safety", "cpsr", "cpnp", "hazmat", "warning")):
+                continue
+            # Boilerplate default content is not evidence.
+            if self._SAFETY_CONTENT_DEFAULT in val.strip().lower():
+                continue
+            # A negative/empty Hazmat flag is not evidence.
+            if "hazmat" in low and val.strip().lower() in ("no", "false", "0", "n/a", "-"):
+                continue
+            # Null-like placeholder strings from empty cells are not evidence.
+            if val.strip().lower() in ("none", "null", "n/a", "na", "-"):
+                continue
+            display = val if len(val) <= 60 else val[:57] + "..."
+            evidence.append(f"{key}={display}")
+        sc = getattr(schema, "safety_warning_content", None)
+        if sc and self._SAFETY_CONTENT_DEFAULT not in str(sc).strip().lower():
+            evidence.append("safety_warning_content provided")
+        # Deduplicate while preserving order.
+        seen: set = set()
+        uniq: List[str] = []
+        for item in evidence:
+            if item not in seen:
+                seen.add(item)
+                uniq.append(item)
+        return uniq
+
     def _run_prevalidate(
         self, product_payload: Dict[str, Any]
     ) -> Optional[Dict[str, Any]]:
@@ -3505,6 +3662,7 @@ def _validate_title(title: str) -> None:
 def _validate_create_payload(
     payload: Dict[str, Any],
     seller_sku_required: bool = False,
+    draft: bool = False,
 ) -> None:
     """Validate a Miravia ``/product/create`` Product payload.
 
@@ -3514,7 +3672,9 @@ def _validate_create_payload(
 
     ``seller_sku_required`` is decided by the caller from the category attribute
     API (``_field_is_required``): when False, an empty SellerSku is allowed and
-    the create API auto-generates a unique value.
+    the create API auto-generates a unique value. When True but ``draft`` is set,
+    the empty value is deferred to the draft (surfaced as a draft_issue) rather
+    than hard-blocked, consistent with P7 — only a live publish enforces it.
     """
     attributes = payload.get("Attributes") or {}
     title = attributes.get("name")
@@ -3558,7 +3718,11 @@ def _validate_create_payload(
         raise ValueError(i18n._("pub_seller_sku_duplicate_in_product"))
 
     for idx, sku in enumerate(skus, start=1):
-        if seller_sku_required and not (sku.get("SellerSku") or sku.get("seller_sku")):
+        if (
+            seller_sku_required
+            and not draft
+            and not (sku.get("SellerSku") or sku.get("seller_sku"))
+        ):
             raise ValueError(i18n._("pub_seller_sku_required", idx=idx))
 
         price = sku.get("price")

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@miravia_test/miravia-publish-skill",
-  "version": "0.1.8",
+  "version": "0.1.9",
   "description": "Miravia Product Publish Skill installer — one command to install the Miravia AI product listing skill into any AI Agent (Qoder / Cursor / Claude Code). Upload materials and let the AI extract data and publish products automatically.",
   "bin": {
     "miravia-publish-skill": "bin/cli.js"