minep2p 1.0.0

package/cli.js

@@ -0,0 +1,191 @@
+#!/usr/bin/env node
+const yargs = require('yargs');
+const chalk = require('chalk');
+const MineP2P = require('./lib/client');
+
+const P2P_INSTANCE_FILE = '/tmp/minep2p_instance.json';
+
+let client = null;
+
+const printHeader = () => {
+    console.log(chalk.blue.bold('╔══════════════════════════════════════════╗'));
+    console.log(chalk.blue.bold('║           MineP2P - Vexify 2026          ║'));
+    console.log(chalk.blue.bold('╚══════════════════════════════════════════╝'));
+    console.log(chalk.gray('Copyright (c) Vexify 2026'));
+    console.log('');
+};
+
+const handlePeerConnect = (peerId) => {
+    console.log(chalk.green(`✓  Peer connected: ${peerId.substring(0, 8)}...`));
+};
+
+const handlePeerDisconnect = (peerId) => {
+    console.log(chalk.yellow(`✗  Peer disconnected: ${peerId.substring(0, 8)}...`));
+};
+
+const handleMessage = (peerId, message) => {
+    console.log(chalk.cyan(`[${peerId.substring(0, 8)}]`) + ' ' + JSON.stringify(message));
+};
+
+const handleError = (error) => {
+    console.log(chalk.red(`✗ Error: ${error.message}`));
+};
+
+const startCommand = async (argv) => {
+    printHeader();
+    
+    const room = argv.room || 'minep2p-default';
+    
+    console.log(chalk.cyan(`Starting MineP2P client...`));
+    console.log(chalk.cyan(`Room: ${room}`));
+    
+    client = new MineP2P();
+    
+    client.on('connect', () => {
+        console.log(chalk.green('✓ Connected to signaling server'));
+        console.log(chalk.cyan(`Peer ID: ${client.getStatus().peerId.substring(0, 8)}...`));
+    });
+    
+    client.on('peerConnect', handlePeerConnect);
+    client.on('peerDisconnect', handlePeerDisconnect);
+    client.on('message', handleMessage);
+    client.on('error', handleError);
+    
+    try {
+        await client.start(room);
+        
+        console.log(chalk.green('✓ MineP2P client started successfully!'));
+        console.log('');
+        console.log(chalk.yellow('Press Ctrl+C to stop'));
+        
+        process.stdin.resume();
+        
+    } catch (error) {
+        console.log(chalk.red(`✗ Failed to start: ${error.message}`));
+        process.exit(1);
+    }
+};
+
+const stopCommand = async () => {
+    printHeader();
+    
+    console.log(chalk.cyan('Stopping MineP2P client...'));
+    
+    if (client) {
+        try {
+            await client.stop();
+            console.log(chalk.green('✓ MineP2P client stopped successfully'));
+            process.exit(0);
+        } catch (error) {
+            console.log(chalk.red(`✗ Failed to stop: ${error.message}`));
+            process.exit(1);
+        }
+    } else {
+        console.log(chalk.yellow('No running client found'));
+        process.exit(0);
+    }
+};
+
+const statusCommand = () => {
+    printHeader();
+    
+    if (client) {
+        const status = client.getStatus();
+        console.log(chalk.cyan('Current Status:'));
+        console.log(`  Status: ${chalk.green(status.status)}`);
+        console.log(`  Peer ID: ${status.peerId}`);
+        console.log(`  Room: ${status.room}`);
+        console.log(`  Connected Peers: ${chalk.yellow(status.peerCount)}`);
+        
+        if (status.peerCount > 0) {
+            console.log('  Peer List:');
+            client.getPeers().forEach(peerId => {
+                console.log(`    - ${peerId.substring(0, 8)}...`);
+            });
+        }
+    } else {
+        console.log(chalk.yellow('Client is not running'));
+    }
+};
+
+const connectCommand = async (argv) => {
+    printHeader();
+    
+    if (!client) {
+        console.log(chalk.yellow('Client is not running. Starting...'));
+        client = new MineP2P();
+        
+        client.on('connect', () => {
+            console.log(chalk.green('✓ Connected'));
+        });
+        client.on('peerConnect', handlePeerConnect);
+        client.on('peerDisconnect', handlePeerDisconnect);
+        client.on('message', handleMessage);
+        client.on('error', handleError);
+    }
+    
+    const room = argv.room || 'minep2p-default';
+    
+    console.log(chalk.cyan(`Connecting to room: ${room}`));
+    
+    try {
+        await client.start(room);
+        console.log(chalk.green('✓ Connected to room successfully'));
+    } catch (error) {
+        console.log(chalk.red(`✗ Failed to connect: ${error.message}`));
+        process.exit(1);
+    }
+};
+
+const sendCommand = async (argv) => {
+    printHeader();
+    
+    if (!client) {
+        console.log(chalk.red('✗ Client is not running'));
+        process.exit(1);
+    }
+    
+    const message = argv.message || 'Hello from MineP2P';
+    
+    console.log(chalk.cyan(`Broadcasting message: ${message}`));
+    client.broadcast({ type: 'chat', content: message });
+    console.log(chalk.green('✓ Message sent'));
+};
+
+yargs
+    .command('start', 'Start MineP2P client', (yargs) => {
+        return yargs.option('room', {
+            describe: 'Room name to join',
+            type: 'string',
+            default: 'minep2p-default'
+        });
+    }, startCommand)
+    .command('stop', 'Stop MineP2P client', stopCommand)
+    .command('status', 'Check client status', statusCommand)
+    .command('connect <room>', 'Connect to a specific room', (yargs) => {
+        return yargs.positional('room', {
+            describe: 'Room name',
+            type: 'string'
+        });
+    }, connectCommand)
+    .command('send <message>', 'Send a message to all peers', (yargs) => {
+        return yargs.positional('message', {
+            describe: 'Message to send',
+            type: 'string'
+        });
+    }, sendCommand)
+    .help()
+    .argv;
+
+process.on('SIGINT', async () => {
+    console.log('');
+    console.log(chalk.cyan('Received interrupt signal, stopping...'));
+    if (client) {
+        try {
+            await client.stop();
+        } catch (error) {
+            console.log(chalk.red(`Error stopping: ${error.message}`));
+        }
+    }
+    process.exit(0);
+});

package/index.js

@@ -0,0 +1,8 @@
+const MineP2P = require('./lib/client');
+const config = require('./lib/config');
+
+module.exports = {
+    MineP2P,
+    config,
+    createClient: () => new MineP2P()
+};

package/lib/client.js

@@ -0,0 +1,196 @@
+const { v4: uuidv4 } = require('uuid');
+const Signaling = require('./signaling');
+const Peer = require('./peer');
+const IPv6 = require('./ipv6');
+const config = require('./config');
+
+class MineP2P {
+    constructor() {
+        this.peerId = uuidv4();
+        this.signaling = null;
+        this.peers = new Map();
+        this.room = null;
+        this.status = 'disconnected';
+        this.callbacks = {
+            connect: [],
+            disconnect: [],
+            peerConnect: [],
+            peerDisconnect: [],
+            message: [],
+            statusChange: [],
+            error: []
+        };
+    }
+
+    async start(room = config.defaultRoom) {
+        this.room = room;
+        this.signaling = new Signaling(this.peerId);
+
+        this.signaling.on('peerJoined', (peerId) => {
+            this._handlePeerJoined(peerId);
+        });
+
+        this.signaling.on('peerLeft', (peerId) => {
+            this._handlePeerLeft(peerId);
+        });
+
+        this.signaling.on('message', (message) => {
+            this._handleMessage(message);
+        });
+
+        try {
+            await this.signaling.join(room);
+            this.status = 'connecting';
+            this._emitStatusChange();
+            this.signaling.startPolling();
+            
+            const ipv6 = await IPv6.getIPv6WithRetry();
+            console.log(`IPv6 Address: ${ipv6 || 'Not available'}`);
+            
+            this.status = 'connected';
+            this._emitStatusChange();
+            this.callbacks.connect.forEach(cb => cb());
+            
+        } catch (error) {
+            this.status = 'error';
+            this._emitStatusChange();
+            this.callbacks.error.forEach(cb => cb(error));
+            throw error;
+        }
+    }
+
+    async stop() {
+        if (this.signaling) {
+            this.signaling.stopPolling();
+            await this.signaling.leave();
+        }
+        
+        for (const peer of this.peers.values()) {
+            peer.close();
+        }
+        this.peers.clear();
+        
+        this.status = 'disconnected';
+        this._emitStatusChange();
+        this.callbacks.disconnect.forEach(cb => cb());
+    }
+
+    async sendToPeer(peerId, message) {
+        const peer = this.peers.get(peerId);
+        if (peer) {
+            peer.send(message);
+        }
+    }
+
+    broadcast(message) {
+        for (const peer of this.peers.values()) {
+            peer.send(message);
+        }
+    }
+
+    getPeers() {
+        return Array.from(this.peers.keys());
+    }
+
+    getStatus() {
+        return {
+            status: this.status,
+            peerId: this.peerId,
+            room: this.room,
+            peerCount: this.peers.size
+        };
+    }
+
+    on(event, callback) {
+        if (this.callbacks[event]) {
+            this.callbacks[event].push(callback);
+        }
+    }
+
+    off(event, callback) {
+        if (this.callbacks[event]) {
+            this.callbacks[event] = this.callbacks[event].filter(cb => cb !== callback);
+        }
+    }
+
+    async _handlePeerJoined(peerId) {
+        if (peerId === this.peerId) return;
+        
+        const peer = new Peer(peerId, this.signaling);
+        this.peers.set(peerId, peer);
+        
+        peer.on('connect', () => {
+            this.callbacks.peerConnect.forEach(cb => cb(peerId));
+        });
+        
+        peer.on('disconnect', () => {
+            this._handlePeerLeft(peerId);
+        });
+        
+        peer.on('message', (data) => {
+            this.callbacks.message.forEach(cb => cb(peerId, data));
+        });
+        
+        peer.on('error', (error) => {
+            this.callbacks.error.forEach(cb => cb(error));
+        });
+        
+        await peer.connect(true);
+    }
+
+    _handlePeerLeft(peerId) {
+        const peer = this.peers.get(peerId);
+        if (peer) {
+            peer.close();
+            this.peers.delete(peerId);
+            this.callbacks.peerDisconnect.forEach(cb => cb(peerId));
+        }
+    }
+
+    async _handleMessage(message) {
+        const { type, fromPeerId, sdp, candidate } = message;
+        
+        if (!this.peers.has(fromPeerId)) {
+            const peer = new Peer(fromPeerId, this.signaling);
+            this.peers.set(fromPeerId, peer);
+            
+            peer.on('connect', () => {
+                this.callbacks.peerConnect.forEach(cb => cb(fromPeerId));
+            });
+            
+            peer.on('disconnect', () => {
+                this._handlePeerLeft(fromPeerId);
+            });
+            
+            peer.on('message', (data) => {
+                this.callbacks.message.forEach(cb => cb(fromPeerId, data));
+            });
+            
+            peer.on('error', (error) => {
+                this.callbacks.error.forEach(cb => cb(error));
+            });
+            
+            await peer.connect(false);
+        }
+        
+        const peer = this.peers.get(fromPeerId);
+        
+        switch (type) {
+            case 'offer':
+                await peer.handleOffer(sdp);
+                break;
+            case 'answer':
+                await peer.handleAnswer(sdp);
+                break;
+            case 'ice':
+                await peer.handleIceCandidate(candidate);
+                break;
+        }
+    }
+
+    _emitStatusChange() {
+        this.callbacks.statusChange.forEach(cb => cb(this.status));
+    }
+}
+
+module.exports = MineP2P;

package/lib/config.js

@@ -0,0 +1,19 @@
+module.exports = {
+    apiBaseUrl: 'https://api.vexify.top/mp/',
+    iceServers: [
+        { urls: 'stun:stun.cloudflare.com:3478' },
+        { urls: 'stun:stun1.cloudflare.com:3478' },
+        { urls: 'stun:stun2.cloudflare.com:3478' },
+        { urls: 'stun:stun3.cloudflare.com:3478' },
+        { urls: 'stun:stun4.cloudflare.com:3478' }
+    ],
+    ipv6Endpoints: [
+        'https://api6.ipify.org',
+        'https://ipv6.icanhazip.com',
+        'https://v6.ident.me'
+    ],
+    defaultRoom: 'minep2p-default',
+    pollTimeout: 30,
+    reconnectDelay: 5000,
+    maxRetries: 3
+};

package/lib/ipv6.js

@@ -0,0 +1,74 @@
+const fetch = require('node-fetch');
+const { networkInterfaces } = require('os');
+const config = require('./config');
+
+class IPv6 {
+    static async getPublicIPv6() {
+        for (let i = 0; i < config.ipv6Endpoints.length; i++) {
+            try {
+                const response = await fetch(config.ipv6Endpoints[i], {
+                    timeout: 10000
+                });
+                if (response.ok) {
+                    const ip = await response.text();
+                    if (this.isValidIPv6(ip.trim())) {
+                        return ip.trim();
+                    }
+                }
+            } catch (error) {
+                console.log(`IPv6 attempt ${i + 1} failed:`, error.message);
+            }
+        }
+        return null;
+    }
+
+    static async getIPv6WithRetry(retries = config.maxRetries) {
+        let result = await this.getPublicIPv6();
+        if (result) return result;
+
+        for (let i = 0; i < retries; i++) {
+            console.log(`IPv6 retry attempt ${i + 1}/${retries}`);
+            await new Promise(resolve => setTimeout(resolve, 2000));
+            result = await this.getPublicIPv6();
+            if (result) return result;
+        }
+
+        return this.getLocalIPv6();
+    }
+
+    static getLocalIPv6() {
+        const interfaces = networkInterfaces();
+        for (const interfaceName of Object.keys(interfaces)) {
+            for (const iface of interfaces[interfaceName]) {
+                if (iface.family === 'IPv6' && !iface.internal) {
+                    return iface.address;
+                }
+            }
+        }
+        return null;
+    }
+
+    static isValidIPv6(ip) {
+        try {
+            const parts = ip.split(':');
+            if (parts.length > 8) return false;
+            
+            const hasDoubleColon = ip.includes('::');
+            if (hasDoubleColon && parts.filter(p => p === '').length > 1) {
+                return false;
+            }
+
+            for (const part of parts) {
+                if (part === '') continue;
+                if (!/^[0-9a-fA-F]{1,4}$/.test(part)) {
+                    return false;
+                }
+            }
+            return true;
+        } catch {
+            return false;
+        }
+    }
+}
+
+module.exports = IPv6;

package/lib/peer.js

@@ -0,0 +1,139 @@
+const wrtc = require('wrtc');
+const config = require('./config');
+
+class Peer {
+    constructor(peerId, signaling) {
+        this.peerId = peerId;
+        this.signaling = signaling;
+        this.peerConnection = null;
+        this.dataChannel = null;
+        this.isInitiator = false;
+        this.callbacks = {
+            connect: [],
+            disconnect: [],
+            message: [],
+            error: []
+        };
+    }
+
+    async connect(isInitiator = false) {
+        this.isInitiator = isInitiator;
+        this.peerConnection = new wrtc.RTCPeerConnection({
+            iceServers: config.iceServers
+        });
+
+        this.peerConnection.onicecandidate = (event) => {
+            if (event.candidate) {
+                this.signaling.sendMessage({
+                    type: 'ice',
+                    targetPeerId: this.peerId,
+                    candidate: event.candidate.toJSON()
+                });
+            }
+        };
+
+        this.peerConnection.ondatachannel = (event) => {
+            this.dataChannel = event.channel;
+            this._setupDataChannel();
+        };
+
+        this.peerConnection.onconnectionstatechange = () => {
+            if (this.peerConnection.connectionState === 'connected') {
+                this.callbacks.connect.forEach(cb => cb());
+            } else if (this.peerConnection.connectionState === 'disconnected') {
+                this.callbacks.disconnect.forEach(cb => cb());
+            }
+        };
+
+        if (this.isInitiator) {
+            this.dataChannel = this.peerConnection.createDataChannel('minep2p');
+            this._setupDataChannel();
+            
+            const offer = await this.peerConnection.createOffer();
+            await this.peerConnection.setLocalDescription(offer);
+            
+            this.signaling.sendMessage({
+                type: 'offer',
+                targetPeerId: this.peerId,
+                sdp: offer.toJSON()
+            });
+        }
+    }
+
+    async handleOffer(sdp) {
+        await this.peerConnection.setRemoteDescription(new wrtc.RTCSessionDescription(sdp));
+        
+        const answer = await this.peerConnection.createAnswer();
+        await this.peerConnection.setLocalDescription(answer);
+        
+        this.signaling.sendMessage({
+            type: 'answer',
+            targetPeerId: this.peerId,
+            sdp: answer.toJSON()
+        });
+    }
+
+    async handleAnswer(sdp) {
+        await this.peerConnection.setRemoteDescription(new wrtc.RTCSessionDescription(sdp));
+    }
+
+    async handleIceCandidate(candidate) {
+        try {
+            await this.peerConnection.addIceCandidate(new wrtc.RTCIceCandidate(candidate));
+        } catch (error) {
+            this.callbacks.error.forEach(cb => cb(error));
+        }
+    }
+
+    send(data) {
+        if (this.dataChannel && this.dataChannel.readyState === 'open') {
+            this.dataChannel.send(JSON.stringify(data));
+        }
+    }
+
+    close() {
+        if (this.dataChannel) {
+            this.dataChannel.close();
+        }
+        if (this.peerConnection) {
+            this.peerConnection.close();
+        }
+    }
+
+    on(event, callback) {
+        if (this.callbacks[event]) {
+            this.callbacks[event].push(callback);
+        }
+    }
+
+    off(event, callback) {
+        if (this.callbacks[event]) {
+            this.callbacks[event] = this.callbacks[event].filter(cb => cb !== callback);
+        }
+    }
+
+    _setupDataChannel() {
+        this.dataChannel.onopen = () => {
+            this.callbacks.connect.forEach(cb => cb());
+        };
+
+        this.dataChannel.onclose = () => {
+            this.callbacks.disconnect.forEach(cb => cb());
+        };
+
+        this.dataChannel.onmessage = (event) => {
+            try {
+                const data = JSON.parse(event.data);
+                this.callbacks.message.forEach(cb => cb(data));
+            } catch (error) {
+                this.callbacks.message.forEach(cb => cb(event.data));
+            }
+        };
+
+        this.dataChannel.onerror = (error) => {
+            this.callbacks.error.forEach(cb => cb(error));
+        };
+    }
+}
+
+module.exports = Peer;

package/lib/signaling.js

@@ -0,0 +1,133 @@
+const fetch = require('node-fetch');
+const config = require('./config');
+
+class Signaling {
+    constructor(peerId) {
+        this.peerId = peerId;
+        this.room = null;
+        this.polling = false;
+        this.callbacks = {
+            message: [],
+            peerJoined: [],
+            peerLeft: []
+        };
+    }
+
+    async join(room) {
+        this.room = room;
+        const response = await this._post('/join', {
+            room: room,
+            peerId: this.peerId
+        });
+        return response;
+    }
+
+    async leave() {
+        if (!this.room) return;
+        await this._post('/leave', {
+            room: this.room,
+            peerId: this.peerId
+        });
+        this.room = null;
+        this.polling = false;
+    }
+
+    async sendMessage(message) {
+        if (!this.room) throw new Error('Not joined to any room');
+        
+        return await this._post('/message', {
+            room: this.room,
+            peerId: this.peerId,
+            message: message
+        });
+    }
+
+    async getRooms() {
+        const response = await this._get('/rooms');
+        return response;
+    }
+
+    startPolling() {
+        if (this.polling || !this.room) return;
+        this.polling = true;
+        this._poll();
+    }
+
+    stopPolling() {
+        this.polling = false;
+    }
+
+    on(event, callback) {
+        if (this.callbacks[event]) {
+            this.callbacks[event].push(callback);
+        }
+    }
+
+    off(event, callback) {
+        if (this.callbacks[event]) {
+            this.callbacks[event] = this.callbacks[event].filter(cb => cb !== callback);
+        }
+    }
+
+    async _poll() {
+        if (!this.polling || !this.room) return;
+
+        try {
+            const response = await this._get(`/poll?room=${encodeURIComponent(this.room)}&peerId=${encodeURIComponent(this.peerId)}&timeout=${config.pollTimeout}`);
+            
+            if (response && response.messages) {
+                for (const msg of response.messages) {
+                    this._handleMessage(msg);
+                }
+            }
+        } catch (error) {
+            console.log('Poll error:', error.message);
+        } finally {
+            if (this.polling) {
+                setTimeout(() => this._poll(), 1000);
+            }
+        }
+    }
+
+    _handleMessage(msg) {
+        switch (msg.type) {
+            case 'peerJoined':
+                this.callbacks.peerJoined.forEach(cb => cb(msg.peerId));
+                break;
+            case 'peerLeft':
+                this.callbacks.peerLeft.forEach(cb => cb(msg.peerId));
+                break;
+            default:
+                this.callbacks.message.forEach(cb => cb(msg));
+                break;
+        }
+    }
+
+    async _post(endpoint, data) {
+        try {
+            const response = await fetch(config.apiBaseUrl + endpoint, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json'
+                },
+                body: JSON.stringify(data)
+            });
+            return await response.json();
+        } catch (error) {
+            console.log('POST error:', error.message);
+            throw error;
+        }
+    }
+
+    async _get(endpoint) {
+        try {
+            const response = await fetch(config.apiBaseUrl + endpoint);
+            return await response.json();
+        } catch (error) {
+            console.log('GET error:', error.message);
+            throw error;
+        }
+    }
+}
+
+module.exports = Signaling;

package/package.json

@@ -0,0 +1,27 @@
+{
+    "name": "minep2p",
+    "version": "1.0.0",
+    "description": "MineP2P - A Node.js P2P connection library",
+    "main": "index.js",
+    "bin": {
+        "mp": "./cli.js"
+    },
+    "scripts": {
+        "start": "node cli.js start",
+        "test": "node test.js"
+    },
+    "keywords": ["p2p", "webrtc", "networking"],
+    "author": "andrew-china",
+    "license": "MIT",
+    "dependencies": {
+        "wrtc": "^0.4.7",
+        "node-fetch": "^3.3.2",
+        "uuid": "^9.0.1",
+        "yargs": "^17.7.2",
+        "chalk": "^5.3.0"
+    },
+    "publisher": {
+        "name": "Vexify",
+        "email": "support@vexify.top"
+    }
+}