yakmesh 1.0.0

package/README.md

@@ -0,0 +1,181 @@
+<![CDATA[<div align="center">
+  <img src="https://yakmesh.dev/assets/yakmesh-logo2.png" alt="Yakmesh" width="200">
+
+  # 🏔️ YAKMESH: Sturdy & Secure
+
+  **Yielding Atomic Kernel Modular Encryption Secured Hub**
+
+  [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+  [![Node.js](https://img.shields.io/badge/Node.js-18+-green.svg)](https://nodejs.org)
+  [![Post-Quantum](https://img.shields.io/badge/Crypto-Post--Quantum-blue.svg)](https://csrc.nist.gov/projects/post-quantum-cryptography)
+  [![npm version](https://img.shields.io/npm/v/yakmesh.svg)](https://www.npmjs.com/package/yakmesh)
+</div>
+
+---
+
+YAKMESH is a high-resiliency, decentralized networking layer designed for the 2026 threat landscape. Built with quantum-resistant cryptography at its core and anchored by PCIe atomic timing synchronization, YAKMESH provides a "sturdy" substrate for distributed systems that cannot afford to fail.
+
+## Why YAKMESH?
+
+In an era where traditional ECDSA is increasingly vulnerable and network jitter can desynchronize global state, YAKMESH offers a three-pillar solution:
+
+🌿 **Yielding Resilience**: A self-healing mesh topology that adapts to node failure and adversarial interference without central authority.
+
+⚛️ **Atomic Precision**: Integrated support for PCIe atomic clock hardware, enabling nanosecond-level hardware timestamping for low-latency synchronization.
+
+🔐 **Quantum Hardened**: Fully compatible with Project Zond and the QRL (Quantum Resistant Ledger) ecosystem, utilizing stateless lattice-based signatures (ML-DSA) from Genesis.
+
+---
+
+## The Y.A.K.M.E.S.H. Philosophy
+
+| Letter | Principle | Description |
+|--------|-----------|-------------|
+| **Y** | **Yielding** | Not brittle; flexible enough to absorb network shocks |
+| **A** | **Atomic** | Grounded in the absolute truth of physical time |
+| **K** | **Kernel** | The essential, innermost part of the secure stack |
+| **M** | **Modular** | Swap out encryption primitives or transport layers as tech evolves |
+| **E** | **Encryption** | Privacy and integrity by default |
+| **S** | **Secured** | Hardened against both classical and quantum vectors |
+| **H** | **Hub** | A nexus for decentralized data and peer-to-peer logic |
+
+---
+
+## Features
+
+- 🔒 **Post-Quantum Secure** - ML-DSA-65 (NIST FIPS 204) signatures
+- 🔮 **Self-Verifying Oracle** - Deterministic validation without external trust
+- 🌐 **Mesh Networking** - P2P WebSocket communication with gossip protocol
+- ⏱️ **Precision Timing** - Support for atomic clocks, GPS, PTP, NTP
+- 🔌 **Plugin Architecture** - Adapters for any database or API
+- 🛡️ **Phase Modulation** - Time-based anti-replay protection
+
+## Quick Start
+
+```bash
+npm install yakmesh
+```
+
+```javascript
+import { YakmeshNode } from 'yakmesh';
+
+const node = new YakmeshNode({
+  node: { name: 'My Node' },
+  network: { httpPort: 3000, wsPort: 9001 },
+});
+
+await node.start();
+```
+
+## CLI
+
+```bash
+# Initialize a new node
+npx yakmesh init
+
+# Start the node
+npx yakmesh start
+
+# Check status
+npx yakmesh status
+```
+
+## Documentation
+
+Full documentation available at **[yakmesh.dev](https://yakmesh.dev)**
+
+## Architecture
+
+```
+yakmesh/
+├── oracle/           # Self-verifying validation engine
+├── mesh/             # WebSocket P2P networking
+├── gossip/           # Epidemic-style message propagation
+├── identity/         # Post-quantum key management
+├── database/         # SQLite replication engine
+├── adapters/         # Platform integration plugins
+├── security/         # Pro authentication & encryption
+├── webserver/        # Embedded Caddy web server
+└── server/           # HTTP/WS server
+```
+
+## Network Identity
+
+Each YAKMESH network has a unique identity derived from configurable salts:
+
+```javascript
+import { setIdentityConfig } from 'yakmesh/oracle/network-identity.js';
+
+setIdentityConfig({
+  networkPrefix: 'my',           // Network ID prefix
+  identitySalt: 'my-app-v1',     // Unique network salt
+});
+
+// Different salt = different network (cannot interoperate)
+```
+
+## Time Source Trust Levels
+
+| Level | Source | Tolerance | Oracle Capable |
+|-------|--------|-----------|----------------|
+| ATOMIC | PCIe atomic clock | ±100ms | ✅ Yes |
+| GPS | GPS with PPS | ±500ms | ✅ Yes |
+| PTP | IEEE 1588 (Meinberg) | ±500ms | ⚠️ Partial |
+| NTP | Standard NTP | ±5000ms | ❌ No |
+
+## Adapters
+
+Create custom adapters by extending `BaseAdapter`:
+
+```javascript
+import { BaseAdapter } from 'yakmesh/adapters/base-adapter.js';
+
+class MyAdapter extends BaseAdapter {
+  async init() { /* Connect to your database */ }
+  getSchema() { return { tables: ['users', 'orders'] }; }
+  async fetchChanges(since) { /* Return changed records */ }
+  async applyChange(table, record, op) { /* Write to database */ }
+}
+```
+
+### Official Adapters
+
+- `@yakmesh/adapter-peerquanta` - PeerQuanta phpBB marketplace
+
+## API Endpoints
+
+| Endpoint | Method | Description |
+|----------|--------|-------------|
+| `/health` | GET | Node health status |
+| `/node` | GET | Node identity info |
+| `/peers` | GET | Connected peers |
+| `/oracle/status` | GET | Oracle integrity check |
+| `/network/identity` | GET | Network identity (hash obfuscated) |
+| `/time/status` | GET | Time source detection |
+| `/time/capabilities` | GET | Time oracle eligibility |
+| `/connect` | POST | Connect to a peer |
+
+## Pro Features
+
+YAKMESH Pro includes additional security features:
+
+- 🔐 **WebSocket Authentication** - Challenge-response auth with signatures
+- 🔒 **Message Encryption** - XChaCha20-Poly1305 encrypted messages
+- 📋 **Peer Allowlist/Blocklist** - Access control for private networks
+- 🛡️ **Connection Rate Limiting** - DDoS protection
+
+## License
+
+- **Community Edition**: MIT License
+- **Pro Edition**: Proprietary License
+
+---
+
+<div align="center">
+  <sub>Built with quantum principles. Secured by math.</sub>
+  <br><br>
+  <strong><a href="https://yakmesh.dev">yakmesh.dev</a></strong>
+  <br><br>
+  <sub>© 2026 YAKMESH Project. Sturdy & Secure.</sub>
+</div>
+]]>

package/adapters/base-adapter.js

@@ -0,0 +1,177 @@
+/**
+ * Yakmesh - Base Adapter Interface
+ * 
+ * All platform adapters must extend this class.
+ * Adapters bridge external data sources with the Yakmesh network.
+ * 
+ * @module adapters/base-adapter
+ * @version 1.0.0
+ */
+
+import { EventEmitter } from 'events';
+
+/**
+ * Abstract base class for Yakmesh adapters
+ * 
+ * Implement this to create integrations with:
+ * - phpBB forums (PeerQuanta)
+ * - WordPress/WooCommerce
+ * - Custom REST APIs
+ * - PostgreSQL databases
+ * - MongoDB collections
+ */
+export class BaseAdapter extends EventEmitter {
+  constructor(YakmeshNode, config = {}) {
+    super();
+    
+    if (new.target === BaseAdapter) {
+      throw new Error('BaseAdapter is abstract and cannot be instantiated directly');
+    }
+    
+    this.node = YakmeshNode;
+    this.config = config;
+    this.syncInterval = null;
+    this.isInitialized = false;
+    
+    // Statistics
+    this.stats = {
+      recordsProcessed: 0,
+      recordsValidated: 0,
+      recordsRejected: 0,
+      lastSyncTime: null,
+      errors: [],
+    };
+  }
+  
+  /**
+   * Initialize the adapter
+   * Must be implemented by subclasses
+   * @abstract
+   */
+  async init() {
+    throw new Error('init() must be implemented by subclass');
+  }
+  
+  /**
+   * Get the schema definition for replicated tables
+   * Must be implemented by subclasses
+   * @abstract
+   * @returns {Object} Schema definition
+   */
+  getSchema() {
+    throw new Error('getSchema() must be implemented by subclass');
+  }
+  
+  /**
+   * Fetch records that have changed since last sync
+   * Must be implemented by subclasses
+   * @abstract
+   * @param {Date} since - Timestamp of last sync
+   * @returns {Promise<Array>} Changed records
+   */
+  async fetchChanges(since) {
+    throw new Error('fetchChanges() must be implemented by subclass');
+  }
+  
+  /**
+   * Apply a record change from the mesh to the local database
+   * Must be implemented by subclasses
+   * @abstract
+   * @param {string} table - Table name
+   * @param {Object} record - Record data
+   * @param {string} operation - 'INSERT', 'UPDATE', 'DELETE'
+   */
+  async applyChange(table, record, operation) {
+    throw new Error('applyChange() must be implemented by subclass');
+  }
+  
+  /**
+   * Validate a record using custom rules
+   * Override to add platform-specific validation
+   * @param {string} type - Record type
+   * @param {Object} data - Record data
+   * @returns {Object} { valid: boolean, errors: string[] }
+   */
+  validate(type, data) {
+    return { valid: true, errors: [] };
+  }
+  
+  /**
+   * Start periodic synchronization
+   * @param {number} intervalMs - Sync interval in milliseconds
+   */
+  startSync(intervalMs = 60000) {
+    if (this.syncInterval) {
+      this.stopSync();
+    }
+    
+    console.log('Starting sync every ' + (intervalMs / 1000) + 's');
+    this.sync();
+    
+    this.syncInterval = setInterval(() => {
+      this.sync();
+    }, intervalMs);
+  }
+  
+  /**
+   * Stop periodic synchronization
+   */
+  stopSync() {
+    if (this.syncInterval) {
+      clearInterval(this.syncInterval);
+      this.syncInterval = null;
+    }
+  }
+  
+  /**
+   * Perform a sync cycle
+   */
+  async sync() {
+    try {
+      const changes = await this.fetchChanges(this.stats.lastSyncTime);
+      
+      for (const change of changes) {
+        const validation = this.validate(change.type, change.data);
+        
+        if (validation.valid) {
+          this.node.gossip.spreadRumor('adapter:' + change.type, {
+            table: change.table,
+            operation: change.operation,
+            data: change.data,
+          });
+          this.stats.recordsValidated++;
+        } else {
+          this.stats.recordsRejected++;
+          this.emit('validation-error', { change, errors: validation.errors });
+        }
+        this.stats.recordsProcessed++;
+      }
+      
+      this.stats.lastSyncTime = new Date();
+      this.emit('sync-complete', { processed: changes.length });
+      
+    } catch (error) {
+      this.stats.errors.push({ time: new Date(), error: error.message });
+      this.emit('sync-error', error);
+    }
+  }
+  
+  getStats() {
+    return {
+      ...this.stats,
+      isRunning: this.syncInterval !== null,
+      adapterType: this.constructor.name,
+    };
+  }
+  
+  async handleRumor(topic, data, origin) {
+    if (topic.startsWith('adapter:')) {
+      const { table, operation, data: recordData } = data;
+      await this.applyChange(table, recordData, operation);
+    }
+  }
+}
+
+export default BaseAdapter;
+
+

package/cli/index.js

@@ -0,0 +1,307 @@
+#!/usr/bin/env node
+
+/**
+ * Yakmesh CLI
+ * Command-line interface for managing Yakmesh nodes
+ */
+
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { existsSync, mkdirSync, writeFileSync, readFileSync } from 'fs';
+import { join, resolve } from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = fileURLToPath(new URL('.', import.meta.url));
+const VERSION = '0.1.0';
+
+const program = new Command();
+
+// Banner
+function showBanner() {
+  console.log(chalk.cyan(`
+  🦬 Yakmesh Network v${VERSION}
+  Post-Quantum Secure • Decentralized • Federated
+  `));
+}
+
+// ===== INIT COMMAND =====
+program
+  .command('init')
+  .description('Initialize a new Yakmesh Node in the current directory')
+  .option('-n, --name <name>', 'Node name', 'My Yakmesh Node')
+  .option('-r, --region <region>', 'Geographic region', 'local')
+  .option('-p, --port <port>', 'HTTP port', '3000')
+  .option('-w, --ws-port <port>', 'WebSocket port', '9001')
+  .option('--bootstrap <urls>', 'Comma-separated bootstrap node URLs')
+  .action(async (options) => {
+    showBanner();
+    console.log(chalk.yellow('Initializing new Yakmesh Node...\n'));
+
+    const dataDir = resolve('./data');
+    const configPath = resolve('./yakmesh.config.js');
+
+    // Check if already initialized
+    if (existsSync(configPath)) {
+      console.log(chalk.red('✗ Error: yakmesh.config.js already exists'));
+      console.log(chalk.gray('  Use --force to reinitialize'));
+      process.exit(1);
+    }
+
+    // Create data directory
+    if (!existsSync(dataDir)) {
+      mkdirSync(dataDir, { recursive: true });
+      console.log(chalk.green('✓ Created data directory'));
+    }
+
+    // Parse bootstrap nodes
+    const bootstrapNodes = options.bootstrap 
+      ? options.bootstrap.split(',').map(s => s.trim())
+      : ['wss://peerquanta.com:9001'];
+
+    // Generate config
+    const config = `/**
+ * Yakmesh Node Configuration
+ * Generated by: npx yakmesh init
+ */
+export default {
+  // Node identity
+  node: {
+    name: '${options.name}',
+    region: '${options.region}',
+    capabilities: ['listings', 'chat', 'forum', 'qcoa'],
+  },
+  
+  // Network settings
+  network: {
+    httpPort: ${options.port},
+    wsPort: ${options.wsPort},
+    publicHost: 'localhost',
+  },
+  
+  // Bootstrap nodes (well-known entry points)
+  bootstrap: ${JSON.stringify(bootstrapNodes, null, 4).replace(/\n/g, '\n  ')},
+  
+  // Database
+  database: {
+    path: './data/peerquanta.db',
+    replication: {
+      enabled: true,
+      syncInterval: 30000,  // 30 seconds
+    },
+  },
+  
+  // Security
+  security: {
+    maxPeers: 50,
+    requireAuth: false,
+  },
+};
+`;
+
+    writeFileSync(configPath, config);
+    console.log(chalk.green('✓ Created yakmesh.config.js'));
+
+    console.log(chalk.cyan('\n📋 Node Configuration:'));
+    console.log(chalk.gray(`   Name:       ${options.name}`));
+    console.log(chalk.gray(`   Region:     ${options.region}`));
+    console.log(chalk.gray(`   HTTP Port:  ${options.port}`));
+    console.log(chalk.gray(`   WS Port:    ${options.wsPort}`));
+    console.log(chalk.gray(`   Bootstrap:  ${bootstrapNodes.length} node(s)`));
+
+    console.log(chalk.green('\n✓ Initialization complete!\n'));
+    console.log(chalk.white('Next steps:'));
+    console.log(chalk.gray('  1. Edit yakmesh.config.js to customize settings'));
+    console.log(chalk.gray('  2. Run: npx yakmesh start'));
+    console.log('');
+  });
+
+// ===== START COMMAND =====
+program
+  .command('start')
+  .description('Start the Yakmesh Node')
+  .option('-c, --config <path>', 'Path to config file', './yakmesh.config.js')
+  .option('-d, --daemon', 'Run as background daemon')
+  .action(async (options) => {
+    showBanner();
+    
+    const configPath = resolve(options.config);
+    
+    if (!existsSync(configPath)) {
+      console.log(chalk.red('✗ Error: yakmesh.config.js not found'));
+      console.log(chalk.gray('  Run: npx yakmesh init'));
+      process.exit(1);
+    }
+
+    console.log(chalk.yellow('Starting Yakmesh Node...\n'));
+
+    // Dynamic import of server - use the package's server module
+    const serverPath = join(__dirname, '..', 'server', 'index.js');
+    const serverURL = new URL(`file:///${serverPath.replace(/\\/g, '/')}`);
+    const { YakmeshNode } = await import(serverURL.href);
+    
+    // Load config from current working directory
+    const configURL = new URL(`file:///${configPath.replace(/\\/g, '/')}`);
+    const { default: config } = await import(configURL.href);
+
+    const node = new YakmeshNode(config);
+
+    // Handle shutdown
+    process.on('SIGINT', async () => {
+      console.log(chalk.yellow('\n\nShutting down...'));
+      await node.stop();
+      process.exit(0);
+    });
+
+    process.on('SIGTERM', async () => {
+      await node.stop();
+      process.exit(0);
+    });
+
+    await node.start();
+  });
+
+// ===== STATUS COMMAND =====
+program
+  .command('status')
+  .description('Show node status')
+  .option('-p, --port <port>', 'HTTP port of local node', '3000')
+  .action(async (options) => {
+    try {
+      const response = await fetch(`http://localhost:${options.port}/health`);
+      const data = await response.json();
+
+      showBanner();
+      console.log(chalk.green('✓ Node is running\n'));
+      console.log(chalk.cyan('📊 Status:'));
+      console.log(chalk.gray(`   Node ID:    ${data.nodeId}`));
+      console.log(chalk.gray(`   Peers:      ${data.peers}`));
+      console.log(chalk.gray(`   Algorithm:  ${data.algorithm}`));
+      console.log('');
+    } catch (e) {
+      console.log(chalk.red('✗ Node is not running'));
+      console.log(chalk.gray(`  Could not connect to http://localhost:${options.port}`));
+      process.exit(1);
+    }
+  });
+
+// ===== PEERS COMMAND =====
+program
+  .command('peers')
+  .description('List connected peers')
+  .option('-p, --port <port>', 'HTTP port of local node', '3000')
+  .action(async (options) => {
+    try {
+      const response = await fetch(`http://localhost:${options.port}/peers`);
+      const peers = await response.json();
+
+      showBanner();
+      
+      if (peers.length === 0) {
+        console.log(chalk.yellow('No peers connected\n'));
+        return;
+      }
+
+      console.log(chalk.cyan(`📡 Connected Peers (${peers.length}):\n`));
+      
+      for (const peer of peers) {
+        const ago = Math.floor((Date.now() - peer.lastSeen) / 1000);
+        console.log(chalk.white(`  ${peer.name}`));
+        console.log(chalk.gray(`    ID:        ${peer.nodeId.slice(0, 24)}...`));
+        console.log(chalk.gray(`    Endpoint:  ${peer.endpoint || 'inbound'}`));
+        console.log(chalk.gray(`    Last seen: ${ago}s ago`));
+        console.log('');
+      }
+    } catch (e) {
+      console.log(chalk.red('✗ Could not fetch peers'));
+      console.log(chalk.gray(`  Is the node running on port ${options.port}?`));
+      process.exit(1);
+    }
+  });
+
+// ===== INFO COMMAND =====
+program
+  .command('info')
+  .description('Show detailed node information')
+  .option('-p, --port <port>', 'HTTP port of local node', '3000')
+  .action(async (options) => {
+    try {
+      const [nodeRes, replRes] = await Promise.all([
+        fetch(`http://localhost:${options.port}/node`),
+        fetch(`http://localhost:${options.port}/replication`),
+      ]);
+      
+      const node = await nodeRes.json();
+      const repl = await replRes.json();
+
+      showBanner();
+      console.log(chalk.cyan('🦬 Node Information:\n'));
+      
+      console.log(chalk.white('  Identity:'));
+      console.log(chalk.gray(`    Node ID:      ${node.nodeId}`));
+      console.log(chalk.gray(`    Name:         ${node.name}`));
+      console.log(chalk.gray(`    Region:       ${node.region}`));
+      console.log(chalk.gray(`    Algorithm:    ${node.algorithm} (NIST Level ${node.nistLevel})`));
+      console.log(chalk.gray(`    Created:      ${new Date(node.createdAt).toISOString()}`));
+      
+      console.log(chalk.white('\n  Capabilities:'));
+      for (const cap of node.capabilities) {
+        console.log(chalk.gray(`    • ${cap}`));
+      }
+      
+      console.log(chalk.white('\n  Replication:'));
+      console.log(chalk.gray(`    Log entries:  ${repl.replicationLogSize}`));
+      console.log(chalk.gray(`    Peer states:  ${repl.peerStates.length}`));
+      console.log(chalk.gray(`    Tables:       ${repl.replicatedTables.join(', ')}`));
+      
+      console.log(chalk.white('\n  Public Key (ML-DSA-65):'));
+      console.log(chalk.gray(`    ${node.publicKey.slice(0, 64)}...`));
+      console.log('');
+    } catch (e) {
+      console.log(chalk.red('✗ Could not fetch node info'));
+      process.exit(1);
+    }
+  });
+
+// ===== JOIN COMMAND =====
+program
+  .command('join <endpoint>')
+  .description('Connect to a peer node')
+  .option('-p, --port <port>', 'HTTP port of local node', '3000')
+  .action(async (endpoint, options) => {
+    try {
+      const response = await fetch(`http://localhost:${options.port}/connect`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ endpoint }),
+      });
+      
+      const result = await response.json();
+      
+      if (result.success) {
+        console.log(chalk.green(`✓ Connected to ${endpoint}`));
+      } else {
+        console.log(chalk.red(`✗ Failed to connect: ${result.error}`));
+      }
+    } catch (e) {
+      console.log(chalk.red('✗ Could not connect'));
+      console.log(chalk.gray(`  ${e.message}`));
+      process.exit(1);
+    }
+  });
+
+// ===== VERSION =====
+program
+  .version(VERSION)
+  .description('Yakmesh Network - Post-Quantum Decentralized Node');
+
+// Parse arguments
+program.parse();
+
+// Show help if no command
+if (!process.argv.slice(2).length) {
+  showBanner();
+  program.outputHelp();
+}
+
+
+