@misudev/dconnect 1.6.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Yasin Çakmak
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,120 @@
+<div align="center">
+  
+# dconnect
+
+**Discord kullanıcı token’ı ile bir voice channel’a bağlanan CLI aracı.**  
+Gateway + Voice + UDP handshake dahil, _gerçek_ voice bağlantısı kurar.
+
+> Eğitimsel ve deneysel amaçlıdır. Token’la oynuyorsan risk sende.
+
+</div>
+
+---
+
+## ✨ Özellikler
+
+- Discord **Gateway v10** bağlantısı
+- **Gerçek voice channel** bağlantısı (bot değil, user token)
+- Voice WebSocket + UDP discovery
+- Otomatik heartbeat yönetimi
+- Mute / Deaf opsiyonları
+- Event tabanlı mimari  
+  (`READY`, `VOICE_STATE_UPDATE`, `VOICE_SERVER_UPDATE`)
+- Tek komut, hızlı bağlantı
+
+---
+
+## ⚠️ Güvenlik Uyarısı
+
+Bu araç **doğrudan Discord hesabına bağlanır**.
+
+- Token’ını **ASLA** paylaşma
+- Ana hesabında kullanman önerilmez
+- Discord ToS ihlali riski vardır
+- **Educational purposes only**
+
+Uygulama çalışmadan önce bu uyarıyı zaten terminalde gösterir.
+
+---
+
+## 📦 Kurulum
+
+Node.js **18+** gereklidir.
+
+```bash
+npm install -g dconnect
+```
+
+veya projeden:
+
+```bash
+pnpm install
+```
+
+---
+
+## 🚀 Kullanım
+
+```bash
+dconnect <token> --guild <guild_id> --channel <channel_id>
+```
+
+### Gerekli Parametreler
+
+- `<token>` → Discord **user token**
+- `--guild, -g` → Sunucu (Guild) ID
+- `--channel, -c` → Voice Channel ID
+
+### Opsiyonlar
+
+| Flag         | Açıklama            |
+| ------------ | ------------------- |
+| `--mute, -m` | Sese kapalı gir     |
+| `--deaf, -d` | Kulaklık kapalı gir |
+| `--help`     | Yardım menüsü       |
+| `--version`  | Versiyon bilgisi    |
+
+---
+
+## 🧪 Örnek
+
+```bash
+dconnect MTIzNDU2Nzg5... --guild 123456789012345678 --channel 987654321098765432 --mute
+```
+
+Başarılı bağlantıdan sonra:
+
+- Gateway bağlantısı kurulur
+- Voice server + state alınır
+- UDP discovery yapılır
+- Voice WebSocket hazır olur
+- Hesap voice channel’a girer
+
+Çıkmak için:
+
+```bash
+Ctrl + C
+```
+
+---
+
+## 🧠 Teknik Detaylar
+
+- Discord Gateway **v10**
+- Voice protocol **v4**
+- Encryption mode: `xsalsa20_poly1305`
+- UDP discovery + SSRC handling
+- Tamamen **EventEmitter** tabanlı yapı
+
+---
+
+## 📜 Lisans
+
+MIT License  
+© 2025
+
+---
+
+> Bu proje bot değildir.  
+> User token kullanır.  
+> Ne yaptığını bilmiyorsan kullanma.

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@misudev/dconnect",
+  "version": "1.6.2",
+  "description": "Connect to Discord voice channel",
+  "main": "index.mjs",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "discord",
+    "status",
+    "user",
+    "presence",
+    "spotify",
+    "lanyard"
+  ],
+  "author": "misu",
+  "license": "MIT",
+  "dependencies": {
+    "axios": "^1.10.0",
+    "boxen": "^8.0.1",
+    "chalk": "^5.4.1",
+    "cli-highlight": "^2.1.11",
+    "clipboardy": "^4.0.0",
+    "commander": "^12.1.0",
+    "consola": "^3.4.2",
+    "events": "^3.3.0",
+    "inquirer": "^13.1.0",
+    "open": "^10.1.2",
+    "ora": "^8.2.0",
+    "ws": "^8.18.3"
+  },
+  "bin": {
+    "dconnect": "src/index.mjs"
+  },
+  "funding": {
+    "type": "github",
+    "url": "https://github.com/sponsors/mishuw"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mishuw/dconnect.git"
+  },
+  "bugs": {
+    "url": "https://github.com/mishuw/dconnect/issues"
+  },
+  "type": "module"
+}

package/src/index.mjs

@@ -0,0 +1,524 @@
+#!/usr/bin/env node
+
+import { program } from "commander";
+import { WebSocket } from "ws";
+import chalk from "chalk";
+import ora from "ora";
+import consola from "consola";
+import { EventEmitter } from "events";
+import dgram from "dgram";
+import boxen from "boxen";
+
+const GATEWAY_VERSION = "10";
+const GATEWAY_ENCODING = "json";
+
+const OP_CODES = {
+  DISPATCH: 0,
+  HEARTBEAT: 1,
+  IDENTIFY: 2,
+  VOICE_STATE_UPDATE: 4,
+  INVALID_SESSION: 9,
+  HELLO: 10,
+  HEARTBEAT_ACK: 11,
+};
+
+const VOICE_OP_CODES = {
+  IDENTIFY: 0,
+  SELECT_PROTOCOL: 1,
+  READY: 2,
+  HEARTBEAT: 3,
+  SESSION_DESCRIPTION: 4,
+  SPEAKING: 5,
+  HEARTBEAT_ACK: 6,
+  HELLO: 8,
+};
+
+const INTENTS = {
+  GUILDS: 1 << 0,
+  GUILD_VOICE_STATES: 1 << 7,
+};
+
+class VoiceConnection extends EventEmitter {
+  constructor(guildId, channelId, userId, sessionId, token, endpoint) {
+    super();
+    this.guildId = guildId;
+    this.channelId = channelId;
+    this.userId = userId;
+    this.sessionId = sessionId;
+    this.token = token;
+    this.endpoint = endpoint;
+    this.ws = null;
+    this.udp = null;
+    this.heartbeatInterval = null;
+    this.ready = false;
+    this.ssrc = null;
+    this.port = null;
+    this.ip = null;
+    this.secretKey = null;
+  }
+
+  async connect() {
+    return new Promise((resolve, reject) => {
+      const wsUrl = `wss://${this.endpoint.replace(":80", "")}?v=4`;
+      this.ws = new WebSocket(wsUrl);
+
+      const onOpen = () => {
+        this.sendIdentify();
+      };
+
+      const onMessage = (data) => {
+        try {
+          const payload = JSON.parse(data.toString());
+          this.handleVoicePayload(payload, resolve);
+        } catch (error) {
+          reject(error);
+        }
+      };
+
+      const onError = (error) => reject(error);
+      const onClose = (code, reason) => {
+        this.cleanup();
+        reject(new Error(`Voice closed: ${code} ${reason}`));
+      };
+
+      this.ws.once("open", onOpen);
+      this.ws.on("message", onMessage);
+      this.ws.once("error", onError);
+      this.ws.once("close", onClose);
+
+      this.ws.once("open", () => {
+        this.ws.removeListener("error", onError);
+      });
+    });
+  }
+
+  sendIdentify() {
+    const identifyPayload = {
+      op: VOICE_OP_CODES.IDENTIFY,
+      d: {
+        server_id: this.guildId,
+        user_id: this.userId,
+        session_id: this.sessionId,
+        token: this.token,
+      },
+    };
+    this.ws.send(JSON.stringify(identifyPayload));
+  }
+
+  async handleVoicePayload(payload, resolve) {
+    const { op, d } = payload;
+
+    switch (op) {
+      case VOICE_OP_CODES.READY:
+        this.ssrc = d.ssrc;
+        this.port = d.port;
+        this.ip = d.ip;
+        await this.setupUDP();
+        this.selectProtocol();
+        break;
+
+      case VOICE_OP_CODES.SESSION_DESCRIPTION:
+        this.secretKey = new Uint8Array(d.secret_key);
+        this.ready = true;
+        this.setupHeartbeat();
+        resolve(this);
+        break;
+
+      case VOICE_OP_CODES.HELLO:
+        this.setupHeartbeat();
+        break;
+    }
+  }
+
+  setupHeartbeat() {
+    if (this.heartbeatInterval) clearInterval(this.heartbeatInterval);
+
+    this.heartbeatInterval = setInterval(() => {
+      if (this.ws?.readyState === WebSocket.OPEN) {
+        this.ws.send(
+          JSON.stringify({
+            op: VOICE_OP_CODES.HEARTBEAT,
+            d: Date.now(),
+          }),
+        );
+      }
+    }, 30000);
+  }
+
+  async setupUDP() {
+    return new Promise((resolve, reject) => {
+      this.udp = dgram.createSocket("udp4");
+      const discoveryPacket = Buffer.alloc(70);
+      discoveryPacket.writeUInt32BE(this.ssrc, 0);
+
+      this.udp.once("message", () => resolve());
+      this.udp.once("error", reject);
+
+      this.udp.send(discoveryPacket, 0, 70, this.port, this.ip, (err) => {
+        if (err) reject(err);
+      });
+    });
+  }
+
+  selectProtocol() {
+    const protocolPayload = {
+      op: VOICE_OP_CODES.SELECT_PROTOCOL,
+      d: {
+        protocol: "udp",
+        data: {
+          address: this.ip,
+          port: this.port,
+          mode: "xsalsa20_poly1305",
+        },
+      },
+    };
+    this.ws.send(JSON.stringify(protocolPayload));
+  }
+
+  setSpeaking(speaking = true) {
+    if (this.ws?.readyState === WebSocket.OPEN) {
+      this.ws.send(
+        JSON.stringify({
+          op: VOICE_OP_CODES.SPEAKING,
+          d: {
+            speaking: speaking ? 1 : 0,
+            delay: 0,
+            ssrc: this.ssrc,
+          },
+        }),
+      );
+    }
+  }
+
+  cleanup() {
+    if (this.heartbeatInterval) {
+      clearInterval(this.heartbeatInterval);
+      this.heartbeatInterval = null;
+    }
+    if (this.udp) {
+      this.udp.close();
+      this.udp = null;
+    }
+    if (this.ws) {
+      this.ws.close(1000);
+      this.ws = null;
+    }
+  }
+}
+
+class DiscordGateway extends EventEmitter {
+  constructor(token) {
+    super();
+    this.token = token;
+    this.ws = null;
+    this.heartbeatInterval = null;
+    this.sequence = null;
+    this.sessionId = null;
+    this.userData = null;
+    this.voiceConnection = null;
+  }
+
+  async connect() {
+    const gatewayUrl = await this.getGatewayUrl();
+    return new Promise((resolve, reject) => {
+      this.ws = new WebSocket(gatewayUrl);
+
+      const onOpen = () => {
+        this.ws.removeListener("error", onError);
+        resolve();
+      };
+
+      const onError = (error) => reject(error);
+
+      this.ws.once("open", onOpen);
+      this.ws.once("error", onError);
+
+      this.ws.on("message", (data) => {
+        try {
+          const payload = JSON.parse(data.toString());
+          this.handlePayload(payload);
+        } catch (error) {
+          consola.error("Parse error:", error);
+        }
+      });
+
+      this.ws.on("close", (code, reason) => {
+        this.cleanup();
+        consola.warn(`Gateway closed: ${code} ${reason}`);
+      });
+    });
+  }
+
+  async getGatewayUrl() {
+    const response = await fetch("https://discord.com/api/gateway");
+    const { url } = await response.json();
+    return `${url}?v=${GATEWAY_VERSION}&encoding=${GATEWAY_ENCODING}`;
+  }
+
+  handlePayload(payload) {
+    const { op, d, s, t } = payload;
+    if (s !== null) this.sequence = s;
+
+    switch (op) {
+      case OP_CODES.HELLO:
+        this.handleHello(d);
+        break;
+      case OP_CODES.DISPATCH:
+        this.handleDispatch(t, d);
+        break;
+      case OP_CODES.INVALID_SESSION:
+        setTimeout(() => this.identify(), 1000);
+        break;
+    }
+  }
+
+  handleHello(data) {
+    this.heartbeatInterval = setInterval(() => {
+      if (this.ws?.readyState === WebSocket.OPEN) {
+        this.ws.send(
+          JSON.stringify({
+            op: OP_CODES.HEARTBEAT,
+            d: this.sequence,
+          }),
+        );
+      }
+    }, data.heartbeat_interval);
+
+    setImmediate(() => this.identify());
+  }
+
+  identify() {
+    const identifyPayload = {
+      op: OP_CODES.IDENTIFY,
+      d: {
+        token: this.token,
+        properties: {
+          os: "linux",
+          browser: "misu",
+          device: "misu",
+        },
+        compress: false,
+        intents: INTENTS.GUILDS | INTENTS.GUILD_VOICE_STATES,
+      },
+    };
+    this.ws.send(JSON.stringify(identifyPayload));
+  }
+
+  handleDispatch(event, data) {
+    switch (event) {
+      case "READY":
+        this.sessionId = data.session_id;
+        this.userData = data.user;
+        this.emit("ready", data);
+        break;
+      case "VOICE_STATE_UPDATE":
+        if (data.user_id === this.userData?.id) {
+          this.emit("voice_state_update", data);
+        }
+        break;
+      case "VOICE_SERVER_UPDATE":
+        this.emit("voice_server_update", data);
+        break;
+    }
+  }
+
+  async joinVoiceChannel(guildId, channelId, mute = false, deaf = false) {
+    const voiceStatePayload = {
+      op: OP_CODES.VOICE_STATE_UPDATE,
+      d: {
+        guild_id: guildId,
+        channel_id: channelId,
+        self_mute: mute,
+        self_deaf: deaf,
+      },
+    };
+    this.ws.send(JSON.stringify(voiceStatePayload));
+
+    return new Promise((resolve, reject) => {
+      let voiceState = null;
+      let voiceServer = null;
+      let timeout = null;
+
+      const checkReady = () => {
+        if (voiceState && voiceServer) {
+          clearTimeout(timeout);
+          this.off("voice_state_update", onVoiceState);
+          this.off("voice_server_update", onVoiceServer);
+          this.createVoiceConnection(
+            guildId,
+            channelId,
+            voiceState,
+            voiceServer,
+          )
+            .then(resolve)
+            .catch(reject);
+        }
+      };
+
+      const onVoiceState = (data) => {
+        if (data.guild_id === guildId && data.user_id === this.userData?.id) {
+          voiceState = data;
+          checkReady();
+        }
+      };
+
+      const onVoiceServer = (data) => {
+        if (data.guild_id === guildId) {
+          voiceServer = data;
+          checkReady();
+        }
+      };
+
+      this.on("voice_state_update", onVoiceState);
+      this.on("voice_server_update", onVoiceServer);
+
+      timeout = setTimeout(() => {
+        this.off("voice_state_update", onVoiceState);
+        this.off("voice_server_update", onVoiceServer);
+        reject(new Error("Voice connection timeout (10s)"));
+      }, 10000);
+    });
+  }
+
+  async createVoiceConnection(guildId, channelId, voiceState, voiceServer) {
+    this.voiceConnection = new VoiceConnection(
+      guildId,
+      channelId,
+      this.userData.id,
+      voiceState.session_id,
+      voiceServer.token,
+      voiceServer.endpoint,
+    );
+
+    this.voiceConnection.on("disconnected", () => {
+      this.voiceConnection = null;
+    });
+
+    await this.voiceConnection.connect();
+    return this.voiceConnection;
+  }
+
+  cleanup() {
+    if (this.heartbeatInterval) {
+      clearInterval(this.heartbeatInterval);
+      this.heartbeatInterval = null;
+    }
+    if (this.voiceConnection) {
+      this.voiceConnection.cleanup();
+      this.voiceConnection = null;
+    }
+    if (this.ws) {
+      this.ws.close(1000);
+      this.ws = null;
+    }
+  }
+}
+
+function validateToken(token) {
+  if (!token || token.length < 59) {
+    return { valid: false, error: "Invalid token format" };
+  }
+  return { valid: true };
+}
+
+program
+  .name("dconnect")
+  .description("Connect to Discord voice channel")
+  .version("1.0.0")
+  .argument("<token>", "Discord token")
+  .requiredOption("-g, --guild <id>", "Guild ID")
+  .requiredOption("-c, --channel <id>", "Voice channel ID")
+  .option("-m, --mute", "Join muted", false)
+  .option("-d, --deaf", "Join deafened", false)
+  .action(async (token, options) => {
+    const validation = validateToken(token);
+    if (!validation.valid) {
+      consola.error(`Invalid token: ${validation.error}`);
+      process.exit(1);
+    }
+
+    console.clear();
+    console.log(
+      boxen(
+        chalk.bold.red("⚠ SECURITY WARNING ⚠\n\n") +
+          chalk.yellow(
+            "This tool connects directly to your Discord account.\n",
+          ) +
+          chalk.yellow("• Token security is VERY IMPORTANT\n") +
+          chalk.yellow("• EDUCATIONAL PURPOSES ONLY\n") +
+          chalk.yellow("• NEVER share your token\n") +
+          chalk.yellow("• Your account may be at risk\n\n") +
+          chalk.white.bold("Press Enter to continue or Ctrl+C to cancel"),
+        {
+          padding: 1,
+          borderColor: "red",
+          borderStyle: "double",
+          margin: 1,
+        },
+      ),
+    );
+
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+    await new Promise((r) => process.stdin.once("data", r));
+    process.stdin.setRawMode(false);
+
+    const spinner = ora({
+      text: "Connecting to Discord...",
+      spinner: "dots",
+      color: "cyan",
+      hideCursor: true,
+    }).start();
+
+    try {
+      const startTime = Date.now();
+      const gateway = new DiscordGateway(token);
+      let voiceConn = null;
+
+      gateway.once("ready", async (data) => {
+        const connectTime = Date.now() - startTime;
+        spinner.succeed(`Connected in @${data.user.username} ${connectTime}ms`);
+
+        consola.info(`Guild: ${options.guild}`);
+        consola.info(`Channel: ${options.channel}`);
+        consola.info(`Mute: ${options.mute ? "Yes" : "No"}`);
+        consola.info(`Deaf: ${options.deaf ? "Yes" : "No"}`);
+        try {
+          voiceConn = await gateway.joinVoiceChannel(
+            options.guild,
+            options.channel,
+            options.mute,
+            options.deaf,
+          );
+
+          consola.success("✓ Voice connected!");
+
+          if (!options.mute) {
+            voiceConn.setSpeaking(true);
+          }
+
+          consola.info("Press Ctrl+C to exit");
+        } catch (err) {
+          consola.error(`Voice error: ${err.message}`);
+          process.exit(1);
+        }
+      });
+
+      await gateway.connect();
+
+      const exitHandler = () => {
+        consola.info("\nDisconnecting...");
+        if (voiceConn) voiceConn.cleanup();
+        gateway.cleanup();
+        process.exit(0);
+      };
+
+      process.on("SIGINT", exitHandler);
+      process.on("SIGTERM", exitHandler);
+    } catch (error) {
+      spinner.fail(`Connection failed: ${error.message}`);
+      process.exit(1);
+    }
+  });
+
+program.parse(process.argv);

package/src/utils.mjs

@@ -0,0 +1,31 @@
+import axios from 'axios';
+import chalk from 'chalk';
+import consola from 'consola';
+
+export async function getUserPresence(userID) {
+  try {
+    const response = await axios.get(`https://api.lanyard.rest/v1/users/${userID}`);
+    return response.data;
+  } catch (error) {
+    consola.error(new Error(chalk.red(`An error occurred fetching data from the Lanyard API: ${error.message}`)));
+    process.exit(1);
+  }
+}
+
+export function isCustomEmoji(emoji) {
+  if (!emoji || typeof emoji !== 'object') return false;
+  return emoji.id && typeof emoji.id === 'string' && !emoji.id.startsWith('<a:');
+}
+
+export function formatDuration(duration) {
+  const hours = Math.floor(duration / 3600);
+  const minutes = Math.floor((duration % 3600) / 60);
+  const seconds = Math.floor(duration % 60);
+  if (hours > 0) {
+    return `${hours}hr ${minutes}min ${seconds}sec`;
+  } else if (minutes > 0) {
+    return `${minutes}min ${seconds}sec`;
+  } else {
+    return `${seconds} seconds`;
+  }
+}