치지직 채팅창 인식 추가 및 주사위 횟수 증가 추가.

This commit is contained in:
kimyu
2026-09-16 02:21:39 +09:00
parent 171a4e19f6
commit 7c402dfd8f
22 changed files with 2133 additions and 90 deletions

135
lib/chzzk/channel.ts Normal file
View File

@@ -0,0 +1,135 @@
/** 치지직 라이브/채널 URL에서 channelId 추출 */
export function parseChzzkChannelId(input: string): string | null {
const raw = input.trim();
if (!raw) return null;
// 해시만 붙여 넣은 경우
if (/^[a-f0-9]{32}$/i.test(raw)) return raw.toLowerCase();
try {
const url = new URL(raw.startsWith('http') ? raw : `https://${raw}`);
if (!url.hostname.includes('chzzk.naver.com')) return null;
const parts = url.pathname.split('/').filter(Boolean);
// /live/{id} | /{id} | /channel/{id}
const liveIdx = parts.indexOf('live');
if (liveIdx >= 0 && parts[liveIdx + 1]) {
const id = parts[liveIdx + 1];
return /^[a-f0-9]{32}$/i.test(id) ? id.toLowerCase() : null;
}
const channelIdx = parts.indexOf('channel');
if (channelIdx >= 0 && parts[channelIdx + 1]) {
const id = parts[channelIdx + 1];
return /^[a-f0-9]{32}$/i.test(id) ? id.toLowerCase() : null;
}
if (parts[0] && /^[a-f0-9]{32}$/i.test(parts[0])) {
return parts[0].toLowerCase();
}
} catch {
return null;
}
return null;
}
const CHZZK_API = 'https://api.chzzk.naver.com';
const GAME_API = 'https://comm-api.game.naver.com/nng_main';
const DEFAULT_HEADERS = {
Accept: 'application/json',
'User-Agent':
'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36',
Origin: 'https://chzzk.naver.com',
Referer: 'https://chzzk.naver.com/',
};
async function getJson<T>(url: string): Promise<T> {
const res = await fetch(url, {
headers: DEFAULT_HEADERS,
cache: 'no-store',
});
if (!res.ok) {
throw new Error(`치지직 API 오류 (${res.status})`);
}
return (await res.json()) as T;
}
export type ChannelInfo = {
channelId: string;
channelName: string | null;
};
export async function fetchChannelInfo(channelId: string): Promise<ChannelInfo> {
const data = await getJson<{
content?: { channelId?: string; channelName?: string };
}>(`${CHZZK_API}/service/v1/channels/${channelId}`);
return {
channelId: data.content?.channelId || channelId,
channelName: data.content?.channelName ?? null,
};
}
export type LiveChatInfo = {
chatChannelId: string;
liveTitle: string | null;
status: string | null;
};
/** 방송 중일 때 chatChannelId를 얻는다. */
export async function fetchLiveChatInfo(channelId: string): Promise<LiveChatInfo> {
// polling live-status 우선
try {
const status = await getJson<{
content?: { chatChannelId?: string; status?: string; liveTitle?: string };
}>(`${CHZZK_API}/polling/v2/channels/${channelId}/live-status`);
if (status.content?.chatChannelId) {
return {
chatChannelId: status.content.chatChannelId,
liveTitle: status.content.liveTitle ?? null,
status: status.content.status ?? null,
};
}
} catch {
// fallback below
}
const detail = await getJson<{
content?: { chatChannelId?: string; liveTitle?: string; status?: string };
}>(`${CHZZK_API}/service/v3/channels/${channelId}/live-detail`);
if (!detail.content?.chatChannelId) {
throw new Error('방송이 꺼져 있거나 chatChannelId를 찾지 못했습니다.');
}
return {
chatChannelId: detail.content.chatChannelId,
liveTitle: detail.content.liveTitle ?? null,
status: detail.content.status ?? null,
};
}
export async function fetchChatAccessToken(chatChannelId: string): Promise<string> {
const data = await getJson<{
code?: number;
message?: string;
content?: { accessToken?: string };
}>(
`${GAME_API}/v1/chats/access-token?channelId=${encodeURIComponent(chatChannelId)}&chatType=STREAMING`,
);
if (data.code === 42601) {
throw new Error('연령 제한 방송이라 익명 채팅 토큰을 받을 수 없습니다.');
}
const token = data.content?.accessToken;
if (!token) {
throw new Error(data.message || '채팅 accessToken을 받지 못했습니다.');
}
return token;
}
export function chatServerUrl(chatChannelId: string) {
const sum = chatChannelId
.split('')
.map((c) => c.charCodeAt(0))
.reduce((a, b) => a + b, 0);
const serverId = (Math.abs(sum) % 9) + 1;
return `wss://kr-ss${serverId}.chat.naver.com/chat`;
}

505
lib/chzzk/chat-session.ts Normal file
View File

@@ -0,0 +1,505 @@
import WebSocket from 'ws';
import {
chatServerUrl,
fetchChannelInfo,
fetchChatAccessToken,
fetchLiveChatInfo,
} from './channel';
import {
addChatMessage,
addDiceFromDonation,
clearChatFeed,
getRoom,
getRoomViewerCount,
hasSeenDonationKey,
markSeenDonationKey,
notifyRoom,
setRoomMeta,
} from '../rooms/store';
const ChatCmd = {
PING: 0,
PONG: 10000,
CONNECT: 100,
CONNECTED: 10100,
REQUEST_RECENT_CHAT: 5101,
RECENT_CHAT: 15101,
CHAT: 93101,
DONATION: 93102,
} as const;
const ChatType = {
TEXT: 1,
DONATION: 10,
SUBSCRIPTION: 11,
} as const;
type SessionHandle = {
roomId: string;
ws: WebSocket;
chatChannelId: string;
sid: string | null;
pingTimer: ReturnType<typeof setTimeout> | null;
pollTimer: ReturnType<typeof setInterval> | null;
closed: boolean;
/** 이번 연결에서 이미 피드에 넣은 메시지 키 */
seenMessageKeys: Set<string>;
};
const SEEN_KEYS_MAX = 800;
const RECENT_CHAT_COUNT = 50;
const globalForSessions = globalThis as typeof globalThis & {
__drinkmarbleChatSessions?: Map<string, SessionHandle>;
};
function getSessions() {
if (!globalForSessions.__drinkmarbleChatSessions) {
globalForSessions.__drinkmarbleChatSessions = new Map();
}
return globalForSessions.__drinkmarbleChatSessions;
}
function clearPing(handle: SessionHandle) {
if (handle.pingTimer) clearTimeout(handle.pingTimer);
handle.pingTimer = null;
}
function schedulePing(handle: SessionHandle) {
clearPing(handle);
handle.pingTimer = setTimeout(() => {
if (handle.closed || handle.ws.readyState !== WebSocket.OPEN) return;
handle.ws.send(JSON.stringify({ cmd: ChatCmd.PING, ver: '2' }));
schedulePing(handle);
}, 20000);
}
function parseMaybeJson<T>(value: unknown): T | null {
if (value == null) return null;
if (typeof value === 'object') return value as T;
if (typeof value !== 'string') return null;
try {
return JSON.parse(value) as T;
} catch {
return null;
}
}
function messageTimeMs(chat: Record<string, unknown>): number | null {
const raw = chat.msgTime ?? chat.messageTime;
const n = typeof raw === 'string' ? Number(raw) : Number(raw);
if (!Number.isFinite(n) || n <= 0) return null;
return n;
}
function messageKey(
chat: Record<string, unknown>,
kind: 'donation' | 'chat',
): string | null {
const id = chat.msgUid ?? chat.messageId ?? null;
if (id != null && String(id).length > 0) {
return `${kind}:${String(id)}`;
}
const time = messageTimeMs(chat);
const profile = parseMaybeJson<{ nickname?: string; userIdHash?: string }>(
chat.profile,
);
const extras = parseMaybeJson<{ payAmount?: number }>(chat.extras);
const who = profile?.userIdHash || profile?.nickname || '';
const msg = String(chat.msg ?? chat.content ?? '');
if (time == null && !who && !msg) return null;
if (kind === 'donation') {
return `donation:${time ?? 0}:${who}:${Number(extras?.payAmount ?? 0)}:${msg}`;
}
return `chat:${time ?? 0}:${who}:${msg}`;
}
function rememberMessageKey(handle: SessionHandle, key: string | null): boolean {
if (!key) return true;
if (handle.seenMessageKeys.has(key)) return false;
handle.seenMessageKeys.add(key);
if (handle.seenMessageKeys.size > SEEN_KEYS_MAX) {
const oldest = handle.seenMessageKeys.values().next().value;
if (oldest != null) handle.seenMessageKeys.delete(oldest);
}
return true;
}
function handleDonationBody(
roomId: string,
handle: SessionHandle,
chat: Record<string, unknown>,
isRecent: boolean,
): boolean {
const key = messageKey(chat, 'donation');
if (!rememberMessageKey(handle, key)) return false;
const extras = parseMaybeJson<{
payAmount?: number;
donationType?: string;
}>(chat.extras);
const profile = parseMaybeJson<{ nickname?: string }>(chat.profile);
const payAmount = Number(extras?.payAmount ?? 0);
if (!Number.isFinite(payAmount) || payAmount <= 0) return false;
// 히스토리 후원: 피드에만 표시하고, 이미 본 것으로 표시해 재적용 방지
if (isRecent) {
if (key) markSeenDonationKey(roomId, key);
addDiceFromDonation(roomId, {
payAmount,
donatorNickname: profile?.nickname,
donationText: String(chat.msg ?? chat.content ?? ''),
applyDice: false,
});
return true;
}
if (key && hasSeenDonationKey(roomId, key)) {
return false;
}
if (key) markSeenDonationKey(roomId, key);
addDiceFromDonation(roomId, {
payAmount,
donatorNickname: profile?.nickname,
donationText: String(chat.msg ?? chat.content ?? ''),
applyDice: true,
});
return true;
}
function handleChatBody(
roomId: string,
handle: SessionHandle,
chat: Record<string, unknown>,
): boolean {
const key = messageKey(chat, 'chat');
if (!rememberMessageKey(handle, key)) return false;
const profile = parseMaybeJson<{ nickname?: string }>(chat.profile);
const message = String(chat.msg ?? chat.content ?? '').trim();
if (!message) return false;
addChatMessage(roomId, {
nickname: profile?.nickname,
message,
});
return true;
}
function processMessageList(
roomId: string,
handle: SessionHandle,
body: Record<string, unknown> | unknown[] | undefined,
cmd: number,
) {
const isRecent = cmd === ChatCmd.RECENT_CHAT;
const list = Array.isArray(body)
? body
: Array.isArray((body as { messageList?: unknown[] })?.messageList)
? ((body as { messageList: unknown[] }).messageList)
: body
? [body]
: [];
let changed = false;
for (const item of list) {
if (!item || typeof item !== 'object') continue;
const chat = item as Record<string, unknown>;
const type = Number(chat.msgTypeCode ?? chat.messageTypeCode ?? 0);
if (cmd === ChatCmd.DONATION || type === ChatType.DONATION) {
if (handleDonationBody(roomId, handle, chat, isRecent)) changed = true;
} else if (
type === ChatType.TEXT ||
type === ChatType.SUBSCRIPTION ||
!type
) {
if (handleChatBody(roomId, handle, chat)) changed = true;
}
}
// 최근 채팅 50개를 메시지마다 SSE로 보내면 주사위 Canvas가 깨질 수 있어 한 번만 알림
if (changed) notifyRoom(roomId);
}
function requestRecentChat(handle: SessionHandle) {
if (
handle.closed ||
!handle.sid ||
handle.ws.readyState !== WebSocket.OPEN
) {
return;
}
handle.ws.send(
JSON.stringify({
ver: '2',
cmd: ChatCmd.REQUEST_RECENT_CHAT,
svcid: 'game',
cid: handle.chatChannelId,
sid: handle.sid,
tid: 2,
bdy: { recentMessageCount: RECENT_CHAT_COUNT },
}),
);
}
function onSocketMessage(roomId: string, handle: SessionHandle, raw: WebSocket.RawData) {
let json: {
cmd?: number;
bdy?: unknown;
};
try {
json = JSON.parse(String(raw));
} catch {
return;
}
const cmd = json.cmd;
const body = json.bdy as Record<string, unknown> | unknown[] | undefined;
if (cmd === ChatCmd.CONNECTED) {
const sid =
body && !Array.isArray(body) && typeof body.sid === 'string'
? body.sid
: null;
handle.sid = sid;
handle.seenMessageKeys.clear();
clearChatFeed(roomId);
setRoomMeta(roomId, { chatStatus: 'connected', chatError: null });
notifyRoom(roomId);
schedulePing(handle);
requestRecentChat(handle);
return;
}
if (cmd === ChatCmd.PING) {
if (handle.ws.readyState === WebSocket.OPEN) {
handle.ws.send(JSON.stringify({ cmd: ChatCmd.PONG, ver: '2' }));
}
return;
}
if (
cmd === ChatCmd.CHAT ||
cmd === ChatCmd.DONATION ||
cmd === ChatCmd.RECENT_CHAT
) {
processMessageList(roomId, handle, body, cmd ?? 0);
schedulePing(handle);
}
}
async function openSocket(roomId: string, channelId: string): Promise<SessionHandle> {
const live = await fetchLiveChatInfo(channelId);
const accessToken = await fetchChatAccessToken(live.chatChannelId);
const url = chatServerUrl(live.chatChannelId);
setRoomMeta(roomId, {
chatChannelId: live.chatChannelId,
chatStatus: 'connecting',
chatError: null,
});
notifyRoom(roomId);
const ws = new WebSocket(url, {
headers: {
Origin: 'https://chzzk.naver.com',
'User-Agent':
'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36',
},
});
const handle: SessionHandle = {
roomId,
ws,
chatChannelId: live.chatChannelId,
sid: null,
pingTimer: null,
pollTimer: null,
closed: false,
seenMessageKeys: new Set(),
};
await new Promise<void>((resolve, reject) => {
const timer = setTimeout(() => {
reject(new Error('채팅 웹소켓 연결 시간 초과'));
}, 12000);
ws.on('open', () => {
ws.send(
JSON.stringify({
ver: '2',
cmd: ChatCmd.CONNECT,
svcid: 'game',
cid: live.chatChannelId,
tid: 1,
bdy: {
uid: null,
devType: 2001,
accTkn: accessToken,
auth: 'READ',
},
}),
);
});
ws.on('message', (data) => {
try {
const json = JSON.parse(String(data)) as { cmd?: number };
if (json.cmd === ChatCmd.CONNECTED) {
clearTimeout(timer);
onSocketMessage(roomId, handle, data);
resolve();
return;
}
} catch {
// fallthrough
}
onSocketMessage(roomId, handle, data);
});
ws.on('error', (err) => {
clearTimeout(timer);
reject(err instanceof Error ? err : new Error('웹소켓 오류'));
});
ws.on('close', () => {
handle.closed = true;
clearPing(handle);
if (handle.pollTimer) clearInterval(handle.pollTimer);
const current = getSessions().get(roomId);
if (current === handle) {
getSessions().delete(roomId);
setRoomMeta(roomId, { chatStatus: 'disconnected' });
notifyRoom(roomId);
}
});
});
// chatChannelId 변경 폴링 (방송 재시작 대응)
handle.pollTimer = setInterval(() => {
void (async () => {
try {
const next = await fetchLiveChatInfo(channelId);
if (next.chatChannelId && next.chatChannelId !== handle.chatChannelId) {
await disconnectRoomChat(roomId);
await connectRoomChat(roomId);
}
} catch {
// ignore poll errors
}
})();
}, 30000);
getSessions().set(roomId, handle);
return handle;
}
export function isRoomChatLive(roomId: string) {
const handle = getSessions().get(roomId);
return Boolean(
handle &&
!handle.closed &&
handle.ws.readyState === WebSocket.OPEN &&
handle.sid,
);
}
const globalForDisconnect = globalThis as typeof globalThis & {
__drinkmarbleChatDisconnectTimers?: Map<string, ReturnType<typeof setTimeout>>;
};
function getDisconnectTimers() {
if (!globalForDisconnect.__drinkmarbleChatDisconnectTimers) {
globalForDisconnect.__drinkmarbleChatDisconnectTimers = new Map();
}
return globalForDisconnect.__drinkmarbleChatDisconnectTimers;
}
/** 빠른 재입장 시 이전 leave가 새 연결을 끊지 않도록 예약 해제 */
export function cancelScheduledDisconnectRoomChat(roomId: string) {
const timers = getDisconnectTimers();
const t = timers.get(roomId);
if (!t) return;
clearTimeout(t);
timers.delete(roomId);
}
/**
* 시청자가 0이 되어도 바로 끊지 않고 잠시 대기.
* 그 사이 재입장하면 채팅 세션을 유지한다.
*/
export function scheduleDisconnectRoomChat(roomId: string, delayMs = 4000) {
cancelScheduledDisconnectRoomChat(roomId);
const timers = getDisconnectTimers();
const t = setTimeout(() => {
timers.delete(roomId);
if (getRoomViewerCount(roomId) > 0) return;
void disconnectRoomChat(roomId);
}, delayMs);
timers.set(roomId, t);
}
/** 살아 있으면 유지(최근 채팅만 재요청), 아니면 재연결 */
export async function ensureRoomChat(roomId: string) {
cancelScheduledDisconnectRoomChat(roomId);
const room = getRoom(roomId);
if (!room) throw new Error('방을 찾을 수 없습니다.');
if (!room.settings.chzzkEnabled) {
throw new Error('이 방은 치지직 연동이 꺼져 있습니다.');
}
if (isRoomChatLive(roomId)) {
const handle = getSessions().get(roomId);
if (handle) requestRecentChat(handle);
setRoomMeta(roomId, { chatStatus: 'connected', chatError: null });
notifyRoom(roomId);
return;
}
await connectRoomChat(roomId);
}
export async function connectRoomChat(roomId: string) {
cancelScheduledDisconnectRoomChat(roomId);
const room = getRoom(roomId);
if (!room) throw new Error('방을 찾을 수 없습니다.');
if (!room.settings.chzzkEnabled) {
throw new Error('이 방은 치지직 연동이 꺼져 있습니다.');
}
const channelId = room.settings.channelId;
if (!channelId) throw new Error('channelId가 없습니다.');
await disconnectRoomChat(roomId);
try {
const info = await fetchChannelInfo(channelId);
setRoomMeta(roomId, { channelName: info.channelName, chatStatus: 'connecting' });
notifyRoom(roomId);
await openSocket(roomId, channelId);
} catch (e) {
const message = e instanceof Error ? e.message : '채팅 연결 실패';
setRoomMeta(roomId, { chatStatus: 'error', chatError: message });
notifyRoom(roomId);
throw e instanceof Error ? e : new Error(message);
}
}
export async function disconnectRoomChat(roomId: string) {
cancelScheduledDisconnectRoomChat(roomId);
const handle = getSessions().get(roomId);
if (!handle) {
setRoomMeta(roomId, { chatStatus: 'disconnected' });
notifyRoom(roomId);
return;
}
handle.closed = true;
clearPing(handle);
if (handle.pollTimer) clearInterval(handle.pollTimer);
getSessions().delete(roomId);
try {
handle.ws.close();
} catch {
// ignore
}
setRoomMeta(roomId, { chatStatus: 'disconnected' });
notifyRoom(roomId);
}