app.py

from __future__ import annotations

import html
import json
import tempfile

import gradio as gr

from scanner import ScanError, ScanResult, result_json, scan_repository


def _summary_markdown(result: ScanResult) -> str:
    counts = result.counts()
    badges = " · ".join(
        f"**{name.title()}: {counts.get(name, 0)}**"
        for name in ("critical", "high", "medium", "low", "info")
    )
    artifacts = result.artifacts
    priority = "No unresolved non-informational finding was detected."
    for finding in result.finding_groups():
        if finding["status"] != "unresolved" or finding["severity"] == "info":
            continue
        priority = f"**{finding['severity'].upper()} · {finding['rule_id']}** — {html.escape(finding['title'])}"
        break
    return f"""### Scan complete: `{html.escape(result.target)}`

{badges}

- **Type / revision:** {result.repo_type.title()} · `{result.revision[:12]}`
- **Coverage / OSV:** `{html.escape(str(artifacts.get('static_coverage', 'unknown')).upper())}` {artifacts.get('inspected_text_files', len(result.inspected_files))}/{artifacts.get('eligible_text_files', len(result.inspected_files))} · `{html.escape(str(result.osv_summary.get('status', 'not checked')).upper())}` {result.osv_summary.get('queried_packages', 0)}/{result.osv_summary.get('exact_packages', 0)}
- **Top priority:** {priority}
"""


def _safe(value: object, fallback: str = "not stated") -> str:
    text = str(value) if value not in (None, "") else fallback
    return html.escape(text)


def _overview_markdown(result: ScanResult) -> str:
    metadata = result.metadata_summary
    artifacts = result.artifacts
    dependencies = ", ".join(f"`{_safe(item)}`" for item in result.dependencies) or "None declared in Hub metadata"
    notes = "\n".join(f"- {_safe(note)}" for note in result.notes) or "- No additional note was produced."
    exact = sum(1 for item in result.package_inventory if item.get("source_type") == "exact")
    unresolved = sum(1 for item in result.package_inventory if item.get("source_type") != "exact")
    return f"""### Repository details

- **License / task / library:** `{_safe(metadata.get('license'), 'undeclared')}` / `{_safe(metadata.get('pipeline_tag'), 'undeclared')}` / `{_safe(metadata.get('library'), 'undeclared')}`
- **Architecture:** `{_safe(metadata.get('architecture'), 'not identified')}`
- **Text/config files inspected:** {len(result.inspected_files)}
- **Candidate files skipped:** {result.skipped_files}
- **Published files:** {artifacts.get('repository_file_count', 0)} totaling {artifacts.get('repository_size', '0 B')}
- **Weight artifacts:** {artifacts.get('weight_file_count', 0)} totaling {artifacts.get('weight_size', '0 B')} ({_safe(artifacts.get('weight_formats') or 'none')})
- **Safetensors index:** {artifacts.get('index_referenced_shards', 0)} referenced shards; {artifacts.get('index_declared_tensor_size', '0 B')} declared tensor data
- **Declared dependencies:** {dependencies}
- **Package inventory:** {len(result.package_inventory)} components ({exact} exact; {unresolved} unresolved/direct)

### Important limitations

{notes}
"""


def _coverage_items(result: ScanResult) -> list[dict[str, str]]:
    items = []
    for item in result.checks:
        status = item.status.upper().replace("_", " ")
        items.append({
            "label": f"{status} · {item.category}",
            "detail": f"### {_safe(item.category)}\n\n**Status:** `{_safe(status)}`\n\n{_safe(item.detail)}",
        })
    return items or [{"label": "No coverage records", "detail": "No coverage record was produced."}]


def _dependency_items(result: ScanResult) -> list[dict[str, str]]:
    items = []
    for item in result.dependency_details:
        relations = ", ".join(item.get("relation") or [])
        items.append({
            "label": f"{relations or 'declared'} · {item.get('repository', 'unknown')}",
            "detail": f"### {_safe(item.get('repository'))}\n\n"
            f"- **Relationship:** {_safe(relations)}\n"
            f"- **Depth:** {_safe(item.get('depth'))}\n"
            f"- **License:** {_safe(item.get('license'), 'undeclared')}\n"
            f"- **Status:** {_safe(item.get('status'), 'unknown')}\n"
            f"- **Revision:** `{_safe(item.get('revision'))}`\n"
            f"- **Gated:** {_safe(item.get('gated', False))}",
        })
    if not items:
        items = [{"label": f"declared · {item}", "detail": f"### {_safe(item)}\n\nDeclared dependency; details were not checked."} for item in result.dependencies]
    return items or [{"label": "No upstream dependencies", "detail": "No upstream repository dependency was declared."}]


def _finding_items(result: ScanResult) -> list[dict[str, str]]:
    items = []
    for finding in result.finding_groups():
        occurrences = finding["occurrences"]
        locations = []
        evidence = ""
        for occurrence in occurrences[:3]:
            location = occurrence.get("path") or "Repository metadata"
            if occurrence.get("line"):
                location += f":{occurrence['line']}"
            locations.append(location)
            if not evidence and occurrence.get("evidence"):
                evidence = occurrence["evidence"]
        location_text = ", ".join(locations) + (" …" if len(occurrences) > 3 else "")
        evidence_line = f"\n- **Evidence:** `{_safe(evidence)}`" if evidence else ""
        label = f"{finding['severity'].upper()} · {finding['rule_id']} · {finding['title']}"
        items.append({
            "label": label,
            "detail": f"### {_safe(label)}\n\n"
            f"- **Status:** {_safe(finding['status'].upper())}\n"
            f"- **Occurrences:** {len(occurrences)}\n"
            f"- **Locations:** {_safe(location_text)}"
            f"{evidence_line}\n"
            f"- **Confidence:** {_safe(finding['confidence'])}\n\n"
            f"**Why it matters**\n\n{_safe(finding['detail'])}\n\n"
            f"**Remediation**\n\n{_safe(finding['remediation'])}",
        })
    return items or [{"label": "No findings", "detail": "No evidence-linked finding was produced."}]


def _package_items(result: ScanResult) -> list[dict[str, str]]:
    items = []
    for item in result.package_inventory:
        manifests = ", ".join(sorted({occurrence.get("path", "") for occurrence in item.get("occurrences", [])}))
        version = item.get("version") or "unresolved"
        label = f"{item.get('name', 'unknown')} · {version}"
        items.append({
            "label": label,
            "detail": f"### {_safe(label)}\n\n"
            f"- **Source type:** {_safe(item.get('source_type'))}\n"
            f"- **Constraint:** `{_safe(item.get('constraint'))}`\n"
            f"- **PURL:** `{_safe(item.get('purl'))}`\n"
            f"- **Manifest:** {_safe(manifests)}",
        })
    return items or [{"label": "No packages", "detail": "No supported package declaration was found."}]


def _vulnerability_items(result: ScanResult) -> list[dict[str, str]]:
    items = []
    for item in result.vulnerabilities:
        label = f"{item.get('severity', '').upper()} · {item.get('id', 'unknown')} · {item.get('package', 'unknown')}"
        items.append({
            "label": label,
            "detail": f"### {_safe(label)}\n\n"
            f"{_safe(item.get('summary'))}\n\n"
            f"- **Package:** {_safe(item.get('package'))} `{_safe(item.get('version'))}`\n"
            f"- **Aliases:** {_safe(', '.join(item.get('aliases') or []))}\n"
            f"- **Fixed versions:** {_safe(', '.join(item.get('fixed_versions') or []))}\n"
            f"- **Advisory:** {_safe(item.get('url'))}",
        })
    return items or [{"label": "No known matches", "detail": "No known OSV match was returned for the exactly pinned packages checked."}]


def _selector_update(items: list[dict[str, str]], label: str):
    choices = [(item["label"], str(index)) for index, item in enumerate(items)]
    return gr.Dropdown(choices=choices, value="0", label=f"{label} ({len(items)})")


def _select_detail(selection: str | None, state: dict[str, list[str]] | None, section: str) -> str:
    details = (state or {}).get(section) or []
    try:
        index = int(selection or 0)
    except (TypeError, ValueError):
        index = 0
    if not details:
        return "Run a scan to populate this section."
    return details[index] if 0 <= index < len(details) else details[0]


def _write_sbom(result: ScanResult) -> str:
    with tempfile.NamedTemporaryFile(
        mode="w", encoding="utf-8", prefix="modelsentry-", suffix=".cdx.json", delete=False,
    ) as handle:
        json.dump(result.sbom, handle, indent=2, ensure_ascii=False)
        handle.write("\n")
        return handle.name


def run_scan(target: str):
    try:
        result = scan_repository(target)
    except ScanError as exc:
        raise gr.Error(str(exc)) from exc
    except Exception as exc:
        raise gr.Error("The public repository could not be scanned because of an unexpected service error. Please try again.") from exc
    sections = {
        "overview": [{"label": "Repository profile", "detail": _overview_markdown(result)}] + _coverage_items(result),
        "dependencies": _dependency_items(result),
        "packages": _package_items(result),
        "vulnerabilities": _vulnerability_items(result),
        "findings": _finding_items(result),
    }
    view_state = {name: [item["detail"] for item in items] for name, items in sections.items()}
    return (
        _summary_markdown(result),
        _selector_update(sections["overview"], "Overview topic"),
        sections["overview"][0]["detail"],
        _selector_update(sections["dependencies"], "Upstream repository"),
        sections["dependencies"][0]["detail"],
        _selector_update(sections["packages"], "Package"),
        sections["packages"][0]["detail"],
        _selector_update(sections["vulnerabilities"], "Known vulnerability"),
        sections["vulnerabilities"][0]["detail"],
        _selector_update(sections["findings"], "Finding"),
        sections["findings"][0]["detail"],
        result_json(result),
        _write_sbom(result),
        view_state,
    )


DESCRIPTION = """Inspect a public Hugging Face Model or Space at an immutable revision. ModelSentry never executes
repository code or downloads model weights; its findings are bounded static evidence, not a safety certification."""

APP_CSS = """
html,
body {
    height: 100%;
    overflow: hidden !important;
    margin: 0;
}
.audit-cards,
.audit-cards p,
.audit-cards li,
.audit-cards code {
    overflow-wrap: anywhere;
    word-break: break-word;
    white-space: normal;
}
.scan-summary {
    border: 1px solid var(--border-color-primary);
    border-left: 0.35rem solid var(--primary-500);
    border-radius: var(--radius-lg);
    padding: 0.25rem 1rem;
    background: var(--background-fill-secondary);
    min-height: 12rem;
}
.detail-card {
    border: 1px solid var(--border-color-primary);
    border-radius: var(--radius-lg);
    padding: 0.75rem 1rem;
    min-height: 22rem;
    background: var(--background-fill-primary);
}
.compact-note {
    font-size: 0.85rem;
    color: var(--body-text-color-subdued);
}
.gradio-container {
    width: 100%;
    max-width: none !important;
    height: 100vh !important;
    overflow-y: scroll !important;
    overflow-x: hidden !important;
    scrollbar-gutter: stable;
    scrollbar-width: auto;
    scrollbar-color: rgba(100, 116, 139, 0.9) rgba(148, 163, 184, 0.22);
    box-sizing: border-box;
    padding: 1rem max(1rem, calc((100vw - 1200px) / 2)) 2rem !important;
}
.gradio-container::-webkit-scrollbar {
    width: 14px;
}
.gradio-container::-webkit-scrollbar-track {
    background: rgba(148, 163, 184, 0.22);
}
.gradio-container::-webkit-scrollbar-thumb {
    background: rgba(100, 116, 139, 0.9);
    border: 3px solid transparent;
    border-radius: 999px;
    background-clip: padding-box;
}
.gradio-container::-webkit-scrollbar-thumb:hover {
    background: var(--primary-500, #6366f1);
    background-clip: padding-box;
}
"""

with gr.Blocks(title="ModelSentry", delete_cache=(600, 1800)) as demo:
    gr.Markdown("# 🛡️ ModelSentry · Hugging Face repository auditor")
    gr.Markdown(DESCRIPTION)
    with gr.Row():
        target = gr.Textbox(
            label="Public Model or Space",
            placeholder="https://huggingface.co/spaces/owner/name or model:owner/name",
            scale=5,
        )
        scan = gr.Button("Scan immutable revision", variant="primary", scale=1)
    summary = gr.Markdown(
        "### Ready to scan\n\nEnter `model:owner/name`, `space:owner/name`, or a public Hugging Face URL.\n\nThe result summary will stay in this fixed panel.",
        elem_classes=["scan-summary", "audit-cards"],
    )
    view_state = gr.State({})
    with gr.Tabs():
        with gr.Tab("Overview"):
            with gr.Row(equal_height=False):
                with gr.Column(scale=1, min_width=280):
                    coverage_selector = gr.Dropdown(label="Overview topic", choices=[], interactive=True)
                with gr.Column(scale=2, min_width=360):
                    coverage_detail = gr.Markdown(
                        "### Overview inspector\n\nRun a scan, then choose the repository profile or a coverage area.",
                        elem_classes=["detail-card", "audit-cards"],
                    )
        with gr.Tab("Findings"):
            with gr.Row(equal_height=False):
                with gr.Column(scale=1, min_width=280):
                    finding_selector = gr.Dropdown(label="Finding", choices=[], interactive=True)
                with gr.Column(scale=2, min_width=360):
                    finding_detail = gr.Markdown("Select a finding.", elem_classes=["detail-card", "audit-cards"])
        with gr.Tab("Provenance"):
            with gr.Row(equal_height=False):
                with gr.Column(scale=1, min_width=280):
                    dependency_selector = gr.Dropdown(label="Upstream repository", choices=[], interactive=True)
                with gr.Column(scale=2, min_width=360):
                    dependency_detail = gr.Markdown("Select an upstream repository.", elem_classes=["detail-card", "audit-cards"])
        with gr.Tab("Packages"):
            with gr.Row(equal_height=False):
                with gr.Column(scale=1, min_width=280):
                    package_selector = gr.Dropdown(label="Package", choices=[], interactive=True)
                with gr.Column(scale=2, min_width=360):
                    package_detail = gr.Markdown("Select a package.", elem_classes=["detail-card", "audit-cards"])
        with gr.Tab("Vulnerabilities"):
            with gr.Row(equal_height=False):
                with gr.Column(scale=1, min_width=280):
                    vulnerability_selector = gr.Dropdown(label="Known vulnerability", choices=[], interactive=True)
                with gr.Column(scale=2, min_width=360):
                    vulnerability_detail = gr.Markdown("Select a vulnerability.", elem_classes=["detail-card", "audit-cards"])
        with gr.Tab("JSON / SBOM"):
            report = gr.Code(language="json", label="modelsentry.scan.v4 JSON", lines=18)
            sbom = gr.File(label="CycloneDX 1.6 SBOM", interactive=False)
    gr.Markdown(
        "Static evidence requires human review. SBOM download files are eligible for automatic cleanup within 30 minutes.",
        elem_classes=["compact-note"],
    )
    outputs = [
        summary,
        coverage_selector,
        coverage_detail,
        dependency_selector,
        dependency_detail,
        package_selector,
        package_detail,
        vulnerability_selector,
        vulnerability_detail,
        finding_selector,
        finding_detail,
        report,
        sbom,
        view_state,
    ]
    scan.click(run_scan, inputs=target, outputs=outputs)
    target.submit(run_scan, inputs=target, outputs=outputs)
    coverage_selector.change(
        lambda selection, state: _select_detail(selection, state, "overview"),
        inputs=[coverage_selector, view_state],
        outputs=coverage_detail,
        api_name=False,
    )
    dependency_selector.change(
        lambda selection, state: _select_detail(selection, state, "dependencies"),
        inputs=[dependency_selector, view_state],
        outputs=dependency_detail,
        api_name=False,
    )
    package_selector.change(
        lambda selection, state: _select_detail(selection, state, "packages"),
        inputs=[package_selector, view_state],
        outputs=package_detail,
        api_name=False,
    )
    vulnerability_selector.change(
        lambda selection, state: _select_detail(selection, state, "vulnerabilities"),
        inputs=[vulnerability_selector, view_state],
        outputs=vulnerability_detail,
        api_name=False,
    )
    finding_selector.change(
        lambda selection, state: _select_detail(selection, state, "findings"),
        inputs=[finding_selector, view_state],
        outputs=finding_detail,
        api_name=False,
    )

if __name__ == "__main__":
    demo.launch(theme=gr.themes.Soft(), css=APP_CSS)