Upload 14 files

app.py

@@ -430,12 +430,22 @@ class ValidateResourceRequest(BaseModel):
 
 from resource_probe_service import probe_resource
 from github_probe_transport import open_github_probe
+from skill_preflight import verify_skill_manifest
+from router_proxy import _send_with_validated_redirects
+from safe_http_transport import ValidatedAsyncHTTPTransport
+import httpx
+
+
+def _probe_skill_manifest(item, token):
+    return verify_skill_manifest(item, token, send=_send_with_validated_redirects,
+        client_factory=httpx.AsyncClient, transport_factory=ValidatedAsyncHTTPTransport)
 
 @app.post("/api/validate_resource")
-def validate_resource(req_data: ValidateResourceRequest, sql_db: Session = Depends(get_db), current_user: str = Depends(require_auth)):
+@shared_limit(30)
+def validate_resource(req_data: ValidateResourceRequest, request: Request, sql_db: Session = Depends(get_db), current_user: str = Depends(require_auth)):
     return probe_resource(req_data.item_id, store=db, download=hf_hub_download,
                           open_url=open_github_probe, token_selector=select_github_token,
-                          error_response=create_error_response)
+                          error_response=create_error_response, skill_probe=_probe_skill_manifest)
 
 # ==========================================
 # 🔒 管理员：系统配置 API

github_archive.py

@@ -3,7 +3,7 @@ import datetime
 import hashlib
 import json
 import re
-from github_source import canonical_repository
+from github_source import canonical_resource_source
 
 ARCHIVE_SCHEMA = 3
 ARCHIVE_MAX_BYTES = 500 * 1024 * 1024
@@ -34,7 +34,7 @@ def source_signature(item, token):
     author = item.get('author')
     if not isinstance(author, str) or not author.strip():
         raise ValueError('invalid archive author')
-    source = [canonical_repository(item.get('link')).lower(), author, token or '']
+    source = [canonical_resource_source(item), author, token or '']
     # 元数据只保存摘要，不保存或输出凭据。
     return hashlib.sha256(json.dumps(source, ensure_ascii=True, separators=(',', ':')).encode()).hexdigest()
 

github_source.py

@@ -2,6 +2,7 @@
 import os
 import re
 from urllib.parse import urlsplit
+from skill_archive_source import item_source, source_key
 
 
 def repository_parts(url):
@@ -28,6 +29,14 @@ def canonical_repository(url):
     return f'https://github.com/{owner}/{repo}'
 
 
+def github_item_source(item):
+    return item_source(item, repository_parts)
+
+
+def canonical_resource_source(item):
+    return source_key(github_item_source(item))
+
+
 def _token(value):
     if value is None or value == '':
         return None
@@ -37,7 +46,7 @@ def _token(value):
 
 
 def select_github_token(item, *, admin_check=None):
-    repository_parts(item.get('link'))
+    github_item_source(item)
     author = item.get('author')
     if not isinstance(author, str) or not author.strip():
         raise ValueError('invalid resource author')

github_versions.py

@@ -2,7 +2,7 @@
 import asyncio
 import uuid
 from github_archive import commit_sha, source_signature
-from github_source import select_github_token
+from github_source import select_github_token, github_item_source
 from proxy_access import read_proxy_item
 
 
@@ -83,7 +83,19 @@ def invalidate_source(store, item_id):
 async def refresh_resource_version(store, item_id):
     from 云端_定时版本检测引擎 import fetch_github_commit
     operation = await asyncio.to_thread(begin_probe, store, item_id)
-    sha = await fetch_github_commit(operation['item']['link'], operation['token'])
+    source = github_item_source(operation['item'])
+    if source['tree']:
+        import httpx
+        from skill_archive_source import resolve_tree
+        from safe_http_transport import ValidatedAsyncHTTPTransport
+        from router_proxy import _send_with_validated_redirects
+        try:
+            sha, _ = await resolve_tree(source, operation['token'], send=_send_with_validated_redirects,
+                client_factory=httpx.AsyncClient, transport_factory=ValidatedAsyncHTTPTransport)
+        except Exception:
+            return None
+    else:
+        sha = await fetch_github_commit(operation['item']['link'], operation['token'])
     if not sha:
         return None
     return await asyncio.to_thread(finish_probe, store, operation, sha)

github_zip_service.py

@@ -2,7 +2,8 @@
 import asyncio
 import os
 from github_archive import cached_archive
-from github_source import repository_parts
+from github_source import github_item_source
+from skill_archive_source import resolve_tree, source_header, installation_revision, source_key
 from proxy_resources import ProxyResources
 from workflow_stream_response import OwnedProxyResponse
 from zip_stream import zip_response_length, stream_zip_bytes
@@ -10,12 +11,14 @@ from zip_stream import zip_response_length, stream_zip_bytes
 
 async def prepare_github_zip(item, item_id, *, store, token_selector, resolve_commit,
                              send, client_factory, transport_factory, error_response,
-                             cache_max_bytes, direct_max_bytes):
+                             cache_max_bytes, direct_max_bytes, signing_key=None):
     # 按服务端资源解析仓库，普通作者只使用本人绑定凭据或匿名GitHub。
     try:
-        repo_url = item.get("link", "")
-        owner, repo = repository_parts(repo_url)
+        source = github_item_source(item)
+        repo_url = source["repository"] if source["tree"] else item.get("link", "")
+        owner, repo = source["owner"], source["repo"]
         active_token = token_selector(item)
+        skill_revision = installation_revision(item, source_key(source), active_token, signing_key=signing_key) if source['skill'] else None
     except ValueError:
         return error_response(content={"error": "资源仓库或凭据暂时无法核实"}, status_code=503)
 
@@ -25,7 +28,7 @@ async def prepare_github_zip(item, item_id, *, store, token_selector, resolve_co
     try:
         versions_db = store.load_data("versions.json", default_data={})
         item_version = versions_db.get(item_id)
-        archive = cached_archive(item, active_token, item_version, repo_id=store.DATASET_REPO_ID)
+        archive = None if source["tree"] else cached_archive(item, active_token, item_version, repo_id=store.DATASET_REPO_ID)
         hf_cache_token = os.environ.get("HF_TOKEN")
         if archive and hf_cache_token:
             hf_headers = {"Authorization": f"Bearer {hf_cache_token}"}
@@ -48,6 +51,9 @@ async def prepare_github_zip(item, item_id, *, store, token_selector, resolve_co
                     cache_length = zip_response_length(stream_resp.headers, max_bytes=cache_max_bytes,
                                                        expected_size=expected_size)
                     cache_headers = {}
+                    if source["skill"]:
+                        cache_headers["X-Ranking-Skill-Source"] = source_header(source, ())
+                        cache_headers['X-Ranking-Skill-Revision'] = skill_revision
                     content_length = stream_resp.headers.get('content-length')
                     if content_length:
                         cache_headers["Content-Length"] = content_length
@@ -82,7 +88,15 @@ async def prepare_github_zip(item, item_id, *, store, token_selector, resolve_co
             await cache_resources.close()
 
     # 先取得完整commit，再按它下载；不在下载后另取“最新版本”冒充实际内容。
-    live_commit = await resolve_commit(repo_url, active_token)
+    subdirectory = ()
+    if source["tree"]:
+        try:
+            live_commit, subdirectory = await resolve_tree(source, active_token, send=send,
+                client_factory=client_factory, transport_factory=transport_factory)
+        except Exception:
+            return error_response(content={"error": "资源目录或版本暂时无法核实，请稍后重试"}, status_code=502)
+    else:
+        live_commit = await resolve_commit(repo_url, active_token)
     if not live_commit:
         return error_response(content={"error": "资源版本暂时无法核实，请稍后重试"}, status_code=502)
     github_zip_api = f"https://api.github.com/repos/{owner}/{repo}/zipball/{live_commit}"
@@ -113,6 +127,9 @@ async def prepare_github_zip(item, item_id, *, store, token_selector, resolve_co
             return error_response(content={"error": f"GITHUB_DOWNLOAD_FAILED: {err_msg}"}, status_code=502)
         declared_length = zip_response_length(response.headers, max_bytes=direct_max_bytes)
         resp_headers = {}
+        if source["skill"]:
+            resp_headers["X-Ranking-Skill-Source"] = source_header(source, subdirectory)
+            resp_headers['X-Ranking-Skill-Revision'] = skill_revision
         content_length = response.headers.get('content-length', '')
         if content_length:
             resp_headers["Content-Length"] = content_length

resource_probe_service.py

@@ -7,14 +7,15 @@ import urllib.parse
 import urllib.request
 import uuid
 from fastapi.responses import JSONResponse
-from github_source import repository_parts
+from github_source import github_item_source
 from proxy_access import read_proxy_item, ProxyAccessError
 from workflow_source import authorized_workflow_path, WorkflowSourceError
+from skill_archive_source import SkillSourceError
 
 logger = logging.getLogger("ComfyUI-Ranking")
 
 
-def probe_resource(item_id, *, store, download, open_url, token_selector, error_response):
+def probe_resource(item_id, *, store, download, open_url, token_selector, error_response, skill_probe):
     # 购买前只探测资源可用性；真实下载仍须通过独立所有权授权。
     try:
         item = read_proxy_item(store, item_id)
@@ -36,9 +37,14 @@ def probe_resource(item_id, *, store, download, open_url, token_selector, error_
     if parsed.hostname not in ("github.com", "huggingface.co"):
         return JSONResponse(content={"error": "无效的下载链接"}, status_code=400)
     try:
-        if target_url.startswith("https://github.com/"):
-            owner, repo = repository_parts(target_url)
+        if parsed.hostname == "github.com":
+            source = github_item_source(item)
+            owner, repo = source['owner'], source['repo']
             active_token = token_selector(item)
+            if source['skill']:
+                if skill_probe(item, active_token) is not True:
+                    raise SkillSourceError('invalid_metadata')
+                return {'status': 'success', 'message': '资源有效', 'skill_manifest_verified': True}
             headers = {"User-Agent": "ComfyUI-Ranking-SaaS"}
             if active_token:
                 headers["Authorization"] = f"Bearer {active_token}"
@@ -74,6 +80,12 @@ def probe_resource(item_id, *, store, download, open_url, token_selector, error_
 
             return {"status": "success", "message": "资源有效"}
 
+    except SkillSourceError as error:
+        if str(error) == 'invalid_skill_package':
+            return JSONResponse(content={'error': '所选目录没有有效的Skill清单',
+                'error_code': 'invalid_skill_package'}, status_code=400)
+        return JSONResponse(content={'error': 'Skill内容暂时无法核实，请稍后重试',
+            'error_code': 'source_unavailable'}, status_code=503 if str(error) == 'probe_busy' else 502)
     except WorkflowSourceError as error:
         return JSONResponse(content={"error": error.message}, status_code=error.status_code)
     except urllib.error.HTTPError as e:

router_proxy.py

@@ -21,12 +21,13 @@ from workflow_source import authorized_workflow_path, workflow_credential_target
 from proxy_access import authorized_proxy_item, ProxyAccessError
 from github_source import repository_parts, select_github_token
 from github_archive import ARCHIVE_MAX_BYTES
-from 安全认证 import require_auth
+from 安全认证 import require_auth, JWT_SECRET
 from safe_http_transport import ValidatedAsyncHTTPTransport
 from workflow_download_service import prepare_workflow_download
 from zip_stream import ZIP_DOWNLOAD_MAX_BYTES
 from github_zip_service import prepare_github_zip
 from proxy_resources import close_redirect_response
+from skill_archive_source import install_source, SkillSourceError
 
 router = APIRouter()
 MAX_PROXY_DOWNLOAD_BYTES = int(os.environ.get("MAX_PROXY_DOWNLOAD_BYTES", str(256 * 1024 * 1024)))
@@ -117,6 +118,27 @@ class ProxyGithubZipRequest(BaseModel):
             raise ValueError('item_id只能包含字母、数字、下划线和连字符')
         return v
 
+
+class SkillInstallSourceRequest(BaseModel):
+    model_config = {'extra': 'forbid'}
+    item_id: str = Field(..., min_length=1, max_length=100, pattern=r'^[A-Za-z0-9_-]+$')
+
+
+@router.post('/api/skill_install_source')
+@shared_limit(30)
+async def skill_install_source(request: Request, req_data: SkillInstallSourceRequest,
+                               account: str = Depends(require_auth), db: Session = Depends(get_db)):
+    try:
+        item = await authorized_proxy_item(json_db, db, req_data.item_id, account)
+        result = install_source(item, account, token_selector=select_github_token, signing_key=JWT_SECRET)
+    except ProxyAccessError as error:
+        return JSONResponse(content={'error': error.message}, status_code=error.status_code,
+                            headers={'Cache-Control': 'no-store'})
+    except SkillSourceError:
+        return JSONResponse(content={'error': '该资源不是可安装的Skill来源'}, status_code=400,
+                            headers={'Cache-Control': 'no-store'})
+    return JSONResponse(content=result, headers={'Cache-Control': 'no-store', 'Vary': 'Authorization'})
+
 @router.post("/api/proxy_github_zip")
 @shared_limit(5)
 async def proxy_github_zip(request: Request, req_data: ProxyGithubZipRequest, account: str = Depends(require_auth), db: Session = Depends(get_db)):
@@ -132,6 +154,7 @@ async def proxy_github_zip(request: Request, req_data: ProxyGithubZipRequest, ac
         return await fetch_github_commit(repo_url, token)
 
     return await prepare_github_zip(item, req_data.item_id, store=json_db,
+        signing_key=JWT_SECRET,
         token_selector=select_github_token, resolve_commit=resolve_commit,
         send=_send_with_validated_redirects, client_factory=httpx.AsyncClient,
         transport_factory=ValidatedAsyncHTTPTransport, error_response=JSONResponse,

skill_archive_source.py

@@ -0,0 +1,246 @@
+"""Skill目录来源解析与有界GitHub引用读取。"""
+import asyncio
+import base64
+import hashlib
+import hmac
+import json
+import re
+from urllib.parse import quote, unquote, urlsplit
+
+from proxy_resources import ProxyResources
+
+
+SKILL_TYPES = frozenset(("skill", "recommend_skill"))
+MAX_SOURCE_BYTES = 4096
+MAX_METADATA_BYTES = 256 * 1024
+MAX_REFERENCES = 512
+MAX_TAG_DEPTH = 8
+METADATA_SECONDS = 20
+SHA = re.compile(r"[0-9a-fA-F]{40}\Z")
+
+
+class SkillSourceError(ValueError):
+    pass
+
+
+def item_source(item, repository_parser):
+    if not isinstance(item, dict):
+        raise SkillSourceError("invalid_source")
+    value = item.get("link")
+    if (not isinstance(value, str) or not value or value != value.strip()
+            or len(value) > MAX_SOURCE_BYTES
+            or "\\" in value or any(ord(c) < 32 or ord(c) == 127 for c in value)):
+        raise SkillSourceError("invalid_source")
+    try:
+        if len(value.encode("utf-8")) > MAX_SOURCE_BYTES:
+            raise ValueError()
+        parsed = urlsplit(value)
+        if parsed.username is not None or parsed.password is not None:
+            raise ValueError()
+        parts = parsed.path.strip("/").split("/")
+        root = parsed._replace(path="/" + "/".join(parts[:2])).geturl()
+        owner, repo = repository_parser(root)
+        kind = item.get("type")
+        if kind is not None and not isinstance(kind, str):
+            raise ValueError()
+        skill = kind in SKILL_TYPES
+        tree = ()
+        if len(parts) != 2:
+            if not skill or len(parts) < 5 or len(parts) > 132 or parts[2] != "tree":
+                raise ValueError()
+            tree = tuple(unquote(part, errors="strict") for part in parts[3:])
+            if any(not part or part in (".", "..") or part.casefold() == ".git"
+                   or "/" in part or "\\" in part
+                   or any(ord(c) < 32 or ord(c) == 127 for c in part) for part in tree):
+                raise ValueError()
+        if "//" in parsed.path or parsed.netloc.endswith(":"):
+            raise ValueError()
+        return dict(repository=f"https://github.com/{owner}/{repo}", owner=owner,
+                    repo=repo, tree=tree, skill=skill)
+    except (ValueError, UnicodeError, IndexError):
+        raise SkillSourceError("invalid_source") from None
+
+
+def source_key(source):
+    suffix = "/tree/" + "/".join(quote(part, safe="") for part in source["tree"]) if source["tree"] else ""
+    return source["repository"].lower() + suffix
+
+
+def source_header(source, subdirectory):
+    data = dict(schema=1, repository=source["repository"], name=subdirectory[-1] if subdirectory else source["repo"],
+                subdirectory=list(subdirectory))
+    return base64.urlsafe_b64encode(json.dumps(data, ensure_ascii=True,
+        separators=(",", ":")).encode("ascii")).decode("ascii")
+
+
+def installation_revision(item, link, token, *, signing_key):
+    if (not isinstance(item, dict) or not isinstance(item.get('id'), str)
+            or not re.fullmatch('[A-Za-z0-9_-]{1,100}', item['id'])
+            or not isinstance(item.get('type'), str) or item['type'] not in SKILL_TYPES
+            or not isinstance(item.get('author'), str) or not item['author'].strip()
+            or not isinstance(link, str) or token is not None and not isinstance(token, str)
+            or not isinstance(signing_key, str) or len(signing_key.encode('utf-8')) < 32):
+        raise SkillSourceError('invalid_source')
+    message = b'ComfyUI-Ranking.Skill.InstallSource.v1\0' + json.dumps(
+        [item['id'], item['type'], link, item['author'], token or ''],
+        ensure_ascii=True, separators=(',', ':')).encode('ascii')
+    return hmac.new(signing_key.encode('utf-8'), message, hashlib.sha256).hexdigest()
+
+
+def install_source(item, account, *, token_selector, signing_key):
+    """仅描述已授权的Skill来源，不返回凭据或下载任意请求地址。"""
+    if (not isinstance(item, dict) or not isinstance(item.get('type'), str)
+            or item['type'] not in SKILL_TYPES or item.get('is_netdisk', False) is not False):
+        raise SkillSourceError('invalid_source')
+    value = item.get('link')
+    if (not isinstance(value, str) or not value or value != value.strip() or len(value) > MAX_SOURCE_BYTES
+            or '\\' in value or any(ord(c) < 32 or ord(c) == 127 for c in value)):
+        raise SkillSourceError('invalid_source')
+    try:
+        if len(value.encode('utf-8')) > MAX_SOURCE_BYTES:
+            raise ValueError()
+        parsed = urlsplit(value)
+        if (parsed.scheme != 'https' or parsed.username is not None or parsed.password is not None
+                or parsed.port not in (None, 443) or parsed.query or parsed.fragment
+                or parsed.netloc.endswith(':') or '//' in parsed.path):
+            raise ValueError()
+        if parsed.hostname == 'github.com':
+            from github_source import repository_parts
+            source = item_source(item, repository_parts)
+            repository, link = source['repository'], source_key(source)
+            token = token_selector(item)
+            transport = 'github_zip'
+        else:
+            if (parsed.hostname not in ('gitlab.com', 'gitee.com', 'bitbucket.org', 'kkgithub.com')
+                    or not re.fullmatch(r'/[A-Za-z0-9_.-]+/[A-Za-z0-9_.-]+/?', parsed.path)
+                    or item.get('github_token') not in (None, '')):
+                raise ValueError()
+            parts = parsed.path.strip('/').split('/')
+            if any(part in ('.', '..') for part in parts):
+                raise ValueError()
+            repository = f'https://{parsed.hostname}/' + '/'.join(parts)
+            link, token, transport = repository, None, 'public_git'
+    except (ValueError, UnicodeError):
+        raise SkillSourceError('invalid_source') from None
+    author, item_id = item.get('author'), item.get('id')
+    if (not isinstance(author, str) or not author.strip() or not isinstance(item_id, str)
+            or not re.fullmatch(r'[A-Za-z0-9_-]{1,100}', item_id)
+            or not isinstance(account, str) or not account):
+        raise SkillSourceError('invalid_source')
+    revision = installation_revision(item, link, token, signing_key=signing_key)
+    return dict(status='success', schema=1, item_id=item_id, account=account,
+                transport=transport, repository=repository, link=link, revision=revision)
+
+
+def _unique_object(pairs):
+    result = {}
+    for key, value in pairs:
+        if key in result:
+            raise SkillSourceError("invalid_metadata")
+        result[key] = value
+    return result
+
+
+def _invalid_constant(_):
+    raise SkillSourceError("invalid_metadata")
+
+
+async def read_metadata_response(response, resources):
+    try:
+        if response.status_code == 404:
+            return None
+        if response.status_code != 200 or (response.headers.get("content-encoding") or "identity").lower() != "identity":
+            raise SkillSourceError("metadata_unavailable")
+        if response.headers.get("link"):
+            raise SkillSourceError("incomplete_metadata")
+        declared = response.headers.get("content-length")
+        if declared is not None and (not re.fullmatch(r"[0-9]{1,10}", declared)
+                                     or not 0 < int(declared) <= MAX_METADATA_BYTES):
+            raise SkillSourceError("invalid_metadata")
+        body = bytearray()
+        async for chunk in response.aiter_raw(chunk_size=65536):
+            if len(body) + len(chunk) > MAX_METADATA_BYTES:
+                raise SkillSourceError("metadata_too_large")
+            body.extend(chunk)
+            await asyncio.sleep(0)
+        if declared is not None and len(body) != int(declared):
+            raise SkillSourceError("invalid_metadata")
+        try:
+            return json.loads(body.decode("utf-8"), object_pairs_hook=_unique_object,
+                parse_constant=_invalid_constant)
+        except (UnicodeError, ValueError, RecursionError):
+            raise SkillSourceError("invalid_metadata") from None
+    finally:
+        await resources.close_response(response)
+
+
+async def resolve_tree(source, token, *, send, client_factory, transport_factory):
+    tree = source["tree"]
+    if not tree:
+        raise SkillSourceError("missing_reference")
+    client = client_factory(follow_redirects=False, trust_env=False, transport=transport_factory())
+    resources = ProxyResources(client)
+    headers = {"Accept": "application/vnd.github+json", "Accept-Encoding": "identity",
+               "User-Agent": "ComfyUI-Ranking-SaaS"}
+    if token:
+        headers["Authorization"] = f"Bearer {token}"
+    prefix = f"https://api.github.com/repos/{source['owner']}/{source['repo']}/git/"
+
+    async def read_json(path):
+        response = resources.track(await send(client, "GET", prefix + path, headers=headers,
+                                               timeout=METADATA_SECONDS))
+        return await read_metadata_response(response, resources)
+
+    try:
+        async with asyncio.timeout(METADATA_SECONDS):
+            if SHA.fullmatch(tree[0]):
+                sha = tree[0].lower()
+                value = await read_json("commits/" + sha)
+                if not isinstance(value, dict) or value.get("sha") != sha:
+                    raise SkillSourceError("invalid_commit")
+                return sha, tree[1:]
+            candidates = []
+            for namespace in ("heads", "tags"):
+                values = await read_json("matching-refs/" + namespace + "/" + quote(tree[0], safe=""))
+                if values is None:
+                    continue
+                if not isinstance(values, list) or len(values) > MAX_REFERENCES:
+                    raise SkillSourceError("invalid_metadata")
+                seen = set()
+                for row in values:
+                    if not isinstance(row, dict) or not isinstance(row.get("ref"), str):
+                        raise SkillSourceError("invalid_metadata")
+                    reference, obj = row["ref"], row.get("object")
+                    if (reference in seen or not reference.startswith("refs/" + namespace + "/")
+                            or not isinstance(obj, dict) or obj.get("type") not in ("commit", "tag")
+                            or not isinstance(obj.get("sha"), str) or not SHA.fullmatch(obj["sha"])
+                            or namespace == "heads" and obj["type"] != "commit"):
+                        raise SkillSourceError("invalid_metadata")
+                    seen.add(reference)
+                    parts = tuple(reference[len("refs/" + namespace + "/"):].split("/"))
+                    if parts and tree[:len(parts)] == parts and len(tree) > len(parts):
+                        candidates.append((len(parts), obj, tree[len(parts):]))
+            if not candidates:
+                raise SkillSourceError("missing_reference")
+            longest = max(depth for depth, _, _ in candidates)
+            choices = set()
+            for depth, obj, subdirectory in candidates:
+                if depth != longest:
+                    continue
+                visited = set()
+                while obj["type"] == "tag":
+                    sha = obj["sha"].lower()
+                    if sha in visited or len(visited) >= MAX_TAG_DEPTH:
+                        raise SkillSourceError("invalid_tag")
+                    visited.add(sha)
+                    value = await read_json("tags/" + sha)
+                    obj = value.get("object") if isinstance(value, dict) else None
+                    if (not isinstance(obj, dict) or obj.get("type") not in ("commit", "tag")
+                            or not isinstance(obj.get("sha"), str) or not SHA.fullmatch(obj["sha"])):
+                        raise SkillSourceError("invalid_tag")
+                choices.add((obj["sha"].lower(), subdirectory))
+            if len(choices) != 1:
+                raise SkillSourceError("ambiguous_reference")
+            return next(iter(choices))
+    finally:
+        await resources.close()

skill_preflight.py

@@ -0,0 +1,146 @@
+"""购买前只核实Skill清单，不交付私有内容或替代下载授权。"""
+import asyncio
+import threading
+from urllib.parse import quote
+
+from proxy_resources import ProxyResources
+from github_source import repository_parts, github_item_source
+from skill_archive_source import resolve_tree, read_metadata_response, SkillSourceError, SHA, METADATA_SECONDS
+
+MAX_TREE_ENTRIES = 1000
+MAX_REQUESTS = 256
+
+
+def _sha(value):
+    if not isinstance(value, str) or not SHA.fullmatch(value):
+        raise SkillSourceError('invalid_metadata')
+    return value.lower()
+
+
+def _segment(value):
+    try:
+        size = len(value.encode('utf-8')) if isinstance(value, str) else 0
+    except UnicodeError:
+        return False
+    return (isinstance(value, str) and 0 < size <= 4096
+            and value not in ('.', '..') and value.casefold() != '.git'
+            and '/' not in value and '\\' not in value
+            and not any(ord(c) < 32 or ord(c) == 127 for c in value))
+
+
+def _tree(value, expected):
+    if (not isinstance(value, dict) or _sha(value.get('sha')) != expected
+            or value.get('truncated') is not False or not isinstance(value.get('tree'), list)
+            or len(value['tree']) > MAX_TREE_ENTRIES):
+        raise SkillSourceError('invalid_metadata')
+    result = {}
+    aliases = set()
+    for row in value['tree']:
+        if (not isinstance(row, dict) or not _segment(row.get('path'))
+                or row['path'].casefold() in aliases):
+            raise SkillSourceError('invalid_metadata')
+        _sha(row.get('sha'))
+        kind, mode = row.get('type'), row.get('mode')
+        if ((kind, mode) not in {('blob', '100644'), ('blob', '100755'), ('blob', '120000'),
+                                ('tree', '040000'), ('commit', '160000')}
+                or kind == 'blob' and (type(row.get('size')) is not int or row['size'] < 0)):
+            raise SkillSourceError('invalid_metadata')
+        aliases.add(row['path'].casefold()); result[row['path']] = row
+    return result
+
+
+def _manifest(rows):
+    for name in ('SKILL.md', 'SKILL.cn.md'):
+        if name in rows:
+            row = rows[name]
+            if row['type'] != 'blob' or row['mode'] not in ('100644', '100755'):
+                raise SkillSourceError('invalid_skill_package')
+            return True
+    return False
+
+
+async def probe_github_skill(source, token, *, send, client_factory, transport_factory):
+    if not isinstance(source, dict) or source.get('skill') is not True:
+        raise SkillSourceError('invalid_source')
+    try:
+        if (repository_parts(source['repository']) != (source['owner'], source['repo'])
+                or not isinstance(source['tree'], tuple) or len(source['tree']) > 129
+                or not all(_segment(part) for part in source['tree'])):
+            raise ValueError()
+    except (KeyError, TypeError, ValueError):
+        raise SkillSourceError('invalid_source') from None
+    prefix = 'https://api.github.com/repos/' + source['owner'] + '/' + source['repo']
+    client = client_factory(follow_redirects=False, trust_env=False, transport=transport_factory())
+    resources = ProxyResources(client)
+    headers = {'Accept': 'application/vnd.github+json', 'Accept-Encoding': 'identity',
+               'User-Agent': 'ComfyUI-Ranking-SaaS'}
+    if token:
+        headers['Authorization'] = 'Bearer ' + token
+    requests = 0
+    async def bounded_send(*args, **kwargs):
+        nonlocal requests
+        requests += 1
+        if requests > MAX_REQUESTS:
+            raise SkillSourceError('metadata_too_large')
+        return await send(*args, **kwargs)
+
+    async def read(path):
+        response = resources.track(await bounded_send(client, 'GET', prefix + path,
+            headers=headers, timeout=METADATA_SECONDS))
+        return await read_metadata_response(response, resources)
+
+    async def get_tree(sha):
+        return _tree(await read('/git/trees/' + sha), sha)
+
+    try:
+        async with asyncio.timeout(METADATA_SECONDS):
+            if source['tree']:
+                commit, subdirectory = await resolve_tree(source, token, send=bounded_send,
+                    client_factory=client_factory, transport_factory=transport_factory)
+            else:
+                repository = await read('')
+                branch = repository.get('default_branch') if isinstance(repository, dict) else None
+                if (not isinstance(branch, str) or not all(_segment(part) for part in branch.split('/'))
+                        or len(branch.encode('utf-8')) > 4096):
+                    raise SkillSourceError('invalid_metadata')
+                reference = 'refs/heads/' + branch
+                values = await read('/git/matching-refs/heads/' + quote(branch, safe=''))
+                if not isinstance(values, list) or len(values) > MAX_TREE_ENTRIES:
+                    raise SkillSourceError('invalid_metadata')
+                matches = [row for row in values if isinstance(row, dict) and row.get('ref') == reference]
+                if len(matches) != 1 or not isinstance(matches[0].get('object'), dict) or matches[0]['object'].get('type') != 'commit':
+                    raise SkillSourceError('invalid_metadata')
+                commit, subdirectory = _sha(matches[0]['object'].get('sha')), ()
+            metadata = await read('/git/commits/' + commit)
+            if (not isinstance(metadata, dict) or _sha(metadata.get('sha')) != commit
+                    or not isinstance(metadata.get('tree'), dict)):
+                raise SkillSourceError('invalid_metadata')
+            rows = await get_tree(_sha(metadata['tree'].get('sha')))
+            for name in subdirectory:
+                row = rows.get(name)
+                if not row or row['type'] != 'tree' or row['mode'] != '040000':
+                    raise SkillSourceError('invalid_skill_package')
+                rows = await get_tree(_sha(row['sha']))
+            if _manifest(rows):
+                return True
+            for row in rows.values():
+                if row['type'] == 'tree' and row['mode'] == '040000':
+                    if _manifest(await get_tree(_sha(row['sha']))):
+                        return True
+            raise SkillSourceError('invalid_skill_package')
+    finally:
+        await resources.close()
+
+
+_PROBE_CAPACITY = threading.BoundedSemaphore(2)
+
+
+def verify_skill_manifest(item, token, *, send, client_factory, transport_factory):
+    if not _PROBE_CAPACITY.acquire(blocking=False):
+        raise SkillSourceError('probe_busy')
+    try:
+        source = github_item_source(item)
+        return asyncio.run(probe_github_skill(source, token, send=send,
+            client_factory=client_factory, transport_factory=transport_factory))
+    finally:
+        _PROBE_CAPACITY.release()

管理界面/app.js

@@ -2085,7 +2085,18 @@
             const res = await apiRequest('GET', '/api/disputes/' + encodeURIComponent(disputeId));
             if (!read.isCurrent()) return;
             const dispute = parseAdminDispute(res, disputeId);
-            renderDisputeDetail(body, dispute);
+            let display = dispute;
+            if ([dispute.evidence, dispute.response_evidence].some(images => Array.isArray(images) && images.length)) {
+                const { normalizeDisputeEvidence } = await import('../m/assets/task/申诉数据工具.js').catch(() => {
+                    throw new ApiError(adminMessage('admin_data_unavailable'), 0);
+                });
+                if (!read.isCurrent()) return;
+                const serviceBaseUrl = new URL(API_BASE || window.location.origin, window.location.href).href;
+                display = { ...dispute,
+                    evidence: normalizeDisputeEvidence(dispute.evidence, serviceBaseUrl),
+                    response_evidence: normalizeDisputeEvidence(dispute.response_evidence, serviceBaseUrl) };
+            }
+            renderDisputeDetail(body, display);
         } catch (err) {
             if (isStaleSessionError(err) || !read.isCurrent()) return;
             body.innerHTML = '<div class="state-block state-error"><div class="empty-mark">!</div><h3>' + escapeHtml(adminMessage('dispute_load_failed')) + '</h3><p>' +