Spaces:
Sleeping
Sleeping
| """Transmission Zero - the first public anomaly surface for Nexusmon.""" | |
| from __future__ import annotations | |
| import json | |
| import os | |
| import time | |
| from pathlib import Path | |
| from typing import Any | |
| from urllib.error import HTTPError, URLError | |
| from urllib.request import Request, urlopen | |
| import gradio as gr | |
| SPACE_DIR = Path(__file__).resolve().parent | |
| SHARD_PATH = SPACE_DIR / "shard-0x00.txt" | |
| BRIDGE_ENDPOINTS = ("/api/organism/state", "/v1/organism/status", "/api/missions") | |
| TOKEN_ENV_KEYS = ("NEXUSMON_READ_TOKEN", "NEXUSMON_OPERATOR_KEY", "NEXUSMON_API_TOKEN") | |
| FRAGMENTS = ( | |
| "signal sheath engaged", | |
| "membrane pressure rising", | |
| "veil geometry stabilizing", | |
| "operator presence detected", | |
| "shard resonance locking", | |
| "transmission queued", | |
| ) | |
| def _clean(text: str) -> str: | |
| return " ".join((text or "").strip().split()) | |
| def _short(text: Any, limit: int = 96) -> str: | |
| value = str(text).strip() | |
| if len(value) <= limit: | |
| return value | |
| return value[: max(0, limit - 3)].rstrip() + "..." | |
| def _normalize_base_url() -> str: | |
| raw = _clean(os.getenv("NEXUSMON_BASE_URL", "") or os.getenv("NEXUSMON_API_URL", "")) | |
| if not raw: | |
| return "" | |
| if "://" not in raw: | |
| raw = f"https://{raw}" | |
| return raw.rstrip("/") | |
| def _bridge_token() -> str: | |
| for key in TOKEN_ENV_KEYS: | |
| token = _clean(os.getenv(key, "")) | |
| if token: | |
| return token | |
| return "" | |
| def _fetch_json(url: str, token: str = "") -> Any: | |
| headers = {"User-Agent": "NexusmonTransmissionZero/1.0"} | |
| if token: | |
| headers["Authorization"] = f"Bearer {token}" | |
| headers["x-operator-key"] = token | |
| request = Request(url, headers=headers) | |
| with urlopen(request, timeout=6) as response: | |
| charset = response.headers.get_content_charset() or "utf-8" | |
| payload = response.read().decode(charset, errors="replace") | |
| return json.loads(payload) | |
| def _extract_state(payload: Any) -> dict[str, Any]: | |
| if isinstance(payload, dict): | |
| if isinstance(payload.get("organism"), dict): | |
| return dict(payload["organism"]) | |
| if isinstance(payload.get("state"), dict): | |
| return dict(payload["state"]) | |
| return dict(payload) | |
| return {} | |
| def _extract_missions(payload: Any) -> list[Any]: | |
| if isinstance(payload, list): | |
| return payload | |
| if isinstance(payload, dict): | |
| for key in ("missions", "items", "results", "data"): | |
| value = payload.get(key) | |
| if isinstance(value, list): | |
| return value | |
| return [] | |
| def _bridge_snapshot() -> dict[str, Any]: | |
| base_url = _normalize_base_url() | |
| token = _bridge_token() | |
| if not base_url: | |
| return { | |
| "connected": False, | |
| "base_url": "", | |
| "state": {}, | |
| "state_source": "", | |
| "missions": [], | |
| "errors": [], | |
| } | |
| state_payload: Any = None | |
| state_source = "" | |
| errors: list[str] = [] | |
| for endpoint in BRIDGE_ENDPOINTS[:2]: | |
| try: | |
| state_payload = _fetch_json(f"{base_url}{endpoint}", token=token) | |
| state_source = endpoint | |
| break | |
| except (HTTPError, URLError, TimeoutError, json.JSONDecodeError, ValueError) as exc: | |
| errors.append(f"{endpoint}: {_short(exc, 120)}") | |
| missions_payload: Any = None | |
| try: | |
| missions_payload = _fetch_json(f"{base_url}/api/missions", token=token) | |
| except (HTTPError, URLError, TimeoutError, json.JSONDecodeError, ValueError) as exc: | |
| errors.append(f"/api/missions: {_short(exc, 120)}") | |
| return { | |
| "connected": state_payload is not None or missions_payload is not None, | |
| "base_url": base_url, | |
| "state": _extract_state(state_payload), | |
| "state_source": state_source, | |
| "missions": _extract_missions(missions_payload), | |
| "errors": errors, | |
| } | |
| def _pulse_markdown(snapshot: dict[str, Any]) -> str: | |
| if not snapshot["connected"]: | |
| return "\n".join( | |
| [ | |
| "### Live pulse", | |
| "- **Status:** offline", | |
| "- **Bridge:** absent", | |
| "- The public seed stays sealed until a read-only Nexusmon runtime is connected.", | |
| ] | |
| ) | |
| lines = [ | |
| "### Live pulse", | |
| f"- **Status:** live from `{snapshot['base_url']}`", | |
| ] | |
| if snapshot["state_source"]: | |
| lines.append(f"- **State source:** `{snapshot['state_source']}`") | |
| state = snapshot["state"] | |
| if isinstance(state, dict) and state: | |
| for label, key in (("Status", "status"), ("State", "state"), ("Form", "form"), ("Zone", "zone")): | |
| value = state.get(key) | |
| if value not in (None, "", [], {}): | |
| lines.append(f"- **{label}:** {_short(value, 72)}") | |
| missions = snapshot["missions"] | |
| if missions: | |
| first = missions[0] | |
| if isinstance(first, dict): | |
| title = first.get("title") or first.get("name") or first.get("task") or "Untitled mission" | |
| lines.append(f"- **Mission feed:** {_short(title, 84)}") | |
| else: | |
| lines.append(f"- **Mission feed:** {_short(first, 84)}") | |
| if snapshot["errors"]: | |
| lines.append("- **Bridge note:** partial read only, but still honest.") | |
| return "\n".join(lines) | |
| def _sigil_html() -> str: | |
| return """ | |
| <div class="nx-sigil-frame"> | |
| <div class="nx-sigil-mark"> | |
| <span></span><span></span><span></span><span></span> | |
| </div> | |
| <div class="nx-sigil-copy"> | |
| <div class="nx-eyebrow">NEXUSMON / TRANSMISSION ZERO</div> | |
| <div class="nx-microcopy">first contact surface • public anomaly • sealed core</div> | |
| </div> | |
| </div> | |
| """ | |
| def _hero_html() -> str: | |
| return """ | |
| <div class="nx-hero"> | |
| <div class="nx-sigil">transmission zero</div> | |
| <h1 class="nx-title">The First Anomaly</h1> | |
| <p class="nx-sub"> | |
| A signal breached containment. The public face stays small, deliberate, and sealed. | |
| </p> | |
| <div class="nx-badge-row"> | |
| <span class="nx-badge">first contact</span> | |
| <span class="nx-badge">read-only pulse</span> | |
| <span class="nx-badge">artifact drop</span> | |
| <span class="nx-badge">sealed core</span> | |
| </div> | |
| </div> | |
| """ | |
| def _artifact_copy() -> str: | |
| return "\n".join( | |
| [ | |
| "### Artifact drop", | |
| "- `shard-0x00.txt` is attached below.", | |
| "- Three redacted traces live in `logs/`.", | |
| "- The shard stays public-safe. The core stays hidden.", | |
| ] | |
| ) | |
| def _stream_transmission() -> Any: | |
| transcript: list[str] = [] | |
| for fragment in FRAGMENTS: | |
| transcript.append(f"> {fragment}...") | |
| yield "\n".join(transcript) | |
| time.sleep(0.55) | |
| def build_ui() -> gr.Blocks: | |
| theme = gr.themes.Base( | |
| primary_hue=gr.themes.Color( | |
| c50="#e7fbff", | |
| c100="#c7f4ff", | |
| c200="#96e9ff", | |
| c300="#5fd6ff", | |
| c400="#2cc2ff", | |
| c500="#00aef2", | |
| c600="#008fcc", | |
| c700="#006fa0", | |
| c800="#0a567f", | |
| c900="#0a3e5b", | |
| c950="#08283b", | |
| ), | |
| secondary_hue=gr.themes.Color( | |
| c50="#fff7df", | |
| c100="#ffe9ad", | |
| c200="#ffd56d", | |
| c300="#ffc63b", | |
| c400="#ffb200", | |
| c500="#e29a00", | |
| c600="#b87900", | |
| c700="#8f5d00", | |
| c800="#6d4700", | |
| c900="#4f3300", | |
| c950="#2d1e00", | |
| ), | |
| neutral_hue=gr.themes.colors.slate, | |
| font=[gr.themes.GoogleFont("Space Grotesk"), "system-ui", "sans-serif"], | |
| font_mono=[gr.themes.GoogleFont("IBM Plex Mono"), "monospace"], | |
| ).set( | |
| body_background_fill="#050812", | |
| body_text_color="#e8f4ff", | |
| block_background_fill="#0a0e18", | |
| block_border_width="1px", | |
| block_border_color="rgba(120, 200, 255, 0.18)", | |
| input_background_fill="#0f1524", | |
| input_border_color="rgba(56, 189, 248, 0.22)", | |
| button_primary_background_fill="#00aef2", | |
| button_primary_text_color="#08131d", | |
| ) | |
| css = """ | |
| body { | |
| background: | |
| radial-gradient(circle at 12% 10%, rgba(0, 174, 242, 0.18), transparent 24%), | |
| radial-gradient(circle at 88% 8%, rgba(112, 76, 255, 0.14), transparent 20%), | |
| radial-gradient(circle at 50% 120%, rgba(224, 76, 255, 0.12), transparent 26%), | |
| linear-gradient(180deg, #050812 0%, #040711 46%, #03050c 100%); | |
| color: #e8f4ff; | |
| } | |
| body::before { | |
| content: ""; | |
| position: fixed; | |
| inset: 0; | |
| pointer-events: none; | |
| background-image: | |
| linear-gradient(rgba(120, 200, 255, 0.06) 1px, transparent 1px), | |
| linear-gradient(90deg, rgba(120, 200, 255, 0.04) 1px, transparent 1px); | |
| background-size: 100% 28px, 28px 100%; | |
| mask-image: linear-gradient(180deg, rgba(0, 0, 0, 0.45), transparent 92%); | |
| opacity: 0.55; | |
| } | |
| .gradio-container { | |
| max-width: 1240px !important; | |
| } | |
| .nx-sigil-frame { | |
| display: flex; | |
| align-items: center; | |
| justify-content: space-between; | |
| gap: 1rem; | |
| margin: 0 0 1rem; | |
| padding: 0.95rem 1.05rem; | |
| border: 1px solid rgba(120, 200, 255, 0.18); | |
| border-radius: 18px; | |
| background: | |
| linear-gradient(180deg, rgba(12, 16, 27, 0.92), rgba(8, 10, 16, 0.88)); | |
| box-shadow: 0 18px 72px rgba(0, 0, 0, 0.28); | |
| } | |
| .nx-sigil-mark { | |
| display: grid; | |
| grid-template-columns: repeat(2, 10px); | |
| grid-auto-rows: 10px; | |
| gap: 8px; | |
| position: relative; | |
| width: 36px; | |
| min-width: 36px; | |
| height: 36px; | |
| align-content: center; | |
| justify-content: center; | |
| } | |
| .nx-sigil-mark span { | |
| border-radius: 999px; | |
| background: linear-gradient(180deg, #00d9ff, #6e4fff); | |
| box-shadow: 0 0 14px rgba(0, 217, 255, 0.55); | |
| animation: nxPulse 3.6s ease-in-out infinite; | |
| } | |
| .nx-sigil-mark span:nth-child(2), | |
| .nx-sigil-mark span:nth-child(4) { | |
| animation-delay: 0.45s; | |
| } | |
| .nx-eyebrow { | |
| text-transform: uppercase; | |
| letter-spacing: 0.3em; | |
| font-size: 0.7rem; | |
| color: #87dfff; | |
| margin-bottom: 0.22rem; | |
| } | |
| .nx-microcopy { | |
| color: #9db4cb; | |
| font-size: 0.88rem; | |
| } | |
| .nx-hero { | |
| position: relative; | |
| overflow: hidden; | |
| border: 1px solid rgba(120, 200, 255, 0.18); | |
| border-radius: 24px; | |
| padding: 1.3rem 1.35rem; | |
| background: | |
| radial-gradient(circle at top, rgba(0, 174, 242, 0.22), transparent 38%), | |
| radial-gradient(circle at 85% 12%, rgba(110, 79, 255, 0.16), transparent 24%), | |
| linear-gradient(180deg, rgba(10, 14, 24, 0.98), rgba(8, 10, 16, 0.98)); | |
| box-shadow: 0 0 0 1px rgba(255, 255, 255, 0.03), 0 28px 92px rgba(0, 0, 0, 0.45); | |
| } | |
| .nx-hero::after { | |
| content: ""; | |
| position: absolute; | |
| inset: 0; | |
| pointer-events: none; | |
| background: | |
| linear-gradient(115deg, transparent 0%, rgba(255, 255, 255, 0.06) 48%, transparent 60%); | |
| opacity: 0.18; | |
| transform: translateX(-28%); | |
| animation: nxSweep 12s ease-in-out infinite; | |
| } | |
| .nx-sigil { | |
| text-transform: uppercase; | |
| letter-spacing: 0.32em; | |
| font-size: 0.72rem; | |
| color: #7bd7ff; | |
| margin-bottom: 0.6rem; | |
| } | |
| .nx-title { | |
| margin: 0; | |
| font-size: clamp(2.8rem, 5vw, 5rem); | |
| line-height: 0.92; | |
| color: #f4fbff; | |
| text-wrap: balance; | |
| } | |
| .nx-sub { | |
| margin: 0.8rem 0 0; | |
| color: #b7c7dd; | |
| font-size: 1.02rem; | |
| max-width: 44rem; | |
| } | |
| .nx-badge-row { | |
| display: flex; | |
| gap: 0.5rem; | |
| flex-wrap: wrap; | |
| margin-top: 1rem; | |
| } | |
| .nx-badge { | |
| padding: 0.35rem 0.65rem; | |
| border-radius: 999px; | |
| border: 1px solid rgba(120, 200, 255, 0.2); | |
| background: rgba(10, 16, 28, 0.84); | |
| color: #d9f4ff; | |
| font-size: 0.78rem; | |
| text-transform: uppercase; | |
| letter-spacing: 0.08em; | |
| } | |
| .nx-card { | |
| position: relative; | |
| overflow: hidden; | |
| border-radius: 18px; | |
| padding: 1rem 1.05rem 0.95rem; | |
| background: | |
| linear-gradient(180deg, rgba(10, 14, 24, 0.88), rgba(8, 10, 16, 0.95)); | |
| border: 1px solid rgba(120, 200, 255, 0.16); | |
| box-shadow: 0 20px 65px rgba(0, 0, 0, 0.3); | |
| } | |
| .nx-card::before { | |
| content: ""; | |
| position: absolute; | |
| inset: 0; | |
| pointer-events: none; | |
| background: radial-gradient(circle at top left, rgba(0, 174, 242, 0.12), transparent 36%); | |
| opacity: 0.9; | |
| } | |
| .nx-card--artifact .gr-file { | |
| border-radius: 14px; | |
| overflow: hidden; | |
| } | |
| .nx-card--terminal textarea { | |
| min-height: 236px !important; | |
| font-family: "IBM Plex Mono", monospace !important; | |
| background: linear-gradient(180deg, rgba(4, 10, 16, 0.98), rgba(6, 12, 19, 0.98)) !important; | |
| border: 1px solid rgba(0, 174, 242, 0.15) !important; | |
| color: #e8f4ff !important; | |
| box-shadow: inset 0 0 0 1px rgba(255, 255, 255, 0.02); | |
| } | |
| .nx-card--terminal textarea::selection { | |
| background: rgba(0, 174, 242, 0.3); | |
| } | |
| .nx-terminal-rail { | |
| display: grid; | |
| grid-template-columns: repeat(3, 1fr); | |
| gap: 0.6rem; | |
| margin-top: 0.8rem; | |
| } | |
| .nx-chip { | |
| border-radius: 12px; | |
| border: 1px solid rgba(120, 200, 255, 0.14); | |
| padding: 0.75rem 0.8rem; | |
| background: rgba(13, 18, 30, 0.72); | |
| } | |
| .nx-chip-label { | |
| display: block; | |
| color: #8ca6be; | |
| font-size: 0.72rem; | |
| text-transform: uppercase; | |
| letter-spacing: 0.12em; | |
| margin-bottom: 0.25rem; | |
| } | |
| .nx-chip-value { | |
| display: block; | |
| color: #eff9ff; | |
| font-size: 0.92rem; | |
| } | |
| .nx-shard-note { | |
| margin-top: 0.7rem; | |
| color: #89a6c4; | |
| font-size: 0.84rem; | |
| } | |
| .nx-status-orb { | |
| width: 12px; | |
| height: 12px; | |
| border-radius: 999px; | |
| background: #00d9ff; | |
| box-shadow: 0 0 0 0 rgba(0, 217, 255, 0.45); | |
| animation: nxPing 2.1s infinite; | |
| margin-top: 0.2rem; | |
| } | |
| .nx-terminal-header { | |
| display: flex; | |
| align-items: flex-start; | |
| justify-content: space-between; | |
| gap: 1rem; | |
| margin-bottom: 0.8rem; | |
| } | |
| .nx-terminal-title { | |
| margin: 0; | |
| font-size: 1.02rem; | |
| color: #eff9ff; | |
| text-transform: uppercase; | |
| letter-spacing: 0.14em; | |
| } | |
| .nx-terminal-sub { | |
| margin: 0.3rem 0 0; | |
| color: #97afc8; | |
| font-size: 0.86rem; | |
| } | |
| .nx-rail-note { | |
| color: #88a1ba; | |
| font-size: 0.82rem; | |
| margin: 0.7rem 0 0; | |
| } | |
| button, .gr-button { | |
| border-radius: 999px !important; | |
| background: linear-gradient(90deg, #00aef2, #6e4fff) !important; | |
| color: #07111b !important; | |
| border: 0 !important; | |
| font-weight: 700 !important; | |
| letter-spacing: 0.08em; | |
| text-transform: uppercase; | |
| box-shadow: 0 16px 36px rgba(0, 174, 242, 0.22); | |
| } | |
| button:hover, .gr-button:hover { | |
| filter: brightness(1.08); | |
| transform: translateY(-1px); | |
| } | |
| .gr-file > div { | |
| background: rgba(7, 12, 20, 0.9) !important; | |
| border-color: rgba(120, 200, 255, 0.16) !important; | |
| } | |
| @keyframes nxPulse { | |
| 0%, 100% { transform: scale(0.96); opacity: 0.78; } | |
| 50% { transform: scale(1.12); opacity: 1; } | |
| } | |
| @keyframes nxPing { | |
| 0% { box-shadow: 0 0 0 0 rgba(0, 217, 255, 0.44); } | |
| 70% { box-shadow: 0 0 0 16px rgba(0, 217, 255, 0); } | |
| 100% { box-shadow: 0 0 0 0 rgba(0, 217, 255, 0); } | |
| } | |
| @keyframes nxSweep { | |
| 0%, 70% { transform: translateX(-28%); opacity: 0.08; } | |
| 85% { opacity: 0.2; } | |
| 100% { transform: translateX(28%); opacity: 0.06; } | |
| } | |
| """ | |
| with gr.Blocks(theme=theme, css=css, title="Transmission Zero", analytics_enabled=False) as demo: | |
| gr.HTML(_sigil_html()) | |
| gr.HTML(_hero_html()) | |
| with gr.Row(equal_height=True): | |
| with gr.Column(scale=5, min_width=360): | |
| with gr.Group(elem_classes=["nx-card"]): | |
| pulse = gr.Markdown() | |
| gr.HTML( | |
| """ | |
| <div class="nx-terminal-rail"> | |
| <div class="nx-chip"> | |
| <span class="nx-chip-label">Containment</span> | |
| <span class="nx-chip-value">sealed public shell</span> | |
| </div> | |
| <div class="nx-chip"> | |
| <span class="nx-chip-label">Surface</span> | |
| <span class="nx-chip-value">first-contact anomaly</span> | |
| </div> | |
| <div class="nx-chip"> | |
| <span class="nx-chip-label">Truth</span> | |
| <span class="nx-chip-value">read-only pulse only</span> | |
| </div> | |
| </div> | |
| """ | |
| ) | |
| with gr.Column(scale=7, min_width=360): | |
| with gr.Group(elem_classes=["nx-card", "nx-card--artifact"]): | |
| gr.Markdown(_artifact_copy()) | |
| gr.File( | |
| value=str(SHARD_PATH), | |
| label="Shard-0X00", | |
| interactive=False, | |
| ) | |
| gr.Markdown( | |
| "<p class='nx-shard-note'>" | |
| "Three redacted traces. One shard. The core remains hidden." | |
| "</p>" | |
| ) | |
| with gr.Row(): | |
| with gr.Column(): | |
| with gr.Group(elem_classes=["nx-card", "nx-card--terminal"]): | |
| gr.HTML( | |
| """ | |
| <div class="nx-terminal-header"> | |
| <div> | |
| <h3 class="nx-terminal-title">Transmission terminal</h3> | |
| <p class="nx-terminal-sub">A deliberate signal path for the first anomaly.</p> | |
| </div> | |
| <div class="nx-status-orb" aria-hidden="true"></div> | |
| </div> | |
| """ | |
| ) | |
| terminal = gr.Textbox( | |
| value="> awaiting the first anomaly...", | |
| label="", | |
| lines=8, | |
| interactive=False, | |
| show_label=False, | |
| elem_classes=["nx-terminal"], | |
| ) | |
| btn = gr.Button("INITIATE LINK", variant="primary") | |
| gr.Markdown( | |
| "<p class='nx-rail-note'>" | |
| "Read-only by default. No private data is exposed here." | |
| "</p>" | |
| ) | |
| btn.click(fn=_stream_transmission, outputs=terminal) | |
| demo.load(fn=lambda: _pulse_markdown(_bridge_snapshot()), outputs=pulse) | |
| return demo | |
| demo = build_ui() | |
| demo.queue() | |
| if __name__ == "__main__": | |
| demo.launch() | |