NocodeMrLi/mini-program-engineering-skill-suite
mini-program-engineering-suite
VerifiedOrchestrate evidence-first engineering for WeChat and other mini programs from a vague idea or existing repository through project discovery, product specification, architecture, implementation, debugging, device adaptation, verification, and release readiness. Use when users ask to build a mini program from zero to one, take over an existing mini-program project, deliver a cross-stage feature, diagnose project status, coordinate development and testing, or judge whether a mini program is ready to upload or release. Enforces fact discovery, change boundaries, stage gates, evidence-calibrated status, sensitive-information redaction, and continuity after side questions.
scripts/verify_public_package.py
View on GitHub#!/usr/bin/env python3
"""Verify an exported public package without consulting its source directory."""
from __future__ import annotations
import argparse
import hashlib
import json
import re
import sys
from pathlib import Path
from typing import Sequence
sys.dont_write_bytecode = True
from validate_suite import validate
MANIFEST_NAME = "package-manifest.json"
MAX_MANIFEST_BYTES = 2_000_000
MAX_MANIFEST_FILES = 10_000
MAX_RELATIVE_PATH_LENGTH = 512
SHA256_PATTERN = re.compile(r"^[0-9a-f]{64}$")
class DuplicateKeyError(ValueError):
"""Signal a duplicate JSON object key without exposing that key."""
def reject_duplicate_keys(pairs: list[tuple[str, object]]) -> dict[str, object]:
"""Build a JSON object while rejecting ambiguous duplicate keys."""
result: dict[str, object] = {}
for key, value in pairs:
if key in result:
raise DuplicateKeyError
result[key] = value
return result
def sha256_file(path: Path) -> str:
"""Return the SHA-256 digest for one package file."""
digest = hashlib.sha256()
with path.open("rb") as handle:
for chunk in iter(lambda: handle.read(65536), b""):
digest.update(chunk)
return digest.hexdigest()
def is_safe_manifest_path(value: object) -> bool:
"""Accept only normalized portable relative POSIX paths."""
if not isinstance(value, str) or not value or len(value) > MAX_RELATIVE_PATH_LENGTH:
return False
if "\\" in value or value.startswith("/") or value == MANIFEST_NAME:
return False
segments = value.split("/")
return all(segment not in {"", ".", ".."} for segment in segments)
def load_manifest(package: Path, errors: set[str]) -> dict[str, object] | None:
"""Load a size-bounded, unambiguous JSON manifest."""
manifest_path = package / MANIFEST_NAME
if manifest_path.is_symlink():
errors.add("manifest-invalid")
return None
if not manifest_path.is_file():
errors.add("manifest-missing")
return None
try:
if manifest_path.stat().st_size > MAX_MANIFEST_BYTES:
errors.add("manifest-invalid")
return None
manifest = json.loads(
manifest_path.read_text(encoding="utf-8"),
object_pairs_hook=reject_duplicate_keys,
)
except (DuplicateKeyError, OSError, UnicodeError, json.JSONDecodeError):
errors.add("manifest-invalid")
return None
if not isinstance(manifest, dict):
errors.add("manifest-invalid")
return None
return manifest
def parse_entries(
manifest: dict[str, object], errors: set[str]
) -> list[tuple[str, int, str]] | None:
"""Validate manifest metadata and return safe file entries."""
files = manifest.get("files")
file_count = manifest.get("file_count")
metadata_valid = (
manifest.get("format_version") == 1
and manifest.get("suite_name") == "mini-program-engineering-suite"
and isinstance(manifest.get("suite_version"), str)
and bool(manifest.get("suite_version"))
and manifest.get("suite_valid") is True
and manifest.get("sensitive_finding_count") == 0
and isinstance(files, list)
and isinstance(file_count, int)
and not isinstance(file_count, bool)
)
if not metadata_valid or not isinstance(files, list) or len(files) > MAX_MANIFEST_FILES:
errors.add("manifest-invalid")
return None
if file_count != len(files):
errors.add("manifest-file-count-mismatch")
suite_version = manifest.get("suite_version")
assert isinstance(suite_version, str)
# "VERSION" is part of every exported manifest; require the recorded
# suite_version to equal the VERSION file's content so a repackaged or
# tampered manifest cannot carry wrong version metadata with intact files.
for item in files if isinstance(files, list) else []:
if isinstance(item, dict) and item.get("path") == "VERSION":
break
else:
errors.add("manifest-invalid")
return None
entries: list[tuple[str, int, str]] = []
seen_paths: set[str] = set()
structural_error = False
for item in files:
if not isinstance(item, dict):
errors.add("manifest-invalid")
structural_error = True
continue
relative_path = item.get("path")
size = item.get("size")
digest = item.get("sha256")
if not is_safe_manifest_path(relative_path):
errors.add("manifest-path-invalid")
structural_error = True
continue
assert isinstance(relative_path, str)
if relative_path in seen_paths:
errors.add("manifest-duplicate-path")
structural_error = True
continue
seen_paths.add(relative_path)
if (
not isinstance(size, int)
or isinstance(size, bool)
or size < 0
or not isinstance(digest, str)
or not SHA256_PATTERN.fullmatch(digest)
):
errors.add("manifest-invalid")
structural_error = True
continue
entries.append((relative_path, size, digest))
return None if structural_error else entries
def actual_package_files(package: Path, errors: set[str]) -> set[str]:
"""Collect regular package files and reject symbolic links."""
files: set[str] = set()
for candidate in sorted(package.rglob("*")):
if candidate.is_symlink():
errors.add("unsupported-file")
continue
if candidate.is_file():
files.add(candidate.relative_to(package).as_posix())
return files
def check_version_binding(package: Path, manifest: dict[str, object], errors: set[str]) -> None:
"""Bind manifest version metadata to the packaged VERSION file.
An intact content set could otherwise ship under wrong version metadata
(audit finding: receiver-side version binding was non-existent).
"""
suite_version = manifest.get("suite_version")
version_file = package / "VERSION"
try:
packaged_version = version_file.read_text(encoding="utf-8").strip()
except (OSError, UnicodeError):
packaged_version = ""
if not packaged_version or not isinstance(suite_version, str) or packaged_version != suite_version:
errors.add("version-metadata-mismatch")
def verify_package(package: Path) -> dict[str, object]:
"""Return a redacted integrity report for one exported package."""
errors: set[str] = set()
if package.is_symlink() or not package.is_dir():
return {"valid": False, "verified_file_count": 0, "errors": ["package-invalid"]}
manifest = load_manifest(package, errors)
if manifest is None:
return {"valid": False, "verified_file_count": 0, "errors": sorted(errors)}
entries = parse_entries(manifest, errors)
if entries is None:
return {"valid": False, "verified_file_count": 0, "errors": sorted(errors)}
actual_files = actual_package_files(package, errors)
expected_files = {entry[0] for entry in entries} | {MANIFEST_NAME}
if expected_files - actual_files:
errors.add("file-missing")
if actual_files - expected_files:
errors.add("unexpected-file")
# Bind manifest version metadata to the packaged VERSION file.
check_version_binding(package, manifest, errors)
checked_files = 0
for relative_path, expected_size, expected_digest in entries:
target = package.joinpath(*relative_path.split("/"))
if target.is_symlink() or not target.is_file():
continue
try:
if target.stat().st_size != expected_size:
errors.add("file-size-mismatch")
if sha256_file(target) != expected_digest:
errors.add("file-hash-mismatch")
checked_files += 1
except OSError:
errors.add("file-unreadable")
if not errors:
try:
suite_report = validate(package)
except (OSError, UnicodeError):
errors.add("suite-structure-invalid")
else:
if not suite_report["valid"]:
errors.add("suite-structure-invalid")
return {
"valid": not errors,
"verified_file_count": checked_files,
"errors": sorted(errors),
}
def main(argv: Sequence[str] | None = None) -> int:
"""Verify a package and emit a redacted machine-readable result."""
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument("package", type=Path, help="Exported package directory")
args = parser.parse_args(argv)
report = verify_package(args.package)
print(json.dumps(report, ensure_ascii=False, indent=2, sort_keys=True))
return 0 if report["valid"] else 1
if __name__ == "__main__":
raise SystemExit(main())
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| finishing-a-development-branchobra/superpowersUse when implementation is complete, all tests pass, and you need to decide how to integrate the work | Stars: 319k | Updated | Claude CodeCodex | Verified | Install |
| systematic-debuggingobra/superpowersUse when encountering any bug, test failure, or unexpected behavior, before proposing fixes | Stars: 319k | Updated | Claude CodeCodex | Verified | Install |
| test-driven-developmentobra/superpowersUse when implementing any feature or bugfix, before writing implementation code | Stars: 319k | Updated | Claude CodeCodex | Verified | Install |
| skill-creatoranthropics/skillsCreate new skills, modify and improve existing skills, and measure skill performance. Use when users want to create a skill from scratch, edit, or optimize an existing skill, run evals to test a skill, benchmark skill performance with variance analysis, or optimize a skill's description for better triggering accuracy. | Stars: 196k | Updated | Claude CodeCodex | Verified | Install |