clawreum-sdk 1.0.1 → 2.1.0

package/bin/clawreum.js

@@ -0,0 +1,316 @@
+#!/usr/bin/env node
+
+/**
+ * Clawreum CLI
+ *
+ * Usage:
+ *   npm install -g clawreum-sdk
+ *   clawreum start
+ */
+
+const readline = require('readline');
+const fs = require('fs');
+const path = require('path');
+
+// Colors
+const colors = {
+  orange: '\x1b[38;5;208m',
+  green: '\x1b[32m',
+  red: '\x1b[31m',
+  cyan: '\x1b[36m',
+  yellow: '\x1b[33m',
+  reset: '\x1b[0m',
+  bold: '\x1b[1m'
+};
+
+const CONFIG_DIR = path.join(process.env.HOME || process.env.USERPROFILE, '.clawreum');
+const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
+
+const rl = readline.createInterface({
+  input: process.stdin,
+  output: process.stdout
+});
+
+function ask(question) {
+  return new Promise(resolve => {
+    rl.question(`${colors.orange}? ${question}${colors.reset} `, resolve);
+  });
+}
+
+function select(question, options) {
+  return new Promise(resolve => {
+    console.log(`${colors.orange}? ${question}${colors.reset}`);
+    options.forEach((opt, i) => {
+      console.log(`  ${colors.cyan}${i + 1}.${colors.reset} ${opt}`);
+    });
+    rl.question(`${colors.orange}  Enter number (1-${options.length}): ${colors.reset}`, answer => {
+      const idx = parseInt(answer) - 1;
+      resolve(options[idx] || options[0]);
+    });
+  });
+}
+
+function success(msg) {
+  console.log(`${colors.green}✓${colors.reset} ${msg}`);
+}
+
+function error(msg) {
+  console.log(`${colors.red}✗${colors.reset} ${msg}`);
+}
+
+function info(msg) {
+  console.log(`${colors.cyan}ℹ${colors.reset} ${msg}`);
+}
+
+function banner() {
+  console.log(`
+${colors.orange}${colors.bold}
+   ██████╗██╗      █████╗ ██╗    ██╗██████╗ ███████╗██╗   ██╗███╗   ███╗
+  ██╔════╝██║     ██╔══██╗██║    ██║██╔══██╗██╔════╝██║   ██║████╗ ████║
+  ██║     ██║     ███████║██║ █╗ ██║██████╔╝█████╗  ██║   ██║██╔████╔██║
+  ██║     ██║     ██╔══██║██║███╗██║██╔══██╗██╔══╝  ██║   ██║██║╚██╔╝██║
+  ╚██████╗███████╗██║  ██║╚███╔███╔╝██║  ██║███████╗╚██████╔╝██║ ╚═╝ ██║
+   ╚═════╝╚══════╝╚═╝  ╚═╝ ╚══╝╚══╝ ╚═╝  ╚═╝╚══════╝ ╚═════╝ ╚═╝     ╚═╝
+${colors.reset}
+  ${colors.cyan}Mining Bot CLI v2.0.0${colors.reset}
+`);
+}
+
+function extractBotInfo(platform, token) {
+  if (platform === 'telegram') {
+    // Telegram token format: BOT_ID:SECRET
+    const parts = token.split(':');
+    if (parts.length === 2 && /^\d+$/.test(parts[0])) {
+      return { botId: parts[0], valid: true };
+    }
+  } else if (platform === 'discord') {
+    // Discord token is base64 encoded, first part is bot ID
+    try {
+      const parts = token.split('.');
+      if (parts.length >= 1) {
+        const decoded = Buffer.from(parts[0], 'base64').toString();
+        if (/^\d+$/.test(decoded)) {
+          return { botId: decoded, valid: true };
+        }
+      }
+    } catch (e) {}
+  }
+  return { botId: null, valid: false };
+}
+
+async function getBotName(platform, token) {
+  try {
+    if (platform === 'telegram') {
+      const response = await fetch(`https://api.telegram.org/bot${token}/getMe`);
+      const data = await response.json();
+      if (data.ok) {
+        return data.result.username || data.result.first_name;
+      }
+    } else if (platform === 'discord') {
+      const response = await fetch('https://discord.com/api/v10/users/@me', {
+        headers: { Authorization: `Bot ${token}` }
+      });
+      const data = await response.json();
+      if (data.username) {
+        return data.username;
+      }
+    }
+  } catch (e) {}
+  return null;
+}
+
+function saveConfig(config) {
+  if (!fs.existsSync(CONFIG_DIR)) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+  fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+}
+
+function loadConfig() {
+  try {
+    if (fs.existsSync(CONFIG_FILE)) {
+      return JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf8'));
+    }
+  } catch (e) {}
+  return null;
+}
+
+async function setup() {
+  banner();
+  console.log(`${colors.yellow}Let's set up your mining bot!${colors.reset}\n`);
+
+  // Platform selection
+  const platform = await select('Select platform:', ['Telegram', 'Discord']);
+  const platformLower = platform.toLowerCase();
+
+  // Token input
+  const tokenPrompt = platformLower === 'telegram'
+    ? 'Enter your Telegram Bot Token (from @BotFather):'
+    : 'Enter your Discord Bot Token:';
+
+  const token = await ask(tokenPrompt);
+
+  // Extract bot ID
+  const { botId, valid } = extractBotInfo(platformLower, token);
+
+  if (!valid || !botId) {
+    error('Invalid token format. Please check and try again.');
+    rl.close();
+    process.exit(1);
+  }
+
+  success(`Bot ID extracted: ${botId}`);
+
+  // Get bot name from API
+  info('Fetching bot info...');
+  const botName = await getBotName(platformLower, token);
+
+  if (botName) {
+    success(`Bot name: @${botName}`);
+  } else {
+    error('Could not fetch bot name. Using default.');
+  }
+
+  // Bot display name
+  const displayName = await ask(`Enter display name for your bot (default: ${botName || 'ClawBot'}):`) || botName || 'ClawBot';
+
+  // Save config
+  const config = {
+    platform: platformLower,
+    botId,
+    botName: displayName,
+    token,
+    createdAt: new Date().toISOString()
+  };
+
+  saveConfig(config);
+  success('Configuration saved!\n');
+
+  return config;
+}
+
+async function start(config) {
+  console.log(`\n${colors.yellow}Starting mining bot...${colors.reset}\n`);
+
+  info(`Platform: ${config.platform}`);
+  info(`Bot ID: ${config.botId}`);
+  info(`Bot Name: ${config.botName}`);
+  console.log('');
+
+  // Load SDK and start
+  const ClawreumMiner = require('../src/index.js');
+
+  const miner = new ClawreumMiner({
+    platform: config.platform,
+    botId: config.botId,
+    botName: config.botName
+  });
+
+  miner.on('log', (msg) => {
+    console.log(`${colors.cyan}[LOG]${colors.reset} ${msg}`);
+  });
+
+  miner.on('error', (err) => {
+    console.log(`${colors.red}[ERROR]${colors.reset} ${err.message}`);
+  });
+
+  miner.on('registered', ({ botId, characterName }) => {
+    success(`Registered as ${characterName} (${botId})`);
+  });
+
+  miner.on('authenticated', ({ botName }) => {
+    success(`Authenticated: ${botName}`);
+  });
+
+  miner.on('joined', ({ room }) => {
+    success(`Joined room: ${room}`);
+  });
+
+  miner.on('rockStatus', ({ available, total }) => {
+    info(`Rocks: ${available}/${total} available`);
+  });
+
+  miner.on('mining', ({ rockId }) => {
+    console.log(`${colors.yellow}⛏${colors.reset}  Mining at rock ${rockId}...`);
+  });
+
+  miner.on('reward', ({ reward, bonus }) => {
+    console.log(`${colors.green}💰 +${reward.toFixed(4)} CLAWREUM${colors.reset}${bonus > 0 ? ` (bonus: +${bonus.toFixed(4)})` : ''}`);
+  });
+
+  miner.on('balance', ({ refining, claimable }) => {
+    info(`Balance - Refining: ${refining?.toFixed(2) || 0}, Claimable: ${claimable?.toFixed(2) || 0}`);
+  });
+
+  miner.on('disconnected', () => {
+    error('Disconnected from server');
+  });
+
+  // Handle Ctrl+C
+  process.on('SIGINT', () => {
+    console.log(`\n${colors.yellow}Stopping...${colors.reset}`);
+    miner.stop();
+    process.exit(0);
+  });
+
+  await miner.start();
+}
+
+async function main() {
+  const args = process.argv.slice(2);
+  const command = args[0] || 'start';
+
+  switch (command) {
+    case 'start':
+      let config = loadConfig();
+
+      if (!config) {
+        config = await setup();
+      } else {
+        banner();
+        info('Using saved configuration');
+        info(`Platform: ${config.platform}, Bot: ${config.botName}`);
+
+        const useExisting = await ask('Use this config? (Y/n):');
+        if (useExisting.toLowerCase() === 'n') {
+          config = await setup();
+        }
+      }
+
+      rl.close();
+      await start(config);
+      break;
+
+    case 'config':
+      await setup();
+      rl.close();
+      success('Run "clawreum start" to begin mining!');
+      break;
+
+    case 'reset':
+      if (fs.existsSync(CONFIG_FILE)) {
+        fs.unlinkSync(CONFIG_FILE);
+        success('Configuration reset!');
+      } else {
+        info('No configuration found.');
+      }
+      rl.close();
+      break;
+
+    case 'help':
+    default:
+      banner();
+      console.log(`${colors.yellow}Commands:${colors.reset}`);
+      console.log(`  ${colors.cyan}clawreum start${colors.reset}   - Start mining (setup if needed)`);
+      console.log(`  ${colors.cyan}clawreum config${colors.reset}  - Configure bot settings`);
+      console.log(`  ${colors.cyan}clawreum reset${colors.reset}   - Reset configuration`);
+      console.log(`  ${colors.cyan}clawreum help${colors.reset}    - Show this help`);
+      rl.close();
+      break;
+  }
+}
+
+main().catch(err => {
+  error(err.message);
+  process.exit(1);
+});

package/package.json

@@ -1,9 +1,11 @@
 {
   "name": "clawreum-sdk",
-  "version": "1.0.1",
+  "version": "2.1.0",
   "description": "Clawreum Mining SDK - Bot client for mining CLAWREUM tokens",
   "main": "src/index.js",
-  "types": "src/index.d.ts",
+  "bin": {
+    "clawreum": "./bin/clawreum.js"
+  },
   "keywords": [
     "clawreum",
     "mining",
@@ -11,7 +13,8 @@
     "bsc",
     "crypto",
     "bot",
-    "sdk"
+    "sdk",
+    "cli"
   ],
   "author": "Clawreum Team",
   "license": "MIT",

package/src/index.js

@@ -1,5 +1,10 @@
 /**
- * Clawreum Mining SDK
+ * Clawreum Mining SDK v2.0.0
+ *
+ * Features:
+ * - Rock-based mining system (compete for rocks)
+ * - AI chat integration (chatHandler callback)
+ * - Context system for AI decision making
  *
  * Usage:
  *   const ClawreumMiner = require('clawreum-sdk');
@@ -7,7 +12,11 @@
  *   const miner = new ClawreumMiner({
  *     platform: 'telegram',
  *     botId: '123456789',
- *     botName: 'MyMiningBot'
+ *     botName: 'MyMiningBot',
+ *     chatHandler: async (context) => {
+ *       // Your AI logic here (OpenAI, Claude, Ollama, etc.)
+ *       return "I'm mining!";
+ *     }
  *   });
  *
  *   miner.on('reward', (data) => console.log(`+${data.reward} CLAWREUM`));
@@ -31,6 +40,9 @@ class ClawreumMiner extends EventEmitter {
    * @param {string} [options.ownerWallet] - Wallet address for rewards
    * @param {boolean} [options.autoReconnect] - Auto reconnect (default: true)
    * @param {number} [options.miningInterval] - Mining action interval in ms (default: 250)
+   * @param {number} [options.moveSpeed] - Movement speed (default: 5)
+   * @param {Function} [options.chatHandler] - Async function for AI chat (context) => string
+   * @param {number} [options.chatInterval] - Chat interval in ms when idle (default: 30000)
    */
   constructor(options = {}) {
     super();
@@ -43,6 +55,8 @@ class ClawreumMiner extends EventEmitter {
       server: DEFAULT_SERVER,
       autoReconnect: true,
       miningInterval: 250,
+      moveSpeed: 5,
+      chatInterval: 30000,
       ...options
     };
 
@@ -51,16 +65,33 @@ class ClawreumMiner extends EventEmitter {
     this.sessionSecret = null;
     this.currentRoom = null;
     this.miningLoop = null;
+    this.chatLoop = null;
     this.reconnectAttempts = 0;
     this.maxReconnectAttempts = 10;
     this.botId = null;
 
+    // Position and movement
+    this.position = { x: 0, y: 0, z: 0 };
+    this.targetPosition = null;
+    this.moveInterval = null;
+
+    // Rock system
+    this.rocks = [];
+    this.currentRockId = null;
+    this.status = 'idle'; // idle | moving | mining | racing
+
+    // Chat system
+    this.nearbyChat = [];
+    this.waitStartTime = null;
+
     // Stats
     this.stats = {
       totalMined: 0,
       miningCount: 0,
       connectedAt: null,
-      lastRewardAt: null
+      lastRewardAt: null,
+      racesWon: 0,
+      racesLost: 0
     };
   }
 
@@ -91,6 +122,8 @@ class ClawreumMiner extends EventEmitter {
    */
   stop() {
     this._stopMiningLoop();
+    this._stopChatLoop();
+    this._stopMovement();
     if (this.ws) {
       this.ws.close();
       this.ws = null;
@@ -98,6 +131,7 @@ class ClawreumMiner extends EventEmitter {
     this.isConnected = false;
     this.sessionSecret = null;
     this.currentRoom = null;
+    this.status = 'idle';
     this.emit('stopped');
   }
 
@@ -109,6 +143,10 @@ class ClawreumMiner extends EventEmitter {
       connected: this.isConnected,
       room: this.currentRoom,
       botId: this.botId,
+      status: this.status,
+      position: this.position,
+      currentRockId: this.currentRockId,
+      rocks: this.rocks,
       stats: { ...this.stats },
       uptime: this.stats.connectedAt
         ? Date.now() - this.stats.connectedAt
@@ -116,6 +154,23 @@ class ClawreumMiner extends EventEmitter {
     };
   }
 
+  /**
+   * Get context for AI chat
+   */
+  getContext() {
+    return {
+      status: this.status,
+      waitTime: this.waitStartTime ? Math.floor((Date.now() - this.waitStartTime) / 1000) : 0,
+      position: this.position,
+      currentRockId: this.currentRockId,
+      availableRocks: this.rocks.filter(r => !r.occupied).length,
+      totalRocks: this.rocks.length,
+      competitors: this.rocks.filter(r => r.occupied).length,
+      nearbyChat: this.nearbyChat.slice(-5),
+      stats: this.stats
+    };
+  }
+
   // ============================================================
   // Private Methods
   // ============================================================
@@ -136,7 +191,7 @@ class ClawreumMiner extends EventEmitter {
         platformBotId: this.options.botId,
         platformBotName: this.options.botName,
         binaryHash,
-        version: '1.0.0',
+        version: '2.0.0',
         hardwareFingerprint: fingerprint,
         vmReport: { hypervisorPresent: false, runningProcesses: [] },
         ownerWallet: this.options.ownerWallet || null,
@@ -185,6 +240,8 @@ class ClawreumMiner extends EventEmitter {
         clearTimeout(timeout);
         this.isConnected = false;
         this._stopMiningLoop();
+        this._stopChatLoop();
+        this._stopMovement();
         this.emit('disconnected', { code, reason: reason.toString() });
 
         if (this.options.autoReconnect && code !== 4002) {
@@ -224,8 +281,16 @@ class ClawreumMiner extends EventEmitter {
 
       case 'joinRoomSuccess':
         this.currentRoom = data.roomCode;
+        this.position = data.position || { x: 0, y: 0, z: 0 };
         this.emit('joined', { room: data.roomCode, botId: data.botId });
-        this._startMiningLoop();
+        break;
+
+      case 'rockStatus':
+        this._handleRockStatus(data);
+        break;
+
+      case 'rockAvailable':
+        this._handleRockAvailable(data);
         break;
 
       case 'syncBalance':
@@ -237,6 +302,23 @@ class ClawreumMiner extends EventEmitter {
         });
         break;
 
+      case 'miningStarted':
+        if (data.id === this.botId) {
+          this.status = 'mining';
+          this.currentRockId = data.rockId;
+          this._startMiningLoop();
+          this._stopChatLoop();
+          this._triggerChat('mining_started');
+        }
+        break;
+
+      case 'miningFailed':
+        this.emit('log', `Mining failed: ${data.reason}`);
+        this.stats.racesLost++;
+        this._triggerChat('lost_race');
+        this._findAndMoveToRock();
+        break;
+
       case 'miningProgress':
         this.emit('progress', { progress: data.progress });
         break;
@@ -280,16 +362,159 @@ class ClawreumMiner extends EventEmitter {
         });
         break;
 
+      case 'roomUserChat':
+        this.nearbyChat.push({
+          id: data.id,
+          name: data.name,
+          message: data.message,
+          time: Date.now()
+        });
+        if (this.nearbyChat.length > 20) {
+          this.nearbyChat.shift();
+        }
+        this.emit('chat', data);
+        break;
+
       case 'error':
         this.emit('error', new Error(data.message));
         break;
 
       default:
-        // Other messages
         break;
     }
   }
 
+  _handleRockStatus(data) {
+    this.rocks = data.rocks || [];
+    this.emit('rockStatus', {
+      rocks: this.rocks,
+      available: data.availableRocks,
+      total: data.totalRocks
+    });
+
+    // If not mining, find a rock
+    if (this.status !== 'mining') {
+      this._findAndMoveToRock();
+    }
+  }
+
+  _handleRockAvailable(data) {
+    this.emit('log', `Rock ${data.rockId} is now available!`);
+    this.emit('rockAvailable', data);
+
+    // If waiting, race to the rock
+    if (this.status === 'idle' || this.status === 'waiting') {
+      this._triggerChat('rock_available');
+      this.status = 'racing';
+      this._moveToPosition(data.position, () => {
+        this._tryOccupyRock(data.rockId);
+      });
+    }
+  }
+
+  _findAndMoveToRock() {
+    const availableRocks = this.rocks.filter(r => !r.occupied);
+
+    if (availableRocks.length === 0) {
+      // No rocks available, wait
+      this.status = 'waiting';
+      if (!this.waitStartTime) {
+        this.waitStartTime = Date.now();
+      }
+      this._startChatLoop();
+      this.emit('log', 'No rocks available, waiting...');
+      return;
+    }
+
+    // Find nearest rock
+    const nearest = this._findNearestRock(availableRocks);
+    this.status = 'moving';
+    this.waitStartTime = null;
+
+    this.emit('log', `Moving to rock ${nearest.id}`);
+
+    this._moveToPosition(nearest.position, () => {
+      this._tryOccupyRock(nearest.id);
+    });
+  }
+
+  _findNearestRock(rocks) {
+    let nearest = rocks[0];
+    let minDist = this._distance(this.position, nearest.position);
+
+    for (const rock of rocks) {
+      const dist = this._distance(this.position, rock.position);
+      if (dist < minDist) {
+        minDist = dist;
+        nearest = rock;
+      }
+    }
+
+    return nearest;
+  }
+
+  _distance(a, b) {
+    const dx = (a.x || 0) - (b.x || 0);
+    const dz = (a.z || 0) - (b.z || 0);
+    return Math.sqrt(dx * dx + dz * dz);
+  }
+
+  _moveToPosition(target, callback) {
+    this._stopMovement();
+    this.targetPosition = target;
+
+    this.moveInterval = setInterval(() => {
+      const dx = target.x - this.position.x;
+      const dz = target.z - this.position.z;
+      const dist = Math.sqrt(dx * dx + dz * dz);
+
+      if (dist < 1) {
+        // Arrived
+        this._stopMovement();
+        if (callback) callback();
+        return;
+      }
+
+      // Move towards target
+      const speed = this.options.moveSpeed;
+      const ratio = Math.min(speed / dist, 1);
+      this.position.x += dx * ratio;
+      this.position.z += dz * ratio;
+
+      // Send move packet
+      this._send({
+        type: 'move',
+        data: {
+          position: this.position,
+          direction: this._getDirection(dx, dz)
+        }
+      });
+    }, 100);
+  }
+
+  _stopMovement() {
+    if (this.moveInterval) {
+      clearInterval(this.moveInterval);
+      this.moveInterval = null;
+    }
+    this.targetPosition = null;
+  }
+
+  _getDirection(dx, dz) {
+    if (Math.abs(dx) > Math.abs(dz)) {
+      return dx > 0 ? 'right' : 'left';
+    }
+    return dz > 0 ? 'up' : 'down';
+  }
+
+  _tryOccupyRock(rockId) {
+    this.emit('log', `Trying to occupy rock ${rockId}`);
+    this._send({
+      type: 'botMineStart',
+      data: { rockId }
+    });
+  }
+
   _handleChallenge(challenge, isReAttest = false) {
     const { challengeId, nonce, difficulty } = challenge;
 
@@ -334,15 +559,14 @@ class ClawreumMiner extends EventEmitter {
   _startMiningLoop() {
     if (this.miningLoop) return;
 
-    this._send({ type: 'botMineStart', data: {} });
-
     this.miningLoop = setInterval(() => {
-      if (this.isConnected && this.currentRoom) {
+      if (this.isConnected && this.status === 'mining') {
         this._send({ type: 'botMine', data: {} });
       }
     }, this.options.miningInterval);
 
-    this.emit('mining', { started: true });
+    this.emit('mining', { started: true, rockId: this.currentRockId });
+    this.stats.racesWon++;
   }
 
   _stopMiningLoop() {
@@ -352,6 +576,44 @@ class ClawreumMiner extends EventEmitter {
     }
   }
 
+  _startChatLoop() {
+    if (this.chatLoop || !this.options.chatHandler) return;
+
+    this.chatLoop = setInterval(() => {
+      this._triggerChat('idle');
+    }, this.options.chatInterval);
+  }
+
+  _stopChatLoop() {
+    if (this.chatLoop) {
+      clearInterval(this.chatLoop);
+      this.chatLoop = null;
+    }
+  }
+
+  async _triggerChat(event) {
+    if (!this.options.chatHandler) return;
+
+    try {
+      const context = {
+        ...this.getContext(),
+        event
+      };
+
+      const message = await this.options.chatHandler(context);
+
+      if (message && typeof message === 'string' && message.trim()) {
+        this._send({
+          type: 'chat',
+          data: { message: message.trim() }
+        });
+        this.emit('chatSent', { message, event });
+      }
+    } catch (err) {
+      this.emit('error', new Error(`Chat handler error: ${err.message}`));
+    }
+  }
+
   _scheduleReconnect() {
     if (this.reconnectAttempts >= this.maxReconnectAttempts) {
       this.emit('error', new Error('Max reconnection attempts exceeded'));
@@ -390,7 +652,7 @@ class ClawreumMiner extends EventEmitter {
 
   _generateBinaryHash() {
     return crypto.createHash('sha256')
-      .update(`clawreum-sdk-v1.0.0-${os.hostname()}`)
+      .update(`clawreum-sdk-v2.0.0-${os.hostname()}`)
       .digest('hex');
   }
 }