clean: initial commit ohne Secrets

server/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "discord-soundboard-server",
+  "version": "0.1.0",
+  "private": true,
+  "type": "module",
+  "main": "dist/index.js",
+  "scripts": {
+    "dev": "ts-node src/index.ts",
+    "build": "tsc -p tsconfig.json",
+    "start": "node dist/index.js"
+  },
+  "dependencies": {
+    "@discordjs/voice": "^0.17.0",
+    "@discordjs/opus": "^0.9.0",
+    "discord.js": "^14.16.3",
+    "express": "^4.19.2",
+    "libsodium-wrappers": "^0.7.13",
+    "tweetnacl": "^1.0.3",
+    "sodium-native": "^4.0.8",
+    "cors": "^2.8.5",
+    "multer": "^1.4.5-lts.1",
+    "ws": "^8.18.0"
+  },
+  "devDependencies": {
+    "@types/cors": "^2.8.17",
+    "@types/express": "^4.17.21",
+    "@types/node": "^20.12.12",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.5.4"
+  }
+}
+
+

server/pnpm-lock.yaml

@@ -0,0 +1,15 @@
+lockfileVersion: '9.0'
+dependencies:
+  '@discordjs/voice': ^0.17.0
+  discord.js: ^14.16.3
+  express: ^4.19.2
+  multer: ^1.4.5-lts.1
+  ws: ^8.18.0
+devDependencies:
+  ts-node: ^10.9.2
+  typescript: ^5.5.4
+
+
+
+
+

server/src/index.ts

@@ -0,0 +1,215 @@
+import path from 'node:path';
+import fs from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import express, { Request, Response } from 'express';
+import cors from 'cors';
+import { Client, GatewayIntentBits, Partials, ChannelType, Events, type Message } from 'discord.js';
+import {
+  joinVoiceChannel,
+  createAudioPlayer,
+  createAudioResource,
+  AudioPlayerStatus,
+  NoSubscriberBehavior,
+  getVoiceConnection,
+  type VoiceConnection,
+  generateDependencyReport
+} from '@discordjs/voice';
+import sodium from 'libsodium-wrappers';
+import nacl from 'tweetnacl';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// --- Config ---
+const PORT = Number(process.env.PORT ?? 8080);
+const SOUNDS_DIR = process.env.SOUNDS_DIR ?? '/data/sounds';
+const DISCORD_TOKEN = process.env.DISCORD_TOKEN ?? '';
+const ALLOWED_GUILD_IDS = (process.env.ALLOWED_GUILD_IDS ?? '')
+  .split(',')
+  .map((s) => s.trim())
+  .filter(Boolean);
+
+if (!DISCORD_TOKEN) {
+  console.error('Fehlende Umgebungsvariable DISCORD_TOKEN');
+  process.exit(1);
+}
+
+fs.mkdirSync(SOUNDS_DIR, { recursive: true });
+
+// --- Voice Abhängigkeiten prüfen ---
+await sodium.ready;
+// init nacl to ensure it loads
+void nacl.randomBytes(1);
+console.log(generateDependencyReport());
+
+// --- Discord Client ---
+const client = new Client({
+  // 32385 = Guilds + GuildVoiceStates + GuildMessages + GuildMessageReactions + GuildMessageTyping
+  //        + DirectMessages + DirectMessageReactions + DirectMessageTyping
+  // (ohne privilegierte Intents wie MessageContent/GuildMembers/Presences)
+  intents: 32385,
+  partials: [Partials.Channel]
+});
+
+type GuildAudioState = { connection: VoiceConnection; player: ReturnType<typeof createAudioPlayer> };
+const guildAudioState = new Map<string, GuildAudioState>();
+
+client.once(Events.ClientReady, () => {
+  console.log(`Bot eingeloggt als ${client.user?.tag}`);
+});
+
+client.on(Events.MessageCreate, async (message: Message) => {
+  try {
+    if (message.author?.bot) return;
+    if (!message.channel?.isDMBased?.()) return;
+    if (message.attachments.size === 0) return;
+
+    for (const [, attachment] of message.attachments) {
+      const name = attachment.name ?? 'upload.mp3';
+      const lower = name.toLowerCase();
+      if (!lower.endsWith('.mp3')) continue;
+
+      const safeName = name.replace(/[^a-zA-Z0-9_.-]/g, '_');
+      let targetPath = path.join(SOUNDS_DIR, safeName);
+      if (fs.existsSync(targetPath)) {
+        const base = path.parse(safeName).name;
+        const ext = path.parse(safeName).ext || '.mp3';
+        let i = 2;
+        while (fs.existsSync(targetPath)) {
+          targetPath = path.join(SOUNDS_DIR, `${base}-${i}${ext}`);
+          i += 1;
+        }
+      }
+
+      const res = await fetch(attachment.url);
+      if (!res.ok) throw new Error(`Download fehlgeschlagen: ${attachment.url}`);
+      const arrayBuffer = await res.arrayBuffer();
+      fs.writeFileSync(targetPath, Buffer.from(arrayBuffer));
+      await message.reply(`Sound gespeichert: ${path.basename(targetPath)}`);
+    }
+  } catch (err) {
+    console.error('Fehler bei DM-Upload:', err);
+  }
+});
+
+await client.login(DISCORD_TOKEN);
+
+// --- Express App ---
+const app = express();
+app.use(express.json());
+app.use(cors());
+
+app.get('/api/health', (_req: Request, res: Response) => {
+  res.json({ ok: true });
+});
+
+app.get('/api/sounds', (req: Request, res: Response) => {
+  const q = String(req.query.q ?? '').toLowerCase();
+  const files = fs
+    .readdirSync(SOUNDS_DIR, { withFileTypes: true })
+    .filter((d) => d.isFile() && d.name.toLowerCase().endsWith('.mp3'))
+    .map((d) => d.name)
+    .sort((a, b) => a.localeCompare(b));
+
+  const items = files
+    .map((file) => ({ fileName: file, name: path.parse(file).name }))
+    .filter((s) => (q ? s.name.toLowerCase().includes(q) : true));
+
+  res.json(items);
+});
+
+app.get('/api/channels', (_req: Request, res: Response) => {
+  if (!client.isReady()) return res.status(503).json({ error: 'Bot noch nicht bereit' });
+
+  const allowed = new Set(ALLOWED_GUILD_IDS);
+  const result: Array<{ guildId: string; guildName: string; channelId: string; channelName: string }> = [];
+  for (const [, guild] of client.guilds.cache) {
+    if (allowed.size > 0 && !allowed.has(guild.id)) continue;
+    const channels = guild.channels.cache;
+    for (const [, ch] of channels) {
+      if (ch?.type === ChannelType.GuildVoice || ch?.type === ChannelType.GuildStageVoice) {
+        result.push({ guildId: guild.id, guildName: guild.name, channelId: ch.id, channelName: ch.name });
+      }
+    }
+  }
+  result.sort((a, b) => a.guildName.localeCompare(b.guildName) || a.channelName.localeCompare(b.channelName));
+  res.json(result);
+});
+
+app.post('/api/play', async (req: Request, res: Response) => {
+  try {
+    const { soundName, guildId, channelId } = req.body as {
+      soundName?: string;
+      guildId?: string;
+      channelId?: string;
+    };
+    if (!soundName || !guildId || !channelId) return res.status(400).json({ error: 'soundName, guildId, channelId erforderlich' });
+
+    const filePath = path.join(SOUNDS_DIR, `${soundName}.mp3`);
+    if (!fs.existsSync(filePath)) return res.status(404).json({ error: 'Sound nicht gefunden' });
+
+    const guild = client.guilds.cache.get(guildId);
+    if (!guild) return res.status(404).json({ error: 'Guild nicht gefunden' });
+    const channel = guild.channels.cache.get(channelId);
+    if (!channel || (channel.type !== ChannelType.GuildVoice && channel.type !== ChannelType.GuildStageVoice)) {
+      return res.status(400).json({ error: 'Ungültiger Voice-Channel' });
+    }
+
+    let state = guildAudioState.get(guildId);
+    if (!state) {
+      const connection = joinVoiceChannel({
+        channelId,
+        guildId,
+        adapterCreator: guild.voiceAdapterCreator as any
+      });
+      const player = createAudioPlayer({ behaviors: { noSubscriber: NoSubscriberBehavior.Play } });
+      connection.subscribe(player);
+      state = { connection, player };
+      guildAudioState.set(guildId, state);
+
+      state.player.on(AudioPlayerStatus.Idle, () => {
+        // optional: Verbindung bestehen lassen oder nach Timeout trennen
+      });
+    } else {
+      // Wechsel in anderen Channel, wenn nötig
+      const current = getVoiceConnection(guildId);
+      if (current && (current.joinConfig.channelId !== channelId)) {
+        current.destroy();
+        const connection = joinVoiceChannel({
+          channelId,
+          guildId,
+          adapterCreator: guild.voiceAdapterCreator as any
+        });
+        const player = createAudioPlayer({ behaviors: { noSubscriber: NoSubscriberBehavior.Play } });
+        connection.subscribe(player);
+        state = { connection, player };
+        guildAudioState.set(guildId, state);
+      }
+    }
+
+    const resource = createAudioResource(filePath);
+    state.player.stop();
+    state.player.play(resource);
+    return res.json({ ok: true });
+  } catch (err: any) {
+    console.error('Play-Fehler:', err);
+    return res.status(500).json({ error: err?.message ?? 'Unbekannter Fehler' });
+  }
+});
+
+// Static Frontend ausliefern (Vite build)
+const webDistPath = path.resolve(__dirname, '../../web/dist');
+if (fs.existsSync(webDistPath)) {
+  app.use(express.static(webDistPath));
+  app.get('*', (_req, res) => {
+    res.sendFile(path.join(webDistPath, 'index.html'));
+  });
+}
+
+app.listen(PORT, () => {
+  console.log(`Server läuft auf http://0.0.0.0:${PORT}`);
+});
+
+
+
+

server/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ES2022",
+    "moduleResolution": "Node",
+    "outDir": "dist",
+    "rootDir": "src",
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "resolveJsonModule": true
+  },
+  "include": ["src/**/*"]
+}
+
+
+
+
+