rsnarsna
feat(alli-backend): Wave-1 standardization, standalone sys.env node & vault crypto, and DEC-014 security hardening
8628c98 Download lambdas/inspect_handler.py from Rsnarsna/auto: direct link, hf CLI and curl.
- Browser
- Download file 8.62 kB
-
https://huggingface.co/spaces/Rsnarsna/auto/resolve/main/lambdas/inspect_handler.py
- Command line
-
hf download hf://spaces/Rsnarsna/auto/lambdas/inspect_handler.py
-
curl -L -o inspect_handler.py https://huggingface.co/spaces/Rsnarsna/auto/resolve/main/lambdas/inspect_handler.py
8.62 kB
| """ | |
| ALLI Lambda Function 2: Library Inspector (alli-inspect) | |
| Zero-RCE PyPI binary wheel introspection, `.py`/`.pyi` AST extraction, | |
| and persistent MongoDB Atlas blueprint & staged node synthesis. | |
| """ | |
| import json | |
| import os | |
| import re | |
| import tempfile | |
| from typing import Any, Dict, Optional, Tuple | |
| from database.mongo import workflow_repo | |
| from library_inspector.blueprint_models import ( | |
| build_library_blueprint_from_extracted, | |
| compute_directory_sha256, | |
| compute_sha256_hash, | |
| ) | |
| from library_inspector.blueprint_synthesizer import synthesize_package_blueprint_schema | |
| from library_inspector.downloader import download_package_to_sandbox | |
| from library_inspector.extractor import extract_blueprint_from_file | |
| from library_inspector.package_scanner import scan_package_directory | |
| from library_inspector.stdlib_inspector import introspect_package as fallback_introspect | |
| # Backward compatibility alias | |
| _scan_directory = scan_package_directory | |
| class PackageIntrospectionError(ValueError, RuntimeError): | |
| """Dual ValueError/RuntimeError raised on honest package lookup or extraction failures.""" | |
| _SENTINEL_VERSION_STRINGS = {"", "latest", "unknown", "cached", "none", "auto", "*"} | |
| def _normalize_version_arg(raw_version: Optional[str]) -> Optional[str]: | |
| """Strip UI display notes (like '(built-in)') and sentinel placeholders; return clean version or None.""" | |
| if not raw_version: | |
| return None | |
| raw = str(raw_version).strip() | |
| low = raw.lower() | |
| if low in _SENTINEL_VERSION_STRINGS or "built-in" in low or "builtin" in low: | |
| return None | |
| cleaned = re.sub(r"[^a-zA-Z0-9._+-]", "", raw) | |
| if not cleaned or cleaned.lower() in _SENTINEL_VERSION_STRINGS: | |
| return None | |
| if not re.match(r"^[vV]?\d", cleaned): | |
| return None | |
| return cleaned.lstrip("vV") | |
| def _parse_package_spec(package_name: str, version: Optional[str]) -> Tuple[str, Optional[str]]: | |
| raw_input = str(package_name or "") | |
| has_builtin_tag = bool(re.search(r"built[- ]?in", raw_input, re.IGNORECASE)) | |
| raw_stripped = re.sub(r"\s*\([^)]*built[- ]?in[^)]*\)", "", raw_input, flags=re.IGNORECASE).strip() | |
| if raw_stripped.endswith("==") or raw_stripped.endswith("@"): | |
| raw_stripped = raw_stripped.rstrip("=@").strip() | |
| clean_name = re.sub(r"[^a-zA-Z0-9_\-\.=@><~]", "", raw_stripped) | |
| if not clean_name: | |
| raise ValueError("Package name cannot be empty") | |
| target_version = _normalize_version_arg(version) | |
| if "@" in clean_name: | |
| base_name, v = clean_name.split("@", 1) | |
| base_name = base_name.strip().lower() | |
| target_version = target_version or (None if has_builtin_tag else _normalize_version_arg(v)) | |
| elif "==" in clean_name: | |
| base_name, v = clean_name.split("==", 1) | |
| base_name = base_name.strip().lower() | |
| target_version = target_version or (None if has_builtin_tag else _normalize_version_arg(v)) | |
| else: | |
| base_name = clean_name.split(">=")[0].split("<=")[0].split("~=")[0].strip().lower() | |
| if not base_name: | |
| raise ValueError("Package name cannot be empty") | |
| return base_name, target_version | |
| def _convert_blueprint_to_package_schema(pkg_name: str, bp: Dict[str, Any]) -> Dict[str, Any]: | |
| """Converts a raw/stored package blueprint into unified schema and stages candidate nodes.""" | |
| return synthesize_package_blueprint_schema( | |
| pkg_name, | |
| bp, | |
| persist_staged=True, | |
| repo=workflow_repo, | |
| ) | |
| def introspect_package_logic(package_name: str, version: Optional[str] = None) -> Dict[str, Any]: | |
| """ | |
| Zero-RCE business logic for library inspection and persistent blueprint synthesis. | |
| Never fabricates fake `.execute` stub caches when download or extraction fails. | |
| """ | |
| base_name, target_version = _parse_package_spec(package_name, version) | |
| # 1. Check persisted blueprint cache (MongoDB Atlas / in-memory store) | |
| cached_bp = workflow_repo.get_blueprint(base_name, version=target_version) | |
| if cached_bp: | |
| return _convert_blueprint_to_package_schema(base_name, cached_bp) | |
| # 2. Try verified Python standard library inspection | |
| try: | |
| if target_version is None or target_version.startswith("3."): | |
| stdlib_res = fallback_introspect(base_name) | |
| if stdlib_res: | |
| workflow_repo.save_blueprint(base_name, stdlib_res, version=stdlib_res.get("version")) | |
| return stdlib_res | |
| except Exception: | |
| pass | |
| # 3. Ephemeral Zero-RCE PyPI wheel download & static extraction (fail loudly on error) | |
| with tempfile.TemporaryDirectory(prefix=f"alli_inspect_{base_name}_") as temp_dir: | |
| try: | |
| package_spec = f"{base_name}=={target_version}" if target_version else base_name | |
| source_path, metadata = download_package_to_sandbox( | |
| package_spec, | |
| sandbox_base_dir=temp_dir, | |
| ) | |
| if target_version and not metadata.get("version"): | |
| metadata["version"] = target_version | |
| pkg_name = metadata.get("name", base_name) | |
| pkg_version = metadata.get("version", target_version or "unknown") | |
| if os.path.isfile(source_path): | |
| filename = os.path.basename(source_path) | |
| with open(source_path, "rb") as f: | |
| content_hash = compute_sha256_hash(f.read()) | |
| bp = extract_blueprint_from_file( | |
| source_path, | |
| display_path=f"@{pkg_name}/{filename}", | |
| include_ast_dump=False, | |
| ) | |
| bp["package"] = { | |
| "name": pkg_name, | |
| "version": pkg_version, | |
| "summary": metadata.get("summary", ""), | |
| "root": f"@{pkg_name}", | |
| } | |
| else: | |
| content_hash = compute_directory_sha256(source_path) | |
| stubs_sibling = f"{source_path}-stubs" | |
| extra = [stubs_sibling] if os.path.isdir(stubs_sibling) else None | |
| bp = scan_package_directory(source_path, pkg_meta=metadata, extra_dirs=extra) | |
| if not bp.get("functions") and not bp.get("classes") and not bp.get("constants"): | |
| raise ValueError( | |
| f"Package '{base_name}' contained zero extractable `.py`/`.pyi` Python signatures." | |
| ) | |
| bp_model = build_library_blueprint_from_extracted( | |
| base_name=base_name, | |
| pkg_meta_dict=metadata, | |
| extracted_data=bp, | |
| content_hash=content_hash, | |
| source_type="wheel", | |
| ) | |
| bp_dict = bp_model.model_dump() | |
| schema = _convert_blueprint_to_package_schema(base_name, bp) | |
| schema.update(bp_dict) | |
| schema["package_name"] = base_name | |
| schema["version"] = bp_model.package.version | |
| schema["blueprint"] = bp_dict | |
| workflow_repo.save_blueprint(base_name, schema, version=bp_model.package.version) | |
| return schema | |
| except (PackageIntrospectionError, ValueError): | |
| raise | |
| except Exception as err: | |
| raise PackageIntrospectionError( | |
| f"Failed to introspect package '{base_name}': {err}" | |
| ) from err | |
| def handler(event: Dict[str, Any], context: Any = None) -> Dict[str, Any]: | |
| """Standalone AWS Lambda handler entrypoint for alli-inspect function.""" | |
| try: | |
| body_raw = event.get("body", "{}") | |
| body = json.loads(body_raw) if isinstance(body_raw, str) else body_raw | |
| package = body.get("package", "math") | |
| version = body.get("version") | |
| schema = introspect_package_logic(package, version=version) | |
| return { | |
| "statusCode": 200, | |
| "headers": { | |
| "Content-Type": "application/json", | |
| "Access-Control-Allow-Origin": "*", | |
| "Access-Control-Allow-Methods": "POST, OPTIONS", | |
| }, | |
| "body": json.dumps(schema), | |
| } | |
| except ValueError as err: | |
| return { | |
| "statusCode": 400, | |
| "headers": { | |
| "Content-Type": "application/json", | |
| "Access-Control-Allow-Origin": "*", | |
| }, | |
| "body": json.dumps({"error": str(err)}), | |
| } | |
| except Exception as err: | |
| return { | |
| "statusCode": 500, | |
| "headers": { | |
| "Content-Type": "application/json", | |
| "Access-Control-Allow-Origin": "*", | |
| }, | |
| "body": json.dumps({"error": str(err)}), | |
| } | |