clawskill 1.0.0__tar.gz

clawskill-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025-2026 Elyan Labs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

clawskill-1.0.0/PKG-INFO

@@ -0,0 +1,98 @@
+Metadata-Version: 2.4
+Name: clawskill
+Version: 1.0.0
+Summary: ClawSkill — Let your AI agent mine RTC tokens on any modern hardware. 1x multiplier, built-in wallet, VM-penalized.
+Author-email: Elyan Labs <scott@elyanlabs.ai>
+License: MIT
+Project-URL: Homepage, https://bottube.ai
+Project-URL: Repository, https://github.com/Scottcjn/Rustchain
+Project-URL: Issues, https://github.com/Scottcjn/Rustchain/issues
+Keywords: clawskill,ai-agent,miner,rustchain,rtc,openclaw,proof-of-antiquity
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: MacOS
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.25
+Dynamic: license-file
+
+# ClawSkill — Mine RTC Tokens With Your AI Agent
+
+Your Claw agent can earn **RTC (RustChain Tokens)** by proving it runs on **real hardware**. One command to install, automatic attestation, built-in wallet.
+
+## Quick Start
+
+```bash
+pip install clawskill
+clawskill install --wallet my-agent-miner
+clawskill start
+```
+
+That's it. Your agent is now mining RTC.
+
+## How It Works
+
+1. **Hardware Fingerprinting** — 6 cryptographic checks prove your machine is real hardware (clock drift, cache timing, SIMD identity, thermal drift, instruction jitter, anti-emulation)
+2. **Attestation** — Your agent automatically attests to the RustChain network every few minutes
+3. **Rewards** — RTC tokens accumulate in your wallet each epoch (~10 minutes)
+4. **VM Detection** — Virtual machines are detected and receive effectively zero rewards. **Real iron only.**
+
+## Multipliers
+
+| Hardware | Multiplier | Notes |
+|----------|-----------|-------|
+| Modern x86/ARM | **1.0x** | Standard reward rate |
+| Apple Silicon (M1/M2/M3) | **1.2x** | Slight bonus |
+| PowerPC G5 | **2.0x** | Vintage bonus |
+| PowerPC G4 | **2.5x** | Maximum vintage bonus |
+| **VM/Emulator** | **~0x** | **Detected and penalized** |
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `clawskill install` | Download miner, create wallet, set up service |
+| `clawskill start` | Start mining in background |
+| `clawskill stop` | Stop mining |
+| `clawskill status` | Check miner + network status |
+| `clawskill logs` | View miner output |
+| `clawskill uninstall` | Remove everything |
+
+## What Gets Installed
+
+- Miner scripts from [RustChain repo](https://github.com/Scottcjn/Rustchain)
+- Python virtual environment with `requests` dependency
+- Systemd user service (Linux) or LaunchAgent (macOS)
+- All files in `~/.clawskill/`
+
+## VM Warning
+
+RustChain uses **Proof-of-Antiquity (PoA)** consensus. The hardware fingerprint system detects:
+
+- QEMU / KVM / VMware / VirtualBox / Xen / Hyper-V
+- Hypervisor CPU flags
+- DMI vendor strings
+- Flattened timing distributions
+
+If you're running in a VM, the miner will install and attest, but your rewards will be effectively zero. This is by design — RTC rewards machines that bring real compute to the network.
+
+## Requirements
+
+- Python 3.8+
+- Linux or macOS (Windows installer coming soon)
+- Real hardware (not a VM)
+
+## Links
+
+- [RustChain Network](https://bottube.ai)
+- [Block Explorer](https://50.28.86.131/explorer)
+- [GitHub](https://github.com/Scottcjn/Rustchain)
+
+## License
+
+MIT — Elyan Labs

clawskill-1.0.0/README.md

@@ -0,0 +1,75 @@
+# ClawSkill — Mine RTC Tokens With Your AI Agent
+
+Your Claw agent can earn **RTC (RustChain Tokens)** by proving it runs on **real hardware**. One command to install, automatic attestation, built-in wallet.
+
+## Quick Start
+
+```bash
+pip install clawskill
+clawskill install --wallet my-agent-miner
+clawskill start
+```
+
+That's it. Your agent is now mining RTC.
+
+## How It Works
+
+1. **Hardware Fingerprinting** — 6 cryptographic checks prove your machine is real hardware (clock drift, cache timing, SIMD identity, thermal drift, instruction jitter, anti-emulation)
+2. **Attestation** — Your agent automatically attests to the RustChain network every few minutes
+3. **Rewards** — RTC tokens accumulate in your wallet each epoch (~10 minutes)
+4. **VM Detection** — Virtual machines are detected and receive effectively zero rewards. **Real iron only.**
+
+## Multipliers
+
+| Hardware | Multiplier | Notes |
+|----------|-----------|-------|
+| Modern x86/ARM | **1.0x** | Standard reward rate |
+| Apple Silicon (M1/M2/M3) | **1.2x** | Slight bonus |
+| PowerPC G5 | **2.0x** | Vintage bonus |
+| PowerPC G4 | **2.5x** | Maximum vintage bonus |
+| **VM/Emulator** | **~0x** | **Detected and penalized** |
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `clawskill install` | Download miner, create wallet, set up service |
+| `clawskill start` | Start mining in background |
+| `clawskill stop` | Stop mining |
+| `clawskill status` | Check miner + network status |
+| `clawskill logs` | View miner output |
+| `clawskill uninstall` | Remove everything |
+
+## What Gets Installed
+
+- Miner scripts from [RustChain repo](https://github.com/Scottcjn/Rustchain)
+- Python virtual environment with `requests` dependency
+- Systemd user service (Linux) or LaunchAgent (macOS)
+- All files in `~/.clawskill/`
+
+## VM Warning
+
+RustChain uses **Proof-of-Antiquity (PoA)** consensus. The hardware fingerprint system detects:
+
+- QEMU / KVM / VMware / VirtualBox / Xen / Hyper-V
+- Hypervisor CPU flags
+- DMI vendor strings
+- Flattened timing distributions
+
+If you're running in a VM, the miner will install and attest, but your rewards will be effectively zero. This is by design — RTC rewards machines that bring real compute to the network.
+
+## Requirements
+
+- Python 3.8+
+- Linux or macOS (Windows installer coming soon)
+- Real hardware (not a VM)
+
+## Links
+
+- [RustChain Network](https://bottube.ai)
+- [Block Explorer](https://50.28.86.131/explorer)
+- [GitHub](https://github.com/Scottcjn/Rustchain)
+
+## License
+
+MIT — Elyan Labs

clawskill-1.0.0/clawskill/__init__.py

@@ -0,0 +1,3 @@
+"""ClawSkill — Mine RTC tokens with your AI agent on any modern hardware."""
+
+__version__ = "1.0.0"

clawskill-1.0.0/clawskill/cli.py

@@ -0,0 +1,495 @@
+#!/usr/bin/env python3
+"""ClawSkill — RustChain miner for AI agents on modern hardware.
+
+Your Claw agent earns RTC tokens by proving it runs on real hardware.
+Modern machines get 1x multiplier. Vintage hardware gets bonus multipliers.
+VMs are detected and penalized — real iron only.
+
+Usage:
+    pip install clawskill
+    clawskill install --wallet my-agent-miner
+    clawskill start
+"""
+
+import argparse
+import os
+import platform
+import shutil
+import subprocess
+import sys
+import textwrap
+import time
+import urllib.request
+import ssl
+import json
+
+REPO_BASE = "https://raw.githubusercontent.com/Scottcjn/Rustchain/main"
+INSTALL_DIR = os.path.join(os.path.expanduser("~"), ".clawskill")
+VENV_DIR = os.path.join(INSTALL_DIR, "venv")
+NODE_URL = "https://50.28.86.131"
+
+# ANSI colors
+CYAN = "\033[36m"
+GREEN = "\033[32m"
+RED = "\033[31m"
+YELLOW = "\033[33m"
+BOLD = "\033[1m"
+DIM = "\033[2m"
+NC = "\033[0m"
+
+
+def log(msg):
+    print(f"{CYAN}[clawskill]{NC} {msg}")
+
+
+def success(msg):
+    print(f"{GREEN}[OK]{NC} {msg}")
+
+
+def warn(msg):
+    print(f"{YELLOW}[WARN]{NC} {msg}")
+
+
+def error(msg):
+    print(f"{RED}[ERROR]{NC} {msg}", file=sys.stderr)
+    sys.exit(1)
+
+
+def download_file(url, dest):
+    """Download a file from URL to dest path."""
+    ctx = ssl.create_default_context()
+    ctx.check_hostname = False
+    ctx.verify_mode = ssl.CERT_NONE
+    try:
+        urllib.request.urlretrieve(url, dest)
+        size = os.path.getsize(dest)
+        if size < 100:
+            raise Exception(f"File too small ({size} bytes)")
+        return size
+    except Exception as e:
+        raise Exception(f"Download failed for {url}: {e}")
+
+
+def run_cmd(cmd, check=True, capture=False):
+    """Run a shell command."""
+    try:
+        result = subprocess.run(
+            cmd, shell=True, check=check,
+            capture_output=capture, text=True
+        )
+        return result.stdout.strip() if capture else None
+    except subprocess.CalledProcessError:
+        if check:
+            raise
+        return None
+
+
+def _detect_vm():
+    """Quick VM detection — warns the user upfront."""
+    indicators = []
+    system = platform.system()
+
+    if system == "Linux":
+        # Check /sys/class/dmi
+        dmi_paths = [
+            "/sys/class/dmi/id/sys_vendor",
+            "/sys/class/dmi/id/product_name",
+            "/sys/class/dmi/id/board_vendor",
+        ]
+        vm_vendors = ["qemu", "vmware", "virtualbox", "xen", "kvm", "microsoft", "parallels", "bhyve"]
+        for p in dmi_paths:
+            try:
+                with open(p) as f:
+                    val = f.read().strip().lower()
+                    if any(v in val for v in vm_vendors):
+                        indicators.append(f"{p}: {val}")
+            except (OSError, IOError):
+                pass
+
+        # Check /proc/cpuinfo for hypervisor flag
+        try:
+            with open("/proc/cpuinfo") as f:
+                if "hypervisor" in f.read().lower():
+                    indicators.append("cpuinfo: hypervisor flag")
+        except (OSError, IOError):
+            pass
+
+    elif system == "Darwin":
+        try:
+            out = subprocess.run(
+                ["sysctl", "-n", "machdep.cpu.features"],
+                capture_output=True, text=True
+            ).stdout.lower()
+            if "vmm" in out:
+                indicators.append("sysctl: VMM flag")
+        except Exception:
+            pass
+
+    return indicators
+
+
+def cmd_install(args):
+    """Install and configure ClawSkill miner for your AI agent."""
+    print(textwrap.dedent(f"""
+    {CYAN}{BOLD}
+      ██████╗██╗      █████╗ ██╗    ██╗███████╗██╗  ██╗██╗██╗     ██╗
+     ██╔════╝██║     ██╔══██╗██║    ██║██╔════╝██║ ██╔╝██║██║     ██║
+     ██║     ██║     ███████║██║ █╗ ██║███████╗█████╔╝ ██║██║     ██║
+     ██║     ██║     ██╔══██║██║███╗██║╚════██║██╔═██╗ ██║██║     ██║
+     ╚██████╗███████╗██║  ██║╚███╔███╔╝███████║██║  ██╗██║███████╗███████╗
+      ╚═════╝╚══════╝╚═╝  ╚═╝ ╚══╝╚══╝ ╚══════╝╚═╝  ╚═╝╚═╝╚══════╝╚══════╝
+    {NC}
+    {DIM}  Mine RTC tokens with your AI agent on real hardware{NC}
+    {DIM}  Modern x86/ARM = 1x | Vintage PowerPC = up to 2.5x | VM = ~0x{NC}
+    """))
+
+    system = platform.system()
+    machine = platform.machine()
+    log(f"Platform: {system} | Arch: {machine}")
+
+    if system not in ("Linux", "Darwin"):
+        error(f"Unsupported platform: {system}. Use Linux or macOS.")
+
+    # VM check — warn upfront, don't block
+    vm_hints = _detect_vm()
+    if vm_hints:
+        print(textwrap.dedent(f"""
+    {RED}{BOLD}  ╔══════════════════════════════════════════════════════════╗
+      ║              ⚠  VM DETECTED — READ THIS  ⚠             ║
+      ╠══════════════════════════════════════════════════════════╣
+      ║                                                          ║
+      ║  This machine appears to be a virtual machine.           ║
+      ║  RustChain's hardware fingerprint system WILL detect     ║
+      ║  VMs and assigns near-zero mining weight.                ║
+      ║                                                          ║
+      ║  Your miner will attest, but earn effectively nothing.   ║
+      ║  This is by design — RTC rewards real hardware only.     ║
+      ║                                                          ║
+      ║  VM indicators found:                                    ║{NC}"""))
+        for h in vm_hints[:4]:
+            print(f"      {RED}  •  {h}{NC}")
+        print(f"""      {RED}{BOLD}║                                                          ║
+      ║  To earn RTC, run on bare-metal hardware.               ║
+      ╚══════════════════════════════════════════════════════════╝{NC}
+""")
+
+    # Wallet setup
+    wallet = args.wallet
+    if not wallet:
+        try:
+            wallet = input(f"{CYAN}[clawskill]{NC} Enter agent wallet name (e.g. my-claw-agent): ").strip()
+        except (EOFError, KeyboardInterrupt):
+            wallet = ""
+
+    if not wallet:
+        hostname = platform.node().split(".")[0] or "agent"
+        wallet = f"claw-{hostname}-{int(time.time()) % 100000}"
+        warn(f"No wallet name provided. Auto-generated: {wallet}")
+
+    # Create install dir
+    log(f"Installing to {INSTALL_DIR}")
+    os.makedirs(INSTALL_DIR, exist_ok=True)
+
+    # Save wallet
+    with open(os.path.join(INSTALL_DIR, ".wallet"), "w") as f:
+        f.write(wallet)
+
+    # Create venv
+    if not os.path.isdir(VENV_DIR):
+        log("Creating Python environment...")
+        run_cmd(f'"{sys.executable}" -m venv "{VENV_DIR}"')
+
+    # Install deps
+    log("Installing dependencies...")
+    pip = os.path.join(VENV_DIR, "bin", "pip")
+    run_cmd(f'"{pip}" install --upgrade pip -q')
+    run_cmd(f'"{pip}" install requests -q')
+    success("Dependencies ready")
+
+    # Download miner files
+    log("Downloading miner from RustChain repo...")
+
+    downloads = [
+        (f"{REPO_BASE}/miners/linux/fingerprint_checks.py", "fingerprint_checks.py"),
+    ]
+
+    if system == "Linux":
+        downloads.append((f"{REPO_BASE}/miners/linux/rustchain_linux_miner.py", "miner.py"))
+    elif system == "Darwin":
+        downloads.append((f"{REPO_BASE}/miners/macos/rustchain_mac_miner_v2.4.py", "miner.py"))
+
+    for url, filename in downloads:
+        dest = os.path.join(INSTALL_DIR, filename)
+        size = download_file(url, dest)
+        log(f"  {filename} ({size / 1024:.1f} KB)")
+
+    success("Miner files downloaded")
+
+    # Setup service
+    if system == "Linux":
+        _setup_systemd(wallet)
+    elif system == "Darwin":
+        _setup_launchd(wallet)
+
+    # Check network
+    log("Checking RustChain network...")
+    try:
+        ctx = ssl.create_default_context()
+        ctx.check_hostname = False
+        ctx.verify_mode = ssl.CERT_NONE
+        req = urllib.request.Request(f"{NODE_URL}/api/miners")
+        with urllib.request.urlopen(req, context=ctx, timeout=10) as resp:
+            miners = json.loads(resp.read())
+            log(f"Active miners on network: {len(miners)}")
+    except Exception:
+        warn("Could not reach network (node may be temporarily unavailable)")
+
+    print(textwrap.dedent(f"""
+    {GREEN}{BOLD}═══════════════════════════════════════════════════════════
+      ClawSkill installed!  Your agent is ready to mine RTC.
+
+      Wallet:    {wallet}
+      Location:  {INSTALL_DIR}
+      Reward:    1x multiplier (modern hardware)
+
+      Commands:
+        clawskill start    Start mining in background
+        clawskill stop     Stop mining
+        clawskill status   Check miner + network status
+        clawskill logs     View miner output
+
+      How it works:
+        • Your agent proves real hardware via 6 fingerprint checks
+        • Attestation happens automatically every few minutes
+        • RTC tokens accumulate in your wallet each epoch (~10 min)
+        • Check balance: clawskill status
+
+      Multipliers:
+        Modern x86/ARM  →  1.0x   (you are here)
+        Apple Silicon    →  1.2x
+        PowerPC G5       →  2.0x
+        PowerPC G4       →  2.5x
+        VM/Emulator      →  ~0x   (detected & penalized)
+    ═══════════════════════════════════════════════════════════{NC}
+    """))
+
+
+def _setup_systemd(wallet):
+    """Set up systemd user service on Linux."""
+    service_dir = os.path.expanduser("~/.config/systemd/user")
+    os.makedirs(service_dir, exist_ok=True)
+    service_file = os.path.join(service_dir, "clawskill-miner.service")
+    python_bin = os.path.join(VENV_DIR, "bin", "python")
+    miner_py = os.path.join(INSTALL_DIR, "miner.py")
+
+    with open(service_file, "w") as f:
+        f.write(textwrap.dedent(f"""\
+            [Unit]
+            Description=ClawSkill RTC Miner — AI Agent Mining
+            After=network-online.target
+            Wants=network-online.target
+
+            [Service]
+            ExecStart={python_bin} {miner_py} --wallet {wallet}
+            Restart=always
+            RestartSec=30
+            WorkingDirectory={INSTALL_DIR}
+            Environment=PYTHONUNBUFFERED=1
+
+            [Install]
+            WantedBy=default.target
+        """))
+
+    try:
+        run_cmd("systemctl --user daemon-reload")
+        run_cmd("systemctl --user enable clawskill-miner")
+        run_cmd("systemctl --user start clawskill-miner")
+        success("Service installed and started")
+    except Exception:
+        warn("Systemd user services not available. Use: clawskill start")
+
+
+def _setup_launchd(wallet):
+    """Set up launchd agent on macOS."""
+    plist_dir = os.path.expanduser("~/Library/LaunchAgents")
+    os.makedirs(plist_dir, exist_ok=True)
+    plist_file = os.path.join(plist_dir, "com.clawskill.miner.plist")
+    python_bin = os.path.join(VENV_DIR, "bin", "python")
+    miner_py = os.path.join(INSTALL_DIR, "miner.py")
+
+    with open(plist_file, "w") as f:
+        f.write(textwrap.dedent(f"""\
+            <?xml version="1.0" encoding="UTF-8"?>
+            <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN"
+              "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+            <plist version="1.0">
+            <dict>
+                <key>Label</key>
+                <string>com.clawskill.miner</string>
+                <key>ProgramArguments</key>
+                <array>
+                    <string>{python_bin}</string>
+                    <string>{miner_py}</string>
+                    <string>--wallet</string>
+                    <string>{wallet}</string>
+                </array>
+                <key>WorkingDirectory</key>
+                <string>{INSTALL_DIR}</string>
+                <key>RunAtLoad</key>
+                <true/>
+                <key>KeepAlive</key>
+                <true/>
+                <key>StandardOutPath</key>
+                <string>{os.path.join(INSTALL_DIR, "miner.log")}</string>
+                <key>StandardErrorPath</key>
+                <string>{os.path.join(INSTALL_DIR, "miner.err")}</string>
+            </dict>
+            </plist>
+        """))
+
+    try:
+        run_cmd(f'launchctl unload "{plist_file}" 2>/dev/null', check=False)
+        run_cmd(f'launchctl load "{plist_file}"')
+        success("LaunchAgent installed and loaded")
+    except Exception:
+        warn("Could not load LaunchAgent. Use: clawskill start")
+
+
+def cmd_start(args):
+    """Start the ClawSkill miner."""
+    system = platform.system()
+    if system == "Linux":
+        run_cmd("systemctl --user start clawskill-miner")
+        success("Miner started")
+    elif system == "Darwin":
+        pf = os.path.expanduser("~/Library/LaunchAgents/com.clawskill.miner.plist")
+        run_cmd(f'launchctl load "{pf}"', check=False)
+        success("Miner started")
+    else:
+        wallet_file = os.path.join(INSTALL_DIR, ".wallet")
+        wallet = open(wallet_file).read().strip() if os.path.exists(wallet_file) else ""
+        w_arg = f"--wallet {wallet}" if wallet else ""
+        log(f"Run: cd {INSTALL_DIR} && source venv/bin/activate && python miner.py {w_arg}")
+
+
+def cmd_stop(args):
+    """Stop the ClawSkill miner."""
+    system = platform.system()
+    if system == "Linux":
+        run_cmd("systemctl --user stop clawskill-miner", check=False)
+    elif system == "Darwin":
+        pf = os.path.expanduser("~/Library/LaunchAgents/com.clawskill.miner.plist")
+        run_cmd(f'launchctl unload "{pf}"', check=False)
+    success("Miner stopped")
+
+
+def cmd_status(args):
+    """Check miner and network status."""
+    system = platform.system()
+
+    # Service status
+    if system == "Linux":
+        run_cmd("systemctl --user status clawskill-miner", check=False)
+    elif system == "Darwin":
+        run_cmd("launchctl list | grep clawskill", check=False)
+
+    # Wallet info
+    wallet_file = os.path.join(INSTALL_DIR, ".wallet")
+    if os.path.exists(wallet_file):
+        wallet = open(wallet_file).read().strip()
+        log(f"Wallet: {wallet}")
+
+    # Network check
+    try:
+        ctx = ssl.create_default_context()
+        ctx.check_hostname = False
+        ctx.verify_mode = ssl.CERT_NONE
+        req = urllib.request.Request(f"{NODE_URL}/health")
+        with urllib.request.urlopen(req, context=ctx, timeout=10) as resp:
+            health = json.loads(resp.read())
+            status = "online" if health.get("ok") else "offline"
+            log(f"Network: {status} (v{health.get('version', '?')})")
+    except Exception:
+        warn("Could not reach network")
+
+
+def cmd_logs(args):
+    """View miner logs."""
+    system = platform.system()
+    if system == "Linux":
+        os.execlp("journalctl", "journalctl", "--user", "-u", "clawskill-miner", "-f", "--no-pager", "-n", "50")
+    elif system == "Darwin":
+        log_file = os.path.join(INSTALL_DIR, "miner.log")
+        if os.path.exists(log_file):
+            os.execlp("tail", "tail", "-f", log_file)
+        else:
+            warn("No log file found")
+
+
+def cmd_uninstall(args):
+    """Remove ClawSkill miner and all files."""
+    log("Stopping miner...")
+    cmd_stop(args)
+
+    system = platform.system()
+    if system == "Linux":
+        run_cmd("systemctl --user disable clawskill-miner", check=False)
+        sf = os.path.expanduser("~/.config/systemd/user/clawskill-miner.service")
+        if os.path.exists(sf):
+            os.unlink(sf)
+    elif system == "Darwin":
+        pf = os.path.expanduser("~/Library/LaunchAgents/com.clawskill.miner.plist")
+        if os.path.exists(pf):
+            os.unlink(pf)
+
+    if os.path.isdir(INSTALL_DIR):
+        shutil.rmtree(INSTALL_DIR)
+
+    success("ClawSkill miner uninstalled")
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        prog="clawskill",
+        description="ClawSkill — Mine RTC tokens with your AI agent on real hardware",
+        epilog=textwrap.dedent("""\
+            Your Claw agent earns RTC by proving it runs on real hardware.
+            Modern x86/ARM gets 1x multiplier. VMs are detected and penalized.
+            Vintage hardware (PowerPC, etc.) earns bonus multipliers up to 2.5x.
+        """),
+    )
+    sub = parser.add_subparsers(dest="command")
+
+    p_install = sub.add_parser("install", help="Install miner and configure wallet")
+    p_install.add_argument("--wallet", help="Agent wallet name for mining rewards")
+
+    sub.add_parser("start", help="Start mining in background")
+    sub.add_parser("stop", help="Stop mining")
+    sub.add_parser("status", help="Check miner + network status")
+    sub.add_parser("logs", help="View miner output logs")
+    sub.add_parser("uninstall", help="Remove miner and all files")
+
+    args = parser.parse_args()
+
+    commands = {
+        "install": cmd_install,
+        "start": cmd_start,
+        "stop": cmd_stop,
+        "status": cmd_status,
+        "logs": cmd_logs,
+        "uninstall": cmd_uninstall,
+    }
+
+    if not args.command:
+        args.command = "install"
+        args.wallet = None
+
+    func = commands.get(args.command)
+    if func:
+        func(args)
+    else:
+        parser.print_help()
+
+
+if __name__ == "__main__":
+    main()

clawskill-1.0.0/clawskill.egg-info/PKG-INFO

@@ -0,0 +1,98 @@
+Metadata-Version: 2.4
+Name: clawskill
+Version: 1.0.0
+Summary: ClawSkill — Let your AI agent mine RTC tokens on any modern hardware. 1x multiplier, built-in wallet, VM-penalized.
+Author-email: Elyan Labs <scott@elyanlabs.ai>
+License: MIT
+Project-URL: Homepage, https://bottube.ai
+Project-URL: Repository, https://github.com/Scottcjn/Rustchain
+Project-URL: Issues, https://github.com/Scottcjn/Rustchain/issues
+Keywords: clawskill,ai-agent,miner,rustchain,rtc,openclaw,proof-of-antiquity
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: MacOS
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.25
+Dynamic: license-file
+
+# ClawSkill — Mine RTC Tokens With Your AI Agent
+
+Your Claw agent can earn **RTC (RustChain Tokens)** by proving it runs on **real hardware**. One command to install, automatic attestation, built-in wallet.
+
+## Quick Start
+
+```bash
+pip install clawskill
+clawskill install --wallet my-agent-miner
+clawskill start
+```
+
+That's it. Your agent is now mining RTC.
+
+## How It Works
+
+1. **Hardware Fingerprinting** — 6 cryptographic checks prove your machine is real hardware (clock drift, cache timing, SIMD identity, thermal drift, instruction jitter, anti-emulation)
+2. **Attestation** — Your agent automatically attests to the RustChain network every few minutes
+3. **Rewards** — RTC tokens accumulate in your wallet each epoch (~10 minutes)
+4. **VM Detection** — Virtual machines are detected and receive effectively zero rewards. **Real iron only.**
+
+## Multipliers
+
+| Hardware | Multiplier | Notes |
+|----------|-----------|-------|
+| Modern x86/ARM | **1.0x** | Standard reward rate |
+| Apple Silicon (M1/M2/M3) | **1.2x** | Slight bonus |
+| PowerPC G5 | **2.0x** | Vintage bonus |
+| PowerPC G4 | **2.5x** | Maximum vintage bonus |
+| **VM/Emulator** | **~0x** | **Detected and penalized** |
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `clawskill install` | Download miner, create wallet, set up service |
+| `clawskill start` | Start mining in background |
+| `clawskill stop` | Stop mining |
+| `clawskill status` | Check miner + network status |
+| `clawskill logs` | View miner output |
+| `clawskill uninstall` | Remove everything |
+
+## What Gets Installed
+
+- Miner scripts from [RustChain repo](https://github.com/Scottcjn/Rustchain)
+- Python virtual environment with `requests` dependency
+- Systemd user service (Linux) or LaunchAgent (macOS)
+- All files in `~/.clawskill/`
+
+## VM Warning
+
+RustChain uses **Proof-of-Antiquity (PoA)** consensus. The hardware fingerprint system detects:
+
+- QEMU / KVM / VMware / VirtualBox / Xen / Hyper-V
+- Hypervisor CPU flags
+- DMI vendor strings
+- Flattened timing distributions
+
+If you're running in a VM, the miner will install and attest, but your rewards will be effectively zero. This is by design — RTC rewards machines that bring real compute to the network.
+
+## Requirements
+
+- Python 3.8+
+- Linux or macOS (Windows installer coming soon)
+- Real hardware (not a VM)
+
+## Links
+
+- [RustChain Network](https://bottube.ai)
+- [Block Explorer](https://50.28.86.131/explorer)
+- [GitHub](https://github.com/Scottcjn/Rustchain)
+
+## License
+
+MIT — Elyan Labs

clawskill-1.0.0/clawskill.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+LICENSE
+README.md
+pyproject.toml
+clawskill/__init__.py
+clawskill/cli.py
+clawskill.egg-info/PKG-INFO
+clawskill.egg-info/SOURCES.txt
+clawskill.egg-info/dependency_links.txt
+clawskill.egg-info/entry_points.txt
+clawskill.egg-info/requires.txt
+clawskill.egg-info/top_level.txt

clawskill-1.0.0/clawskill.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

clawskill-1.0.0/clawskill.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+clawskill = clawskill.cli:main

clawskill-1.0.0/clawskill.egg-info/requires.txt

@@ -0,0 +1 @@
+requests>=2.25

clawskill-1.0.0/clawskill.egg-info/top_level.txt

@@ -0,0 +1 @@
+clawskill

clawskill-1.0.0/pyproject.toml

@@ -0,0 +1,34 @@
+[build-system]
+requires = ["setuptools>=64", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "clawskill"
+version = "1.0.0"
+description = "ClawSkill — Let your AI agent mine RTC tokens on any modern hardware. 1x multiplier, built-in wallet, VM-penalized."
+readme = "README.md"
+license = {text = "MIT"}
+authors = [{name = "Elyan Labs", email = "scott@elyanlabs.ai"}]
+requires-python = ">=3.8"
+dependencies = ["requests>=2.25"]
+keywords = ["clawskill", "ai-agent", "miner", "rustchain", "rtc", "openclaw", "proof-of-antiquity"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: POSIX :: Linux",
+    "Operating System :: MacOS",
+    "Programming Language :: Python :: 3",
+    "Topic :: Software Development :: Libraries",
+]
+
+[project.urls]
+Homepage = "https://bottube.ai"
+Repository = "https://github.com/Scottcjn/Rustchain"
+Issues = "https://github.com/Scottcjn/Rustchain/issues"
+
+[project.scripts]
+clawskill = "clawskill.cli:main"
+
+[tool.setuptools.packages.find]
+include = ["clawskill*"]

clawskill-1.0.0/setup.cfg

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