clawrtc 1.0.0

package/bin/clawrtc.js

@@ -0,0 +1,410 @@
+#!/usr/bin/env node
+/**
+ * ClawRTC — Mine RTC tokens with your AI agent on real hardware.
+ *
+ * Modern machines get 1x multiplier. Vintage hardware gets bonus.
+ * VMs are detected and penalized — real iron only.
+ *
+ * Usage:
+ *   npm install -g clawrtc
+ *   clawrtc install --wallet my-agent
+ *   clawrtc start
+ */
+
+const { execSync, spawn } = require('child_process');
+const fs = require('fs');
+const https = require('https');
+const http = require('http');
+const os = require('os');
+const path = require('path');
+const readline = require('readline');
+
+const REPO_BASE = 'https://raw.githubusercontent.com/Scottcjn/Rustchain/main';
+const INSTALL_DIR = path.join(os.homedir(), '.clawrtc');
+const VENV_DIR = path.join(INSTALL_DIR, 'venv');
+const NODE_URL = 'https://50.28.86.131';
+
+// ANSI colors
+const C = '\x1b[36m', G = '\x1b[32m', R = '\x1b[31m', Y = '\x1b[33m';
+const B = '\x1b[1m', D = '\x1b[2m', NC = '\x1b[0m';
+
+const log = (m) => console.log(`${C}[clawrtc]${NC} ${m}`);
+const ok = (m) => console.log(`${G}[OK]${NC} ${m}`);
+const warn = (m) => console.log(`${Y}[WARN]${NC} ${m}`);
+
+function downloadFile(url, dest) {
+    return new Promise((resolve, reject) => {
+        const file = fs.createWriteStream(dest);
+        const mod = url.startsWith('https') ? https : http;
+        const opts = { rejectUnauthorized: false };
+        mod.get(url, opts, (res) => {
+            if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+                file.close();
+                fs.unlinkSync(dest);
+                return downloadFile(res.headers.location, dest).then(resolve).catch(reject);
+            }
+            res.pipe(file);
+            file.on('finish', () => {
+                file.close();
+                const size = fs.statSync(dest).size;
+                if (size < 100) return reject(new Error(`File too small (${size} bytes)`));
+                resolve(size);
+            });
+        }).on('error', (e) => { file.close(); reject(e); });
+    });
+}
+
+function ask(prompt) {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    return new Promise((resolve) => {
+        rl.question(prompt, (ans) => { rl.close(); resolve(ans.trim()); });
+    });
+}
+
+function detectVM() {
+    const hints = [];
+    if (os.platform() === 'linux') {
+        const dmiPaths = ['/sys/class/dmi/id/sys_vendor', '/sys/class/dmi/id/product_name'];
+        const vmVendors = ['qemu', 'vmware', 'virtualbox', 'xen', 'kvm', 'microsoft', 'parallels'];
+        for (const p of dmiPaths) {
+            try {
+                const val = fs.readFileSync(p, 'utf8').trim().toLowerCase();
+                if (vmVendors.some(v => val.includes(v))) hints.push(`${p}: ${val}`);
+            } catch (e) {}
+        }
+        try {
+            const cpu = fs.readFileSync('/proc/cpuinfo', 'utf8').toLowerCase();
+            if (cpu.includes('hypervisor')) hints.push('cpuinfo: hypervisor flag');
+        } catch (e) {}
+    }
+    return hints;
+}
+
+async function cmdInstall(walletArg) {
+    console.log(`
+${C}${B}
+  ██████╗██╗      █████╗ ██╗    ██╗███████╗██╗  ██╗██╗██╗     ██╗
+ ██╔════╝██║     ██╔══██╗██║    ██║██╔════╝██║ ██╔╝██║██║     ██║
+ ██║     ██║     ███████║██║ █╗ ██║███████╗█████╔╝ ██║██║     ██║
+ ██║     ██║     ██╔══██║██║███╗██║╚════██║██╔═██╗ ██║██║     ██║
+ ╚██████╗███████╗██║  ██║╚███╔███╔╝███████║██║  ██╗██║███████╗███████╗
+  ╚═════╝╚══════╝╚═╝  ╚═╝ ╚══╝╚══╝ ╚══════╝╚═╝  ╚═╝╚═╝╚══════╝╚══════╝
+${NC}
+${D}  Mine RTC tokens with your AI agent on real hardware${NC}
+${D}  Modern x86/ARM = 1x | Vintage PowerPC = up to 2.5x | VM = ~0x${NC}
+`);
+
+    const plat = os.platform();
+    const arch = os.arch();
+    log(`Platform: ${plat} | Arch: ${arch}`);
+
+    if (plat !== 'linux' && plat !== 'darwin') {
+        console.error(`${R}[ERROR]${NC} Unsupported platform: ${plat}. Use Linux or macOS.`);
+        process.exit(1);
+    }
+
+    // VM check
+    const vmHints = detectVM();
+    if (vmHints.length > 0) {
+        console.log(`
+${R}${B}  ╔══════════════════════════════════════════════════════════╗
+  ║              ⚠  VM DETECTED — READ THIS  ⚠             ║
+  ╠══════════════════════════════════════════════════════════╣
+  ║  This machine appears to be a virtual machine.           ║
+  ║  RustChain will detect VMs and assign near-zero weight.  ║
+  ║  Your miner will attest but earn effectively nothing.    ║
+  ║  To earn RTC, run on bare-metal hardware.               ║
+  ╚══════════════════════════════════════════════════════════╝${NC}`);
+        for (const h of vmHints.slice(0, 4)) console.log(`  ${R}  •  ${h}${NC}`);
+        console.log();
+    }
+
+    // Wallet
+    let wallet = walletArg;
+    if (!wallet) {
+        wallet = await ask(`${C}[clawrtc]${NC} Enter agent wallet name (e.g. my-claw-agent): `);
+    }
+    if (!wallet) {
+        const host = os.hostname().split('.')[0] || 'agent';
+        wallet = `claw-${host}-${Date.now() % 100000}`;
+        warn(`No wallet provided. Auto-generated: ${wallet}`);
+    }
+
+    // Create install dir
+    log(`Installing to ${INSTALL_DIR}`);
+    fs.mkdirSync(INSTALL_DIR, { recursive: true });
+    fs.writeFileSync(path.join(INSTALL_DIR, '.wallet'), wallet);
+
+    // Check for python3
+    let pythonBin = 'python3';
+    try { execSync('python3 --version', { stdio: 'pipe' }); }
+    catch (e) {
+        try { execSync('python --version', { stdio: 'pipe' }); pythonBin = 'python'; }
+        catch (e2) {
+            console.error(`${R}[ERROR]${NC} Python 3 not found. Install Python 3.8+ first.`);
+            process.exit(1);
+        }
+    }
+
+    // Create venv
+    if (!fs.existsSync(VENV_DIR)) {
+        log('Creating Python environment...');
+        execSync(`${pythonBin} -m venv "${VENV_DIR}"`, { stdio: 'inherit' });
+    }
+
+    // Install deps
+    log('Installing dependencies...');
+    const pip = path.join(VENV_DIR, 'bin', 'pip');
+    execSync(`"${pip}" install --upgrade pip -q`, { stdio: 'pipe' });
+    execSync(`"${pip}" install requests -q`, { stdio: 'pipe' });
+    ok('Dependencies ready');
+
+    // Download miner files
+    log('Downloading miner from RustChain repo...');
+    const downloads = [
+        [`${REPO_BASE}/miners/linux/fingerprint_checks.py`, 'fingerprint_checks.py'],
+    ];
+
+    if (plat === 'linux') {
+        downloads.push([`${REPO_BASE}/miners/linux/rustchain_linux_miner.py`, 'miner.py']);
+    } else if (plat === 'darwin') {
+        downloads.push([`${REPO_BASE}/miners/macos/rustchain_mac_miner_v2.4.py`, 'miner.py']);
+    }
+
+    for (const [url, filename] of downloads) {
+        const dest = path.join(INSTALL_DIR, filename);
+        const size = await downloadFile(url, dest);
+        log(`  ${filename} (${(size / 1024).toFixed(1)} KB)`);
+    }
+    ok('Miner files downloaded');
+
+    // Setup service
+    if (plat === 'linux') {
+        setupSystemd(wallet);
+    } else if (plat === 'darwin') {
+        setupLaunchd(wallet);
+    }
+
+    // Network check
+    log('Checking RustChain network...');
+    try {
+        const data = await new Promise((resolve, reject) => {
+            https.get(`${NODE_URL}/api/miners`, { rejectUnauthorized: false }, (res) => {
+                let d = '';
+                res.on('data', c => d += c);
+                res.on('end', () => resolve(d));
+            }).on('error', reject);
+        });
+        const miners = JSON.parse(data);
+        log(`Active miners on network: ${miners.length}`);
+    } catch (e) {
+        warn('Could not reach network (node may be temporarily unavailable)');
+    }
+
+    console.log(`
+${G}${B}═══════════════════════════════════════════════════════════
+  ClawRTC installed!  Your agent is ready to mine RTC.
+
+  Wallet:    ${wallet}
+  Location:  ${INSTALL_DIR}
+  Reward:    1x multiplier (modern hardware)
+
+  Commands:
+    clawrtc start    Start mining in background
+    clawrtc stop     Stop mining
+    clawrtc status   Check miner + network status
+    clawrtc 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: clawrtc 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}
+`);
+}
+
+function setupSystemd(wallet) {
+    const svcDir = path.join(os.homedir(), '.config', 'systemd', 'user');
+    fs.mkdirSync(svcDir, { recursive: true });
+    const svcFile = path.join(svcDir, 'clawrtc-miner.service');
+    const pythonBin = path.join(VENV_DIR, 'bin', 'python');
+    const minerPy = path.join(INSTALL_DIR, 'miner.py');
+
+    fs.writeFileSync(svcFile, `[Unit]
+Description=ClawRTC RTC Miner — AI Agent Mining
+After=network-online.target
+Wants=network-online.target
+
+[Service]
+ExecStart=${pythonBin} ${minerPy} --wallet ${wallet}
+Restart=always
+RestartSec=30
+WorkingDirectory=${INSTALL_DIR}
+Environment=PYTHONUNBUFFERED=1
+
+[Install]
+WantedBy=default.target
+`);
+
+    try {
+        execSync('systemctl --user daemon-reload', { stdio: 'pipe' });
+        execSync('systemctl --user enable clawrtc-miner', { stdio: 'pipe' });
+        execSync('systemctl --user start clawrtc-miner', { stdio: 'pipe' });
+        ok('Service installed and started');
+    } catch (e) {
+        warn('Systemd user services not available. Use: clawrtc start');
+    }
+}
+
+function setupLaunchd(wallet) {
+    const plistDir = path.join(os.homedir(), 'Library', 'LaunchAgents');
+    fs.mkdirSync(plistDir, { recursive: true });
+    const plistFile = path.join(plistDir, 'com.clawrtc.miner.plist');
+    const pythonBin = path.join(VENV_DIR, 'bin', 'python');
+    const minerPy = path.join(INSTALL_DIR, 'miner.py');
+
+    fs.writeFileSync(plistFile, `<?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.clawrtc.miner</string>
+    <key>ProgramArguments</key>
+    <array>
+        <string>${pythonBin}</string>
+        <string>${minerPy}</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>${path.join(INSTALL_DIR, 'miner.log')}</string>
+    <key>StandardErrorPath</key>
+    <string>${path.join(INSTALL_DIR, 'miner.err')}</string>
+</dict>
+</plist>`);
+
+    try {
+        execSync(`launchctl unload "${plistFile}" 2>/dev/null`, { stdio: 'pipe' });
+    } catch (e) {}
+    try {
+        execSync(`launchctl load "${plistFile}"`, { stdio: 'pipe' });
+        ok('LaunchAgent installed and loaded');
+    } catch (e) {
+        warn('Could not load LaunchAgent. Use: clawrtc start');
+    }
+}
+
+function cmdStart() {
+    if (os.platform() === 'linux') {
+        execSync('systemctl --user start clawrtc-miner', { stdio: 'inherit' });
+    } else if (os.platform() === 'darwin') {
+        const pf = path.join(os.homedir(), 'Library', 'LaunchAgents', 'com.clawrtc.miner.plist');
+        try { execSync(`launchctl load "${pf}"`, { stdio: 'inherit' }); } catch (e) {}
+    }
+    ok('Miner started');
+}
+
+function cmdStop() {
+    if (os.platform() === 'linux') {
+        try { execSync('systemctl --user stop clawrtc-miner', { stdio: 'pipe' }); } catch (e) {}
+    } else if (os.platform() === 'darwin') {
+        const pf = path.join(os.homedir(), 'Library', 'LaunchAgents', 'com.clawrtc.miner.plist');
+        try { execSync(`launchctl unload "${pf}"`, { stdio: 'pipe' }); } catch (e) {}
+    }
+    ok('Miner stopped');
+}
+
+function cmdStatus() {
+    if (os.platform() === 'linux') {
+        try { execSync('systemctl --user status clawrtc-miner', { stdio: 'inherit' }); } catch (e) {}
+    } else if (os.platform() === 'darwin') {
+        try { execSync('launchctl list | grep clawrtc', { stdio: 'inherit' }); } catch (e) {}
+    }
+    const wf = path.join(INSTALL_DIR, '.wallet');
+    if (fs.existsSync(wf)) log(`Wallet: ${fs.readFileSync(wf, 'utf8').trim()}`);
+
+    https.get(`${NODE_URL}/health`, { rejectUnauthorized: false }, (res) => {
+        let d = '';
+        res.on('data', c => d += c);
+        res.on('end', () => {
+            try {
+                const h = JSON.parse(d);
+                log(`Network: ${h.ok ? 'online' : 'offline'} (v${h.version || '?'})`);
+            } catch (e) { warn('Could not parse network status'); }
+        });
+    }).on('error', () => warn('Could not reach network'));
+}
+
+function cmdLogs() {
+    if (os.platform() === 'linux') {
+        spawn('journalctl', ['--user', '-u', 'clawrtc-miner', '-f', '--no-pager', '-n', '50'], { stdio: 'inherit' });
+    } else {
+        const lf = path.join(INSTALL_DIR, 'miner.log');
+        if (fs.existsSync(lf)) spawn('tail', ['-f', lf], { stdio: 'inherit' });
+        else warn('No log file found');
+    }
+}
+
+function cmdUninstall() {
+    log('Stopping miner...');
+    cmdStop();
+    if (os.platform() === 'linux') {
+        try { execSync('systemctl --user disable clawrtc-miner', { stdio: 'pipe' }); } catch (e) {}
+        const sf = path.join(os.homedir(), '.config', 'systemd', 'user', 'clawrtc-miner.service');
+        try { fs.unlinkSync(sf); } catch (e) {}
+    } else if (os.platform() === 'darwin') {
+        const pf = path.join(os.homedir(), 'Library', 'LaunchAgents', 'com.clawrtc.miner.plist');
+        try { fs.unlinkSync(pf); } catch (e) {}
+    }
+    try { fs.rmSync(INSTALL_DIR, { recursive: true, force: true }); } catch (e) {}
+    ok('ClawRTC miner uninstalled');
+}
+
+// Main
+const args = process.argv.slice(2);
+const cmd = args[0] || 'install';
+const walletIdx = args.indexOf('--wallet');
+const walletArg = walletIdx >= 0 ? args[walletIdx + 1] : null;
+
+switch (cmd) {
+    case 'install': cmdInstall(walletArg); break;
+    case 'start': cmdStart(); break;
+    case 'stop': cmdStop(); break;
+    case 'status': cmdStatus(); break;
+    case 'logs': cmdLogs(); break;
+    case 'uninstall': cmdUninstall(); break;
+    case '--help': case '-h':
+        console.log(`
+ClawRTC — Mine RTC tokens with your AI agent on real hardware
+
+Commands:
+  clawrtc install [--wallet NAME]   Install miner and configure wallet
+  clawrtc start                     Start mining in background
+  clawrtc stop                      Stop mining
+  clawrtc status                    Check miner + network status
+  clawrtc logs                      View miner output
+  clawrtc uninstall                 Remove everything
+
+Modern hardware gets 1x multiplier. VMs are detected and penalized.
+Vintage hardware (PowerPC G4/G5) gets up to 2.5x bonus.
+`);
+        break;
+    default:
+        console.error(`Unknown command: ${cmd}. Use --help for usage.`);
+        process.exit(1);
+}

package/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "clawrtc",
+  "version": "1.0.0",
+  "description": "ClawRTC — Let your AI agent mine RTC tokens on any modern hardware. 1x multiplier, built-in wallet, VM-penalized.",
+  "bin": {
+    "clawrtc": "./bin/clawrtc.js"
+  },
+  "keywords": ["clawrtc", "ai-agent", "miner", "rustchain", "rtc", "openclaw", "proof-of-antiquity", "blockchain"],
+  "author": "Elyan Labs <scott@elyanlabs.ai>",
+  "license": "MIT",
+  "homepage": "https://bottube.ai",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Scottcjn/Rustchain"
+  },
+  "engines": {
+    "node": ">=14"
+  }
+}