ghostnexus-node 0.1.0__py3-none-any.whl

ghostnexus_node/__init__.py

@@ -0,0 +1,2 @@
+"""GhostNexus Provider Node — earn money with your idle GPU."""
+__version__ = "0.1.0"

ghostnexus_node/cli.py

@@ -0,0 +1,80 @@
+"""
+GhostNexus Node CLI — ghostnexus-node start --api-key gn_live_...
+"""
+import argparse
+import asyncio
+import os
+import sys
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        prog="ghostnexus-node",
+        description="GhostNexus Provider Node — earn money with your idle GPU",
+    )
+    subparsers = parser.add_subparsers(dest="command")
+
+    # start command
+    start_parser = subparsers.add_parser("start", help="Start the provider node")
+    start_parser.add_argument(
+        "--api-key",
+        default=os.environ.get("GHOSTNEXUS_PROVIDER_API_KEY", ""),
+        help="Your GhostNexus provider API key (gn_live_...)",
+    )
+    start_parser.add_argument(
+        "--server",
+        default="wss://ghostnexus.net/ws/provider",
+        help="GhostNexus server WebSocket URL",
+    )
+    start_parser.add_argument(
+        "--gpu-passthrough",
+        action="store_true",
+        default=True,
+        help="Pass GPU to Docker containers (default: True)",
+    )
+    start_parser.add_argument(
+        "--memory",
+        default="8g",
+        help="Memory limit per job (default: 8g)",
+    )
+    start_parser.add_argument(
+        "--cpus",
+        default="4.0",
+        help="CPU limit per job (default: 4.0)",
+    )
+
+    args = parser.parse_args()
+
+    if args.command == "start":
+        if not args.api_key:
+            print(
+                "Error: API key required.\n"
+                "  ghostnexus-node start --api-key gn_live_...\n"
+                "  or set GHOSTNEXUS_PROVIDER_API_KEY environment variable\n\n"
+                "Get your provider API key at: https://ghostnexus.net/login"
+            )
+            sys.exit(1)
+
+        # Set env vars and import the actual provider node
+        os.environ["GHOSTNEXUS_WS_URL"] = args.server
+        os.environ["GHOSTNEXUS_PROVIDER_API_KEY"] = args.api_key
+        os.environ["GHOSTNEXUS_GPU_PASSTHROUGH"] = "true" if args.gpu_passthrough else "false"
+        os.environ["GHOSTNEXUS_JOB_MEMORY"] = args.memory
+        os.environ["GHOSTNEXUS_JOB_CPUS"] = args.cpus
+        os.environ["GHOSTNEXUS_JOB_TIMEOUT"] = "3600"
+
+        print(f"GhostNexus Provider Node v0.1.0")
+        print(f"Connecting to {args.server} ...")
+
+        try:
+            from ghostnexus_node.node import run
+            run()
+        except ImportError as e:
+            print(f"Error loading node: {e}")
+            sys.exit(1)
+    else:
+        parser.print_help()
+
+
+if __name__ == "__main__":
+    main()

ghostnexus_node/gpu_detector.py

@@ -0,0 +1,74 @@
+"""
+GhostNexus - Provider Node
+GPU detection module (fake/mock for development without NVIDIA hardware).
+"""
+
+import logging
+from dataclasses import dataclass
+from typing import Optional
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class GPUInfo:
+    """GPU hardware information."""
+
+    model: str
+    vram_mb: int
+    temperature_c: Optional[int] = None
+    utilization_pct: Optional[int] = None
+
+
+def detect_gpu() -> Optional[GPUInfo]:
+    """
+    Detect available GPU. Uses pynvml if NVIDIA GPU present, otherwise returns mock data.
+    Mock data allows development/testing without physical GPU.
+    """
+    try:
+        import pynvml
+
+        pynvml.nvmlInit()
+        handle = pynvml.nvmlDeviceGetHandleByIndex(0)
+        name = pynvml.nvmlDeviceGetName(handle)
+        if isinstance(name, bytes):
+            name = name.decode("utf-8", errors="replace")
+        mem_info = pynvml.nvmlDeviceGetMemoryInfo(handle)
+        vram_mb = mem_info.total // (1024 * 1024)
+
+        temp = None
+        try:
+            temp = pynvml.nvmlDeviceGetTemperature(handle, pynvml.NVML_TEMPERATURE_GPU)
+        except Exception:
+            pass
+
+        util = None
+        try:
+            util = pynvml.nvmlDeviceGetUtilizationRates(handle)
+            util = util.gpu if util else None
+        except Exception:
+            pass
+
+        pynvml.nvmlShutdown()
+        return GPUInfo(
+            model=name.strip(),
+            vram_mb=vram_mb,
+            temperature_c=temp,
+            utilization_pct=util,
+        )
+    except ImportError:
+        logger.info("pynvml not installed, using mock GPU for development")
+        return _get_mock_gpu()
+    except Exception as e:
+        logger.warning(f"GPU detection failed: {e}, using mock GPU")
+        return _get_mock_gpu()
+
+
+def _get_mock_gpu() -> GPUInfo:
+    """Return fake GPU info for development/testing without NVIDIA hardware."""
+    return GPUInfo(
+        model="NVIDIA GeForce RTX 4090 (Mock)",
+        vram_mb=24576,
+        temperature_c=45,
+        utilization_pct=0,
+    )

ghostnexus_node/node.py

@@ -0,0 +1,485 @@
+"""
+GhostNexus - Provider Node
+Lightweight client that detects GPU, connects via WebSocket, sends heartbeat,
+and executes Python scripts received from the Matchmaker.
+
+Job execution is sandboxed inside Docker containers with strict resource and
+security limits (no network, no new privileges, read-only filesystem, CPU/RAM cap).
+"""
+
+import asyncio
+import json
+import logging
+import os
+import signal
+import sys
+import tempfile
+import time
+
+from ghostnexus_node.gpu_detector import GPUInfo, detect_gpu
+
+logging.basicConfig(
+    level=os.getenv("LOG_LEVEL", "INFO").upper(),
+    format="%(asctime)s [%(levelname)s] %(name)s — %(message)s",
+    stream=sys.stdout,
+)
+logger = logging.getLogger("ghostnexus.provider")
+
+# ── Configuration ─────────────────────────────────────────────────────────────
+WS_URL = os.getenv("GHOSTNEXUS_WS_URL", "ws://localhost:8000/ws/provider")
+PROVIDER_API_KEY = os.getenv("GHOSTNEXUS_PROVIDER_API_KEY", "")
+HEARTBEAT_INTERVAL = 10  # seconds
+
+# Build authenticated WebSocket URL (token passed as query param — auth happens
+# server-side before websocket.accept(), so no token = immediate close with 4001)
+def _build_ws_url() -> str:
+    if not PROVIDER_API_KEY:
+        logger.error(
+            "GHOSTNEXUS_PROVIDER_API_KEY is not set. "
+            "Set this environment variable to your provider API key and restart."
+        )
+        sys.exit(1)
+    separator = "&" if "?" in WS_URL else "?"
+    return f"{WS_URL}{separator}token={PROVIDER_API_KEY}"
+
+# Reconnect backoff: starts at 3s, doubles each attempt, capped at 60s
+_RECONNECT_MIN = 3
+_RECONNECT_MAX = 60
+
+# ── Docker sandbox configuration ──────────────────────────────────────────────
+DOCKER_IMAGE = os.getenv("GHOSTNEXUS_DOCKER_IMAGE", "python:3.11-slim")
+JOB_MEMORY_LIMIT = os.getenv("GHOSTNEXUS_JOB_MEMORY", "512m")
+JOB_CPU_LIMIT = os.getenv("GHOSTNEXUS_JOB_CPUS", "1.0")
+GPU_PASSTHROUGH = os.getenv("GHOSTNEXUS_GPU_PASSTHROUGH", "false").lower() == "true"
+JOB_TIMEOUT = int(os.getenv("GHOSTNEXUS_JOB_TIMEOUT", "300"))
+
+
+async def _check_docker() -> bool:
+    """Verify that Docker daemon is reachable before accepting any jobs."""
+    try:
+        proc = await asyncio.create_subprocess_exec(
+            "docker", "info",
+            stdout=asyncio.subprocess.DEVNULL,
+            stderr=asyncio.subprocess.DEVNULL,
+        )
+        await proc.wait()
+        return proc.returncode == 0
+    except FileNotFoundError:
+        return False
+
+
+def _build_docker_cmd(container_name: str, script_host_path: str) -> list[str]:
+    """
+    Construct the `docker run` command that sandboxes the user script.
+
+    Security flags applied:
+      --security-opt no-new-privileges:true   prevent setuid/setgid escalation
+      --network=none        no inbound or outbound network
+      --read-only           immutable root filesystem
+      --tmpfs /tmp          writable scratch space (no exec, size-capped)
+      --cap-drop=ALL        drop all Linux capabilities
+      --memory / --cpus     hard resource limits
+      --user 65534          run as nobody (unprivileged UID)
+    """
+    cmd = [
+        "docker", "run",
+        "--rm",
+        "--name", container_name,
+        "--network=none",
+        "--memory", JOB_MEMORY_LIMIT,
+        "--memory-swap", JOB_MEMORY_LIMIT,   # disables swap
+        "--cpus", JOB_CPU_LIMIT,
+        "--read-only",
+        "--tmpfs", "/tmp:size=64m,noexec,nosuid",
+        "--cap-drop=ALL",
+        "--security-opt", "no-new-privileges:true",
+        "-v", f"{script_host_path}:/job/script.py:ro",
+        "-w", "/job",
+        "--user", "65534:65534",   # nobody:nogroup
+    ]
+    if GPU_PASSTHROUGH:
+        cmd.extend(["--gpus", "all"])
+    cmd.extend([DOCKER_IMAGE, "python", "/job/script.py"])
+    return cmd
+
+
+async def _kill_container(container_name: str) -> None:
+    """Send SIGKILL to a running container (best-effort)."""
+    try:
+        proc = await asyncio.create_subprocess_exec(
+            "docker", "kill", container_name,
+            stdout=asyncio.subprocess.DEVNULL,
+            stderr=asyncio.subprocess.DEVNULL,
+        )
+        await asyncio.wait_for(proc.wait(), timeout=10.0)
+    except Exception as exc:
+        logger.warning(f"docker kill {container_name}: {exc}")
+
+
+# ── Heartbeat ─────────────────────────────────────────────────────────────────
+
+async def heartbeat_sender(ws, gpu: GPUInfo):
+    """Send heartbeat every 10 seconds."""
+    while True:
+        await asyncio.sleep(HEARTBEAT_INTERVAL)
+        try:
+            await ws.send(
+                json.dumps(
+                    {
+                        "type": "heartbeat",
+                        "vram_mb": gpu.vram_mb,
+                        "temperature_c": gpu.temperature_c,
+                    }
+                )
+            )
+            logger.debug("Heartbeat sent")
+        except Exception:
+            break
+
+
+# ── Message receiver ──────────────────────────────────────────────────────────
+
+async def message_receiver(ws, gpu: GPUInfo):
+    """Listen for messages: heartbeat_ack or job_execute."""
+    while True:
+        try:
+            msg = await ws.recv()
+            data = json.loads(msg)
+            msg_type = data.get("type", "unknown")
+
+            if msg_type == "heartbeat_ack":
+                logger.debug("Heartbeat acknowledged")
+
+            elif msg_type == "job_execute":
+                job_id = data.get("job_id")
+                task_name = data.get("task_name", "unknown")
+                script_content = data.get("script_content", "")
+
+                if not script_content:
+                    await ws.send(
+                        json.dumps(
+                            {
+                                "type": "job_result",
+                                "job_id": job_id,
+                                "status": "failed",
+                                "task_name": task_name,
+                                "duration_seconds": 0,
+                                "stdout": "",
+                                "stderr": "No script content provided",
+                            }
+                        )
+                    )
+                    continue
+
+                logger.info(
+                    f"Job received: {job_id} | task={task_name} | "
+                    f"spawning Docker container (image={DOCKER_IMAGE})"
+                )
+
+                # Safe container name: alphanumeric + dash, max 63 chars
+                container_name = f"gn-job-{job_id[:20]}"
+                temp_path = None
+                try:
+                    # Write script to a named temp file so Docker can bind-mount it
+                    with tempfile.NamedTemporaryFile(
+                        mode="w",
+                        suffix="_job.py",
+                        delete=False,
+                        encoding="utf-8",
+                    ) as f:
+                        f.write(script_content)
+                        temp_path = f.name
+
+                    docker_cmd = _build_docker_cmd(container_name, temp_path)
+                    start = time.perf_counter()
+
+                    proc = await asyncio.create_subprocess_exec(
+                        *docker_cmd,
+                        stdout=asyncio.subprocess.PIPE,
+                        stderr=asyncio.subprocess.PIPE,
+                    )
+
+                    task_comm = asyncio.create_task(
+                        asyncio.wait_for(proc.communicate(), timeout=JOB_TIMEOUT)
+                    )
+                    task_recv = asyncio.create_task(ws.recv())
+
+                    done, pending = await asyncio.wait(
+                        [task_comm, task_recv],
+                        return_when=asyncio.FIRST_COMPLETED,
+                    )
+
+                    killed = False
+
+                    if task_recv in done:
+                        # A message arrived while job was running
+                        try:
+                            recv_data = json.loads(task_recv.result())
+                            if (
+                                recv_data.get("type") == "job_kill"
+                                and recv_data.get("job_id") == job_id
+                            ):
+                                killed = True
+                                # Kill the Docker container, not just the docker-run process
+                                await _kill_container(container_name)
+                                try:
+                                    stdout, stderr = await asyncio.wait_for(
+                                        proc.communicate(), timeout=10.0
+                                    )
+                                except asyncio.TimeoutError:
+                                    proc.kill()
+                                    stdout, stderr = await proc.communicate()
+                            else:
+                                # Unrelated message — let job finish
+                                stdout, stderr = await task_comm
+                        except (json.JSONDecodeError, KeyError):
+                            stdout, stderr = await task_comm
+                    else:
+                        # Job finished first
+                        try:
+                            stdout, stderr = await task_comm
+                        except asyncio.TimeoutError:
+                            # Hard timeout: kill container
+                            await _kill_container(container_name)
+                            try:
+                                proc.terminate()
+                            except ProcessLookupError:
+                                pass
+                            stdout, stderr = await proc.communicate()
+                            duration_seconds = time.perf_counter() - start
+                            await ws.send(
+                                json.dumps(
+                                    {
+                                        "type": "job_result",
+                                        "job_id": job_id,
+                                        "status": "failed",
+                                        "task_name": task_name,
+                                        "duration_seconds": round(duration_seconds, 2),
+                                        "stdout": (stdout or b"").decode("utf-8", errors="replace"),
+                                        "stderr": f"Script execution timed out ({JOB_TIMEOUT}s)",
+                                    }
+                                )
+                            )
+                            for t in pending:
+                                t.cancel()
+                                try:
+                                    await t
+                                except (asyncio.CancelledError, Exception):
+                                    pass
+                            continue
+
+                    # Cancel any remaining tasks
+                    for t in pending:
+                        t.cancel()
+                        try:
+                            await t
+                        except (asyncio.CancelledError, Exception):
+                            pass
+
+                    duration_seconds = time.perf_counter() - start
+                    stdout_str = (stdout or b"").decode("utf-8", errors="replace")
+                    stderr_str = (stderr or b"").decode("utf-8", errors="replace")
+
+                    if killed:
+                        status = "failed_insufficient_funds"
+                        stderr_str = "Insufficient funds — job killed by backend"
+                        logger.info(f"Job {job_id} killed (insufficient funds)")
+                    else:
+                        status = "success" if proc.returncode == 0 else "failed"
+                        logger.info(
+                            f"Job {job_id} completed | status={status} | "
+                            f"duration={duration_seconds:.2f}s | "
+                            f"exit_code={proc.returncode}"
+                        )
+
+                    await ws.send(
+                        json.dumps(
+                            {
+                                "type": "job_result",
+                                "job_id": job_id,
+                                "status": status,
+                                "task_name": task_name,
+                                "duration_seconds": round(duration_seconds, 2),
+                                "stdout": stdout_str,
+                                "stderr": stderr_str,
+                            }
+                        )
+                    )
+
+                except asyncio.CancelledError:
+                    raise
+                except Exception as e:
+                    logger.exception(f"Job {job_id} execution error: {e}")
+                    await ws.send(
+                        json.dumps(
+                            {
+                                "type": "job_result",
+                                "job_id": job_id,
+                                "status": "failed",
+                                "task_name": task_name,
+                                "duration_seconds": 0,
+                                "stdout": "",
+                                "stderr": str(e),
+                            }
+                        )
+                    )
+                finally:
+                    if temp_path and os.path.exists(temp_path):
+                        try:
+                            os.unlink(temp_path)
+                        except OSError:
+                            pass
+
+            elif msg_type == "result_received":
+                logger.debug("Backend acknowledged job result")
+
+            else:
+                logger.warning(f"Unknown message type: {msg_type}")
+
+        except Exception as e:
+            logger.error(f"Message receiver error: {e}")
+            raise
+
+
+# ── Main loop ─────────────────────────────────────────────────────────────────
+
+async def run_provider_node(shutdown: asyncio.Event):
+    """Main loop: connect, register GPU, heartbeat + job listener.
+    Reconnects with exponential backoff on disconnect.
+    """
+    import websockets
+
+    # Verify Docker is available before anything else
+    if not await _check_docker():
+        logger.error(
+            "Docker daemon is not reachable. "
+            "Install Docker and ensure the daemon is running, then retry."
+        )
+        sys.exit(1)
+    logger.info(
+        f"Docker OK | image={DOCKER_IMAGE} | "
+        f"mem={JOB_MEMORY_LIMIT} | cpus={JOB_CPU_LIMIT} | "
+        f"gpu_passthrough={GPU_PASSTHROUGH}"
+    )
+
+    gpu = detect_gpu()
+    if not gpu:
+        logger.error("No GPU detected — exiting.")
+        sys.exit(1)
+
+    ws_connect_url = _build_ws_url()
+    logger.info(f"GPU detected: {gpu.model} | VRAM: {gpu.vram_mb} MB")
+    logger.info(f"Connecting to {WS_URL} …")
+
+    reconnect_delay = _RECONNECT_MIN
+    attempt = 0
+
+    while not shutdown.is_set():
+        attempt += 1
+        try:
+            async with websockets.connect(
+                ws_connect_url,
+                ping_interval=20,
+                ping_timeout=10,
+                close_timeout=5,
+            ) as ws:
+                reconnect_delay = _RECONNECT_MIN  # reset on successful connect
+                logger.info(f"Connected (attempt #{attempt})")
+
+                # Register with GPU info (identity already verified via ?token= at connect)
+                register_payload = {
+                    "type": "register",
+                    "gpu_model": gpu.model,
+                    "vram_mb": gpu.vram_mb,
+                    "temperature_c": gpu.temperature_c,
+                    "utilization_pct": gpu.utilization_pct,
+                }
+                logger.info("Sending GPU registration")
+
+                await ws.send(json.dumps(register_payload))
+                reg_response = await ws.recv()
+                reg_data = json.loads(reg_response)
+                if reg_data.get("type") == "registered":
+                    logger.info(
+                        f"Registered as node {reg_data.get('node_id')} | "
+                        f"GPU: {gpu.model} | Status: {reg_data.get('status', 'ok')}"
+                    )
+
+                # Run heartbeat + message receiver concurrently; stop on shutdown
+                async def _shutdown_watcher():
+                    await shutdown.wait()
+
+                done, pending = await asyncio.wait(
+                    [
+                        asyncio.create_task(heartbeat_sender(ws, gpu)),
+                        asyncio.create_task(message_receiver(ws, gpu)),
+                        asyncio.create_task(_shutdown_watcher()),
+                    ],
+                    return_when=asyncio.FIRST_COMPLETED,
+                )
+                for task in pending:
+                    task.cancel()
+                    try:
+                        await task
+                    except asyncio.CancelledError:
+                        pass
+
+                if shutdown.is_set():
+                    logger.info("Shutdown signal received — disconnecting cleanly.")
+                    break
+
+        except Exception as e:
+            logger.error(
+                f"Connection lost: {e} — reconnecting in {reconnect_delay}s "
+                f"(attempt #{attempt})"
+            )
+            try:
+                await asyncio.wait_for(shutdown.wait(), timeout=reconnect_delay)
+                break  # Shutdown was requested during wait
+            except asyncio.TimeoutError:
+                pass
+            reconnect_delay = min(reconnect_delay * 2, _RECONNECT_MAX)
+
+
+def _handle_signal(shutdown: asyncio.Event):
+    logger.info("Interrupt received — shutting down …")
+    shutdown.set()
+
+
+if __name__ == "__main__":
+    loop = asyncio.new_event_loop()
+    asyncio.set_event_loop(loop)
+    shutdown_event = asyncio.Event()
+
+    for sig in (signal.SIGINT, signal.SIGTERM):
+        try:
+            loop.add_signal_handler(sig, _handle_signal, shutdown_event)
+        except NotImplementedError:
+            # Windows doesn't support add_signal_handler for all signals
+            pass
+
+    try:
+        loop.run_until_complete(run_provider_node(shutdown_event))
+    finally:
+        loop.close()
+        logger.info("Provider node stopped.")
+
+
+def run():
+    """Entry point called by CLI."""
+    import signal
+    loop = asyncio.new_event_loop()
+    asyncio.set_event_loop(loop)
+    shutdown_event = asyncio.Event()
+
+    for sig in (signal.SIGINT, signal.SIGTERM):
+        try:
+            loop.add_signal_handler(sig, _handle_signal, shutdown_event)
+        except NotImplementedError:
+            pass
+
+    try:
+        loop.run_until_complete(run_provider_node(shutdown_event))
+    finally:
+        loop.close()
+

ghostnexus_node-0.1.0.dist-info/METADATA

@@ -0,0 +1,72 @@
+Metadata-Version: 2.4
+Name: ghostnexus-node
+Version: 0.1.0
+Summary: GhostNexus Provider Node — earn money with your idle GPU
+Author-email: GhostNexus <contact@ghostnexus.net>
+License: MIT
+Project-URL: Homepage, https://ghostnexus.net/become-provider
+Project-URL: Documentation, https://ghostnexus.net/become-provider
+Project-URL: Repository, https://github.com/ghostnexus/ghostnexus-node
+Keywords: gpu,mining,ai,compute,provider,passive-income
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: websockets>=12.0
+Requires-Dist: nvidia-ml-py>=12.0
+
+# ghostnexus-node
+
+**Earn money with your idle GPU — GhostNexus Provider Node.**
+
+Turn your gaming GPU into a passive income source. When you're not gaming, your GPU runs AI training jobs for other developers and you earn money.
+
+- **RTX 4070**: up to ~$90/month at 50% utilization
+- **RTX 4090**: up to ~$126/month at 50% utilization
+- **70% revenue share** — paid via Wise or crypto from $50
+- Fully isolated Docker sandbox — your data is never exposed
+- Stop anytime — no contract, no commitment
+
+## Install
+
+```bash
+pip install ghostnexus-node
+```
+
+Docker required: [docker.com/products/docker-desktop](https://www.docker.com/products/docker-desktop/)
+
+## Quick Start
+
+```bash
+# Get your provider API key at ghostnexus.net/login (free)
+ghostnexus-node start --api-key gn_live_...
+```
+
+Or set it as an environment variable:
+
+```bash
+export GHOSTNEXUS_PROVIDER_API_KEY="gn_live_..."
+ghostnexus-node start
+```
+
+## How It Works
+
+1. Your node connects to the GhostNexus network
+2. When a client submits a job, it's dispatched to your GPU
+3. The job runs in an isolated Docker container (no network access, memory/CPU limits)
+4. Results are sent back, you earn credits
+5. Cash out via Wise or crypto once you reach $50
+
+## Sign Up
+
+Create your provider account at [ghostnexus.net/login](https://ghostnexus.net/login) — it's free.
+
+## License
+
+MIT

ghostnexus_node-0.1.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+ghostnexus_node/__init__.py,sha256=SLGxt8TYYAK37iOT2qDNm21RA0gbqovjhEI3vqMEutY,88
+ghostnexus_node/cli.py,sha256=FwOKGUPHsUVT4XEt_VVZUUvcvvJh-scD6HQGioWzqjw,2461
+ghostnexus_node/gpu_detector.py,sha256=Kpm7hCHCmLWXw0QZG95xATIW2ojx1Bblf1yX3WiVquQ,2116
+ghostnexus_node/node.py,sha256=4sy5aM4J_qLXM7OPXWCxnWhqkYtpToTpG4VUIwqz2NA,19296
+ghostnexus_node-0.1.0.dist-info/METADATA,sha256=1JC9eOeZ3kFpo5MahMEBRhqeN1JLzKi4hj3TnbQ3SzI,2399
+ghostnexus_node-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+ghostnexus_node-0.1.0.dist-info/entry_points.txt,sha256=TGajxybnqT9Z1kOimjA5oQ2v2tuTt_QCtDfwagix5fk,61
+ghostnexus_node-0.1.0.dist-info/top_level.txt,sha256=ZMrESYDaNalbqfnhK2kZMdgSMO-qly7usIRkLfrVm6Y,16
+ghostnexus_node-0.1.0.dist-info/RECORD,,

ghostnexus_node-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

ghostnexus_node-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+ghostnexus-node = ghostnexus_node.cli:main

ghostnexus_node-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+ghostnexus_node