Create index.js

index.js

@@ -0,0 +1,315 @@
+const express = require('express');
+const axios = require('axios');
+const FormData = require('form-data');
+const fs = require('fs');
+const path = require('path');
+
+const app = express();
+const PORT = 7860;
+app.get('/addsong', async (req, res) => {
+  const youtubeUrl = req.query.url;
+  if (!youtubeUrl) return res.status(400).send('No URL provided.');
+  
+  try {
+    const ytdlResponse = await axios.get(
+      `https://ccproject.serv00.net/ytdl2.php?url=${encodeURIComponent(youtubeUrl)}`,
+      { headers: { 'User-Agent': 'Mozilla/5.1' } }
+    );
+
+    const data = ytdlResponse.data;
+    if (!data.download || !data.title) return res.status(400).send('Invalid response from YTDL API.');
+
+    const downloadUrl = data.download;
+    const title = data.title;
+    const timestamp = Date.now();
+    const filename = `${timestamp}.mp3`;
+    const filePath = path.join(__dirname, filename);
+
+    const fileDownload = await axios({
+      method: 'get',
+      url: downloadUrl,
+      responseType: 'stream',
+      headers: { 'User-Agent': 'Mozilla/5.1' }
+    });
+
+    const writer = fs.createWriteStream(filePath);
+    fileDownload.data.pipe(writer);
+
+    await new Promise((resolve, reject) => {
+      writer.on('finish', resolve);
+      writer.on('error', reject);
+    });
+
+    const form = new FormData();
+    form.append('file', fs.createReadStream(filePath));
+
+    const uploadResponse = await axios.post(
+      'https://ccproject.serv00.net/cc.php',
+      form,
+      { headers: { ...form.getHeaders(), 'User-Agent': 'Mozilla/5.1' } }
+    );
+
+    if (!uploadResponse.data.url) {
+      fs.unlinkSync(filePath);
+      return res.status(400).send('Invalid response from upload API.');
+    }
+
+    const uploadedUrl = uploadResponse.data.url;
+    const addSongApi = `http://gdphps.ccproject.serv00.net/dashboard/api/addSong.php?download=${encodeURIComponent(uploadedUrl)}&author=GdphMusicGD&name=${encodeURIComponent(title)}`;
+    const finalResponse = await axios.get(addSongApi, {
+      headers: { 'User-Agent': 'Mozilla/5.1' }
+    });
+
+    fs.unlinkSync(filePath);
+    res.send(finalResponse.data);
+
+  } catch (error) {
+    res.status(500).send(error.toString());
+  }
+});
+
+
+app.get("/api/catbox", async (req, res) => {
+    const url = req.query.url;
+    if (!url) return res.status(400).json({ error: "Missing 'url' parameter" });
+
+    try {
+        const saveDir = path.join(__dirname, "public");
+        if (!fs.existsSync(saveDir)) fs.mkdirSync(saveDir, { recursive: true });
+
+        const timestamp = Date.now();
+        const filePath = path.join(saveDir, `${timestamp}.mp3`);
+
+        const response = await axios.get(url, { responseType: "arraybuffer" });
+        fs.writeFileSync(filePath, response.data);
+
+        const form = new FormData();
+        form.append("reqtype", "fileupload");
+        form.append("userhash", "");
+        form.append("fileToUpload", fs.createReadStream(filePath));
+
+        const uploadResponse = await axios.post("https://catbox.moe/user/api.php", form, {
+            headers: {
+                ...form.getHeaders(),
+                "User-Agent": "Mozilla/5.0",
+                "Accept": "application/json",
+                "Accept-Encoding": "gzip, deflate, br, zstd",
+                "sec-ch-ua-platform": '"Android"',
+                "cache-control": "no-cache",
+                "sec-ch-ua": '"Chromium";v="130", "Google Chrome";v="130", "Not?A_Brand";v="99"',
+                "sec-ch-ua-mobile": "?1",
+                "x-requested-with": "XMLHttpRequest",
+                "dnt": "1",
+                "origin": "https://catbox.moe",
+                "sec-fetch-site": "same-origin",
+                "sec-fetch-mode": "cors",
+                "sec-fetch-dest": "empty",
+                "referer": "https://catbox.moe/",
+                "accept-language": "en-US,en;q=0.9",
+                "priority": "u=1, i"
+            }
+        });
+
+        fs.unlink(filePath, () => {});
+        res.json({ fileUrl: uploadResponse.data.trim() });
+    } catch (error) {
+        res.status(500).json({ error: "Failed to upload file", details: error.message });
+    }
+});
+const cheerio = require('cheerio');
+const categoryEmojiMap = {
+  "Night icon": "🌙",
+  "Gear icon": "⚙️",
+  "Egg icon": "🥚",
+  "Cosmetics icon": "💅",
+  "Honey icon": "🍯",
+  "Seeds icon": "🌱" 
+};
+
+async function getStockItems() {
+  const url = 'https://growagarden.gg/stocks';
+  try {
+    const { data } = await axios.get(url);
+    const $ = cheerio.load(data);
+
+    const stocks = [];
+
+    $('article.group.relative.rounded-lg.border-border\\/40.bg-card\\/20.p-4.transition-all.duration-300.hover\\:shadow-xl.hover\\:shadow-primary\\/10').each((i, parentElem) => {
+      const stockCategory = $(parentElem).find('h2.text-lg.font-semibold').text().trim();
+      const svgAriaLabel = $(parentElem).find('svg').attr('aria-label');
+      const categoryEmoji = categoryEmojiMap[svgAriaLabel] || '';
+
+      const items = [];
+
+      $(parentElem).find('article.group.relative.flex.items-center.gap-3.rounded-lg.border.bg-background\\/50.p-3.transition-all.duration-300.hover\\:scale-\\[1\\.02\\].hover\\:bg-background\\/80').each((j, itemElem) => {
+        const itemName = $(itemElem).find('h3.text-sm.font-medium').text().trim();
+        const itemEmoji = $(itemElem).find('div.absolute.-bottom-1.-right-1.rounded-full.border.border-border\\/50.bg-background\\/80.p-0.5.text-lg.shadow-sm').text().trim();
+        items.push({ 
+          name: itemName, 
+          emoji: itemEmoji,
+          id: `${stockCategory.toLowerCase().replace(/\s+/g, '-')}-${i}-${j}`
+        });
+      });
+
+      stocks.push({ 
+        category: stockCategory, 
+        categoryEmoji: categoryEmoji, 
+        items: items,
+        count: items.length
+      });
+    });
+
+    return {
+      success: true,
+      lastUpdated: new Date().toISOString(),
+      data: stocks.filter(stock => 
+        ["Night Stock", "Gear Stock", "Egg Stock", "Cosmetics Stock", "Honey Stock", "Seeds Stock"]
+        .includes(stock.category)
+      )
+    };
+
+  } catch (error) {
+    console.error(`Error fetching stock data: ${error}`);
+    return {
+      success: false,
+      error: error.message,
+      message: "Failed to fetch stock data"
+    };
+  }
+}
+
+app.get('/grow', async (req, res) => {
+  try {
+    const stockData = await getStockItems();
+    res.json(stockData);
+  } catch (error) {
+    console.error('Error in /grow route:', error);
+    res.status(500).json({
+      success: false,
+      error: error.message,
+      message: "Internal server error"
+    });
+  }
+});
+const { spawn } = require("child_process");
+
+const botFiles = [
+  "bot.js"
+];
+
+function startBot(file) {
+  console.log(`Starting bot: ${file}`);
+  const child = spawn("node", ["--trace-warnings", "--async-stack-traces", file], {
+    cwd: __dirname,
+    stdio: "inherit",
+    shell: true,
+  });
+
+  child.on("close", (codeExit) => {
+    console.log(`Bot process (${file}) exited with code: ${codeExit}`);
+    if (codeExit !== 0) {
+      setTimeout(() => startBot(file), 3000);
+    }
+  });
+
+  child.on("error", (error) => {
+    console.error(`An error occurred starting the bot (${file}): ${error}`);
+  });
+}
+
+botFiles.forEach(startBot);
+// Spotify part api nowiybru
+/*
+const SPOTIFY_API = {
+  BASE: 'https://api.spotify.com/v1',
+  AUTH: 'https://accounts.spotify.com/api/token',
+  CLIENT_ID: 'b0cdfaef5b0b401299244ef88df29ffb',
+  CLIENT_SECRET: '3e5949b78a214aecb2558b861911c1a9'
+};
+
+const FAB_DL_API = 'https://api.fabdl.com';
+
+let spotifyToken = null;
+let tokenExpiry = null;
+
+async function getSpotifyToken() {
+  if (spotifyToken && Date.now() < tokenExpiry) {
+    return spotifyToken;
+  }
+
+  try {
+    const authString = Buffer.from(`${SPOTIFY_API.CLIENT_ID}:${SPOTIFY_API.CLIENT_SECRET}`).toString('base64');
+    const response = await axios.post(SPOTIFY_API.AUTH, 'grant_type=client_credentials', {
+      headers: {
+        'Content-Type': 'application/x-www-form-urlencoded',
+        'Authorization': `Basic ${authString}`
+      }
+    });
+    spotifyToken = response.data.access_token;
+    tokenExpiry = Date.now() + (response.data.expires_in * 1000);
+    return spotifyToken;
+  } catch (error) {
+    console.error(error);
+    throw new Error('Failed to get Spotify token');
+  }
+}
+
+function formatDuration(ms) {
+  const minutes = Math.floor(ms / 60000);
+  const seconds = Math.floor((ms % 60000) / 1000);
+  return `${minutes}:${seconds.toString().padStart(2, '0')}`;
+}
+
+app.get('/api/spotify', async (req, res) => {
+  try {
+    const { url, search } = req.query;
+
+    if (url) {
+      const token = await getSpotifyToken();
+      const trackId = url.split('/').pop().split('?')[0];
+      const trackResponse = await axios.get(`${SPOTIFY_API.BASE}/tracks/${trackId}`, {
+        headers: { 'Authorization': `Bearer ${token}` }
+      });
+      
+      const fabResponse = await axios.get(`${FAB_DL_API}/spotify/get?url=${url}`);
+      const downloadResponse = await axios.get(
+        `${FAB_DL_API}/spotify/mp3-convert-task/${fabResponse.data.result.gid}/${fabResponse.data.result.id}`
+      );
+
+      res.json({
+        title: trackResponse.data.name,
+        artist: trackResponse.data.artists.map(a => a.name).join(', '),
+        duration: formatDuration(trackResponse.data.duration_ms),
+        cover: trackResponse.data.album.images[0]?.url,
+        downloadUrl: `${FAB_DL_API}${downloadResponse.data.result.download_url}`
+      });
+
+    } else if (search) {
+      const token = await getSpotifyToken();
+      const searchResponse = await axios.get(
+        `${SPOTIFY_API.BASE}/search?q=${encodeURIComponent(search)}&type=track&limit=10`,
+        { headers: { 'Authorization': `Bearer ${token}` } }
+      );
+
+      const tracks = searchResponse.data.tracks.items.map(track => ({
+        id: track.id,
+        title: track.name,
+        artist: track.artists.map(a => a.name).join(', '),
+        duration: formatDuration(track.duration_ms),
+        cover: track.album.images[0]?.url,
+        url: track.external_urls.spotify
+      }));
+
+      res.json(tracks);
+    } else {
+      res.status(400).json({ error: 'Missing url or search parameter' });
+    }
+  } catch (error) {
+    console.error(error);
+    res.status(500).json({ error: 'Internal server error' });
+  }
+});
+*/
+app.listen(PORT, () => {
+  console.log(`Server running at http://localhost:${PORT}`);
+});