rtlinux 0.1.0__tar.gz

rtlinux-0.1.0/LICENSE

@@ -0,0 +1,17 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+
+   Copyright 2024-2026 MeshPOP

rtlinux-0.1.0/PKG-INFO

@@ -0,0 +1,163 @@
+Metadata-Version: 2.4
+Name: rtlinux
+Version: 0.1.0
+Summary: MeshPOP Runtime Linux — L0 node OS for AI infrastructure mesh
+Author-email: MeshPOP <meshpop@proton.me>
+License: Apache-2.0
+Project-URL: Homepage, https://mpop.dev
+Project-URL: Repository, https://github.com/meshpop/rtlinux
+Project-URL: Documentation, https://mpop.dev/docs/
+Project-URL: Issues, https://github.com/meshpop/rtlinux/issues
+Keywords: meshpop,runtime,linux,buildroot,wireguard,mesh,infrastructure,ai,mcp,distributed,vssh,orchestration,node-os,l0
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: System Administrators
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: MacOS
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: System :: Operating System
+Classifier: Topic :: System :: Systems Administration
+Classifier: Topic :: System :: Clustering
+Classifier: Topic :: System :: Networking
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# rtlinux — MeshPOP Runtime Linux
+
+**Layer 0 of the MeshPOP stack.** A Buildroot-based minimal Linux distribution purpose-built for AI infrastructure mesh nodes.
+
+```
+L0  rtlinux   — Runtime OS (kernel + musl + busybox + MeshPOP)
+L1  Wire      — WireGuard mesh VPN         (pip install meshpop-wire)
+L2  vssh      — Secure remote execution    (pip install vssh)
+L3  mpop      — Fleet orchestration        (pip install meshpop)
+L4  MeshDB    — Distributed search         (pip install meshpop-db)
+L5  Vault     — Secrets management         (pip install sv-vault)
+```
+
+## What It Does
+
+Builds a minimal, network-hardened Linux OS with the full MeshPOP tool suite pre-installed. Boot a node → it auto-joins the Wire mesh → instantly manageable via `mpop exec`, `mpop deploy`, `mpop ask`.
+
+**Like Talos Linux for Kubernetes, but for MeshPOP.**
+
+## Install
+
+```bash
+pip install rtlinux
+```
+
+## Quick Start
+
+```bash
+# Build runtime image (Buildroot — from source, zero dependencies)
+rtlinux build --method buildroot
+
+# Deploy to a new node
+rtlinux deploy g5 --image output/meshpoplinux-rootfs.tar.gz
+
+# Verify all nodes
+rtlinux verify --all
+
+# Full CI/CD loop: build → deploy → verify → fix
+rtlinux loop --nodes "g1 g2 g3 d1 d2"
+
+# Fleet status
+rtlinux status
+```
+
+## Build Methods
+
+| Method | Dependencies | Time | Output |
+|--------|-------------|------|--------|
+| **Buildroot** (recommended) | None — kernel+BusyBox+musl from source | 20-60 min | bzImage + rootfs.cpio |
+| Alpine | Docker | ~2 min | rootfs.tar.gz |
+| Scratch | Linux host or Docker | ~1 min | rootfs.tar.gz |
+
+## MCP Server
+
+rtlinux includes an MCP server for AI-driven node management:
+
+```json
+{
+  "mcpServers": {
+    "rtlinux": {
+      "command": "python3",
+      "args": ["-m", "rtlinux.mcp.rtlinux_mcp_server"]
+    }
+  }
+}
+```
+
+### MCP Tools
+
+| Tool | Description |
+|------|-------------|
+| `rtlinux_build` | Build runtime image |
+| `rtlinux_deploy` | Deploy to a node |
+| `rtlinux_verify` | Health check (all 5 layers) |
+| `rtlinux_fleet` | Fleet status overview |
+| `rtlinux_fix` | Auto-fix degraded node |
+| `rtlinux_cicd` | Full CI/CD loop |
+
+## Python API
+
+```python
+import rtlinux
+
+# Build
+result = rtlinux.build(method="buildroot")
+
+# Deploy
+result = rtlinux.deploy("g5")
+
+# Verify single node
+health = rtlinux.verify("g1")
+# → {"status": "healthy", "layers_ok": "5/5", ...}
+
+# Verify fleet
+fleet = rtlinux.verify_fleet(["g1", "g2", "d1", "d2"])
+# → {"summary": "4/4 healthy", "fleet": {...}}
+```
+
+## Architecture
+
+```
+┌────────────────────────────────────────────────┐
+│              rtlinux Node                       │
+│                                                │
+│  kernel (Buildroot-compiled)                   │
+│  └─ WireGuard (mesh VPN, auto-peering)         │
+│  └─ vssh daemon (remote execution)             │
+│  └─ mpop agent (orchestration)                 │
+│  └─ MeshDB indexer (file search)               │
+│  └─ minimal userspace (BusyBox + musl)         │
+│                                                │
+│  No SSH. No package manager. No systemd.       │
+│  Just MeshPOP.                                 │
+└────────────────────────────────────────────────┘
+```
+
+## The MeshPOP Stack
+
+| Layer | Package | PyPI |
+|-------|---------|------|
+| L0 | **rtlinux** | `pip install rtlinux` |
+| L1 | Wire | `pip install meshpop-wire` |
+| L2 | vssh | `pip install vssh` |
+| L3 | mpop | `pip install meshpop` |
+| L4 | MeshDB | `pip install meshpop-db` |
+| L5 | Vault | `pip install sv-vault` |
+
+## Links
+
+- **Homepage**: [mpop.dev](https://mpop.dev)
+- **GitHub**: [github.com/meshpop/rtlinux](https://github.com/meshpop/rtlinux)
+- **All repos**: [github.com/meshpop](https://github.com/meshpop)
+
+## License
+
+Apache-2.0

rtlinux-0.1.0/README.md

@@ -0,0 +1,136 @@
+# rtlinux — MeshPOP Runtime Linux
+
+**Layer 0 of the MeshPOP stack.** A Buildroot-based minimal Linux distribution purpose-built for AI infrastructure mesh nodes.
+
+```
+L0  rtlinux   — Runtime OS (kernel + musl + busybox + MeshPOP)
+L1  Wire      — WireGuard mesh VPN         (pip install meshpop-wire)
+L2  vssh      — Secure remote execution    (pip install vssh)
+L3  mpop      — Fleet orchestration        (pip install meshpop)
+L4  MeshDB    — Distributed search         (pip install meshpop-db)
+L5  Vault     — Secrets management         (pip install sv-vault)
+```
+
+## What It Does
+
+Builds a minimal, network-hardened Linux OS with the full MeshPOP tool suite pre-installed. Boot a node → it auto-joins the Wire mesh → instantly manageable via `mpop exec`, `mpop deploy`, `mpop ask`.
+
+**Like Talos Linux for Kubernetes, but for MeshPOP.**
+
+## Install
+
+```bash
+pip install rtlinux
+```
+
+## Quick Start
+
+```bash
+# Build runtime image (Buildroot — from source, zero dependencies)
+rtlinux build --method buildroot
+
+# Deploy to a new node
+rtlinux deploy g5 --image output/meshpoplinux-rootfs.tar.gz
+
+# Verify all nodes
+rtlinux verify --all
+
+# Full CI/CD loop: build → deploy → verify → fix
+rtlinux loop --nodes "g1 g2 g3 d1 d2"
+
+# Fleet status
+rtlinux status
+```
+
+## Build Methods
+
+| Method | Dependencies | Time | Output |
+|--------|-------------|------|--------|
+| **Buildroot** (recommended) | None — kernel+BusyBox+musl from source | 20-60 min | bzImage + rootfs.cpio |
+| Alpine | Docker | ~2 min | rootfs.tar.gz |
+| Scratch | Linux host or Docker | ~1 min | rootfs.tar.gz |
+
+## MCP Server
+
+rtlinux includes an MCP server for AI-driven node management:
+
+```json
+{
+  "mcpServers": {
+    "rtlinux": {
+      "command": "python3",
+      "args": ["-m", "rtlinux.mcp.rtlinux_mcp_server"]
+    }
+  }
+}
+```
+
+### MCP Tools
+
+| Tool | Description |
+|------|-------------|
+| `rtlinux_build` | Build runtime image |
+| `rtlinux_deploy` | Deploy to a node |
+| `rtlinux_verify` | Health check (all 5 layers) |
+| `rtlinux_fleet` | Fleet status overview |
+| `rtlinux_fix` | Auto-fix degraded node |
+| `rtlinux_cicd` | Full CI/CD loop |
+
+## Python API
+
+```python
+import rtlinux
+
+# Build
+result = rtlinux.build(method="buildroot")
+
+# Deploy
+result = rtlinux.deploy("g5")
+
+# Verify single node
+health = rtlinux.verify("g1")
+# → {"status": "healthy", "layers_ok": "5/5", ...}
+
+# Verify fleet
+fleet = rtlinux.verify_fleet(["g1", "g2", "d1", "d2"])
+# → {"summary": "4/4 healthy", "fleet": {...}}
+```
+
+## Architecture
+
+```
+┌────────────────────────────────────────────────┐
+│              rtlinux Node                       │
+│                                                │
+│  kernel (Buildroot-compiled)                   │
+│  └─ WireGuard (mesh VPN, auto-peering)         │
+│  └─ vssh daemon (remote execution)             │
+│  └─ mpop agent (orchestration)                 │
+│  └─ MeshDB indexer (file search)               │
+│  └─ minimal userspace (BusyBox + musl)         │
+│                                                │
+│  No SSH. No package manager. No systemd.       │
+│  Just MeshPOP.                                 │
+└────────────────────────────────────────────────┘
+```
+
+## The MeshPOP Stack
+
+| Layer | Package | PyPI |
+|-------|---------|------|
+| L0 | **rtlinux** | `pip install rtlinux` |
+| L1 | Wire | `pip install meshpop-wire` |
+| L2 | vssh | `pip install vssh` |
+| L3 | mpop | `pip install meshpop` |
+| L4 | MeshDB | `pip install meshpop-db` |
+| L5 | Vault | `pip install sv-vault` |
+
+## Links
+
+- **Homepage**: [mpop.dev](https://mpop.dev)
+- **GitHub**: [github.com/meshpop/rtlinux](https://github.com/meshpop/rtlinux)
+- **All repos**: [github.com/meshpop](https://github.com/meshpop)
+
+## License
+
+Apache-2.0

rtlinux-0.1.0/pyproject.toml

@@ -0,0 +1,45 @@
+[build-system]
+requires = ["setuptools>=68.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "rtlinux"
+version = "0.1.0"
+description = "MeshPOP Runtime Linux — L0 node OS for AI infrastructure mesh"
+readme = "README.md"
+license = {text = "Apache-2.0"}
+requires-python = ">=3.8"
+authors = [{name = "MeshPOP", email = "meshpop@proton.me"}]
+keywords = [
+    "meshpop", "runtime", "linux", "buildroot", "wireguard",
+    "mesh", "infrastructure", "ai", "mcp", "distributed",
+    "vssh", "orchestration", "node-os", "l0"
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: System Administrators",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: Apache Software License",
+    "Operating System :: POSIX :: Linux",
+    "Operating System :: MacOS",
+    "Programming Language :: Python :: 3",
+    "Topic :: System :: Operating System",
+    "Topic :: System :: Systems Administration",
+    "Topic :: System :: Clustering",
+    "Topic :: System :: Networking",
+]
+
+[project.urls]
+Homepage = "https://mpop.dev"
+Repository = "https://github.com/meshpop/rtlinux"
+Documentation = "https://mpop.dev/docs/"
+Issues = "https://github.com/meshpop/rtlinux/issues"
+
+[project.scripts]
+rtlinux = "rtlinux:main"
+
+[project.entry-points."meshpop.mcp"]
+rtlinux = "rtlinux.mcp.rtlinux_mcp_server"
+
+[tool.setuptools.packages.find]
+where = ["src"]

rtlinux-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

rtlinux-0.1.0/src/rtlinux/__init__.py

@@ -0,0 +1,317 @@
+"""
+rtlinux — MeshPOP Runtime Linux (L0)
+====================================
+
+MeshPOP-native runtime OS for AI infrastructure nodes.
+Buildroot-based minimal Linux: boot → wire connect → vssh listen → ready.
+
+Layer 0 of the MeshPOP stack:
+
+    L0  rtlinux   — Runtime OS (kernel + musl + busybox + MeshPOP)
+    L1  Wire      — WireGuard mesh VPN
+    L2  vssh      — Secure remote execution
+    L3  mpop      — Fleet orchestration
+    L4  MeshDB    — Distributed search
+    L5  Vault     — Secrets management
+
+Usage::
+
+    # Build runtime image
+    rtlinux build --method buildroot
+
+    # Deploy to new node
+    rtlinux deploy g5 --image meshpoplinux-rootfs.tar.gz
+
+    # Verify fleet health
+    rtlinux verify --all
+
+    # Full CI/CD loop
+    rtlinux loop --nodes "g1 g2 g3 d1 d2"
+
+Install::
+
+    pip install rtlinux
+
+Links:
+    - GitHub: https://github.com/meshpop/rtlinux
+    - Docs: https://mpop.dev
+    - PyPI: https://pypi.org/project/rtlinux/
+"""
+
+__version__ = "0.1.0"
+__author__ = "MeshPOP"
+__license__ = "Apache-2.0"
+
+import os
+import sys
+import json
+import base64
+import subprocess
+from pathlib import Path
+
+
+# ── Config ──────────────────────────────────────────────────────────
+RTLINUX_DIR = os.environ.get("RTLINUX_DIR", os.path.expanduser("~/meshpoplinux"))
+BUILD_METHODS = ["buildroot", "alpine", "scratch"]
+DEFAULT_METHOD = "buildroot"
+
+MESHPOP_PACKAGES = ["meshpop", "vssh", "meshpop-wire", "meshpop-db", "sv-vault"]
+
+
+def _vssh_exec(node: str, cmd: str) -> str:
+    """Execute command on remote node via vssh Python module."""
+    try:
+        import vssh
+        import io
+        old = sys.stdout
+        sys.stdout = buf = io.StringIO()
+        vssh.ssh(node, cmd)
+        sys.stdout = old
+        return buf.getvalue().strip()
+    except ImportError:
+        # Fallback to CLI
+        r = subprocess.run(
+            ["vssh", "exec", node, cmd],
+            capture_output=True, text=True, timeout=30
+        )
+        return r.stdout.strip()
+
+
+def _vssh_put(local_path: str, node: str, remote_path: str) -> bool:
+    """Upload file to remote node via vssh."""
+    try:
+        import vssh
+        vssh.put(local_path, node, remote_path)
+        return True
+    except ImportError:
+        r = subprocess.run(
+            ["vssh", "put", local_path, f"{node}:{remote_path}"],
+            capture_output=True, text=True, timeout=120
+        )
+        return r.returncode == 0
+
+
+# ── Build ───────────────────────────────────────────────────────────
+def build(method: str = DEFAULT_METHOD, output_dir: str = None) -> dict:
+    """Build meshpoplinux runtime image.
+
+    Args:
+        method: Build method (buildroot, alpine, scratch)
+        output_dir: Output directory for artifacts
+
+    Returns:
+        dict with build results
+    """
+    if method not in BUILD_METHODS:
+        return {"error": f"Unknown method: {method}. Use: {BUILD_METHODS}"}
+
+    output_dir = output_dir or os.path.join(RTLINUX_DIR, "output")
+    os.makedirs(output_dir, exist_ok=True)
+
+    scripts = {
+        "buildroot": "scripts/build-buildroot.sh",
+        "alpine": "scripts/build-docker.sh",
+        "scratch": "scripts/build-from-scratch.sh",
+    }
+
+    script = os.path.join(RTLINUX_DIR, scripts[method])
+    if not os.path.exists(script):
+        return {"error": f"Build script not found: {script}"}
+
+    r = subprocess.run(
+        ["bash", script, output_dir],
+        capture_output=True, text=True, timeout=3600
+    )
+
+    rootfs = os.path.join(output_dir, "meshpoplinux-rootfs.tar.gz")
+    if os.path.exists(rootfs):
+        size = os.path.getsize(rootfs)
+        return {
+            "status": "ok",
+            "method": method,
+            "artifact": rootfs,
+            "size_bytes": size,
+            "size_human": f"{size / 1024 / 1024:.1f}MB",
+        }
+    return {"error": "Build failed — rootfs not produced", "output": r.stderr[-500:]}
+
+
+# ── Deploy ──────────────────────────────────────────────────────────
+def deploy(node: str, image: str = None, install_stack: bool = True) -> dict:
+    """Deploy runtime image to a node.
+
+    Args:
+        node: Target node name (g1, d2, etc.)
+        image: Path to rootfs image (default: output/meshpoplinux-rootfs.tar.gz)
+        install_stack: Whether to install MeshPOP packages
+
+    Returns:
+        dict with deployment results
+    """
+    image = image or os.path.join(RTLINUX_DIR, "output", "meshpoplinux-rootfs.tar.gz")
+    if not os.path.exists(image):
+        return {"error": f"Image not found: {image}. Run: rtlinux build"}
+
+    results = {"node": node, "steps": []}
+
+    # Upload
+    ok = _vssh_put(image, node, "/tmp/meshpoplinux-rootfs.tar.gz")
+    results["steps"].append({"upload": "ok" if ok else "failed"})
+
+    # Extract
+    out = _vssh_exec(node, "mkdir -p /opt/meshpoplinux && tar xzf /tmp/meshpoplinux-rootfs.tar.gz -C /opt/meshpoplinux 2>&1 | tail -3")
+    results["steps"].append({"extract": out or "ok"})
+
+    # Install MeshPOP stack
+    if install_stack:
+        for pkg in MESHPOP_PACKAGES:
+            out = _vssh_exec(node, f"pip3 install --break-system-packages --upgrade {pkg} 2>&1 | tail -1")
+            results["steps"].append({pkg: out})
+
+    # Cleanup
+    _vssh_exec(node, "rm -f /tmp/meshpoplinux-rootfs.tar.gz")
+
+    results["status"] = "ok"
+    return results
+
+
+# ── Verify ──────────────────────────────────────────────────────────
+def verify(node: str) -> dict:
+    """Verify a node's health across all 5 MeshPOP layers.
+
+    Returns:
+        dict with check results per layer
+    """
+    checks = {"node": node, "layers": {}}
+
+    # L0: Reachable?
+    ping = _vssh_exec(node, "echo pong")
+    checks["layers"]["L0_reachable"] = ping == "pong"
+    if not checks["layers"]["L0_reachable"]:
+        checks["status"] = "unreachable"
+        return checks
+
+    # System info
+    checks["hostname"] = _vssh_exec(node, "hostname")
+    checks["kernel"] = _vssh_exec(node, "uname -r")
+    checks["python"] = _vssh_exec(node, "python3 --version 2>&1")
+
+    # L1: Wire
+    wg = _vssh_exec(node, "ip -4 addr show wg0 2>/dev/null | grep -oP 'inet \\K[0-9./]+'")
+    checks["layers"]["L1_wire"] = bool(wg)
+    checks["wire_ip"] = wg
+
+    # L2: vssh
+    checks["layers"]["L2_vssh"] = True  # Already reachable
+
+    # L3: mpop packages
+    pkg_ok = 0
+    for pkg in MESHPOP_PACKAGES:
+        ver = _vssh_exec(node, f"python3 -c \"import importlib.metadata; print(importlib.metadata.version('{pkg}'))\" 2>/dev/null")
+        checks[f"pkg_{pkg}"] = ver if ver else None
+        if ver:
+            pkg_ok += 1
+    checks["layers"]["L3_mpop"] = pkg_ok >= 3
+
+    # L4: MeshDB
+    mdb = _vssh_exec(node, "python3 -c 'import meshpop_db; print(\"ok\")' 2>&1")
+    checks["layers"]["L4_meshdb"] = "ok" in mdb
+
+    # L5: Vault
+    vlt = _vssh_exec(node, "python3 -c 'import sv_vault; print(\"ok\")' 2>&1")
+    checks["layers"]["L5_vault"] = "ok" in vlt
+
+    # Disk
+    disk = _vssh_exec(node, "df / | tail -1 | tr -s ' ' | cut -d' ' -f5 | tr -d '%'")
+    try:
+        checks["disk_pct"] = int(disk)
+    except:
+        checks["disk_pct"] = None
+
+    # Overall
+    layer_ok = sum(1 for v in checks["layers"].values() if v)
+    checks["status"] = "healthy" if layer_ok >= 4 else "degraded" if layer_ok >= 2 else "critical"
+    checks["layers_ok"] = f"{layer_ok}/{len(checks['layers'])}"
+
+    return checks
+
+
+def verify_fleet(nodes: list) -> dict:
+    """Verify all nodes in the fleet."""
+    results = {}
+    for node in nodes:
+        results[node] = verify(node)
+
+    healthy = sum(1 for r in results.values() if r.get("status") == "healthy")
+    return {
+        "fleet": results,
+        "summary": f"{healthy}/{len(nodes)} healthy",
+    }
+
+
+# ── CLI ─────────────────────────────────────────────────────────────
+def main():
+    """CLI entry point."""
+    import argparse
+
+    parser = argparse.ArgumentParser(
+        prog="rtlinux",
+        description="MeshPOP Runtime Linux — L0 node OS management"
+    )
+    sub = parser.add_subparsers(dest="cmd")
+
+    # build
+    p_build = sub.add_parser("build", help="Build runtime image")
+    p_build.add_argument("--method", default=DEFAULT_METHOD, choices=BUILD_METHODS)
+    p_build.add_argument("--output", default=None)
+
+    # deploy
+    p_deploy = sub.add_parser("deploy", help="Deploy to a node")
+    p_deploy.add_argument("node", help="Target node (g1, d2, etc.)")
+    p_deploy.add_argument("--image", default=None)
+    p_deploy.add_argument("--no-stack", action="store_true")
+
+    # verify
+    p_verify = sub.add_parser("verify", help="Verify node health")
+    p_verify.add_argument("node", nargs="?", help="Node name")
+    p_verify.add_argument("--all", action="store_true")
+    p_verify.add_argument("--nodes", default="g1 g2 g3 d1 d2")
+
+    # status
+    sub.add_parser("status", help="Fleet status")
+
+    # version
+    sub.add_parser("version", help="Show version")
+
+    args = parser.parse_args()
+
+    if args.cmd == "build":
+        result = build(method=args.method, output_dir=args.output)
+        print(json.dumps(result, indent=2))
+
+    elif args.cmd == "deploy":
+        result = deploy(args.node, image=args.image, install_stack=not args.no_stack)
+        print(json.dumps(result, indent=2))
+
+    elif args.cmd == "verify":
+        if args.all or not args.node:
+            nodes = args.nodes.split()
+            result = verify_fleet(nodes)
+        else:
+            result = verify(args.node)
+        print(json.dumps(result, indent=2))
+
+    elif args.cmd == "status":
+        nodes = "g1 g2 g3 d1 d2".split()
+        result = verify_fleet(nodes)
+        print(json.dumps(result, indent=2))
+
+    elif args.cmd == "version":
+        print(f"rtlinux {__version__}")
+
+    else:
+        parser.print_help()
+
+
+if __name__ == "__main__":
+    main()

rtlinux-0.1.0/src/rtlinux.egg-info/PKG-INFO

@@ -0,0 +1,163 @@
+Metadata-Version: 2.4
+Name: rtlinux
+Version: 0.1.0
+Summary: MeshPOP Runtime Linux — L0 node OS for AI infrastructure mesh
+Author-email: MeshPOP <meshpop@proton.me>
+License: Apache-2.0
+Project-URL: Homepage, https://mpop.dev
+Project-URL: Repository, https://github.com/meshpop/rtlinux
+Project-URL: Documentation, https://mpop.dev/docs/
+Project-URL: Issues, https://github.com/meshpop/rtlinux/issues
+Keywords: meshpop,runtime,linux,buildroot,wireguard,mesh,infrastructure,ai,mcp,distributed,vssh,orchestration,node-os,l0
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: System Administrators
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: MacOS
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: System :: Operating System
+Classifier: Topic :: System :: Systems Administration
+Classifier: Topic :: System :: Clustering
+Classifier: Topic :: System :: Networking
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# rtlinux — MeshPOP Runtime Linux
+
+**Layer 0 of the MeshPOP stack.** A Buildroot-based minimal Linux distribution purpose-built for AI infrastructure mesh nodes.
+
+```
+L0  rtlinux   — Runtime OS (kernel + musl + busybox + MeshPOP)
+L1  Wire      — WireGuard mesh VPN         (pip install meshpop-wire)
+L2  vssh      — Secure remote execution    (pip install vssh)
+L3  mpop      — Fleet orchestration        (pip install meshpop)
+L4  MeshDB    — Distributed search         (pip install meshpop-db)
+L5  Vault     — Secrets management         (pip install sv-vault)
+```
+
+## What It Does
+
+Builds a minimal, network-hardened Linux OS with the full MeshPOP tool suite pre-installed. Boot a node → it auto-joins the Wire mesh → instantly manageable via `mpop exec`, `mpop deploy`, `mpop ask`.
+
+**Like Talos Linux for Kubernetes, but for MeshPOP.**
+
+## Install
+
+```bash
+pip install rtlinux
+```
+
+## Quick Start
+
+```bash
+# Build runtime image (Buildroot — from source, zero dependencies)
+rtlinux build --method buildroot
+
+# Deploy to a new node
+rtlinux deploy g5 --image output/meshpoplinux-rootfs.tar.gz
+
+# Verify all nodes
+rtlinux verify --all
+
+# Full CI/CD loop: build → deploy → verify → fix
+rtlinux loop --nodes "g1 g2 g3 d1 d2"
+
+# Fleet status
+rtlinux status
+```
+
+## Build Methods
+
+| Method | Dependencies | Time | Output |
+|--------|-------------|------|--------|
+| **Buildroot** (recommended) | None — kernel+BusyBox+musl from source | 20-60 min | bzImage + rootfs.cpio |
+| Alpine | Docker | ~2 min | rootfs.tar.gz |
+| Scratch | Linux host or Docker | ~1 min | rootfs.tar.gz |
+
+## MCP Server
+
+rtlinux includes an MCP server for AI-driven node management:
+
+```json
+{
+  "mcpServers": {
+    "rtlinux": {
+      "command": "python3",
+      "args": ["-m", "rtlinux.mcp.rtlinux_mcp_server"]
+    }
+  }
+}
+```
+
+### MCP Tools
+
+| Tool | Description |
+|------|-------------|
+| `rtlinux_build` | Build runtime image |
+| `rtlinux_deploy` | Deploy to a node |
+| `rtlinux_verify` | Health check (all 5 layers) |
+| `rtlinux_fleet` | Fleet status overview |
+| `rtlinux_fix` | Auto-fix degraded node |
+| `rtlinux_cicd` | Full CI/CD loop |
+
+## Python API
+
+```python
+import rtlinux
+
+# Build
+result = rtlinux.build(method="buildroot")
+
+# Deploy
+result = rtlinux.deploy("g5")
+
+# Verify single node
+health = rtlinux.verify("g1")
+# → {"status": "healthy", "layers_ok": "5/5", ...}
+
+# Verify fleet
+fleet = rtlinux.verify_fleet(["g1", "g2", "d1", "d2"])
+# → {"summary": "4/4 healthy", "fleet": {...}}
+```
+
+## Architecture
+
+```
+┌────────────────────────────────────────────────┐
+│              rtlinux Node                       │
+│                                                │
+│  kernel (Buildroot-compiled)                   │
+│  └─ WireGuard (mesh VPN, auto-peering)         │
+│  └─ vssh daemon (remote execution)             │
+│  └─ mpop agent (orchestration)                 │
+│  └─ MeshDB indexer (file search)               │
+│  └─ minimal userspace (BusyBox + musl)         │
+│                                                │
+│  No SSH. No package manager. No systemd.       │
+│  Just MeshPOP.                                 │
+└────────────────────────────────────────────────┘
+```
+
+## The MeshPOP Stack
+
+| Layer | Package | PyPI |
+|-------|---------|------|
+| L0 | **rtlinux** | `pip install rtlinux` |
+| L1 | Wire | `pip install meshpop-wire` |
+| L2 | vssh | `pip install vssh` |
+| L3 | mpop | `pip install meshpop` |
+| L4 | MeshDB | `pip install meshpop-db` |
+| L5 | Vault | `pip install sv-vault` |
+
+## Links
+
+- **Homepage**: [mpop.dev](https://mpop.dev)
+- **GitHub**: [github.com/meshpop/rtlinux](https://github.com/meshpop/rtlinux)
+- **All repos**: [github.com/meshpop](https://github.com/meshpop)
+
+## License
+
+Apache-2.0

rtlinux-0.1.0/src/rtlinux.egg-info/SOURCES.txt

@@ -0,0 +1,9 @@
+LICENSE
+README.md
+pyproject.toml
+src/rtlinux/__init__.py
+src/rtlinux.egg-info/PKG-INFO
+src/rtlinux.egg-info/SOURCES.txt
+src/rtlinux.egg-info/dependency_links.txt
+src/rtlinux.egg-info/entry_points.txt
+src/rtlinux.egg-info/top_level.txt

rtlinux-0.1.0/src/rtlinux.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

rtlinux-0.1.0/src/rtlinux.egg-info/entry_points.txt

@@ -0,0 +1,5 @@
+[console_scripts]
+rtlinux = rtlinux:main
+
+[meshpop.mcp]
+rtlinux = rtlinux.mcp.rtlinux_mcp_server

rtlinux-0.1.0/src/rtlinux.egg-info/top_level.txt

@@ -0,0 +1 @@
+rtlinux