dankgrinder 1.0.0

package/README.md

@@ -0,0 +1,47 @@
+# DankGrinder CLI
+
+Dank Memer automation engine — grind coins while you sleep.
+
+## Installation & Usage
+
+```bash
+# Run directly (no install needed)
+npx dankgrinder --key dkg_your_api_key
+
+# Or install globally
+npm install -g dankgrinder
+dankgrinder --key dkg_your_api_key
+```
+
+## Options
+
+| Flag | Description | Default |
+|------|-------------|---------|
+| `--key <key>` | Your DankGrinder API key (required) | — |
+| `--url <url>` | API server URL | `http://localhost:3000` |
+| `--help` | Show help | — |
+| `--version` | Show version | — |
+
+## Setup
+
+1. Sign up at your DankGrinder dashboard
+2. Go to **Config** → set your Discord token and channel ID
+3. Enable the commands you want to automate
+4. Go to **API Keys** → create a new key
+5. Run: `npx dankgrinder --key dkg_your_key`
+
+## Supported Commands
+
+- `pls hunt` — Hunt animals for coins
+- `pls dig` — Dig for treasure
+- `pls beg` — Beg for coins
+- `pls search` — Search locations
+- `pls hl` — Play highlow
+- `pls crime` — Commit crime
+- `pls pm` — Post memes
+
+## Requirements
+
+- Node.js 18+
+- A DankGrinder account with API key
+- Discord token configured in dashboard

package/bin/dankgrinder.js

@@ -0,0 +1,61 @@
+#!/usr/bin/env node
+
+const { start } = require('../lib/grinder');
+
+const args = process.argv.slice(2);
+
+if (args.includes('--help') || args.includes('-h')) {
+  console.log(`
+\x1b[35m╔══════════════════════════════════════╗
+║       \x1b[1mDankGrinder CLI v2.0\x1b[0m\x1b[35m           ║
+║   Multi-Account Automation Engine    ║
+╚══════════════════════════════════════╝\x1b[0m
+
+\x1b[1mUsage:\x1b[0m
+  npx dankgrinder --key <API_KEY> [options]
+
+\x1b[1mOptions:\x1b[0m
+  --key <key>    Your DankGrinder API key (required)
+  --url <url>    API server URL (default: http://localhost:3000)
+  --help, -h     Show this help message
+  --version, -v  Show version
+
+\x1b[1mExamples:\x1b[0m
+  npx dankgrinder --key dkg_abc123def456
+  npx dankgrinder --key dkg_abc123def456 --url https://myserver.com
+
+\x1b[1mSetup:\x1b[0m
+  1. Sign up at your DankGrinder dashboard
+  2. Go to the Accounts page and add your Discord accounts
+  3. Configure per-account commands and cooldowns
+  4. Generate an API key from Auth Tokens
+  5. Run this CLI — it spawns one worker per active account
+`);
+  process.exit(0);
+}
+
+if (args.includes('--version') || args.includes('-v')) {
+  const pkg = require('../package.json');
+  console.log(`dankgrinder v${pkg.version}`);
+  process.exit(0);
+}
+
+let apiKey = '';
+let apiUrl = 'http://localhost:3000';
+
+for (let i = 0; i < args.length; i++) {
+  if (args[i] === '--key' && args[i + 1]) apiKey = args[i + 1];
+  if (args[i] === '--url' && args[i + 1]) apiUrl = args[i + 1];
+}
+
+if (!apiKey) {
+  console.error('\x1b[31m✗ Missing API key.\x1b[0m');
+  console.error('');
+  console.error('  Usage: npx dankgrinder --key <YOUR_API_KEY>');
+  console.error('');
+  console.error('  Get your API key from the DankGrinder dashboard.');
+  console.error('  Run \x1b[36mnpx dankgrinder --help\x1b[0m for more info.');
+  process.exit(1);
+}
+
+start(apiKey, apiUrl);

package/lib/grinder.js

@@ -0,0 +1,387 @@
+const { Client } = require('discord.js-selfbot-v13');
+
+const c = {
+  reset: '\x1b[0m',
+  green: '\x1b[32m',
+  red: '\x1b[31m',
+  yellow: '\x1b[33m',
+  cyan: '\x1b[36m',
+  magenta: '\x1b[35m',
+  dim: '\x1b[2m',
+  bold: '\x1b[1m',
+  white: '\x1b[37m',
+  blue: '\x1b[34m',
+};
+
+const ACCOUNT_COLORS = [c.cyan, c.magenta, c.yellow, c.green, c.blue, c.red];
+
+let API_KEY = '';
+let API_URL = '';
+const workers = [];
+
+function log(type, msg, label) {
+  const time = new Date().toLocaleTimeString();
+  const prefix = {
+    info: `${c.cyan}ℹ${c.reset}`,
+    success: `${c.green}✓${c.reset}`,
+    error: `${c.red}✗${c.reset}`,
+    warn: `${c.yellow}⚠${c.reset}`,
+    cmd: `${c.magenta}▸${c.reset}`,
+  };
+  const tag = label ? `${c.bold}[${label}]${c.reset} ` : '';
+  console.log(`  ${c.dim}${time}${c.reset}  ${prefix[type] || prefix.info}  ${tag}${msg}`);
+}
+
+async function fetchConfig() {
+  try {
+    const res = await fetch(`${API_URL}/api/grinder/config`, {
+      headers: { Authorization: `Bearer ${API_KEY}` },
+    });
+    const data = await res.json();
+    if (data.error) {
+      log('error', `Config fetch failed: ${data.error}`);
+      return null;
+    }
+    return data;
+  } catch (err) {
+    log('error', `Cannot reach API: ${err.message}`);
+    return null;
+  }
+}
+
+async function sendLog(command, response, status) {
+  try {
+    await fetch(`${API_URL}/api/grinder/log`, {
+      method: 'POST',
+      headers: {
+        Authorization: `Bearer ${API_KEY}`,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({ command, response, status }),
+    });
+  } catch {
+    // silent fail for logging
+  }
+}
+
+function randomDelay(min, max) {
+  const ms = (Math.random() * (max - min) + min) * 1000;
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function humanDelay() {
+  return new Promise((resolve) => setTimeout(resolve, 200 + Math.random() * 600));
+}
+
+function safeParseJSON(str, fallback) {
+  try {
+    return JSON.parse(str || '[]');
+  } catch {
+    return fallback;
+  }
+}
+
+// ── Worker: one per Discord account ──────────────────────────────
+
+class AccountWorker {
+  constructor(account, idx) {
+    this.account = account;
+    this.label = account.label || `Account ${idx + 1}`;
+    this.color = ACCOUNT_COLORS[idx % ACCOUNT_COLORS.length];
+    this.client = new Client();
+    this.channel = null;
+    this.running = false;
+  }
+
+  log(type, msg) {
+    log(type, msg, `${this.color}${this.label}${c.reset}`);
+  }
+
+  waitForDankMemer(timeout = 15000) {
+    return new Promise((resolve) => {
+      const timer = setTimeout(() => {
+        this.client.removeListener('messageCreate', handler);
+        resolve(null);
+      }, timeout);
+
+      const self = this;
+      function handler(msg) {
+        if (msg.author.id === '270904126974590976' && msg.channel.id === self.channel.id) {
+          clearTimeout(timer);
+          self.client.removeListener('messageCreate', handler);
+          resolve(msg);
+        }
+      }
+
+      this.client.on('messageCreate', handler);
+    });
+  }
+
+  async handleInteraction(msg) {
+    if (!msg) return null;
+
+    if (msg.components && msg.components.length > 0) {
+      for (const row of msg.components) {
+        if (row.components) {
+          for (const component of row.components) {
+            if (component.type === 2) {
+              const label = component.label?.toLowerCase() || '';
+              const searchAnswers = safeParseJSON(this.account.search_answers, []);
+              const crimeAnswers = safeParseJSON(this.account.crime_answers, []);
+              const allSafe = [...searchAnswers, ...crimeAnswers];
+
+              if (allSafe.length > 0) {
+                const match = allSafe.find((a) => label.includes(a.toLowerCase()));
+                if (match) {
+                  await humanDelay();
+                  try {
+                    await component.click();
+                    return `Clicked: ${label}`;
+                  } catch {
+                    return null;
+                  }
+                }
+              }
+            }
+          }
+
+          const buttons = row.components.filter((comp) => comp.type === 2 && !comp.disabled);
+          if (buttons.length > 0) {
+            const btn = buttons[Math.floor(Math.random() * buttons.length)];
+            await humanDelay();
+            try {
+              await btn.click();
+              return `Clicked: ${btn.label || 'button'}`;
+            } catch {
+              return null;
+            }
+          }
+        }
+      }
+    }
+
+    return msg.content?.substring(0, 100) || 'Response received';
+  }
+
+  async handleHighLow(msg) {
+    if (!msg) return null;
+
+    if (msg.embeds && msg.embeds.length > 0) {
+      const embed = msg.embeds[0];
+      const desc = embed.description || '';
+      const match = desc.match(/(\d+)/);
+      if (match) {
+        const num = parseInt(match[1]);
+        const buttons = [];
+        if (msg.components) {
+          for (const row of msg.components) {
+            if (row.components) {
+              for (const comp of row.components) {
+                if (comp.type === 2) buttons.push(comp);
+              }
+            }
+          }
+        }
+
+        if (buttons.length >= 2) {
+          await humanDelay();
+          let targetBtn;
+          if (num > 50) {
+            targetBtn = buttons.find((b) => b.label?.toLowerCase().includes('lower')) || buttons[1];
+          } else if (num < 50) {
+            targetBtn = buttons.find((b) => b.label?.toLowerCase().includes('higher')) || buttons[0];
+          } else {
+            targetBtn = buttons[Math.floor(Math.random() * 2)];
+          }
+
+          try {
+            await targetBtn.click();
+            return `HL: number was ${num}, clicked ${targetBtn.label}`;
+          } catch {
+            return null;
+          }
+        }
+      }
+    }
+
+    return null;
+  }
+
+  async runCommand(cmdName, prefix) {
+    const cmdString = `${prefix} ${cmdName}`;
+    this.log('cmd', `${c.white}${cmdString}${c.reset}`);
+
+    try {
+      await this.channel.send(cmdString);
+      const response = await this.waitForDankMemer();
+
+      if (!response) {
+        this.log('warn', `No response for ${cmdString}`);
+        await sendLog(cmdString, 'No response (timeout)', 'timeout');
+        return;
+      }
+
+      let result;
+      if (cmdName === 'hl') {
+        result = await this.handleHighLow(response);
+      } else if (['search', 'crime'].includes(cmdName)) {
+        result = await this.handleInteraction(response);
+      } else {
+        result = response.content?.substring(0, 100) || 'Embed response';
+        if (response.components && response.components.length > 0) {
+          result = await this.handleInteraction(response);
+        }
+      }
+
+      this.log('success', `${cmdString} ${c.dim}→${c.reset} ${c.green}${result || 'done'}${c.reset}`);
+      await sendLog(cmdString, result || 'done', 'success');
+    } catch (err) {
+      this.log('error', `${cmdString} failed: ${err.message}`);
+      await sendLog(cmdString, err.message, 'error');
+    }
+  }
+
+  async grindLoop() {
+    if (this.running) return;
+    this.running = true;
+
+    const commandMap = {
+      cmd_hunt: 'hunt',
+      cmd_dig: 'dig',
+      cmd_beg: 'beg',
+      cmd_search: 'search',
+      cmd_hl: 'hl',
+      cmd_crime: 'crime',
+      cmd_pm: 'pm',
+    };
+
+    while (this.running) {
+      const acc = this.account;
+      const prefix = acc.use_slash ? '/' : 'pls';
+      const minCD = acc.cooldown_min || 3;
+      const maxCD = acc.cooldown_max || 8;
+
+      const enabledCommands = Object.entries(commandMap)
+        .filter(([key]) => acc[key] === true || acc[key] === 1)
+        .map(([, cmd]) => cmd);
+
+      if (enabledCommands.length === 0) {
+        this.log('warn', 'No commands enabled. Waiting 30s...');
+        await new Promise((r) => setTimeout(r, 30000));
+        continue;
+      }
+
+      for (const cmd of enabledCommands) {
+        if (!this.running) break;
+        await this.runCommand(cmd, prefix);
+        await randomDelay(minCD, maxCD);
+      }
+
+      const cycleDelay = 2 + Math.random() * 3;
+      this.log('info', `${c.dim}Cycle done. Next in ${cycleDelay.toFixed(1)}s${c.reset}`);
+      await new Promise((r) => setTimeout(r, cycleDelay * 1000));
+    }
+  }
+
+  async start() {
+    if (!this.account.discord_token) {
+      this.log('error', 'No Discord token configured.');
+      return;
+    }
+    if (!this.account.channel_id) {
+      this.log('error', 'No channel ID configured.');
+      return;
+    }
+
+    this.log('info', 'Connecting to Discord...');
+
+    return new Promise((resolve) => {
+      this.client.on('ready', async () => {
+        this.log('success', `Logged in as ${c.bold}${this.client.user.tag}${c.reset}`);
+        this.log('info', `Servers: ${c.white}${this.client.guilds.cache.size}${c.reset}`);
+
+        this.channel = await this.client.channels.fetch(this.account.channel_id).catch(() => null);
+
+        if (!this.channel) {
+          this.log('error', `Cannot find channel ${this.account.channel_id}`);
+          resolve();
+          return;
+        }
+
+        this.log('info', `Channel: ${c.white}#${this.channel.name || this.account.channel_id}${c.reset}`);
+
+        const enabled = Object.keys({ cmd_hunt: 1, cmd_dig: 1, cmd_beg: 1, cmd_search: 1, cmd_hl: 1, cmd_crime: 1, cmd_pm: 1 })
+          .filter((k) => this.account[k] === true || this.account[k] === 1)
+          .map((k) => k.replace('cmd_', ''));
+        this.log('info', `Commands: ${c.white}${enabled.join(', ') || 'none'}${c.reset}`);
+        this.log('info', `Cooldown: ${c.white}${this.account.cooldown_min || 3}-${this.account.cooldown_max || 8}s${c.reset}`);
+        console.log('');
+
+        this.grindLoop();
+        resolve();
+      });
+
+      this.client.login(this.account.discord_token);
+    });
+  }
+
+  stop() {
+    this.running = false;
+    try { this.client.destroy(); } catch {}
+  }
+}
+
+// ── Main Entry ──────────────────────────────────
+
+async function start(apiKey, apiUrl) {
+  API_KEY = apiKey;
+  API_URL = apiUrl;
+
+  console.log('');
+  console.log(`  ${c.magenta}${c.bold}╔══════════════════════════════════════════╗${c.reset}`);
+  console.log(`  ${c.magenta}${c.bold}║${c.reset}                                          ${c.magenta}${c.bold}║${c.reset}`);
+  console.log(`  ${c.magenta}${c.bold}║${c.reset}   ${c.white}${c.bold}DankGrinder${c.reset} ${c.dim}v2.0${c.reset}                      ${c.magenta}${c.bold}║${c.reset}`);
+  console.log(`  ${c.magenta}${c.bold}║${c.reset}   ${c.dim}Multi-Account Automation Engine${c.reset}        ${c.magenta}${c.bold}║${c.reset}`);
+  console.log(`  ${c.magenta}${c.bold}║${c.reset}                                          ${c.magenta}${c.bold}║${c.reset}`);
+  console.log(`  ${c.magenta}${c.bold}╚══════════════════════════════════════════╝${c.reset}`);
+  console.log('');
+
+  log('info', `API: ${c.dim}${API_URL}${c.reset}`);
+  log('info', 'Fetching config & accounts...');
+
+  const data = await fetchConfig();
+
+  if (!data) {
+    log('error', 'Failed to fetch config. Check your API key and server.');
+    process.exit(1);
+  }
+
+  const { accounts } = data;
+
+  if (!accounts || accounts.length === 0) {
+    log('error', 'No active accounts found. Add accounts in the dashboard.');
+    process.exit(1);
+  }
+
+  log('success', `Found ${c.bold}${accounts.length}${c.reset} active account(s)`);
+  console.log('');
+
+  // Spawn a worker per account
+  for (let i = 0; i < accounts.length; i++) {
+    const worker = new AccountWorker(accounts[i], i);
+    workers.push(worker);
+    await worker.start();
+  }
+
+  log('info', `${c.bold}All workers running. Press Ctrl+C to stop.${c.reset}`);
+  console.log('');
+
+  process.on('SIGINT', () => {
+    console.log('');
+    log('warn', 'Shutting down all workers...');
+    for (const w of workers) w.stop();
+    setTimeout(() => process.exit(0), 2000);
+  });
+}
+
+module.exports = { start };

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "dankgrinder",
+  "version": "1.0.0",
+  "description": "Dank Memer automation engine — grind coins while you sleep",
+  "bin": {
+    "dankgrinder": "./bin/dankgrinder.js"
+  },
+  "files": [
+    "bin/",
+    "lib/",
+    "README.md"
+  ],
+  "keywords": [
+    "dank-memer",
+    "discord",
+    "grinder",
+    "automation",
+    "selfbot"
+  ],
+  "author": "DankGrinder",
+  "license": "MIT",
+  "dependencies": {
+    "discord.js-selfbot-v13": "^3.6.1"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}