@miraiva_test/miravia-order-report 0.1.13

package/dist/scripts/run.bat

@@ -0,0 +1,15 @@
+@echo off
+REM ──────────────────────────────────────────────────────────────────────
+REM run.bat — Windows CMD wrapper for running any Python script
+REM
+REM Purpose: Bypass PowerShell Constrained Language Mode that blocks
+REM .NET method calls (System.Convert, System.Text.Encoding) in
+REM enterprise-managed Windows environments.
+REM
+REM Usage:  scripts\run.bat <script.py> [arguments...]
+REM Example: scripts\run.bat scripts/export_orders.py --agent-type cursor --ping
+REM          scripts\run.bat scripts/estimate_time.py --agent-type cursor --last-days 30
+REM ──────────────────────────────────────────────────────────────────────
+
+cd /d "%~dp0.."
+python %*

package/dist/scripts/skill_crypto.py

@@ -0,0 +1,86 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Skill Hub encrypted payload decryption.
+
+Aligned with server-side SkillSignatureUtil:
+- Cipher: RSA/ECB/PKCS1Padding (signMethod=SHA256withRSA / SHA1withRSA default)
+         or RSA/ECB/OAEPWithSHA-512AndMGF1Padding (signMethod=SHA512withRSA)
+- Encoding: Base64URL (no padding)
+- Chunking: each ciphertext block = keySize / 8 (RSA-2048 -> 256 bytes)
+
+Dependency: cryptography>=41
+"""
+
+from __future__ import annotations
+
+import base64
+import json
+from typing import Dict
+
+from cryptography.hazmat.primitives import hashes, serialization
+from cryptography.hazmat.primitives.asymmetric import padding as asym_padding
+from cryptography.hazmat.primitives.asymmetric.rsa import RSAPrivateKey
+
+
+class SkillAuthDecryptError(RuntimeError):
+    pass
+
+
+def _b64url_decode(s: str) -> bytes:
+    if not s:
+        raise SkillAuthDecryptError("cipher is empty")
+    s = s.strip()
+    pad = "=" * (-len(s) % 4)
+    try:
+        return base64.urlsafe_b64decode(s + pad)
+    except Exception as e:  # noqa: BLE001
+        raise SkillAuthDecryptError(f"cipher Base64URL decode failed: {e}") from e
+
+
+def _build_padding(sign_method: str):
+    sm = (sign_method or "").upper()
+    if sm == "SHA512WITHRSA":
+        return asym_padding.OAEP(
+            mgf=asym_padding.MGF1(algorithm=hashes.SHA512()),
+            algorithm=hashes.SHA512(),
+            label=None,
+        )
+    # SHA256withRSA / SHA1withRSA defaults to PKCS1v15, aligned with server-side default
+    return asym_padding.PKCS1v15()
+
+
+def decrypt_payload(
+    cipher_b64url: str,
+    private_key_pem: bytes,
+    sign_method: str = "SHA256withRSA",
+) -> Dict:
+    """RSA chunked decryption of encryptedPayload, returns parsed JSON dict."""
+    raw = _b64url_decode(cipher_b64url)
+
+    try:
+        sk = serialization.load_pem_private_key(private_key_pem, password=None)
+    except Exception as e:  # noqa: BLE001
+        raise SkillAuthDecryptError(f"Failed to load private key: {e}") from e
+    if not isinstance(sk, RSAPrivateKey):
+        raise SkillAuthDecryptError("Private key is not RSA type")
+
+    block_size = sk.key_size // 8  # RSA-2048 → 256
+    if len(raw) == 0 or len(raw) % block_size != 0:
+        raise SkillAuthDecryptError(
+            f"cipher length {len(raw)} is not a multiple of block_size={block_size}"
+        )
+
+    pad = _build_padding(sign_method)
+    parts = []
+    try:
+        for i in range(0, len(raw), block_size):
+            parts.append(sk.decrypt(raw[i : i + block_size], pad))
+    except Exception as e:  # noqa: BLE001
+        raise SkillAuthDecryptError(f"RSA chunked decryption failed: {e}") from e
+
+    plaintext = b"".join(parts)
+    try:
+        return json.loads(plaintext.decode("utf-8"))
+    except (UnicodeDecodeError, json.JSONDecodeError) as e:
+        raise SkillAuthDecryptError(f"Plaintext is not valid JSON: {e}") from e

package/dist/scripts/skill_keypair.py

@@ -0,0 +1,86 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Skill keypair management (consumer side only)
+
+The private key is generated by the backend during Skill registration;
+the seller persists it to .keypair.json during initialization.
+This module only reads and normalizes the format (raw Base64 -> PEM).
+
+File location: <skill_dir>/.keypair.json
+File format (example):
+{
+  "skill_code":  "<32-char skillCode>",
+  "private_key": "-----BEGIN PRIVATE KEY-----\\n...\\n-----END PRIVATE KEY-----",
+  "sign_method": "SHA256withRSA"
+}
+
+private_key can also be raw Base64 (PKCS#8 single-line); this module auto-wraps it into PEM.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import textwrap
+from typing import Dict
+
+import config
+
+
+class SkillKeypairError(RuntimeError):
+    pass
+
+
+def _to_pem(private_key_str: str) -> bytes:
+    """Normalize a private key string into PEM bytes.
+
+    Supports two input formats:
+    - Already PEM text (with -----BEGIN/-----END headers);
+    - Raw Base64 PKCS#8 single-line (no headers), auto-wrapped into PEM.
+    """
+    s = private_key_str.strip()
+    if not s:
+        raise SkillKeypairError("private_key is empty")
+    if "BEGIN" in s and "END" in s:
+        # Already PEM; normalize line endings
+        return s.replace("\r\n", "\n").encode("utf-8")
+    # Raw Base64 -> wrap as PEM; fold at 64 chars
+    body = "\n".join(textwrap.wrap(s, 64))
+    pem = f"-----BEGIN PRIVATE KEY-----\n{body}\n-----END PRIVATE KEY-----\n"
+    return pem.encode("utf-8")
+
+
+def load_keypair(path: str = None) -> Dict:
+    """Read .keypair.json and return a dict.
+
+    Returned fields:
+    - skill_code: str
+    - private_key_pem: bytes (PEM format, can be fed directly to cryptography.serialization.load_pem_private_key)
+    - sign_method: str (default SHA256withRSA)
+    """
+    path = path or config.KEYPAIR_FILE
+    if not os.path.exists(path):
+        raise SkillKeypairError(
+            f".keypair.json not found: {path}\n"
+            f"Please persist the Skill-registered private key and skillCode to this file.\n"
+            f"Template: {{\"skill_code\":\"...\",\"private_key\":\"-----BEGIN PRIVATE KEY-----...\",\"sign_method\":\"SHA256withRSA\"}}"
+        )
+    try:
+        with open(path, "r", encoding="utf-8") as f:
+            raw = json.load(f)
+    except json.JSONDecodeError as e:
+        raise SkillKeypairError(f".keypair.json parse failed: {e}") from e
+
+    skill_code = (raw.get("skill_code") or "").strip()
+    private_key = raw.get("private_key") or ""
+    if not skill_code:
+        raise SkillKeypairError(".keypair.json missing skill_code")
+    if not private_key:
+        raise SkillKeypairError(".keypair.json missing private_key")
+
+    return {
+        "skill_code": skill_code,
+        "private_key_pem": _to_pem(private_key),
+        "sign_method": (raw.get("sign_method") or "SHA256withRSA").strip(),
+    }

package/dist/scripts/skill_logger.py

@@ -0,0 +1,262 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Skill invocation logging module
+
+Log file naming: logs/skill-{date}.log
+Appends one JSON line per skill invocation with structured call details.
+
+Field descriptions (aligned with backend reporting protocol):
+  - SellerID        : Current authorized seller ID (from credentials.json, empty if missing)
+  - SkillName       : Fixed "miravia_order_reports"
+  - Action          : Invocation scenario/action (export / refund / business / inspect / ping)
+  - AgentType       : Agent type (empty if not Agent-driven)
+  - ModelName       : Model name (empty if no LLM invoked)
+  - Duration        : Human-readable duration (e.g. "12.3s")
+  - Status          : Invocation result "success" / "fail"
+  - ErrorCode       : Error code (empty on success)
+  - apiCallUrl      : API URLs involved in this call (deduplicated)
+  - apiCallCount    : Total API call count
+  - apiSuccessCount : Successful API call count
+  - dataCount       : Number of data rows fetched
+  - durationMs      : Duration in milliseconds
+  - envData         : Environment info object
+    - os            : Operating system name
+    - os_version    : Operating system version
+    - node_version  : Node.js version (empty for Python skill)
+    - agent_version : Agent/Skill version
+    - locale        : System locale
+  - remark          : Remarks
+"""
+
+import json
+import logging
+import os
+import platform
+import locale
+import time
+from datetime import datetime
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+
+# Skill root directory / logs
+_SKILL_DIR = Path(__file__).resolve().parent.parent
+_LOGS_DIR = _SKILL_DIR / "logs"
+
+SKILL_NAME = "miravia_order_reports"
+
+# Version: read from npm-package/package.json as single source of truth
+def _read_version() -> str:
+    """Read version from npm-package/package.json; fallback to hardcoded if unavailable."""
+    try:
+        pkg_path = _SKILL_DIR / "npm-package" / "package.json"
+        if pkg_path.exists():
+            data = json.loads(pkg_path.read_text(encoding="utf-8"))
+            return str(data.get("version", "0.0.0"))
+    except Exception:
+        pass
+    return "0.0.0"
+
+SKILL_VERSION = _read_version()
+
+# ---- agent_type global state (CLI required input, no auto-detection) ----
+_agent_type: str = ""
+
+
+def set_agent_type(agent_type: str) -> None:
+    """Called by CLI entry at startup to set global agent_type.
+
+    agent_type must be explicitly passed by the calling Agent via --agent-type CLI parameter;
+    no auto-detection or inference is performed.
+    """
+    global _agent_type
+    _agent_type = agent_type.strip()
+
+
+def get_agent_type() -> str:
+    """Get current global agent_type.
+
+    Returns empty string if set_agent_type() has not been called.
+    """
+    return _agent_type
+
+
+def detect_model_name() -> str:
+    """Detect the LLM model name used by the current Agent.
+
+    Priority:
+      1. Environment variable SKILL_MODEL_NAME (explicit override, highest priority)
+      2. Match model env var by AgentType:
+         - claude -> ANTHROPIC_MODEL
+         - qoder  -> QODER_MODEL (not exposed yet, empty)
+         - cursor -> CURSOR_MODEL
+      3. Fallback to empty string (undetectable)
+    """
+    # 1. Explicit override
+    explicit = os.environ.get("SKILL_MODEL_NAME", "").strip()
+    if explicit:
+        return explicit
+
+    agent = get_agent_type()
+
+    # 2. Claude Code: ANTHROPIC_MODEL is its standard config
+    if agent == "claude":
+        val = os.environ.get("ANTHROPIC_MODEL", "").strip()
+        if val:
+            return val
+
+    # 3. Qoder: does not expose model name env var yet; expects QODER_MODEL later
+    if agent == "qoder":
+        val = os.environ.get("QODER_MODEL", "").strip()
+        if val:
+            return val
+
+    # 4. Cursor
+    if agent == "cursor":
+        for key in ("CURSOR_MODEL", "OPENAI_MODEL"):
+            val = os.environ.get(key, "").strip()
+            if val:
+                return val
+
+    return ""
+
+
+class ApiCallTracker:
+    """Track API call count and results for final log entry."""
+
+    def __init__(self):
+        self.call_count: int = 0
+        self.success_count: int = 0
+        self.urls: List[str] = []
+        self._url_set: set = set()
+
+    def record(self, url: str, success: bool) -> None:
+        self.call_count += 1
+        if success:
+            self.success_count += 1
+        if url not in self._url_set:
+            self._url_set.add(url)
+            self.urls.append(url)
+
+    def reset(self) -> None:
+        self.call_count = 0
+        self.success_count = 0
+        self.urls.clear()
+        self._url_set.clear()
+
+
+# Global tracker instance (referenced by miravia_client.py)
+api_tracker = ApiCallTracker()
+
+
+def _get_seller_id() -> str:
+    """Read seller_id from credentials.json if available, otherwise return empty string."""
+    cred_file = _SKILL_DIR / "credentials.json"
+    if not cred_file.exists():
+        return ""
+    try:
+        data = json.loads(cred_file.read_text(encoding="utf-8"))
+        return str(data.get("seller_id", "") or "")
+    except (OSError, json.JSONDecodeError):
+        return ""
+
+
+def _get_env_data() -> Dict[str, str]:
+    """Collect runtime environment info."""
+    sys_name = platform.system()  # e.g. "Darwin", "Linux", "Windows"
+    sys_version = platform.release()  # e.g. "26.3.1"
+    try:
+        sys_locale = locale.getdefaultlocale()[0] or ""
+    except Exception:
+        sys_locale = ""
+    return {
+        "os": sys_name,
+        "os_version": sys_version,
+        "node_version": "",  # Python skill, not applicable
+        "agent_version": SKILL_VERSION,
+        "locale": sys_locale,
+    }
+
+
+# Log retention days
+_LOG_RETENTION_DAYS = 5
+
+
+def _log_file_path() -> Path:
+    """Return today's log file path: logs/skill-{YYYY-MM-DD}.log"""
+    _LOGS_DIR.mkdir(parents=True, exist_ok=True)
+    date_str = datetime.now().strftime("%Y-%m-%d")
+    return _LOGS_DIR / f"skill-{date_str}.log"
+
+
+def _cleanup_old_logs() -> None:
+    """Delete skill log files older than _LOG_RETENTION_DAYS days."""
+    if not _LOGS_DIR.exists():
+        return
+    from datetime import timedelta
+    cutoff = datetime.now() - timedelta(days=_LOG_RETENTION_DAYS)
+    for f in _LOGS_DIR.glob("skill-*.log"):
+        # Parse date from filename: skill-YYYY-MM-DD.log
+        try:
+            date_part = f.stem.replace("skill-", "")
+            file_date = datetime.strptime(date_part, "%Y-%m-%d")
+            if file_date < cutoff:
+                f.unlink(missing_ok=True)
+        except (ValueError, OSError):
+            pass
+
+
+def write_skill_log(
+    action: str,
+    status: str,
+    duration_ms: int,
+    data_count: int = 0,
+    error_code: str = "",
+    remark: str = "",
+    seller_id: Optional[str] = None,
+) -> None:
+    """Write one skill invocation log entry to logs/skill-{date}.log.
+
+    Args:
+        action: Scenario/action name (export / refund / business / inspect / ping)
+        status: "success" / "fail"
+        duration_ms: Duration in milliseconds
+        data_count: Number of data rows fetched
+        error_code: Error code (empty on success)
+        remark: Remarks
+        seller_id: Optional seller_id override
+    """
+    record = {
+        "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S.%f")[:-3],
+        "SellerID": seller_id if seller_id is not None else _get_seller_id(),
+        "SkillName": SKILL_NAME,
+        "Action": action,
+        "AgentType": get_agent_type(),
+        "ModelName": detect_model_name(),
+        "Duration": f"{duration_ms / 1000:.1f}s" if duration_ms >= 1000 else f"{duration_ms}ms",
+        "Status": status,
+        "ErrorCode": error_code,
+        "apiCallUrl": api_tracker.urls,
+        "apiCallCount": api_tracker.call_count,
+        "apiSuccessCount": api_tracker.success_count,
+        "dataCount": data_count,
+        "durationMs": duration_ms,
+        "envData": _get_env_data(),
+        "remark": remark,
+    }
+
+    log_path = _log_file_path()
+    try:
+        with open(log_path, "a", encoding="utf-8") as f:
+            f.write(json.dumps(record, ensure_ascii=False) + "\n")
+    except OSError as e:
+        logging.getLogger("miravia.skill_logger").warning(
+            "Failed to write skill log: %s", e
+        )
+
+    # Attempt to clean up expired logs after each write
+    try:
+        _cleanup_old_logs()
+    except Exception:
+        pass