page 전체 코드 품질/보안 개선 및 봇 RPC 검증 정합

[보안/인증]
- 모든 player/queue API 라우트에 세션 가드 추가 (이전: /api/servers 만 보호)
- NextAuth 환경변수 부팅 시점 검증, NEXTAUTH_SECRET 명시
- next.config.ts CSP/보안 헤더 추가, 잘못된 allowedDevOrigins 제거
- Redis 호스트 하드코딩 IP 제거(필수 env 로 강제)

[안정성]
- 봇 RPC 패턴(@/lib/api) 공용화: crypto.randomUUID requestId, JSON.parse 안전, EXPIRE 자동, 폴링 백오프
- SSE(@/lib/sse) 공용화: subscriber error 처리, JSON.parse 안전, 30초 keep-alive, abort/에러 정리
- pause API 양 끝(boolean) 정상화: 프론트 String() 캐스트 + 백엔드 .trim().toLowerCase() 비교 제거
- 봇 RedisClient: isPaused/index/seek/volume falsy 거부 → typeof 검사로 교체(0/false 정상 허용)

[타입/품질]
- next-auth 모듈 보강 → session.user.id, session.accessToken 타입 안전
- DiscordServer/Track/SearchTrack 공용 타입 도입, 컴포넌트 any 제거
- BigInt permissions 안전 검증(타입 가드)
- Logger: NODE_ENV 게이트, error → stderr, ISO 기반 안전 timestamp
- tsconfig target → ES2020 (BigInt 리터럴)

[취약점]
- next 16.2.2 → 16.2.4 (DoS/postcss XSS 패치)

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

page/src/app/api/auth/[...nextauth]/route.ts

@@ -1,11 +1,30 @@
 import NextAuth, { NextAuthOptions } from "next-auth";
 import DiscordProvider from "next-auth/providers/discord";
 
+// 환경변수 부팅 시점 검증 — 누락 시 즉시 실패
+const DISCORD_CLIENT_ID = process.env.DISCORD_CLIENT_ID?.trim();
+const DISCORD_CLIENT_SECRET = process.env.DISCORD_CLIENT_SECRET?.trim();
+const NEXTAUTH_SECRET = process.env.NEXTAUTH_SECRET?.trim();
+
+if (!DISCORD_CLIENT_ID || !DISCORD_CLIENT_SECRET) {
+  throw new Error("[NextAuth] DISCORD_CLIENT_ID/DISCORD_CLIENT_SECRET 환경변수가 설정되지 않았습니다.");
+}
+if (!NEXTAUTH_SECRET) {
+  throw new Error("[NextAuth] NEXTAUTH_SECRET 환경변수가 설정되지 않았습니다.");
+}
+
+interface DiscordProfile {
+  id?: string;
+  username?: string;
+  email?: string;
+}
+
 export const authOptions: NextAuthOptions = {
+  secret: NEXTAUTH_SECRET,
   providers: [
     DiscordProvider({
-      clientId: process.env.DISCORD_CLIENT_ID as string,
-      clientSecret: process.env.DISCORD_CLIENT_SECRET as string,
+      clientId: DISCORD_CLIENT_ID,
+      clientSecret: DISCORD_CLIENT_SECRET,
       // 🌟 핵심: 로그인할 때 유저의 기본 정보(identify)와 서버 목록(guilds) 권한을 같이 가져옵니다!
       authorization: { params: { scope: "identify email guilds" } },
     }),
@@ -16,15 +35,16 @@ export const authOptions: NextAuthOptions = {
   callbacks: {
     // 디스코드에서 받은 토큰(accessToken)을 우리 세션에 저장해두는 로직
     async jwt({ token, account, profile }) {
-      if (account && (profile as any)?.id) {
-        token.id = (profile as any).id;
+      const discordProfile = profile as DiscordProfile | undefined;
+      if (account && discordProfile?.id) {
+        token.id = discordProfile.id;
         token.accessToken = account.access_token;
       }
       return token;
     },
-    async session({ session, token }: any) {
-      session.user.id = token.id;
-      session.accessToken = token.accessToken;
+    async session({ session, token }) {
+      if (token.id) session.user.id = token.id;
+      if (token.accessToken) session.accessToken = token.accessToken;
       return session;
     },
   },
@@ -33,4 +53,4 @@ export const authOptions: NextAuthOptions = {
 const handler = NextAuth(authOptions);
 
 // App Router 환경에서는 GET과 POST 메서드를 둘 다 내보내야 합니다.
-export { handler as GET, handler as POST };
+export { handler as GET, handler as POST };

page/src/app/api/player/events/route.ts

@@ -1,54 +1,10 @@
-// src/app/api/queue/events/route.ts
+// src/app/api/player/events/route.ts
 import { NextRequest } from "next/server";
-import { Redis } from "@/lib/Redis"; // 사용 중인 Redis 클라이언트
+import { botEventStream } from "@/lib/sse";
 
 // 이 API는 캐시되지 않고 항상 실시간으로 작동해야 합니다.
 export const dynamic = "force-dynamic";
 
 export async function GET(req: NextRequest) {
-  // 프론트엔드에서 보낸 serverId 가져오기
-  const serverId = req.nextUrl.searchParams.get("serverId");
-
-  if (!serverId) {
-    return new Response("Missing serverId", { status: 400 });
-  }
-
-  // SSE(Server-Sent Events) 스트림 생성
-  const stream = new ReadableStream({
-    async start(controller) {
-      // 🚨 중요: 구독(Subscribe) 전용으로 쓸 독립적인 Redis 연결을 하나 복제합니다.
-      const subscriber = Redis.duplicate();
-
-      // 'bot-site' 채널 구독
-      await subscriber.subscribe("bot-site");
-
-      // 메세지가 들어올 때마다 실행
-      subscriber.on("message", (channel, message) => {
-        if (channel !== "bot-site") return;
-        const data = JSON.parse(message);
-        if (data.guildId !== serverId) return;
-        // 알림이 울린 서버와 현재 유저가 보고 있는 서버가 일치할 때만!
-        if (data.event === "player_update") {
-          // 프론트엔드로 "새로고침해!" 라는 데이터를 전송
-          controller.enqueue(`data: ${JSON.stringify({ type: "player_update" })}\n\n`);
-        }
-      });
-
-      // 클라이언트(웹사이트)가 브라우저를 닫거나 다른 페이지로 가면 연결 종료 및 정리
-      req.signal.addEventListener("abort", () => {
-        subscriber.unsubscribe("bot-site");
-        subscriber.quit();
-        controller.close();
-      });
-    }
-  });
-
-  // 스트림 응답 헤더 설정 (연결을 끊지 않고 계속 유지)
-  return new Response(stream, {
-    headers: {
-      "Content-Type": "text/event-stream",
-      "Cache-Control": "no-cache",
-      "Connection": "keep-alive",
-    },
-  });
-}
+  return botEventStream(req, { botEventName: "player_update" });
+}

page/src/app/api/player/now/route.ts

@@ -1,42 +1,34 @@
 import { NextResponse } from "next/server";
-import { Redis } from "@/lib/Redis";
+import { Logger } from "@/lib/Logger";
+import { botRpc, errorResponse, readJsonBody, requireSession, requireString } from "@/lib/api";
+
+interface NowBody {
+  serverId?: unknown;
+}
 
 export async function POST(request: Request) {
   try {
-    const body = await request.json();
-    const { serverId, userId } = body;
+    const sessionResult = await requireSession();
+    if (!sessionResult.ok) return sessionResult.response;
+    const userId = sessionResult.session.user.id;
 
-    if (!serverId) return NextResponse.json({ error: "serverId 정보가 필요합니다." }, { status: 400 });
-    if (!userId) return NextResponse.json({ error: "userId 정보가 필요합니다." }, { status: 400 });
+    const bodyResult = await readJsonBody<NowBody>(request);
+    if (!bodyResult.ok) return bodyResult.response;
 
-    const requestId = `req:${Date.now()}-${Math.random().toString(36).substring(7)}`;
-    const resultKey = `player:now:${requestId}`; // 봇이 대답을 남길 Redis 방 이름
+    const serverIdResult = requireString(bodyResult.data.serverId, "serverId");
+    if (!serverIdResult.ok) return serverIdResult.response;
 
-    // 봇에게 'player_now' 명령 전송
-    await Redis.publish("site-bot", JSON.stringify({
-      action: "player_now",
-      requestId: requestId,
-      serverId: serverId,
-      userId: userId,
-    }));
-
-    // 3. 봇의 대답 기다리기 (최대 약 3초 대기)
-    for (let i = 0; i < 15; i++) {
-      await new Promise(resolve => setTimeout(resolve, 200)); // 0.2초씩 대기
-      const botReply = await Redis.get(resultKey);
-      if (botReply) {
-        // 봇이 대답을 남겼다면! 읽었으니 Redis에서 삭제하고 프론트로 전달
-        await Redis.del(resultKey);
-        const replyData = JSON.parse(botReply);
-        // replyData.success 가 false면 에러 상태코드(400)로 보냄
-        return NextResponse.json(replyData, { status: replyData.success ? 200 : 400 });
-      }
-    }
-
-    // 3초가 지나도 봇이 묵묵부답일 때
-    return NextResponse.json({ success: false, message: "봇이 응답하지 않거나 오프라인 상태입니다." }, { status: 504 });
+    const { status, body } = await botRpc({
+      channel: "player:now",
+      payload: {
+        action: "player_now",
+        serverId: serverIdResult.value,
+        userId,
+      },
+    });
+    return NextResponse.json(body, { status });
   } catch (error) {
-    console.error("Play API Error:", error);
-    return NextResponse.json({ error: "서버 오류가 발생했습니다." }, { status: 500 });
+    Logger.error(`player/now API error: ${error instanceof Error ? error.message : String(error)}`);
+    return errorResponse("서버 오류가 발생했습니다.", 500);
   }
-}
+}

page/src/app/api/player/pause/route.ts

@@ -1,43 +1,46 @@
 import { NextResponse } from "next/server";
-import { Redis } from "@/lib/Redis";
+import { Logger } from "@/lib/Logger";
+import {
+  botRpc,
+  errorResponse,
+  readJsonBody,
+  requireBoolean,
+  requireSession,
+  requireString,
+} from "@/lib/api";
+
+interface PauseBody {
+  serverId?: unknown;
+  isPaused?: unknown;
+}
 
 export async function POST(request: Request) {
   try {
-    const body = await request.json();
-    const { serverId, userId, isPaused } = body;
-    if (!serverId) return NextResponse.json({ error: "serverId 정보가 필요합니다." }, { status: 400 });
-    if (!userId) return NextResponse.json({ error: "userId 정보가 필요합니다." }, { status: 400 });
-    if (!isPaused) return NextResponse.json({ error: "isPaused 정보가 필요합니다." }, { status: 400 });
+    const sessionResult = await requireSession();
+    if (!sessionResult.ok) return sessionResult.response;
+    const userId = sessionResult.session.user.id;
 
-    const requestId = `req:${Date.now()}-${Math.random().toString(36).substring(7)}`;
-    const resultKey = `player:paused:${requestId}`; // 봇이 대답을 남길 Redis 방 이름
+    const bodyResult = await readJsonBody<PauseBody>(request);
+    if (!bodyResult.ok) return bodyResult.response;
 
-    // 봇에게 'player_pause' 명령 전송
-    await Redis.publish("site-bot", JSON.stringify({
-      action: "player_paused",
-      requestId: requestId,
-      serverId: serverId,
-      userId: userId,
-      isPaused: isPaused,
-    }));
+    const serverIdResult = requireString(bodyResult.data.serverId, "serverId");
+    if (!serverIdResult.ok) return serverIdResult.response;
 
-    // 3. 봇의 대답 기다리기 (최대 약 3초 대기)
-    for (let i = 0; i < 15; i++) {
-      await new Promise(resolve => setTimeout(resolve, 200)); // 0.2초씩 대기
-      const botReply = await Redis.get(resultKey);
-      if (botReply) {
-        // 봇이 대답을 남겼다면! 읽었으니 Redis에서 삭제하고 프론트로 전달
-        await Redis.del(resultKey);
-        const replyData = JSON.parse(botReply);
-        // replyData.success 가 false면 에러 상태코드(400)로 보냄
-        return NextResponse.json(replyData, { status: replyData.success ? 200 : 400 });
-      }
-    }
+    const isPausedResult = requireBoolean(bodyResult.data.isPaused, "isPaused");
+    if (!isPausedResult.ok) return isPausedResult.response;
 
-    // 3초가 지나도 봇이 묵묵부답일 때
-    return NextResponse.json({ success: false, message: "봇이 응답하지 않거나 오프라인 상태입니다." }, { status: 504 });
+    const { status, body } = await botRpc({
+      channel: "player:paused",
+      payload: {
+        action: "player_paused",
+        serverId: serverIdResult.value,
+        userId,
+        isPaused: isPausedResult.value,
+      },
+    });
+    return NextResponse.json(body, { status });
   } catch (error) {
-    console.error("Play API Error:", error);
-    return NextResponse.json({ error: "서버 오류가 발생했습니다." }, { status: 500 });
+    Logger.error(`player/pause API error: ${error instanceof Error ? error.message : String(error)}`);
+    return errorResponse("서버 오류가 발생했습니다.", 500);
   }
-}
+}

page/src/app/api/player/play/route.ts

@@ -1,44 +1,39 @@
 import { NextResponse } from "next/server";
-import { Redis } from "@/lib/Redis";
+import { Logger } from "@/lib/Logger";
+import { botRpc, errorResponse, readJsonBody, requireSession, requireString } from "@/lib/api";
+
+interface PlayBody {
+  serverId?: unknown;
+  track?: unknown;
+}
 
 export async function POST(request: Request) {
   try {
-    const body = await request.json();
-    const { serverId, userId, track } = body;
+    const sessionResult = await requireSession();
+    if (!sessionResult.ok) return sessionResult.response;
+    const userId = sessionResult.session.user.id;
 
-    if (!serverId) return NextResponse.json({ error: "serverId 정보가 필요합니다." }, { status: 400 });
-    if (!userId) return NextResponse.json({ error: "userId 정보가 필요합니다." }, { status: 400 });
-    if (!track) return NextResponse.json({ error: "track 정보가 필요합니다." }, { status: 400 });
+    const bodyResult = await readJsonBody<PlayBody>(request);
+    if (!bodyResult.ok) return bodyResult.response;
 
-    const requestId = `req:${Date.now()}-${Math.random().toString(36).substring(7)}`;
-    const resultKey = `player:play:${requestId}`; // 봇이 대답을 남길 Redis 방 이름
+    const serverIdResult = requireString(bodyResult.data.serverId, "serverId");
+    if (!serverIdResult.ok) return serverIdResult.response;
 
-    // 봇에게 'player_play' 명령 전송
-    await Redis.publish("site-bot", JSON.stringify({
-      action: "player_play",
-      requestId: requestId,
-      serverId: serverId,
-      userId: userId,
-      track: track,
-    }));
+    const track = bodyResult.data.track;
+    if (!track || typeof track !== "object") return errorResponse("track 정보가 필요합니다.");
 
-    // 3. 봇의 대답 기다리기 (최대 약 3초 대기)
-    for (let i = 0; i < 15; i++) {
-      await new Promise(resolve => setTimeout(resolve, 200)); // 0.2초씩 대기
-      const botReply = await Redis.get(resultKey);
-      if (botReply) {
-        // 봇이 대답을 남겼다면! 읽었으니 Redis에서 삭제하고 프론트로 전달
-        await Redis.del(resultKey);
-        const replyData = JSON.parse(botReply);
-        // replyData.success 가 false면 에러 상태코드(400)로 보냄
-        return NextResponse.json(replyData, { status: replyData.success ? 200 : 400 });
-      }
-    }
-
-    // 3초가 지나도 봇이 묵묵부답일 때
-    return NextResponse.json({ success: false, message: "봇이 응답하지 않거나 오프라인 상태입니다." }, { status: 504 });
+    const { status, body } = await botRpc({
+      channel: "player:play",
+      payload: {
+        action: "player_play",
+        serverId: serverIdResult.value,
+        userId,
+        track,
+      },
+    });
+    return NextResponse.json(body, { status });
   } catch (error) {
-    console.error("Play API Error:", error);
-    return NextResponse.json({ error: "서버 오류가 발생했습니다." }, { status: 500 });
+    Logger.error(`player/play API error: ${error instanceof Error ? error.message : String(error)}`);
+    return errorResponse("서버 오류가 발생했습니다.", 500);
   }
-}
+}

page/src/app/api/player/playlist/route.ts

@@ -1,44 +1,39 @@
 import { NextResponse } from "next/server";
-import { Redis } from "@/lib/Redis";
+import { Logger } from "@/lib/Logger";
+import { botRpc, errorResponse, readJsonBody, requireSession, requireString } from "@/lib/api";
+
+interface PlaylistBody {
+  serverId?: unknown;
+  playlistUrl?: unknown;
+}
 
 export async function POST(request: Request) {
   try {
-    const body = await request.json();
-    const { serverId, userId, playlistUrl } = body;
+    const sessionResult = await requireSession();
+    if (!sessionResult.ok) return sessionResult.response;
+    const userId = sessionResult.session.user.id;
 
-    if (!serverId) return NextResponse.json({ error: "serverId 정보가 필요합니다." }, { status: 400 });
-    if (!userId) return NextResponse.json({ error: "userId 정보가 필요합니다." }, { status: 400 });
-    if (!playlistUrl) return NextResponse.json({ error: "playlistUrl 정보가 필요합니다." }, { status: 400 });
+    const bodyResult = await readJsonBody<PlaylistBody>(request);
+    if (!bodyResult.ok) return bodyResult.response;
 
-    const requestId = `req:${Date.now()}-${Math.random().toString(36).substring(7)}`;
-    const resultKey = `player:playlist:${requestId}`; // 봇이 대답을 남길 Redis 방 이름
+    const serverIdResult = requireString(bodyResult.data.serverId, "serverId");
+    if (!serverIdResult.ok) return serverIdResult.response;
 
-    // 봇에게 'player_playlist' 명령 전송
-    await Redis.publish("site-bot", JSON.stringify({
-      action: "player_playlist",
-      requestId: requestId,
-      serverId: serverId,
-      userId: userId,
-      playlistUrl: playlistUrl,
-    }));
+    const urlResult = requireString(bodyResult.data.playlistUrl, "playlistUrl");
+    if (!urlResult.ok) return urlResult.response;
 
-    // 3. 봇의 대답 기다리기 (최대 약 3초 대기)
-    for (let i = 0; i < 15; i++) {
-      await new Promise(resolve => setTimeout(resolve, 200)); // 0.2초씩 대기
-      const botReply = await Redis.get(resultKey);
-      if (botReply) {
-        // 봇이 대답을 남겼다면! 읽었으니 Redis에서 삭제하고 프론트로 전달
-        await Redis.del(resultKey);
-        const replyData = JSON.parse(botReply);
-        // replyData.success 가 false면 에러 상태코드(400)로 보냄
-        return NextResponse.json(replyData, { status: replyData.success ? 200 : 400 });
-      }
-    }
-
-    // 3초가 지나도 봇이 묵묵부답일 때
-    return NextResponse.json({ success: false, message: "봇이 응답하지 않거나 오프라인 상태입니다." }, { status: 504 });
+    const { status, body } = await botRpc({
+      channel: "player:playlist",
+      payload: {
+        action: "player_playlist",
+        serverId: serverIdResult.value,
+        userId,
+        playlistUrl: urlResult.value,
+      },
+    });
+    return NextResponse.json(body, { status });
   } catch (error) {
-    console.error("Queue Adds API Error:", error);
-    return NextResponse.json({ error: "서버 오류가 발생했습니다." }, { status: 500 });
+    Logger.error(`player/playlist API error: ${error instanceof Error ? error.message : String(error)}`);
+    return errorResponse("서버 오류가 발생했습니다.", 500);
   }
-}
+}

page/src/app/api/player/seek/route.ts

@@ -1,44 +1,47 @@
 import { NextResponse } from "next/server";
-import { Redis } from "@/lib/Redis";
+import { Logger } from "@/lib/Logger";
+import {
+  botRpc,
+  errorResponse,
+  readJsonBody,
+  requireNumber,
+  requireSession,
+  requireString,
+} from "@/lib/api";
+
+interface SeekBody {
+  serverId?: unknown;
+  seek?: unknown;
+}
 
 export async function POST(request: Request) {
   try {
-    const body = await request.json();
-    const { serverId, userId, seek } = body;
+    const sessionResult = await requireSession();
+    if (!sessionResult.ok) return sessionResult.response;
+    const userId = sessionResult.session.user.id;
 
-    if (!serverId) return NextResponse.json({ error: "serverId 정보가 필요합니다." }, { status: 400 });
-    if (!userId) return NextResponse.json({ error: "userId 정보가 필요합니다." }, { status: 400 });
-    if (!seek) return NextResponse.json({ error: "seek 정보가 필요합니다." }, { status: 400 });
+    const bodyResult = await readJsonBody<SeekBody>(request);
+    if (!bodyResult.ok) return bodyResult.response;
 
-    const requestId = `req:${Date.now()}-${Math.random().toString(36).substring(7)}`;
-    const resultKey = `player:seek:${requestId}`; // 봇이 대답을 남길 Redis 방 이름
+    const serverIdResult = requireString(bodyResult.data.serverId, "serverId");
+    if (!serverIdResult.ok) return serverIdResult.response;
 
-    // 봇에게 'player_seek' 명령 전송
-    await Redis.publish("site-bot", JSON.stringify({
-      action: "player_seek",
-      requestId: requestId,
-      serverId: serverId,
-      userId: userId,
-      seek: seek,
-    }));
+    // seek 는 0(처음으로 되감기) 도 정상 입력. requireNumber 는 0 허용.
+    const seekResult = requireNumber(bodyResult.data.seek, "seek", { min: 0, integer: true });
+    if (!seekResult.ok) return seekResult.response;
 
-    // 3. 봇의 대답 기다리기 (최대 약 3초 대기)
-    for (let i = 0; i < 15; i++) {
-      await new Promise(resolve => setTimeout(resolve, 200)); // 0.2초씩 대기
-      const botReply = await Redis.get(resultKey);
-      if (botReply) {
-        // 봇이 대답을 남겼다면! 읽었으니 Redis에서 삭제하고 프론트로 전달
-        await Redis.del(resultKey);
-        const replyData = JSON.parse(botReply);
-        // replyData.success 가 false면 에러 상태코드(400)로 보냄
-        return NextResponse.json(replyData, { status: replyData.success ? 200 : 400 });
-      }
-    }
-
-    // 3초가 지나도 봇이 묵묵부답일 때
-    return NextResponse.json({ success: false, message: "봇이 응답하지 않거나 오프라인 상태입니다." }, { status: 504 });
+    const { status, body } = await botRpc({
+      channel: "player:seek",
+      payload: {
+        action: "player_seek",
+        serverId: serverIdResult.value,
+        userId,
+        seek: seekResult.value,
+      },
+    });
+    return NextResponse.json(body, { status });
   } catch (error) {
-    console.error("Play API Error:", error);
-    return NextResponse.json({ error: "서버 오류가 발생했습니다." }, { status: 500 });
+    Logger.error(`player/seek API error: ${error instanceof Error ? error.message : String(error)}`);
+    return errorResponse("서버 오류가 발생했습니다.", 500);
   }
-}
+}

page/src/app/api/player/skip/route.ts

@@ -1,42 +1,34 @@
 import { NextResponse } from "next/server";
-import { Redis } from "@/lib/Redis";
+import { Logger } from "@/lib/Logger";
+import { botRpc, errorResponse, readJsonBody, requireSession, requireString } from "@/lib/api";
+
+interface SkipBody {
+  serverId?: unknown;
+}
 
 export async function POST(request: Request) {
   try {
-    const body = await request.json();
-    const { serverId, userId } = body;
+    const sessionResult = await requireSession();
+    if (!sessionResult.ok) return sessionResult.response;
+    const userId = sessionResult.session.user.id;
 
-    if (!serverId) return NextResponse.json({ error: "serverId 정보가 필요합니다." }, { status: 400 });
-    if (!userId) return NextResponse.json({ error: "userId 정보가 필요합니다." }, { status: 400 });
+    const bodyResult = await readJsonBody<SkipBody>(request);
+    if (!bodyResult.ok) return bodyResult.response;
 
-    const requestId = `req:${Date.now()}-${Math.random().toString(36).substring(7)}`;
-    const resultKey = `player:skip:${requestId}`; // 봇이 대답을 남길 Redis 방 이름
+    const serverIdResult = requireString(bodyResult.data.serverId, "serverId");
+    if (!serverIdResult.ok) return serverIdResult.response;
 
-    // 봇에게 'player_skip' 명령 전송
-    await Redis.publish("site-bot", JSON.stringify({
-      action: "player_skip",
-      requestId: requestId,
-      serverId: serverId,
-      userId: userId,
-    }));
-
-    // 3. 봇의 대답 기다리기 (최대 약 3초 대기)
-    for (let i = 0; i < 15; i++) {
-      await new Promise(resolve => setTimeout(resolve, 200)); // 0.2초씩 대기
-      const botReply = await Redis.get(resultKey);
-      if (botReply) {
-        // 봇이 대답을 남겼다면! 읽었으니 Redis에서 삭제하고 프론트로 전달
-        await Redis.del(resultKey);
-        const replyData = JSON.parse(botReply);
-        // replyData.success 가 false면 에러 상태코드(400)로 보냄
-        return NextResponse.json(replyData, { status: replyData.success ? 200 : 400 });
-      }
-    }
-
-    // 3초가 지나도 봇이 묵묵부답일 때
-    return NextResponse.json({ success: false, message: "봇이 응답하지 않거나 오프라인 상태입니다." }, { status: 504 });
+    const { status, body } = await botRpc({
+      channel: "player:skip",
+      payload: {
+        action: "player_skip",
+        serverId: serverIdResult.value,
+        userId,
+      },
+    });
+    return NextResponse.json(body, { status });
   } catch (error) {
-    console.error("Play API Error:", error);
-    return NextResponse.json({ error: "서버 오류가 발생했습니다." }, { status: 500 });
+    Logger.error(`player/skip API error: ${error instanceof Error ? error.message : String(error)}`);
+    return errorResponse("서버 오류가 발생했습니다.", 500);
   }
-}
+}

page/src/app/api/player/volume/route.ts

@@ -1,44 +1,50 @@
 import { NextResponse } from "next/server";
-import { Redis } from "@/lib/Redis";
+import { Logger } from "@/lib/Logger";
+import {
+  botRpc,
+  errorResponse,
+  readJsonBody,
+  requireNumber,
+  requireSession,
+  requireString,
+} from "@/lib/api";
+
+interface VolumeBody {
+  serverId?: unknown;
+  volume?: unknown;
+}
 
 export async function POST(request: Request) {
   try {
-    const body = await request.json();
-    const { serverId, userId, volume } = body;
+    const sessionResult = await requireSession();
+    if (!sessionResult.ok) return sessionResult.response;
+    const userId = sessionResult.session.user.id;
 
-    if (!serverId) return NextResponse.json({ error: "serverId 정보가 필요합니다." }, { status: 400 });
-    if (!userId) return NextResponse.json({ error: "userId 정보가 필요합니다." }, { status: 400 });
-    if (!volume) return NextResponse.json({ error: "volume 정보가 필요합니다." }, { status: 400 });
+    const bodyResult = await readJsonBody<VolumeBody>(request);
+    if (!bodyResult.ok) return bodyResult.response;
 
-    const requestId = `req:${Date.now()}-${Math.random().toString(36).substring(7)}`;
-    const resultKey = `player:volume:${requestId}`; // 봇이 대답을 남길 Redis 방 이름
+    const serverIdResult = requireString(bodyResult.data.serverId, "serverId");
+    if (!serverIdResult.ok) return serverIdResult.response;
 
-    // 봇에게 'player_volume' 명령 전송
-    await Redis.publish("site-bot", JSON.stringify({
-      action: "player_volume",
-      requestId: requestId,
-      serverId: serverId,
-      userId: userId,
-      volume: volume,
-    }));
+    const volumeResult = requireNumber(bodyResult.data.volume, "volume", {
+      min: 0,
+      max: 100,
+      integer: true,
+    });
+    if (!volumeResult.ok) return volumeResult.response;
 
-    // 3. 봇의 대답 기다리기 (최대 약 3초 대기)
-    for (let i = 0; i < 15; i++) {
-      await new Promise(resolve => setTimeout(resolve, 200)); // 0.2초씩 대기
-      const botReply = await Redis.get(resultKey);
-      if (botReply) {
-        // 봇이 대답을 남겼다면! 읽었으니 Redis에서 삭제하고 프론트로 전달
-        await Redis.del(resultKey);
-        const replyData = JSON.parse(botReply);
-        // replyData.success 가 false면 에러 상태코드(400)로 보냄
-        return NextResponse.json(replyData, { status: replyData.success ? 200 : 400 });
-      }
-    }
-
-    // 3초가 지나도 봇이 묵묵부답일 때
-    return NextResponse.json({ success: false, message: "봇이 응답하지 않거나 오프라인 상태입니다." }, { status: 504 });
+    const { status, body } = await botRpc({
+      channel: "player:volume",
+      payload: {
+        action: "player_volume",
+        serverId: serverIdResult.value,
+        userId,
+        volume: volumeResult.value,
+      },
+    });
+    return NextResponse.json(body, { status });
   } catch (error) {
-    console.error("Play API Error:", error);
-    return NextResponse.json({ error: "서버 오류가 발생했습니다." }, { status: 500 });
+    Logger.error(`player/volume API error: ${error instanceof Error ? error.message : String(error)}`);
+    return errorResponse("서버 오류가 발생했습니다.", 500);
   }
-}
+}

page/src/app/api/queue/events/route.ts

@@ -1,54 +1,10 @@
 // src/app/api/queue/events/route.ts
 import { NextRequest } from "next/server";
-import { Redis } from "@/lib/Redis"; // 사용 중인 Redis 클라이언트
+import { botEventStream } from "@/lib/sse";
 
 // 이 API는 캐시되지 않고 항상 실시간으로 작동해야 합니다.
 export const dynamic = "force-dynamic";
 
 export async function GET(req: NextRequest) {
-  // 프론트엔드에서 보낸 serverId 가져오기
-  const serverId = req.nextUrl.searchParams.get("serverId");
-
-  if (!serverId) {
-    return new Response("Missing serverId", { status: 400 });
-  }
-
-  // SSE(Server-Sent Events) 스트림 생성
-  const stream = new ReadableStream({
-    async start(controller) {
-      // 🚨 중요: 구독(Subscribe) 전용으로 쓸 독립적인 Redis 연결을 하나 복제합니다.
-      const subscriber = Redis.duplicate();
-
-      // 'bot-site' 채널 구독
-      await subscriber.subscribe("bot-site");
-
-      // 메세지가 들어올 때마다 실행
-      subscriber.on("message", (channel, message) => {
-        if (channel !== "bot-site") return;
-        const data = JSON.parse(message);
-        if (data.guildId !== serverId) return;
-        // 알림이 울린 서버와 현재 유저가 보고 있는 서버가 일치할 때만!
-        if (data.event === "queue_update") {
-          // 프론트엔드로 "새로고침해!" 라는 데이터를 전송
-          controller.enqueue(`data: ${JSON.stringify({ type: "queue_update" })}\n\n`);
-        }
-      });
-
-      // 클라이언트(웹사이트)가 브라우저를 닫거나 다른 페이지로 가면 연결 종료 및 정리
-      req.signal.addEventListener("abort", () => {
-        subscriber.unsubscribe("bot-site");
-        subscriber.quit();
-        controller.close();
-      });
-    }
-  });
-
-  // 스트림 응답 헤더 설정 (연결을 끊지 않고 계속 유지)
-  return new Response(stream, {
-    headers: {
-      "Content-Type": "text/event-stream",
-      "Cache-Control": "no-cache",
-      "Connection": "keep-alive",
-    },
-  });
-}
+  return botEventStream(req, { botEventName: "queue_update" });
+}

page/src/app/api/queue/list/route.ts

@@ -1,44 +1,34 @@
 import { NextResponse } from "next/server";
-import { Redis } from "@/lib/Redis";
+import { Logger } from "@/lib/Logger";
+import { botRpc, errorResponse, readJsonBody, requireSession, requireString } from "@/lib/api";
+
+interface QueueListBody {
+  serverId?: unknown;
+}
 
 export async function POST(request: Request) {
   try {
-    const body = await request.json();
-    const { serverId, userId } = body;
+    const sessionResult = await requireSession();
+    if (!sessionResult.ok) return sessionResult.response;
+    const userId = sessionResult.session.user.id;
 
-    if (!serverId) return NextResponse.json({ error: "serverId 정보가 필요합니다." }, { status: 400 });
-    if (!userId) return NextResponse.json({ error: "userId 정보가 필요합니다." }, { status: 400 });
+    const bodyResult = await readJsonBody<QueueListBody>(request);
+    if (!bodyResult.ok) return bodyResult.response;
 
-    // 1. 고유한 요청 ID(진동벨) 생성
-    const requestId = `${Date.now()}-${Math.random().toString(36).substring(7)}`;
-    const resultKey = `queue:list:${requestId}`;
-
-    // 2. 봇에게 'queue_list' 명령 발송
-    await Redis.publish("site-bot", JSON.stringify({
-      action: "queue_list",
-      serverId: serverId,
-      userId: userId,
-      requestId: requestId, // 🌟 봇이 대답을 남길 키
-    }));
-
-    // 3. 봇의 대답 기다리기 (최대 약 3초 대기)
-    for (let i = 0; i < 15; i++) {
-      await new Promise(resolve => setTimeout(resolve, 200)); // 0.2초씩 대기
-      const botReply = await Redis.get(resultKey);
-      if (botReply) {
-        // 봇이 대답을 남겼다면! 읽었으니 Redis에서 삭제하고 프론트로 전달
-        await Redis.del(resultKey);
-        const replyData = JSON.parse(botReply);
-        // replyData.success 가 false면 에러 상태코드(400)로 보냄
-        return NextResponse.json(replyData, { status: replyData.success ? 200 : 400 });
-      }
-    }
-
-    // 3초가 지나도 봇이 묵묵부답일 때
-    return NextResponse.json({ success: false, message: "봇이 응답하지 않거나 오프라인 상태입니다." }, { status: 504 });
+    const serverIdResult = requireString(bodyResult.data.serverId, "serverId");
+    if (!serverIdResult.ok) return serverIdResult.response;
 
+    const { status, body } = await botRpc({
+      channel: "queue:list",
+      payload: {
+        action: "queue_list",
+        serverId: serverIdResult.value,
+        userId,
+      },
+    });
+    return NextResponse.json(body, { status });
   } catch (error) {
-    console.error("Queue List API Error:", error);
-    return NextResponse.json({ success: false, message: "서버 오류가 발생했습니다." }, { status: 500 });
+    Logger.error(`queue/list API error: ${error instanceof Error ? error.message : String(error)}`);
+    return errorResponse("서버 오류가 발생했습니다.", 500);
   }
-}
+}

page/src/app/api/queue/remove/route.ts

@@ -1,45 +1,48 @@
 import { NextResponse } from "next/server";
-import { Redis } from "@/lib/Redis";
+import { Logger } from "@/lib/Logger";
+import {
+  botRpc,
+  errorResponse,
+  readJsonBody,
+  requireNumber,
+  requireSession,
+  requireString,
+} from "@/lib/api";
+
+interface QueueRemoveBody {
+  serverId?: unknown;
+  index?: unknown;
+}
 
 export async function POST(request: Request) {
   try {
-    const body = await request.json();
-    const { serverId, index, userId } = body;
+    const sessionResult = await requireSession();
+    if (!sessionResult.ok) return sessionResult.response;
+    const userId = sessionResult.session.user.id;
 
-    if (!serverId) return NextResponse.json({ error: "serverId 정보가 필요합니다." }, { status: 400 });
-    if (!userId) return NextResponse.json({ error: "userId 정보가 필요합니다." }, { status: 400 });
-    if (!index) return NextResponse.json({ error: "index 정보가 필요합니다." }, { status: 400 });
+    const bodyResult = await readJsonBody<QueueRemoveBody>(request);
+    if (!bodyResult.ok) return bodyResult.response;
 
-    const requestId = `${Date.now()}-${Math.random().toString(36).substring(7)}`;
-    const resultKey = `queue:remove:${requestId}`;
+    const serverIdResult = requireString(bodyResult.data.serverId, "serverId");
+    if (!serverIdResult.ok) return serverIdResult.response;
 
-    // 봇에게 'remove_queue' 명령 발송 (몇 번째 인덱스를 지워라)
-    await Redis.publish("site-bot", JSON.stringify({
-      action: "queue_remove",
-      serverId: serverId,
-      requestId: requestId,
-      userId: userId,
-      index: index,
-    }));
+    // index 0 도 정상값
+    const indexResult = requireNumber(bodyResult.data.index, "index", { min: 0, integer: true });
+    if (!indexResult.ok) return indexResult.response;
 
-    // 4. 결과가 올라올 때까지 기다리기 (Polling)
-    // 최대 10번(약 5초) 동안 0.5초 간격으로 확인합니다.
-    for (let i = 0; i < 10; i++) {
-      // 0.5초 대기
-      await new Promise(resolve => setTimeout(resolve, 500));
-
-      // Redis 게시판 확인
-      const resultData = await Redis.get(resultKey);
-
-      if (resultData) {
-        // 🌟 봇이 결과를 올렸다면! 데이터를 돌려주고 종료
-        return NextResponse.json(JSON.parse(resultData));
-      }
-    }
-
-    // 5초가 지나도 응답이 없으면 타임아웃
-    return NextResponse.json({ error: "봇이 검색에 응답하지 않습니다." }, { status: 504 });
+    const { status, body } = await botRpc({
+      channel: "queue:remove",
+      payload: {
+        action: "queue_remove",
+        serverId: serverIdResult.value,
+        userId,
+        index: indexResult.value,
+      },
+      timeoutMs: 5000,
+    });
+    return NextResponse.json(body, { status });
   } catch (error) {
-    return NextResponse.json({ error: "서버 오류" }, { status: 500 });
+    Logger.error(`queue/remove API error: ${error instanceof Error ? error.message : String(error)}`);
+    return errorResponse("서버 오류가 발생했습니다.", 500);
   }
-}
+}

page/src/app/api/queue/set/route.ts

@@ -1,46 +1,40 @@
 import { NextResponse } from "next/server";
-import { Redis } from "@/lib/Redis";
+import { Logger } from "@/lib/Logger";
+import { botRpc, errorResponse, readJsonBody, requireSession, requireString } from "@/lib/api";
+
+interface QueueSetBody {
+  serverId?: unknown;
+  newQueue?: unknown;
+}
 
 export async function POST(request: Request) {
   try {
-    const body = await request.json();
-    const { serverId, newQueue, userId } = body;
+    const sessionResult = await requireSession();
+    if (!sessionResult.ok) return sessionResult.response;
+    const userId = sessionResult.session.user.id;
 
-    if (!serverId) return NextResponse.json({ error: "serverId 정보가 필요합니다." }, { status: 400 });
-    if (!userId) return NextResponse.json({ error: "userId 정보가 필요합니다." }, { status: 400 });
-    if (newQueue === undefined || newQueue === null) return NextResponse.json({ error: "newQueue 정보가 필요합니다." }, { status: 400 });
+    const bodyResult = await readJsonBody<QueueSetBody>(request);
+    if (!bodyResult.ok) return bodyResult.response;
 
-    const requestId = `${Date.now()}-${Math.random().toString(36).substring(7)}`;
-    const resultKey = `queue:set:${requestId}`;
+    const serverIdResult = requireString(bodyResult.data.serverId, "serverId");
+    if (!serverIdResult.ok) return serverIdResult.response;
 
-    // 봇에게 'queue_set' 명령 발송 (전체 대기열을 통째로 덮어써라!)
-    await Redis.publish("site-bot", JSON.stringify({
-      action: "queue_set",
-      serverId: serverId,
-      requestId: requestId,
-      userId: userId,
-      newQueue: newQueue,
-    }));
+    const newQueue = bodyResult.data.newQueue;
+    if (!Array.isArray(newQueue)) return errorResponse("newQueue 정보가 필요합니다.");
 
-    // 4. 결과가 올라올 때까지 기다리기 (Polling)
-    // 최대 10번(약 5초) 동안 0.5초 간격으로 확인합니다.
-    for (let i = 0; i < 10; i++) {
-      // 0.5초 대기
-      await new Promise(resolve => setTimeout(resolve, 500));
-
-      // Redis 게시판 확인
-      const resultData = await Redis.get(resultKey);
-
-      if (resultData) {
-        // 🌟 봇이 결과를 올렸다면! 데이터를 돌려주고 종료
-        return NextResponse.json(JSON.parse(resultData));
-      }
-    }
-
-    // 5초가 지나도 응답이 없으면 타임아웃
-    return NextResponse.json({ error: "봇이 검색에 응답하지 않습니다." }, { status: 504 });
+    const { status, body } = await botRpc({
+      channel: "queue:set",
+      payload: {
+        action: "queue_set",
+        serverId: serverIdResult.value,
+        userId,
+        newQueue,
+      },
+      timeoutMs: 5000,
+    });
+    return NextResponse.json(body, { status });
   } catch (error) {
-    console.error("Queue Reorder API Error:", error);
-    return NextResponse.json({ error: "서버 오류" }, { status: 500 });
+    Logger.error(`queue/set API error: ${error instanceof Error ? error.message : String(error)}`);
+    return errorResponse("서버 오류가 발생했습니다.", 500);
   }
-}
+}

page/src/app/api/search/route.ts

@@ -1,42 +1,30 @@
 // src/app/api/search/route.ts
 import { NextResponse } from "next/server";
-import { Redis } from "@/lib/Redis";
+import { Logger } from "@/lib/Logger";
+import { botRpc, errorResponse, requireSession } from "@/lib/api";
 
 export async function GET(request: Request) {
-  // 1. 검색어(query) 가져오기
-  const { searchParams } = new URL(request.url);
-  const query = searchParams.get("q");
+  try {
+    const sessionResult = await requireSession();
+    if (!sessionResult.ok) return sessionResult.response;
 
-  if (!query) {
-    return NextResponse.json({ error: "검색어가 없습니다." }, { status: 400 });
+    const { searchParams } = new URL(request.url);
+    const query = searchParams.get("q")?.trim();
+
+    if (!query) return errorResponse("검색어가 없습니다.", 400);
+
+    const { status, body } = await botRpc({
+      channel: "search",
+      payload: {
+        action: "search",
+        query,
+      },
+      timeoutMs: 10000,
+      pollIntervalMs: 250,
+    });
+    return NextResponse.json(body, { status });
+  } catch (error) {
+    Logger.error(`search API error: ${error instanceof Error ? error.message : String(error)}`);
+    return errorResponse("서버 오류가 발생했습니다.", 500);
   }
-
-  // 2. 고유한 요청 ID 생성 (예: 1690001234567-abc)
-  const requestId = `${Date.now()}-${Math.random().toString(36).substring(7)}`;
-  const resultKey = `search:${requestId}`;
-
-  // 3. 봇에게 'site-bot' 채널로 검색 명령 발송 (Publish)
-  await Redis.publish("site-bot", JSON.stringify({
-    action: "search",
-    query: query,
-    requestId: requestId,
-  }));
-
-  // 4. 결과가 올라올 때까지 기다리기 (Polling)
-  // 최대 10번(약 10초) 동안 1.0초 간격으로 확인합니다.
-  for (let i=0; i<10; i++) {
-    // 1.0초 대기
-    await new Promise(resolve => setTimeout(resolve, 1000));
-    
-    // Redis 게시판 확인
-    const resultData = await Redis.get(resultKey);
-    
-    if (resultData) {
-      // 🌟 봇이 결과를 올렸다면! 데이터를 돌려주고 종료
-      return NextResponse.json(JSON.parse(resultData));
-    }
-  }
-
-  // 5초가 지나도 응답이 없으면 타임아웃
-  return NextResponse.json({ error: "봇이 검색에 응답하지 않습니다." }, { status: 504 });
-}
+}

page/src/app/api/servers/route.ts

@@ -1,34 +1,58 @@
 import { NextResponse } from "next/server";
-import { getServerSession } from "next-auth";
 import { Redis } from "@/lib/Redis";
-import { authOptions } from "../auth/[...nextauth]/route";
+import { Logger } from "@/lib/Logger";
+import { requireSession } from "@/lib/api";
+
+interface DiscordGuild {
+  id: string;
+  name: string;
+  icon: string | null;
+  owner: boolean;
+  permissions: string;
+}
 
 export async function GET() {
-  const session = await getServerSession(authOptions) as any;
+  const sessionResult = await requireSession();
+  if (!sessionResult.ok) return sessionResult.response;
 
-  if (!session || !session.accessToken) {
-    return NextResponse.json({ error: "인증되지 않았습니다." }, { status: 401 });
+  const accessToken = sessionResult.session.accessToken;
+  if (!accessToken) {
+    return NextResponse.json({ success: false, error: "Discord 액세스 토큰이 없습니다." }, { status: 401 });
   }
 
   try {
     // 1. 디스코드 API에서 유저가 속한 서버 목록 가져오기
     const userGuildsRes = await fetch("https://discord.com/api/users/@me/guilds", {
-      headers: { Authorization: `Bearer ${session.accessToken}` },
+      headers: { Authorization: `Bearer ${accessToken}` },
     });
-    const userGuilds = await userGuildsRes.json() ?? [];
+    if (!userGuildsRes.ok) {
+      Logger.warn(`Discord guilds API ${userGuildsRes.status} ${userGuildsRes.statusText}`);
+      return NextResponse.json(
+        { success: false, error: "Discord 서버 목록을 가져오지 못했습니다." },
+        { status: 502 },
+      );
+    }
+    const userGuildsRaw: unknown = await userGuildsRes.json();
+    const userGuilds: DiscordGuild[] = Array.isArray(userGuildsRaw) ? (userGuildsRaw as DiscordGuild[]) : [];
 
     // 2. Redis에서 봇이 속한 서버 목록(화이트리스트) 가져오기
     const botGuildsData = await Redis.get("bot-guilds");
-    const botGuildIds: string[] = botGuildsData ? JSON.parse(botGuildsData) : [];
+    let botGuildIds: string[] = [];
+    if (botGuildsData) {
+      try {
+        const parsed = JSON.parse(botGuildsData);
+        if (Array.isArray(parsed)) botGuildIds = parsed.filter((v): v is string => typeof v === "string");
+      } catch {
+        Logger.warn("Redis bot-guilds JSON 파싱 실패");
+      }
+    }
 
     // 3. 🌟 두 목록을 비교해서 봇이 있는 서버만 필터링!
-    const filteredGuilds = userGuilds.filter((guild: any) => 
-      botGuildIds.includes(guild.id)
-    );
+    const filteredGuilds = userGuilds.filter((guild) => botGuildIds.includes(guild.id));
 
     return NextResponse.json(filteredGuilds);
   } catch (error) {
-    console.error("서버 필터링 에러:", error);
-    return NextResponse.json({ error: "서버 목록을 가져오지 못했습니다." }, { status: 500 });
+    Logger.error(`서버 필터링 에러: ${error instanceof Error ? error.message : String(error)}`);
+    return NextResponse.json({ success: false, error: "서버 목록을 가져오지 못했습니다." }, { status: 500 });
   }
-}
+}

page/src/app/page.tsx

@@ -6,13 +6,14 @@ import LeftSidebar from "@/components/layout/LeftSidebar";
 import MainContent from "@/components/player/MainContent";
 import QueueSidebar from "@/components/player/QueueSidebar";
 import PlayerBar from "@/components/player/PlayerBar";
+import type { DiscordServer } from "@/types/music";
 
 // 화면 모드 타입 정의
 export type ViewMode = "SERVER_LIST" | "SERVER_DETAIL" | "SEARCH_RESULT";
 
 export default function MusicPlayerLayout() {
   const [viewMode, setViewMode] = useState<ViewMode>("SERVER_LIST");
-  const [selectedServer, setSelectedServer] = useState<any>(null);
+  const [selectedServer, setSelectedServer] = useState<DiscordServer | null>(null);
   const [searchQuery, setSearchQuery] = useState("");
 
   // 홈 버튼 클릭 시: 서버 목록(또는 상세)으로 복귀
@@ -33,7 +34,7 @@ export default function MusicPlayerLayout() {
   };
 
   // 서버 선택 시
-  const handleSelectServer = (server: any) => {
+  const handleSelectServer = (server: DiscordServer) => {
     setSelectedServer(server);
     setViewMode("SERVER_DETAIL");
   };