muthera 1.0.2

package/.github/dependabot.yml

@@ -0,0 +1,16 @@
+version: 2
+updates:
+  # Enable version updates for npm
+  - package-ecosystem: "npm"
+    # Look for `package.json` and `lock` files in the `root` directory
+    directory: "/"
+    # Check the npm registry for updates every day (weekdays)
+    schedule:
+      interval: "daily"
+  # Enable version updates for Docker
+  - package-ecosystem: "docker"
+    # Look for a `Dockerfile` in the `root` directory
+    directory: "/"
+    # Check for updates once a week
+    schedule:
+      interval: "weekly"

package/.github/workflows/npm-publish.yml

@@ -0,0 +1,22 @@
+name: Publish Package to npmjs
+
+on:
+  release:
+    types: [created]
+  push:
+    branches: "master"
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      # Setup .npmrc file to publish to npm
+      - uses: actions/setup-node@v2
+        with:
+          node-version: '16.x'
+          registry-url: 'https://registry.npmjs.org'
+      - run: npm ci
+      - run: npm publish
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

package/LICENSE

@@ -0,0 +1,15 @@
+ISC License
+
+Copyright (c) 2025 urfavteddybear
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

package/README.md

@@ -0,0 +1,124 @@
+<div align="center">
+  <h1>Muthera</h1>
+  <p>A simple discord music bot wrapper.</p>
+  <p>
+  <a href="https://www.npmjs.com/package/muthera"><img src="https://img.shields.io/npm/v/muthera?maxAge=3600" alt="NPM version" /></a>
+  <p>
+  <p>
+    <a href="https://www.npmjs.com/package/muthera"><img src="https://nodei.co/npm/muthera.png?downloads=true&stars=true" alt="NPM Banner"></a>
+  </p>
+  </div>
+
+## Attribution
+
+This project is forked from the original [Niizuki](https://www.npmjs.com/package/niizuki) package by [LewdHuTao](https://github.com/LewdHuTao). Since the original project is no longer maintained, this fork continues development and maintenance under the name "Muthera".
+
+- **Original Author**: LewdHuTao
+- **Original Repository**: [shittybot/niizuki](https://github.com/shittybot/niizuki)
+- **Current Maintainer**: [urfavteddybear](https://github.com/urfavteddybear)
+
+  ## Install
+```sh
+npm install muthera
+# or
+yarn add muthera
+```
+
+## Example
+```js
+const { Muthera } = require("muthera"); // Import muthera
+
+client.on("ready", async (client) => {
+  // defined nodes
+  const nodes = [
+    {
+      name: "localhost",
+      host: "",
+      password: "",
+      port: 2333,
+      secure: false,
+    },
+  ];
+
+  // initialize manager
+  client.manager = new Muthera(nodes, {
+    send: (payload) => {
+      const guild = this.guilds.cache.get(payload.d.guild_id);
+      if (guild) guild.shard.send(payload);
+    },
+    defaultSearchPlatform: "ytmsearch",
+    reconnectTimeout: 600000,
+    reconnectTries: 1000,
+  });
+});
+
+client.on("interactionCreate", async (interaction) => {
+  if (slashCmd === "play") {
+    const player = client.manager.createConnection({
+      guildId: interaction.guild.id,
+      voiceChannel: interaction.member.voice.channel.id,
+      textChannel: interaction.channel.id,
+      deaf: true,
+    });
+
+    const resolve = await client.manager.resolve({
+      query: query,
+      requester: interaction.user.id,
+    });
+    const { loadType, tracks, playlistInfo } = resolve;
+
+    if (loadType === "track" || loadType === "search") {
+      const track = tracks.shift();
+      player.queue.add(track);
+      interaction.reply(
+        `Add [${track.info.title}](${track.info.uri}) to the queue.`
+      );
+      if (!player.playing && !player.paused) return player.play();
+    }
+
+    if (loadType === "playlist") {
+      for (const track of resolve.tracks) {
+        track.info.requester = interaction.user.id;
+        player.queue.add(track);
+      }
+
+      interaction.reply(`Add \`${playlistInfo.name}\` to the queue`);
+      if (!player.playing && !player.paused) return player.play();
+    } else {
+      return interaction.reply("There are no results found.");
+    }
+  }
+});
+
+client.login("token");
+
+client.manager.on("nodeConnect", async (node) => {
+  console.log(`${node.name} is connected.`);
+});
+
+client.manager.on("nodeDisconnect", async (node) => {
+  console.log(`${node.name} is disconnected.`);
+});
+
+client.manager.on("trackStart", async (player, track) => {
+  const channel = client.channels.cache.get(player.textChannel);
+
+  channel.send(
+    `Now Playing: [${track.info.title}](${track.info.uri}) [${track.info.requester}]`
+  );
+});
+
+client.manager.on("queueEnd", async (player, track) => {
+  const channel = client.channels.cache.get(player.textChannel);
+
+  let autoPlay = false;
+
+  if (autoPlay) {
+    player.autoplay(player);
+  } else {
+    player.destroy();
+    channel.send(`The queue has ended`);
+  }
+});
+
+```

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "muthera",
+  "version": "1.0.2",
+  "description": "A simple Lavalink wrapper for Discord music bot. Forked from Niizuki.",
+  "main": "src/index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "author": "urfavteddybear",
+  "license": "ISC",
+  "dependencies": {
+    "@discordjs/collection": "^2.1.1",
+    "jsdom": "^26.1.0",
+    "ws": "^8.18.3"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/urfavteddybear/muthera.git"
+  },
+  "bugs": {
+    "url": "https://github.com/urfavteddybear/muthera/issues"
+  },
+  "homepage": "https://github.com/urfavteddybear/muthera#readme",
+  "keywords": [
+    "wrapper",
+    "discord",
+    "lavalink-v4",
+    "lavalink",
+    "music-bot"
+  ]
+}

package/src/functions/autoPlay.js

@@ -0,0 +1,171 @@
+const { JSDOM } = require("jsdom");
+
+async function scAutoPlay(url) {
+  const res = await fetch(`${url}/recommended`);
+
+  const html = await res.text();
+
+  const dom = new JSDOM(html);
+  const document = dom.window.document;
+
+  const secondNoscript = document.querySelectorAll("noscript")[1];
+  const sectionElement = secondNoscript.querySelector("section");
+  const articleElements = sectionElement.querySelectorAll("article");
+
+  articleElements.forEach((articleElement) => {
+    const h2Element = articleElement.querySelector('h2[itemprop="name"]');
+
+    const aElement = h2Element.querySelector('a[itemprop="url"]');
+    const href = `https://soundcloud.com${aElement.getAttribute("href")}`;
+
+    return href;
+  });
+}
+
+async function amAutoPlay(track_id, retries = 3) {
+  async function fetchWithRetry(url, options, retries) {
+    for (let attempt = 0; attempt < retries; attempt++) {
+      try {
+        const res = await fetch(url, options);
+        return await res.json();
+      } catch (error) {
+        if (attempt === retries - 1) {
+          throw new Error("No track found.");
+        }
+      }
+    }
+  }
+  const trackData = await fetchWithRetry(
+    `https://itunes.apple.com/lookup?id=${track_id}`,
+    retries
+  );
+
+  if (!trackData.results || trackData.results.length === 0) {
+    throw new Error("No track found.");
+  }
+
+  const track = trackData.results[0];
+  const genreName = track.primaryGenreName;
+
+  const relatedData = await fetchWithRetry(
+    `https://itunes.apple.com/search?term=${encodeURIComponent(
+      genreName
+    )}&entity=song`,
+    retries
+  );
+
+  if (!relatedData.results || relatedData.results.length === 0) {
+    throw new Error("No track found.");
+  }
+
+  return relatedData.results.filter(
+    (item) => item.wrapperType === "track" && item.trackId !== track_id
+  );
+}
+
+async function spAutoPlay(track_id, retries = 3) {
+  async function fetchWithRetry(url, options, retries) {
+    for (let attempt = 0; attempt < retries; attempt++) {
+      try {
+        const res = await fetch(url, options);
+        return await res.json();
+      } catch (error) {
+        if (attempt === retries - 1) {
+          throw new Error("No track found.");
+        }
+      }
+    }
+  }
+  const tokenResponse = await fetchWithRetry(
+    "https://open.spotify.com/get_access_token?reason=transport&productType=embed",
+    {},
+    retries
+  );
+  const accessToken = tokenResponse.accessToken;
+
+  const recommendationsResponse = await fetchWithRetry(
+    `https://api.spotify.com/v1/recommendations?limit=10&seed_tracks=${track_id}`,
+    {
+      headers: {
+        Authorization: `Bearer ${accessToken}`,
+        "Content-Type": "application/json",
+      },
+    },
+    retries
+  );
+
+  return recommendationsResponse.tracks[
+    Math.floor(Math.random() * recommendationsResponse.tracks.length)
+  ].id;
+}
+
+async function dzAutoPlay(trackId, retries = 3) {
+  async function fetchWithRetryJson(url, options = {}, retriesLeft = 3) {
+    for (let attempt = 0; attempt < retriesLeft; attempt++) {
+      try {
+        const res = await fetch(url, options);
+        if (!res.ok) throw new Error(`HTTP ${res.status}`);
+        return await res.json();
+      } catch (err) {
+        if (attempt === retriesLeft - 1) throw err;
+        await new Promise((r) => setTimeout(r, 200 * (attempt + 1)));
+      }
+    }
+  }
+
+  const trackData = await fetchWithRetryJson(`https://api.deezer.com/track/${trackId}`, {}, retries);
+  if (!trackData || trackData.error) throw new Error("Deezer track not found");
+
+  const originalTrackId = String(trackData.id);
+  const artistId = trackData.artist?.id ? String(trackData.artist.id) : null;
+  const candidates = new Map();
+
+  function addTracksArray(arr) {
+    if (!Array.isArray(arr)) return;
+    for (const t of arr) {
+      if (!t || !t.id) continue;
+      const tid = String(t.id);
+      if (tid === originalTrackId) continue;
+      if (!candidates.has(tid)) candidates.set(tid, t);
+    }
+  }
+
+  if (artistId) {
+    try {
+      const topRes = await fetchWithRetryJson(`https://api.deezer.com/artist/${artistId}/top?limit=12`, {}, retries);
+      if (topRes?.data) addTracksArray(topRes.data);
+    } catch (_) {}
+  }
+
+  if (artistId) {
+    try {
+      const relRes = await fetchWithRetryJson(`https://api.deezer.com/artist/${artistId}/related`, {}, retries);
+      const relatedArtists = (relRes && relRes.data) || [];
+      const toFetch = relatedArtists.slice(0, 5);
+
+      const topPromises = toFetch.map((ra) =>
+        fetchWithRetryJson(`https://api.deezer.com/artist/${ra.id}/top?limit=6`, {}, retries)
+          .then((r) => (r?.data ? r.data : []))
+          .catch(() => [])
+      );
+
+      const topResults = await Promise.all(topPromises);
+      topResults.forEach((arr) => addTracksArray(arr));
+    } catch (_) {}
+  }
+
+  if (candidates.size === 0) {
+    try {
+      const q = `${encodeURIComponent(trackData.title || "")} ${encodeURIComponent(trackData.artist?.name || "")}`;
+      const searchRes = await fetchWithRetryJson(`https://api.deezer.com/search?q=${q}&limit=20`, {}, retries);
+      if (searchRes?.data) addTracksArray(searchRes.data);
+    } catch (_) {}
+  }
+
+  const arr = Array.from(candidates.values());
+  if (!arr.length) throw new Error("No Deezer recommendations found");
+  const pick = arr[Math.floor(Math.random() * arr.length)];
+  return `https://www.deezer.com/track/${pick.id}`;
+} 
+
+module.exports = { scAutoPlay, spAutoPlay, amAutoPlay, dzAutoPlay };

package/src/functions/fetchImage.js

@@ -0,0 +1,57 @@
+async function getImageUrl(info) {
+  if (info.sourceName === "spotify") {
+    try {
+      const match = info.uri.match(/track\/([a-zA-Z0-9]+)/);
+      if (match) {
+        const res = await fetch(
+          `https://open.spotify.com/oembed?url=${info.uri}`
+        );
+        const json = await res.json();
+
+        return json.thumbnail_url;
+      }
+    } catch (error) {
+      return null;
+    }
+  }
+
+  if (info.sourceName === "applemusic") {
+    try {
+      const res = await fetch(
+        `https://itunes.apple.com/lookup?id=${info.identifier}`
+      );
+
+      const response = await res.json();
+
+      return response.results[0].artworkUrl100;
+    } catch (error) {
+      return null;
+    }
+  }
+
+  if (info.sourceName === "soundcloud") {
+    try {
+      const res = await fetch(
+        `https://soundcloud.com/oembed?format=json&url=${info.uri}`
+      );
+      const json = await res.json();
+      const thumbnailUrl = json.thumbnail_url;
+
+      return thumbnailUrl;
+    } catch (error) {
+      return null;
+    }
+  }
+
+  if (info.sourceName === "youtube") {
+    try {
+      const thumbnailUrl = `https://img.youtube.com/vi/${info.identifier}/maxresdefault.jpg`;
+
+      return thumbnailUrl;
+    } catch {
+      return null;
+    }
+  }
+}
+
+module.exports = { getImageUrl };