새 사이트에 옛 이름과 이미지가 남지 않게

"""Read-only checks for an explicitly selected public artifact directory.

Marker values are private inputs. Results carry marker indexes, never excerpts.
Media approvals are prior human reviews tied to exact bytes, not OCR or rights checks.
"""
import argparse
import hashlib
import html
from html.parser import HTMLParser
import json
from pathlib import Path
import re
import unicodedata

TEXT = {'.html', '.htm', '.css', '.js', '.mjs', '.json', '.xml', '.txt', '.svg', '.webmanifest'}
MEDIA = {'.png', '.jpg', '.jpeg', '.webp', '.gif', '.avif', '.svg', '.mp4', '.webm', '.mov', '.mp3', '.wav', '.ogg', '.pdf', '.zip', '.woff', '.woff2', '.ico'}
SERVER = {'_worker.js', '_headers', '_redirects', '_routes.json'}

def normalized(value):
    return ''.join(unicodedata.normalize('NFKC', html.unescape(value)).casefold().split())

class PublicHTML(HTMLParser):
    def __init__(self):
        super().__init__(convert_charrefs=True)
        self.text = []
        self.attributes = []
    def handle_data(self, value):
        self.text.append(value)
    def handle_starttag(self, tag, attributes):
        self.attributes.extend(value for _, value in attributes if value)
    handle_startendtag = handle_starttag

def representations(value, suffix):
    result = [value, html.unescape(value)]
    if suffix in {'.html', '.htm', '.svg', '.xml'}:
        parser = PublicHTML()
        parser.feed(value)
        result += [''.join(parser.text), *parser.attributes]
    # Decode only valid JSON string literals, without evaluating JavaScript.
    for match in re.finditer(r'"(?:[^"\\]|\\.)*"', value):
        try:
            decoded = json.loads(match.group())
            if isinstance(decoded, str):
                result.append(decoded)
        except ValueError:
            pass
    return [normalized(v) for v in result]

def digest(path):
    value = hashlib.sha256()
    with path.open('rb') as stream:
        for part in iter(lambda: stream.read(1024 * 1024), b''):
            value.update(part)
    return value.hexdigest()

def scan(root, markers, approved_media=None, contract='all-files', max_text_bytes=16 * 1024 * 1024):
    root = Path(root).resolve(strict=True)
    if not root.is_dir() or contract not in {'all-files', 'pages-worker-bundle'}:
        raise ValueError('Explicit public directory and supported deployment contract required')
    markers = [normalized(v) for v in markers]
    if not markers or any(len(v) < 3 for v in markers):
        raise ValueError('Nonempty private markers of at least three normalized characters required')
    approved_media = approved_media or {}
    findings, reviewed, excluded = [], 0, []
    def flag(relative, reason, **extra):
        public_path = relative
        if any(marker in normalized(relative) for marker in markers):
            public_path = '[identity-path:' + hashlib.sha256(relative.encode('utf-8')).hexdigest()[:16] + ']'
        findings.append({'path': public_path, 'reason': reason, **extra})
    # Do not follow directory links/junctions. A link itself requires review.
    pending = [root]
    while pending:
        folder = pending.pop()
        for path in sorted(folder.iterdir()):
            relative = path.relative_to(root).as_posix()
            resolved = path.resolve()
            if path.is_symlink() or (hasattr(path, 'is_junction') and path.is_junction()) or not resolved.is_relative_to(root):
                flag(relative, 'linked-or-outside-root')
                continue
            if contract == 'pages-worker-bundle' and (relative == '_worker_modules' or relative in SERVER):
                excluded.append(relative)
                continue
            if path.is_dir():
                if path.name.casefold() in {'private', '.git', 'node_modules'}:
                    flag(relative, 'private-directory-in-public-output')
                else:
                    pending.append(path)
                continue
            reviewed += 1
            suffix = path.suffix.lower()
            path_text = normalized(relative)
            for index, marker in enumerate(markers, 1):
                if marker in path_text:
                    flag(relative, 'known-identity-in-path', marker_index=index)
            if path.name.casefold().startswith('.env') or suffix in {'.pem', '.key', '.sqlite', '.db', '.map'}:
                flag(relative, 'private-or-unreviewed-artifact')
                continue
            if suffix in TEXT:
                if path.stat().st_size > max_text_bytes:
                    flag(relative, 'text-too-large-to-check')
                else:
                    try:
                        views = representations(path.read_text('utf-8-sig'), suffix)
                        for index, marker in enumerate(markers, 1):
                            if any(marker in view for view in views):
                                flag(relative, 'known-identity-in-text', marker_index=index)
                    except (UnicodeError, OSError):
                        flag(relative, 'text-unreadable')
            if suffix in MEDIA:
                expected = approved_media.get(relative)
                if not expected:
                    flag(relative, 'media-needs-human-review')
                elif not isinstance(expected, str) or digest(path) != expected:
                    flag(relative, 'reviewed-media-bytes-changed')
            elif suffix not in TEXT:
                flag(relative, 'unknown-artifact-needs-review')
    return {'passed': not findings, 'reviewed_files': reviewed, 'excluded_by_explicit_contract': excluded,
            'findings': findings, 'scope': 'Known markers in selected static output; exact reviewed media hashes. No OCR, remote CMS/R2 enumeration, form delivery or browser rendering.'}

if __name__ == '__main__':
    cli = argparse.ArgumentParser(description=__doc__)
    cli.add_argument('public_root')
    cli.add_argument('--markers', required=True, help='Private JSON array of old identity strings')
    cli.add_argument('--media-approvals', help='Private JSON object: public relative path -> reviewed SHA256')
    cli.add_argument('--contract', choices=['all-files', 'pages-worker-bundle'], default='all-files')
    args = cli.parse_args()
    result = scan(args.public_root, json.loads(Path(args.markers).read_text('utf-8-sig')),
                  json.loads(Path(args.media_approvals).read_text('utf-8-sig')) if args.media_approvals else {}, args.contract)
    print(json.dumps(result, ensure_ascii=False, indent=2))
    raise SystemExit(0 if result['passed'] else 1)