server.js

const fs = require("node:fs");
const http = require("node:http");
const https = require("node:https");
const path = require("node:path");
const crypto = require("node:crypto");
const vm = require("node:vm");
const { spawnSync } = require("node:child_process");
const os = require("node:os");
const store = require("./data-store");
const ot = require("./public/ot-text.js");

loadServerEnvFiles();
store.init();
seedAdminAccount();

// 서버 버전. 클라이언트(앱) 버전은 package.json 의 version 이며 따로 관리한다.
// 규칙: 클라 코드가 바뀌면 서버가 그 코드를 배포하므로 서버·클라 둘 다 올리고,
//       서버만 바뀌면 서버 버전만 올린다.
const VERSION = "3.4.0";
const PORT = Number(process.env.PORT || 25565);
const HOST = process.env.HOST || "0.0.0.0";
const PUBLIC_HOST = cleanHost(process.env.PUBLIC_HOST || "");
const PUBLIC_URL = cleanPublicUrl(process.env.PUBLIC_URL || "", PUBLIC_HOST, PORT);
const REQUIRE_HTTPS = process.env.VOICE_CHAT_REQUIRE_HTTPS === "1" || process.env.HTTPS === "1";
// nginx 같은 리버스 프록시 뒤에서만 1 로 둔다: 루프백 연결의 X-Real-IP 를 실제 접속 IP로 쓴다(IP별 제한용).
const TRUST_PROXY = process.env.TRUST_PROXY === "1";
const MAX_ROOM_LIMIT = 8;
const PUBLIC_DIR = path.join(__dirname, "public");

// ─── 보안/남용 방지 상한 ─────────────────────────────────
// 외부 공격(메모리 고갈·연결/메시지 폭주·브루트포스)에 대한 서버측 방어값.
const MAX_MESSAGE_BYTES = 12 * 1024 * 1024; // WebSocket 단일 메시지 최대 크기(그림판 문서 8MB 여유 포함)
const MAX_PRE_AUTH_MESSAGE_BYTES = 512 * 1024; // 로그인 전 메시지 최대 크기(가입 시 프로필 이미지 400KB 포함)
const MAX_SEND_BUFFER_BYTES = 64 * 1024 * 1024; // 안 읽고 쌓아두는 클라이언트의 송신 대기 상한(메모리 고갈 방어, 멤버 프로필 이미지가 큰 채널 목록 여유 포함)
const MAX_UPLOADS_PER_USER = 3;             // 사용자당 동시 업로드 수(업로드는 메모리에 모았다 저장한다)
const MAX_CONN_PER_IP = 24;                 // 같은 IP 동시 연결 상한(여러 탭/기기 허용, 폭주는 차단)
const MAX_TOTAL_CLIENTS = 500;              // 전체 동시 연결 상한(백스톱)
const MSG_BUCKET_CAP = 600;                 // 메시지 토큰버킷 용량(순간 폭주 허용치)
const MSG_REFILL_PER_MS = 0.3;              // 초당 300개 리필(정상 실시간 사용은 최대 ~80/s)
const MSG_FLOOD_CLOSE = 1500;              // 이 수치를 넘게 초과 전송하면 연결을 끊는다
const AUTH_ATTEMPT_MAX = 20;               // IP당 창(window) 내 로그인/회원가입 시도 상한
const AUTH_WINDOW_MS = 60 * 1000;          // 인증 시도 집계 창
// 채팅에 gif 사이트 페이지 링크(확장자 없음, 예: klipy.com/gifs/...)를 붙였을 때 썸네일을 보여주기 위해
// og:image 메타를 대신 가져와주는 프록시. 임의 URL을 서버가 fetch하면 SSRF(내부망 접근)로 악용될 수 있어
// 알려진 gif 사이트 호스트만 https로 허용한다.
const LINK_PREVIEW_HOSTS = new Set(["klipy.com", "www.klipy.com", "tenor.com", "www.tenor.com", "giphy.com", "www.giphy.com"]);
const LINK_PREVIEW_MAX_BYTES = 512 * 1024;
const LINK_PREVIEW_TIMEOUT_MS = 4000;
// 로그인 전(pre-auth)에 허용하는 메시지 타입. 그 외는 로그인해야 처리한다.
const PRE_AUTH_TYPES = new Set(["register", "login", "auth-token", "logout", "client-log"]);
// 로그인 브라우저 연결의 Origin 검증에 추가로 허용할 오리진(쉼표 구분, 예: 리버스 프록시 도메인).
const EXTRA_WS_ORIGINS = new Set(
  String(process.env.ALLOW_WS_ORIGINS || "")
    .split(",")
    .map((s) => s.trim().toLowerCase())
    .filter(Boolean)
);
const ipConnCounts = new Map(); // ip -> 동시 연결 수
const authAttempts = new Map(); // ip -> { count, resetAt }
const activeUploads = new Map(); // userId -> 진행 중인 업로드 수
const CERT_FILE = path.resolve(process.env.SSL_CERT_FILE || path.join(__dirname, ".cert", "cert.pem"));
const KEY_FILE = path.resolve(process.env.SSL_KEY_FILE || path.join(__dirname, ".cert", "key.pem"));
const CERT_DIR = path.dirname(CERT_FILE);

const clients = new Map();
const rooms = new Map();

// ===== 방 통계 =====
// memoDocs/drawDocs와 같은 패턴: roomId -> { totalMs, users, saveTimer } 메모리 캐시 + 디바운스 저장.
const statsCache = new Map();
const STATS_PERSIST_DEBOUNCE = 2000;

function getRoomStatsMut(roomId) {
  let s = statsCache.get(roomId);
  if (!s) {
    const saved = store.getRoomStats(roomId);
    s = { totalMs: saved.totalMs, users: saved.users, saveTimer: 0 };
    statsCache.set(roomId, s);
  }
  return s;
}

function scheduleStatsPersist(roomId) {
  const s = statsCache.get(roomId);
  if (!s) return;
  if (s.saveTimer) clearTimeout(s.saveTimer);
  s.saveTimer = setTimeout(() => {
    s.saveTimer = 0;
    store.saveRoomStats(roomId, { totalMs: s.totalMs, users: s.users });
  }, STATS_PERSIST_DEBOUNCE);
}

// 유저 하나의 누적 카운터(key)에 amount를 더한다. 표시 이름은 매번 최신으로 갱신.
function addStat(roomId, userId, name, key, amount) {
  if (!roomId || !userId || !amount) return;
  const s = getRoomStatsMut(roomId);
  if (!s.users[userId]) s.users[userId] = { name };
  else s.users[userId].name = name;
  s.users[userId][key] = (s.users[userId][key] || 0) + amount;
  scheduleStatsPersist(roomId);
}

// 마이크/화면/소리공유 on 구간을 열고 닫는다. kind: "mic" | "screen" | "sound".
function setMediaOn(client, kind, on) {
  if (!client.userId || !client.roomId) return;
  const since = client.mediaOn[kind] || 0;
  if (on) {
    if (!since) client.mediaOn[kind] = Date.now();
    return;
  }
  if (since) {
    addStat(client.roomId, client.userId, client.name, `${kind}OnMs`, Date.now() - since);
    client.mediaOn[kind] = 0;
  }
}

// OT 연산(문자열=삽입, 음수=삭제, 양수=유지)에서 입력한 글자수·지운 글자수·입력한 줄수를 셈한다.
function memoOpDelta(o) {
  let charsTyped = 0, charsDeleted = 0, linesTyped = 0;
  for (const comp of o) {
    if (typeof comp === "string") { charsTyped += comp.length; linesTyped += (comp.match(/\n/g) || []).length; }
    else if (comp < 0) charsDeleted += -comp;
  }
  return { charsTyped, charsDeleted, linesTyped };
}

// 방 종류별로 "지금 이 방을 보고 있는지" 판정할 client 필드와, 그 시작 시각 필드.
const STATS_LIVE_FIELDS = {
  voice: { roomField: "roomId", sinceField: "roomJoinedAt", key: "joinMs" },
  chat: { roomField: "chatRoomId", sinceField: "chatJoinedAt", key: "viewMs" },
  memo: { roomField: "memoRoomId", sinceField: "memoJoinedAt", key: "viewMs" },
  draw: { roomField: "drawRoomId", sinceField: "drawJoinedAt", key: "viewMs" },
};

// 조회 시점 기준 스냅샷. 아직 안 닫힌 구간(접속 중인 시간, 켜져 있는 마이크·화면·소리공유 시간,
// 진행 중인 통화의 전체 시간)을 더해 돌려준다 — 통계 창을 열어둔 채로 숫자가 실시간으로 올라가게.
// statsCache 는 절대 건드리지 않는다. 폴링할 때마다 누적되면 값이 몇 배로 부풀기 때문.
function roomStatsSnapshot(roomId, roomType) {
  const s = getRoomStatsMut(roomId);
  const now = Date.now();
  const users = new Map(Object.entries(s.users).map(([userId, u]) => [userId, { userId, ...u }]));
  const bump = (client, key, amount) => {
    if (!amount) return;
    let u = users.get(client.userId);
    if (!u) { u = { userId: client.userId }; users.set(client.userId, u); }
    u.name = client.name;
    u[key] = (u[key] || 0) + amount;
  };

  const live = STATS_LIVE_FIELDS[roomType];
  if (live) {
    for (const c of clients.values()) {
      if (!c.userId || c[live.roomField] !== roomId) continue;
      if (c[live.sinceField]) bump(c, live.key, now - c[live.sinceField]);
      if (roomType !== "voice") continue;
      for (const [kind, since] of Object.entries(c.mediaOn)) {
        if (since) bump(c, `${kind}OnMs`, now - since);
      }
    }
  }

  const room = rooms.get(roomId);
  const totalMs = s.totalMs + (room ? now - (room.startedAt || now) : 0);
  return { totalMs, users: [...users.values()] };
}

// 통화방을 나갈 때 열려 있던 마이크/화면/소리공유 구간을 전부 마감한다.
function finalizeMediaStats(client, roomId) {
  for (const kind of Object.keys(client.mediaOn)) {
    const since = client.mediaOn[kind];
    if (!since) continue;
    addStat(roomId, client.userId, client.name, `${kind}OnMs`, Date.now() - since);
    client.mediaOn[kind] = 0;
  }
}
const tlsOptions = loadTlsOptions();
if (!tlsOptions && REQUIRE_HTTPS) {
  console.error("HTTPS certificate was not created. Install openssl or set SSL_CERT_FILE and SSL_KEY_FILE.");
  process.exit(1);
}
const server = tlsOptions
  ? https.createServer(tlsOptions, safeHandleRequest)
  : http.createServer(safeHandleRequest);

server.on("upgrade", safeHandleUpgrade);
server.on("clientError", handleClientError);
server.listen(PORT, HOST, () => {
  const protocol = tlsOptions ? "https" : "http";
  const localUrl = `${protocol}://localhost:${PORT}`;
  const lanUrl = getLanUrl(protocol, PORT);
  console.log("");
  console.log(`Accord v${VERSION}`);
  console.log(`Local: ${localUrl}`);
  if (lanUrl) console.log(`LAN:   ${lanUrl}`);
  console.log(`Friend: ${PUBLIC_URL || `${protocol}://YOUR_PUBLIC_IP:${PORT}`}`);
  if (!tlsOptions) {
    console.log("Warning: HTTPS certificate was not created. Remote browsers may block microphone and AudioWorklet.");
    console.log("Run `npm run server:https` after installing openssl, or set SSL_CERT_FILE and SSL_KEY_FILE.");
  }
  printTurnStatus();
  console.log("");
});

// 잘못된 URL 인코딩(%C0)·Host 헤더·널 바이트 경로 등은 URL/decodeURIComponent/fs 에서 동기 예외를 던진다.
// 여기서 잡지 않으면 요청 하나로 서버 프로세스 전체가 죽는다.
function safeHandleRequest(req, res) {
  try {
    handleRequest(req, res);
  } catch {
    if (!res.headersSent) sendText(res, 400, "Bad request");
    else res.destroy();
  }
}

function safeHandleUpgrade(req, socket) {
  try {
    handleUpgrade(req, socket);
  } catch {
    socket.destroy();
  }
}

function handleRequest(req, res) {
  if (req.method === "OPTIONS") {
    sendCors(res, 204);
    res.end();
    return;
  }

  const base = `${tlsOptions ? "https" : "http"}://${req.headers.host || "localhost"}`;
  const url = new URL(req.url, base);

  if (req.method === "POST") {
    if (url.pathname === "/upload") {
      handleUpload(req, res, url);
      return;
    }
    sendText(res, 404, "Not found");
    return;
  }

  if (req.method !== "GET") {
    sendText(res, 405, "Method not allowed");
    return;
  }

  if (url.pathname.startsWith("/uploads/")) {
    serveUpload(res, url.pathname);
    return;
  }

  if (url.pathname === "/health") {
    sendJson(res, 200, { ok: true, version: VERSION, secure: Boolean(tlsOptions) });
    return;
  }

  if (url.pathname === "/version") {
    sendJson(res, 200, { version: VERSION, secure: Boolean(tlsOptions), updatedAt: new Date().toISOString() });
    return;
  }

  if (url.pathname === "/config") {
    sendJson(res, 200, {
      version: VERSION,
      secure: Boolean(tlsOptions),
      protocol: tlsOptions ? "https" : "http",
      maxRoomLimit: MAX_ROOM_LIMIT,
      publicUrl: PUBLIC_URL,
      iceServers: getIceServers(),
      turnConfigured: hasTurnServer(),
      stunConfigured: hasStunServer(),
    });
    return;
  }

  if (url.pathname === "/api/link-image") {
    fetchLinkPreviewImage(res, url.searchParams.get("url") || "");
    return;
  }

  const fileName = url.pathname === "/" ? "index.html" : decodeURIComponent(url.pathname.slice(1));
  const filePath = path.normalize(path.join(PUBLIC_DIR, fileName));
  const relativePath = path.relative(PUBLIC_DIR, filePath);

  if (relativePath.startsWith("..") || path.isAbsolute(relativePath)) {
    sendText(res, 403, "Forbidden");
    return;
  }

  fs.readFile(filePath, (error, data) => {
    if (error) {
      sendText(res, 404, "Not found");
      return;
    }

    sendCors(res, 200, {
      "content-type": getContentType(filePath),
      "cache-control": "no-store, max-age=0",
    });
    res.end(data);
  });
}

// 채팅 파일/이미지 업로드. 바이너리 본문 + 헤더(x-file-name)로 받는다.
function handleUpload(req, res, url) {
  const token = url.searchParams.get("token") || req.headers["x-auth-token"] || "";
  const user = store.getUserByToken(token);
  if (!user) {
    sendJson(res, 401, { error: "인증이 필요합니다." });
    return;
  }
  // 업로드는 본문 전체를 메모리에 모으므로 한 사용자가 동시에 여러 개(50MB씩)를 밀어 넣지 못하게 한다.
  const active = activeUploads.get(user.id) || 0;
  if (active >= MAX_UPLOADS_PER_USER) {
    sendJson(res, 429, { error: "이전 업로드가 끝난 뒤 다시 시도해 주세요." });
    return;
  }
  activeUploads.set(user.id, active + 1);
  res.once("close", () => {
    const left = (activeUploads.get(user.id) || 1) - 1;
    if (left > 0) activeUploads.set(user.id, left);
    else activeUploads.delete(user.id);
  });
  const mime = String(req.headers["content-type"] || "application/octet-stream").split(";")[0].trim();
  let rawName = "file";
  try {
    rawName = decodeURIComponent(String(req.headers["x-file-name"] || "file"));
  } catch {
    rawName = String(req.headers["x-file-name"] || "file");
  }

  const chunks = [];
  let size = 0;
  let aborted = false;
  req.on("data", (chunk) => {
    if (aborted) return;
    size += chunk.length;
    if (size > store.UPLOAD_MAX_BYTES) {
      aborted = true;
      sendJson(res, 413, { error: "파일이 너무 큽니다. 50MB 이하만 올릴 수 있습니다." });
      req.destroy();
      return;
    }
    chunks.push(chunk);
  });
  req.on("end", () => {
    if (aborted) return;
    if (!size) {
      sendJson(res, 400, { error: "빈 파일입니다." });
      return;
    }
    try {
      const saved = store.saveUpload({ buffer: Buffer.concat(chunks), name: rawName, mime, ownerId: user.id });
      logServer(`upload file=${saved.fileName} size=${saved.size} by=${user.username}`);
      sendJson(res, 200, { url: `/uploads/${saved.fileName}`, name: saved.name, size: saved.size, mime: saved.mime });
    } catch (error) {
      logServer(`upload failed: ${error.message || error}`);
      sendJson(res, 500, { error: "업로드에 실패했습니다." });
    }
  });
  req.on("error", () => {
    if (!aborted) sendJson(res, 500, { error: "업로드 중 오류가 발생했습니다." });
  });
}

function serveUpload(res, pathname) {
  let fileName = "";
  try {
    fileName = decodeURIComponent(pathname.slice("/uploads/".length));
  } catch {
    sendText(res, 400, "Bad request");
    return;
  }
  const filePath = store.getUploadPath(fileName);
  if (!filePath) {
    sendText(res, 403, "Forbidden");
    return;
  }
  fs.readFile(filePath, (error, data) => {
    if (error) {
      sendText(res, 404, "Not found");
      return;
    }
    // 저장형 XSS 방어: 이미지/영상/오디오 등 안전한 매체만 인라인으로 제공하고,
    // HTML/SVG/스크립트 등은 원래 콘텐츠타입으로 렌더되지 않도록 첨부(다운로드)로 강제한다.
    // (업로드한 HTML/SVG 를 직접 열어 앱 오리진에서 스크립트를 실행 → 토큰 탈취하는 공격 차단)
    const inlineSafe = isInlineSafeUpload(filePath);
    sendCors(res, 200, {
      "content-type": inlineSafe ? getContentType(filePath) : "application/octet-stream",
      "content-disposition": inlineSafe ? "inline" : "attachment",
      "cache-control": "public, max-age=31536000, immutable",
    });
    res.end(data);
  });
}

// 브라우저가 인라인 렌더해도 안전한(스크립트 실행 불가) 업로드 확장자만 허용한다.
// SVG 는 스크립트를 품을 수 있어 제외한다.
const INLINE_SAFE_UPLOAD_EXT = new Set([
  ".png", ".jpg", ".jpeg", ".gif", ".webp", ".bmp", ".ico",
  ".mp4", ".webm", ".mov", ".mp3", ".wav", ".ogg", ".m4a",
]);
function isInlineSafeUpload(filePath) {
  return INLINE_SAFE_UPLOAD_EXT.has(path.extname(filePath).toLowerCase());
}

// WebSocket 연결의 Origin 을 검증한다(브라우저발 교차 사이트 연결 차단).
// - Origin 이 없거나 null(네이티브/파일 로드 클라이언트)은 허용한다.
// - http(s) Origin 은 요청 Host 와 호스트가 같을 때만 허용한다(정상 클라는 항상 same-origin).
// - 환경변수 ALLOW_WS_ORIGINS 로 추가 오리진을 허용할 수 있다.
function isAllowedWsOrigin(req) {
  const origin = String(req.headers.origin || "").trim();
  if (!origin || origin === "null") return true; // 네이티브/Electron 파일 로드 등
  let originHost = "";
  try {
    originHost = new URL(origin).host.toLowerCase();
  } catch {
    return false; // 파싱 불가한 Origin 은 거부
  }
  if (EXTRA_WS_ORIGINS.has(origin.toLowerCase())) return true;
  const hostHeader = String(req.headers.host || "").toLowerCase();
  if (originHost && originHost === hostHeader) return true;
  if (PUBLIC_HOST && originHost === PUBLIC_HOST.toLowerCase()) return true;
  const bareOriginHost = originHost.split(":")[0];
  if (bareOriginHost === "localhost" || bareOriginHost === "127.0.0.1") return true;
  return false;
}

function handleUpgrade(req, socket) {
  const base = `${tlsOptions ? "https" : "http"}://${req.headers.host || "localhost"}`;
  const url = new URL(req.url, base);
  if (url.pathname !== "/signal") {
    socket.destroy();
    return;
  }

  const key = req.headers["sec-websocket-key"];
  if (!key) {
    socket.destroy();
    return;
  }

  if (!isAllowedWsOrigin(req)) {
    logServer(`ws upgrade blocked: origin=${String(req.headers.origin || "").slice(0, 120)}`);
    socket.destroy();
    return;
  }

  // 연결 폭주 방어: IP당 · 전체 동시 연결 상한.
  const ip = clientIpOf(req);
  if (clients.size >= MAX_TOTAL_CLIENTS) {
    logServer(`ws upgrade rejected: server full (${clients.size})`);
    socket.destroy();
    return;
  }
  const ipCount = ipConnCounts.get(ip) || 0;
  if (ipCount >= MAX_CONN_PER_IP) {
    logServer(`ws upgrade rejected: too many connections ip=${ip} count=${ipCount}`);
    socket.destroy();
    return;
  }

  const accept = crypto
    .createHash("sha1")
    .update(`${key}258EAFA5-E914-47DA-95CA-C5AB0DC85B11`)
    .digest("base64");

  socket.write([
    "HTTP/1.1 101 Switching Protocols",
    "Upgrade: websocket",
    "Connection: Upgrade",
    `Sec-WebSocket-Accept: ${accept}`,
    "",
    "",
  ].join("\r\n"));

  // 유휴 상태에서 연결이 끊기지 않도록: 소켓 타임아웃 해제 + TCP keepalive.
  // (아무 것도 안 하고 가만히 있으면 WebSocket이 닫히는 문제 방지)
  socket.setTimeout(0);
  socket.setKeepAlive(true, 30000);
  socket.setNoDelay(true);

  const client = {
    id: crypto.randomBytes(8).toString("hex"),
    name: "Guest",
    roomId: "",
    socket,
    buffer: Buffer.alloc(0),
    closed: false,
    fragments: null,
    fragmentBytes: 0, // 조립 중인 메시지의 누적 바이트(과도 누적 시 연결 차단)
    fragmentOpcode: 0,
    ip,
    msgTokens: MSG_BUCKET_CAP, // 메시지 토큰버킷(플러드 방어)
    msgTokenTs: Date.now(),
    floodStrikes: 0,
    userId: "",
    authToken: "", // 이 연결이 쓰는 세션 토큰(비밀번호 변경 시 이 세션만 남기려고 보관)
    isAdmin: false,
    chatRoomId: "", // 현재 보고 있는 채팅방(입력중 표시 대상 판별용)
    aiRoomId: "", // 현재 보고 있는 AI방(브로드캐스트 대상 판별용)
    memoRoomId: "", // 현재 보고 있는 메모장(실시간 동기화 대상 판별용)
    drawRoomId: "", // 현재 보고 있는 그림판(실시간 동기화 대상 판별용)
    logRoomId: "", // 현재 보고 있는 로그방(실시간 로그 대상 판별용)
    logChannelId: "", // 그 로그방이 속한 채널(채널 단위 피드라 따로 보관)
    dmUserId: "", // 현재 보고 있는 DM 상대(읽음 판별용)
    roomJoinedAt: 0, // 통화방 접속 시각(통계용 접속시간 누적)
    chatJoinedAt: 0, // 채팅방 보기 시작 시각(통계용)
    memoJoinedAt: 0, // 메모장 보기 시작 시각(통계용)
    drawJoinedAt: 0, // 그림판 보기 시작 시각(통계용)
    mediaOn: {}, // 통계용 마이크/화면/소리공유 on 시작 시각. { mic, screen, sound } -> Date.now() 또는 0
  };

  clients.set(client.id, client);
  ipConnCounts.set(ip, ipCount + 1);
  logServer("client connected", client);
  socket.on("data", (chunk) => readFrames(client, chunk));
  socket.on("close", () => removeClient(client));
  socket.on("error", () => removeClient(client));
  send(client, { type: "hello", id: client.id, version: VERSION });
}

function handleClientError(error, socket) {
  if (!socket.writable) return;
  socket.end("HTTP/1.1 400 Bad Request\r\nConnection: close\r\n\r\n");
}

// 메시지 폭주 방어: 토큰버킷. 정상 실시간 사용(최대 ~80/s)엔 걸리지 않고
// 초당 수백~수천 개를 쏟아붓는 플러드만 차단한다. 남는 토큰이 없으면 false.
function allowClientMessage(client) {
  const now = Date.now();
  client.msgTokens = Math.min(
    MSG_BUCKET_CAP,
    client.msgTokens + (now - client.msgTokenTs) * MSG_REFILL_PER_MS
  );
  client.msgTokenTs = now;
  if (client.msgTokens < 1) return false;
  client.msgTokens -= 1;
  return true;
}

function readFrames(client, chunk) {
  client.buffer = Buffer.concat([client.buffer, chunk]);

  while (client.buffer.length >= 2) {
    const first = client.buffer[0];
    const second = client.buffer[1];
    const opcode = first & 0x0f;
    const masked = (second & 0x80) === 0x80;
    let length = second & 0x7f;
    let offset = 2;

    // RFC 6455: 클라이언트→서버 프레임은 반드시 마스킹되어야 한다.
    // 마스킹되지 않은 프레임은 비정상(비브라우저/공격) 클라이언트로 보고 연결을 끊는다.
    if (!masked) {
      closeClient(client);
      return;
    }

    if (length === 126) {
      if (client.buffer.length < 4) return;
      length = client.buffer.readUInt16BE(2);
      offset = 4;
    } else if (length === 127) {
      if (client.buffer.length < 10) return;
      const big = client.buffer.readBigUInt64BE(2);
      if (big > BigInt(Number.MAX_SAFE_INTEGER)) {
        closeClient(client);
        return;
      }
      length = Number(big);
      offset = 10;
    }

    // 메모리 고갈 방어: 상한을 넘는 프레임을 선언하면 버퍼링하지 않고 즉시 끊는다.
    // 로그인 전에는 작은 상한만 허용한다(인증 없이 연결마다 12MB씩 쌓는 공격 차단).
    const maxBytes = client.userId ? MAX_MESSAGE_BYTES : MAX_PRE_AUTH_MESSAGE_BYTES;
    if (length > maxBytes) {
      logServer(`frame too large: ${length} bytes`, client);
      closeClient(client);
      return;
    }

    const frameLength = offset + 4 + length; // 마스킹 키 4바이트(마스킹 안 된 프레임은 위에서 끊었다)
    if (client.buffer.length < frameLength) return;

    const payload = Buffer.from(client.buffer.subarray(offset + 4, frameLength));
    const mask = client.buffer.subarray(offset, offset + 4);
    for (let i = 0; i < payload.length; i += 1) payload[i] ^= mask[i & 3];
    client.buffer = client.buffer.slice(frameLength);
    const fin = (first & 0x80) === 0x80;

    if (opcode === 8) {
      closeClient(client);
      return;
    }
    if (opcode === 9 || opcode === 10) continue; // ping/pong 무시

    // 큰 메시지(예: 이미지 data URL)는 브라우저가 여러 프레임으로 쪼개 보낸다.
    // 연속(continuation) 프레임을 이어붙여 완성된 뒤에 처리한다.
    if (opcode === 0) {
      if (!Array.isArray(client.fragments)) continue; // 시작 없는 연속 프레임은 버린다.
      client.fragments.push(payload);
      client.fragmentBytes += payload.length;
    } else if (opcode === 1 || opcode === 2) {
      client.fragments = [payload];
      client.fragmentOpcode = opcode;
      client.fragmentBytes = payload.length;
    } else {
      continue;
    }

    // 연속 프레임 누적이 상한을 넘으면(조각내어 우회하는 메모리 고갈 시도) 끊는다.
    if (client.fragmentBytes > maxBytes) {
      logServer(`message too large: ${client.fragmentBytes} bytes`, client);
      client.fragments = null;
      client.fragmentBytes = 0;
      closeClient(client);
      return;
    }

    if (!fin) continue;

    const full = client.fragments.length === 1 ? client.fragments[0] : Buffer.concat(client.fragments);
    const op = client.fragmentOpcode;
    client.fragments = null;
    client.fragmentBytes = 0;

    // 메시지 폭주 방어: 완성된 데이터 메시지마다 속도를 검사한다(텍스트·바이너리 모두).
    // 초과 시 파싱/처리 없이 버리고, 지속되면 연결을 끊는다.
    if (!allowClientMessage(client)) {
      client.floodStrikes += 1;
      if (client.floodStrikes > MSG_FLOOD_CLOSE) {
        logServer("message flood: closing connection", client);
        closeClient(client);
        return;
      }
      continue;
    }
    client.floodStrikes = 0;

    if (op !== 1) continue; // 텍스트 메시지만 처리

    try {
      handleMessage(client, JSON.parse(full.toString("utf8")));
    } catch {
      send(client, { type: "error", message: "잘못된 메시지입니다." });
    }
  }
}

function handleMessage(client, message) {
  // 방어: JSON 이 객체가 아니거나 type 이 문자열이 아니면 무시한다.
  if (!message || typeof message !== "object" || Array.isArray(message) || typeof message.type !== "string") {
    return;
  }
  // 로그인 전에는 인증/진단 메시지만 처리한다(pre-auth 공격 표면 축소).
  if (!client.userId && !PRE_AUTH_TYPES.has(message.type)) {
    send(client, { type: "error", message: "로그인이 필요합니다." });
    return;
  }

  if (handleAuthMessage(client, message)) return;
  if (handleAdminMessage(client, message)) return;
  if (handleChannelMessage(client, message)) return;
  if (handleChatMessage(client, message)) return;
  if (handleAiMessage(client, message)) return;
  if (handleMemoMessage(client, message)) return;
  if (handleDrawMessage(client, message)) return;
  if (handleLogMessage(client, message)) return;
  if (handleDmMessage(client, message)) return;

  if (message.type === "join-room") {
    joinVoiceRoom(client, String(message.roomId || ""));
    return;
  }

  if (message.type === "leave-room") {
    leaveRoom(client, true);
    return;
  }

  if (message.type === "media:intent") {
    // 화면/카메라/컴퓨터 사운드 공유 버튼 클릭 즉시 알림(비영속, 발신자 제외 릴레이). 실제 미디어 상태와 무관하다.
    const room = rooms.get(client.roomId);
    if (!room) return;
    const sound = String(message.sound || "");
    if (!["screenOn", "screenOff", "soundOn", "soundOff"].includes(sound)) return;
    setMediaOn(client, sound.startsWith("screen") ? "screen" : "sound", sound.endsWith("On"));
    for (const peerId of room.clients) {
      if (peerId === client.id) continue;
      send(clients.get(peerId), { type: "media:intent", sound });
    }
    return;
  }

  if (message.type === "stats:media") {
    if (message.kind === "mic") setMediaOn(client, "mic", Boolean(message.on));
    return;
  }

  if (
    message.type === "room:force-mute" ||
    message.type === "room:kick-user" ||
    message.type === "room:force-screen-off" ||
    message.type === "room:force-sound-off"
  ) {
    handleRoomModeration(client, message);
    return;
  }

  if (message.type === "client-log") {
    logClientEvent(client, message);
    return;
  }

  if (message.type === "signal") {
    const target = clients.get(String(message.target || ""));
    const signalKind = getSignalKind(message.data);
    if (!target || !client.roomId || target.roomId !== client.roomId) {
      logServer(`signal target missing kind=${signalKind} target=${String(message.target || "")}`, client);
      return;
    }
    logServer(`signal kind=${signalKind} target=${target.id}`, client);
    send(target, {
      type: "signal",
      from: client.id,
      fromName: client.name,
      data: message.data,
    });
  }
}

// 로그인/회원가입 브루트포스 + scrypt CPU 소진 방어: IP당 창(window) 내 시도 상한.
function authRateLimited(client) {
  const now = Date.now();
  let rec = authAttempts.get(client.ip);
  if (!rec || now > rec.resetAt) {
    rec = { count: 0, resetAt: now + AUTH_WINDOW_MS };
    authAttempts.set(client.ip, rec);
  }
  rec.count += 1;
  return rec.count > AUTH_ATTEMPT_MAX;
}

function handleAuthMessage(client, message) {
  switch (message.type) {
    case "register": {
      if (authRateLimited(client)) {
        send(client, { type: "auth-error", action: "register", message: "시도가 너무 많습니다. 잠시 후 다시 시도해 주세요." });
        return true;
      }
      const result = store.createUser({
        username: message.username,
        password: message.password,
        displayName: message.displayName,
        email: message.email,
        avatar: message.avatar,
      });
      if (result.error) {
        send(client, { type: "auth-error", action: "register", message: result.error });
        return true;
      }
      finishAuth(client, result.user, "register");
      return true;
    }
    case "login": {
      if (authRateLimited(client)) {
        send(client, { type: "auth-error", action: "login", message: "시도가 너무 많습니다. 잠시 후 다시 시도해 주세요." });
        return true;
      }
      const result = store.authenticate(message.username, message.password);
      if (result.error) {
        send(client, { type: "auth-error", action: "login", message: result.error });
        return true;
      }
      finishAuth(client, result.user, "login");
      return true;
    }
    case "auth-token": {
      const user = store.getUserByToken(message.token);
      if (!user) {
        send(client, { type: "auth-expired" });
        return true;
      }
      finishAuth(client, user, "resume", message.token);
      return true;
    }
    case "logout": {
      if (message.token) store.destroySession(message.token);
      leaveRoom(client, false);
      client.userId = "";
      client.authToken = "";
      client.isAdmin = false;
      client.name = "Guest";
      client.dmUserId = "";
      dropLostViews(client);
      broadcastPresence();
      return true;
    }
    case "change-password": {
      if (!client.userId) {
        send(client, { type: "auth-error", action: "change-password", message: "로그인이 필요합니다." });
        return true;
      }
      const result = store.changePassword(client.userId, message.oldPassword, message.newPassword, client.authToken);
      if (result.error) {
        send(client, { type: "auth-error", action: "change-password", message: result.error });
        return true;
      }
      // 다른 세션으로 접속해 있던 연결도 끊는다(재접속하면 토큰이 없어져 로그인 화면으로 간다).
      for (const c of clients.values()) {
        if (c !== client && c.userId === client.userId && c.authToken !== client.authToken) closeClient(c);
      }
      send(client, { type: "auth-ok", action: "change-password", user: store.sanitizeUser(result.user) });
      return true;
    }
    case "update-profile": {
      if (!client.userId) {
        send(client, { type: "auth-error", action: "update-profile", message: "로그인이 필요합니다." });
        return true;
      }
      const result = store.updateProfile(client.userId, {
        displayName: message.displayName,
        avatar: message.avatar,
        banner: message.banner,
        bannerGradient: message.bannerGradient,
        email: message.email,
      });
      if (result.error) {
        send(client, { type: "auth-error", action: "update-profile", message: result.error });
        return true;
      }
      client.name = result.user.displayName;
      send(client, { type: "auth-ok", action: "update-profile", user: store.sanitizeUser(result.user) });
      // 닉네임/프로필 변경은 여러 채널의 멤버 표시에 영향 → 접속자 전원 채널 목록 갱신.
      refreshChannelsForAll();
      broadcastPresence();
      return true;
    }
    default:
      return false;
  }
}

function finishAuth(client, user, action, existingToken) {
  const token = existingToken || store.createSession(user.id);
  client.authToken = token;
  client.userId = user.id;
  client.isAdmin = Boolean(user.isAdmin);
  client.name = user.displayName;
  store.recordConnection(user.id, client.ip, action === "resume" ? "connect" : action);
  logServer(`auth ${action} user=${user.username} code=#${user.code} ip=${client.ip}`, client);
  send(client, { type: "auth-ok", action, token, user: store.sanitizeUser(user) });
  sendChannels(client);
  broadcastPresence();
}

function handleAdminMessage(client, message) {
  if (typeof message.type !== "string" || !message.type.startsWith("admin:")) return false;
  if (!client.isAdmin) {
    send(client, { type: "admin-error", message: "관리자 권한이 없습니다." });
    return true;
  }
  switch (message.type) {
    case "admin:list-users":
      sendAdminUsers(client);
      return true;
    case "admin:set-admin": {
      const result = store.setAdmin(message.userId, message.value);
      if (result.error) {
        send(client, { type: "admin-error", message: result.error });
        return true;
      }
      notifyUserUpdate(message.userId);
      sendAdminUsers(client);
      return true;
    }
    case "admin:set-code": {
      const result = store.setUserCode(message.userId, message.code);
      if (result.error) {
        send(client, { type: "admin-error", message: result.error });
        return true;
      }
      notifyUserUpdate(message.userId);
      sendAdminUsers(client);
      return true;
    }
    case "admin:create-user": {
      const result = store.createUser({ username: message.username, password: message.password, displayName: message.displayName });
      if (result.error) {
        send(client, { type: "admin-error", message: result.error });
        return true;
      }
      // 만들면서 미리 채널에 넣어 둔다.
      for (const id of Array.isArray(message.channelIds) ? message.channelIds : []) {
        if (!store.addMember(String(id), result.user.id).error) notifyChannelMembers(String(id));
      }
      sendAdminUsers(client);
      return true;
    }
    case "admin:delete-user": {
      const userId = String(message.userId || "");
      const result = store.deleteUser(userId);
      if (result.error) {
        send(client, { type: "admin-error", message: result.error });
        return true;
      }
      for (const c of [...clients.values()]) {
        if (c.userId !== userId) continue;
        send(c, { type: "auth-expired" });
        closeClient(c);
      }
      for (const id of result.channelIds) notifyChannelMembers(id);
      sendAdminUsers(client);
      return true;
    }
    case "admin:set-member": {
      const channelId = String(message.channelId || "");
      const userId = String(message.userId || "");
      if (!store.findById(userId)) {
        send(client, { type: "admin-error", message: "유저를 찾을 수 없습니다." });
        return true;
      }
      const result = message.value ? store.addMember(channelId, userId) : store.removeMember(channelId, userId);
      if (result.error) {
        send(client, { type: "admin-error", message: result.error });
        return true;
      }
      // channel:kick 과 같이, 빠진 유저는 채널 방에서 내보내고 목록을 갱신한다.
      for (const c of clients.values()) {
        if (c.userId !== userId) continue;
        if (!message.value) forceLeaveChannelRooms(c, channelId);
        sendChannels(c);
      }
      notifyChannelMembers(channelId);
      sendAdminUsers(client);
      return true;
    }
    case "admin:get-ai-prompt":
      send(client, { type: "admin-ai-prompt", prompt: store.getAiGlobalPrompt() });
      return true;
    case "admin:set-ai-prompt": {
      const prompt = store.setAiGlobalPrompt(message.prompt);
      send(client, { type: "admin-ai-prompt", prompt, saved: true });
      return true;
    }
    default:
      return false;
  }
}

function sendAdminUsers(client) {
  const channels = store.listChannelsForUser("", true).map(({ id, name, ownerId, memberIds }) => ({ id, name, ownerId, memberIds }));
  send(client, { type: "admin-users", users: store.listUsers(), online: onlineUserIds(), channels });
}

function onlineUserIds() {
  const ids = new Set();
  for (const c of clients.values()) if (c.userId) ids.add(c.userId);
  return [...ids];
}

// 관리자 지정/코드 변경 등으로 계정이 바뀌면, 접속 중인 해당 유저 클라이언트에 즉시 반영한다.
function notifyUserUpdate(userId) {
  const user = store.findById(userId);
  if (!user) return;
  const payload = { type: "account-updated", user: store.sanitizeUser(user) };
  for (const c of clients.values()) {
    if (c.userId !== userId) continue;
    c.name = user.displayName;
    c.isAdmin = Boolean(user.isAdmin);
    dropLostViews(c);
    send(c, payload);
    // 관리자 승격/해제 시 볼 수 있는 채널이 달라지므로 목록도 갱신한다.
    sendChannels(c);
  }
  broadcastPresence();
}

function seedAdminAccount() {
  const username = process.env.ADMIN_SEED_USERNAME || "craft374";
  const password = process.env.ADMIN_SEED_PASSWORD || "";
  const displayName = process.env.ADMIN_SEED_DISPLAYNAME || username;
  const result = store.seedAdmin({ username, password, displayName });
  if (result.created) console.log(`관리자 계정 생성됨: ${username} (#0000)`);
  else if (result.promoted) console.log(`기존 계정을 관리자(#0000)로 승격: ${username} (비밀번호는 ADMIN_SEED_PASSWORD 로 재설정)`);
  else if (result.skipped === "no-password") {
    console.log("관리자 시드 건너뜀: ADMIN_SEED_PASSWORD 미설정. server.env에 추가하면 첫 실행 시 생성됩니다.");
  }
}

function cleanIp(value) {
  return String(value || "").replace(/^::ffff:/, "");
}

function clientIpOf(req) {
  const ip = cleanIp(req.socket.remoteAddress);
  if (!TRUST_PROXY || (ip !== "127.0.0.1" && ip !== "::1")) return ip;
  return cleanIp(String(req.headers["x-real-ip"] || "").trim()) || ip;
}

function getSignalKind(data) {
  if (data?.description?.type) return data.description.type;
  if (data?.candidate) return "candidate";
  if (data?.trackInfo) return `trackInfo:${data.trackInfo.role || ""}`;
  if (data?.mediaStatus) return "mediaStatus";
  if (data?.repairRequest) return `repair:${data.repairRequest.role || ""}`;
  return "unknown";
}

// 채널 안의 통화방(voice)에 입장. 방 메타데이터는 채널에 영속되고, 여기서는 실시간 접속(presence)만 관리한다.
function joinVoiceRoom(client, roomId) {
  if (!client.userId) {
    send(client, { type: "error", message: "로그인이 필요합니다." });
    return;
  }
  const found = store.findRoom(roomId);
  if (!found || found.room.type !== "voice") {
    send(client, { type: "error", message: "통화방을 찾지 못했습니다." });
    return;
  }
  if (!store.isChannelMember(found.channel.id, client.userId, client.isAdmin)) {
    send(client, { type: "error", message: "채널 멤버만 입장할 수 있습니다." });
    return;
  }
  if (!store.canAccessRoom(found.channel.id, found.room.id, client.userId, client.isAdmin)) {
    send(client, { type: "error", message: "이 방에 접근할 권한이 없습니다." });
    return;
  }

  const limit = roomLimitOf(found.room);
  // 정원 초과 검사(이미 이 방에 있던 경우는 제외).
  const existing = rooms.get(roomId);
  const alreadyIn = existing && existing.clients.has(client.id);
  if (existing && !alreadyIn && existing.clients.size >= limit) {
    send(client, { type: "error", message: `통화방이 가득 찼습니다 (최대 ${limit}명).` });
    return;
  }

  leaveRoom(client, false);

  let room = rooms.get(roomId);
  if (!room) {
    room = { id: roomId, name: found.room.name, channelId: found.channel.id, clients: new Set(), startedAt: Date.now() };
    rooms.set(roomId, room);
  }
  room.limit = limit;
  room.clients.add(client.id);
  client.roomId = roomId;
  client.roomJoinedAt = Date.now();
  logServer(`joined room=${room.name} peers=${room.clients.size - 1}`, client);

  const peers = [...room.clients]
    .filter((id) => id !== client.id)
    .map((id) => {
      const peer = clients.get(id);
      return { id, name: peer?.name || "Guest", userId: peer?.userId || "" };
    });

  send(client, { type: "joined", id: client.id, room: liveRoomInfo(room), peers });

  for (const peerId of room.clients) {
    if (peerId === client.id) continue;
    send(clients.get(peerId), {
      type: "peer-joined",
      peer: { id: client.id, name: client.name, userId: client.userId },
      room: liveRoomInfo(room),
    });
  }

  logChannelEvent(found.channel.id, client, "voice-join", { roomName: room.name });
  broadcastPresence();
}

function leaveRoom(client, notify) {
  if (!client.roomId) return;
  const room = rooms.get(client.roomId);
  const roomId = client.roomId;
  const joinedAt = client.roomJoinedAt;
  client.roomId = "";
  client.roomJoinedAt = 0;
  finalizeMediaStats(client, roomId);
  if (client.userId && joinedAt) addStat(roomId, client.userId, client.name, "joinMs", Date.now() - joinedAt);
  if (!room) return;

  room.clients.delete(client.id);
  logServer(`left room=${room.name} remaining=${room.clients.size}`, client);
  logChannelEvent(room.channelId, client, "voice-leave", { roomName: room.name });
  if (room.clients.size === 0) {
    const s = getRoomStatsMut(room.id);
    s.totalMs += Date.now() - (room.startedAt || Date.now());
    scheduleStatsPersist(room.id);
    rooms.delete(room.id); // 실시간 접속 항목만 정리(방 메타데이터는 채널에 영속).
  } else {
    for (const peerId of room.clients) {
      send(clients.get(peerId), {
        type: "peer-left",
        peerId: client.id,
        room: liveRoomInfo(room),
      });
    }
  }

  if (notify) send(client, { type: "left" });
  broadcastPresence();
}

// 통화방 대표자의 강제 음소거 / 내보내기. 대표자(창설자·공동대표·관리자)만 가능하고,
// 다른 대표자는 대상이 될 수 없다. 결과는 전역 로그에도 기록된다.
function handleRoomModeration(client, message) {
  if (!client.userId) {
    send(client, { type: "error", message: "로그인이 필요합니다." });
    return;
  }
  const roomId = String(message.roomId || "");
  const found = store.findRoom(roomId);
  if (!found || found.room.type !== "voice") return;
  if (!store.isChannelOwner(found.channel.id, client.userId, client.isAdmin)) {
    send(client, { type: "error", message: "대표자만 사용할 수 있습니다." });
    return;
  }
  const target = clients.get(String(message.targetId || ""));
  if (!target || target.roomId !== roomId || target.id === client.id) return;
  // 다른 대표자(창설자·공동대표)는 강제 대상에서 제외해 서로 못 건드리게 한다.
  if (target.userId && store.isChannelOwner(found.channel.id, target.userId, target.isAdmin)) {
    send(client, { type: "error", message: "다른 대표자에게는 사용할 수 없습니다." });
    return;
  }

  if (message.type === "room:force-mute") {
    send(target, { type: "force-muted", roomId, roomName: found.room.name, byName: client.name });
    logChannelEvent(found.channel.id, target, "force-mute", { roomName: found.room.name, byName: client.name });
  } else if (message.type === "room:force-screen-off") {
    send(target, { type: "force-screen-off", roomId, roomName: found.room.name, byName: client.name });
    logChannelEvent(found.channel.id, target, "force-screen-off", { roomName: found.room.name, byName: client.name });
  } else if (message.type === "room:force-sound-off") {
    send(target, { type: "force-sound-off", roomId, roomName: found.room.name, byName: client.name });
    logChannelEvent(found.channel.id, target, "force-sound-off", { roomName: found.room.name, byName: client.name });
  } else {
    send(target, { type: "kicked-from-room", roomId, roomName: found.room.name, byName: client.name });
    logChannelEvent(found.channel.id, target, "voice-kick", { roomName: found.room.name, byName: client.name });
    leaveRoom(target, true); // 강제 퇴장(target 에겐 'left' 가 전달됨)
  }
}

function removeClient(client) {
  if (client.closed) return;
  client.closed = true;
  // IP 동시 연결 카운트 감소(폭주 방어용).
  const ipCount = ipConnCounts.get(client.ip) || 0;
  if (ipCount <= 1) ipConnCounts.delete(client.ip);
  else ipConnCounts.set(client.ip, ipCount - 1);
  logServer("client disconnected", client);
  if (client.userId) store.recordConnection(client.userId, client.ip, "disconnect");
  leaveMemo(client);
  leaveDraw(client);
  leaveChatView(client);
  leaveAiView(client);
  client.logRoomId = "";
  client.logChannelId = "";
  client.dmUserId = "";
  const wasInVoice = !!client.roomId;
  leaveRoom(client, false); // 통화방에 있었다면 여기서 presence 재전송
  clients.delete(client.id);
  // 통화방엔 없고 채팅·메모 등만 보던 사람이 나갈 때도 방 옆 표시가 사라지도록 알린다.
  if (!wasInVoice) broadcastPresence();
  client.socket.destroy();
}

function closeClient(client) {
  client.socket.end();
  removeClient(client);
}

function sendSignal(target, data) {
  send(target, data);
}

function logServer(message, client = null) {
  const stamp = new Date().toISOString();
  const who = client ? ` id=${client.id} name=${client.name || "Guest"}` : "";
  console.log(`[${stamp}] ${message}${who}`);
}

function logClientEvent(client, message) {
  const event = String(message.event || "").slice(0, 80).replace(/\s+/g, " ");
  const session = String(message.session || "").slice(0, 32).replace(/\s+/g, " ");
  const detail = String(message.detail || "").slice(0, 500).replace(/\s+/g, " ");
  const room = client.roomId ? ` room=${client.roomId}` : "";
  const sessionText = session ? ` sid=${session}` : "";
  logServer(`client-log event=${event}${sessionText}${room} detail=${detail}`, client);
}

function send(client, data) {
  if (!client || client.closed || !client.socket.writable) return;
  // 소켓을 읽지 않으면서 큰 응답(그림판 문서 등)을 반복 요청하면 송신 버퍼가 끝없이 쌓인다.
  if (client.socket.writableLength > MAX_SEND_BUFFER_BYTES) {
    logServer(`send buffer overflow: ${client.socket.writableLength} bytes`, client);
    closeClient(client);
    return;
  }
  const payload = Buffer.from(JSON.stringify(data));
  const header = makeFrameHeader(payload.length);
  client.socket.write(Buffer.concat([header, payload]));
}

function makeFrameHeader(length) {
  if (length < 126) return Buffer.from([0x81, length]);
  if (length < 65536) {
    const header = Buffer.alloc(4);
    header[0] = 0x81;
    header[1] = 126;
    header.writeUInt16BE(length, 2);
    return header;
  }
  const header = Buffer.alloc(10);
  header[0] = 0x81;
  header[1] = 127;
  header.writeBigUInt64BE(BigInt(length), 2);
  return header;
}

// 유휴 연결이 NAT·프록시·OS 타임아웃으로 끊기지 않도록 주기적으로 ping 프레임(opcode 9)을 보낸다.
// 브라우저 WebSocket은 자동으로 pong으로 응답하고, 서버는 pong(opcode 10)을 무시한다.
const PING_FRAME = Buffer.from([0x89, 0x00]);
setInterval(() => {
  for (const client of clients.values()) {
    if (client.closed || !client.socket.writable) continue;
    try {
      client.socket.write(PING_FRAME);
    } catch {
      /* 다음 write 실패는 socket 'error'/'close'에서 정리된다 */
    }
  }
}, 25000).unref();

// 인증 시도 집계(authAttempts)의 만료 항목을 주기적으로 정리해 메모리 누수를 막는다.
setInterval(() => {
  const now = Date.now();
  for (const [ip, rec] of authAttempts) {
    if (now > rec.resetAt) authAttempts.delete(ip);
  }
}, AUTH_WINDOW_MS).unref();

// 실시간 통화방 접속 현황 + 온라인 유저를 모든 로그인 클라이언트에 알린다.
function broadcastPresence() {
  const presence = {};
  const roomsMeta = {};
  for (const room of rooms.values()) {
    presence[room.id] = [...room.clients].map((id) => {
      const c = clients.get(id);
      return { clientId: id, userId: c?.userId || "", name: c?.name || "Guest" };
    });
    roomsMeta[room.id] = { startedAt: room.startedAt || 0 };
  }
  // 통화방 외에 채팅·메모·그림판·로그방을 지금 열어 보고 있는 사람도 함께 알려,
  // 다른 사람이 어느 방에 있는지 방 옆에 표시할 수 있게 한다. (방 id는 전역 고유라 통화방과 겹치지 않음)
  for (const client of clients.values()) {
    if (!client.userId) continue;
    for (const rid of [client.chatRoomId, client.aiRoomId, client.memoRoomId, client.drawRoomId, client.logRoomId]) {
      if (!rid) continue;
      if (!presence[rid]) presence[rid] = [];
      presence[rid].push({ clientId: client.id, userId: client.userId, name: client.name || "Guest" });
    }
  }
  const online = onlineUserIds();
  // 누가 어느 방에 있는지는 그 방을 볼 수 있는 사람에게만 알린다(다른 채널의 접속 현황·clientId 유출 방지).
  for (const client of clients.values()) {
    if (!client.userId) continue;
    const visible = {};
    for (const [rid, list] of Object.entries(presence)) if (canViewRoom(client, rid)) visible[rid] = list;
    send(client, { type: "presence", rooms: visible, roomsMeta, online });
  }
}

function liveRoomInfo(room) {
  return {
    id: room.id,
    name: room.name,
    channelId: room.channelId || "",
    limit: room.limit || MAX_ROOM_LIMIT,
    count: room.clients.size,
    startedAt: room.startedAt || 0,
    participants: [...room.clients].map((id) => clients.get(id)?.name || "Guest"),
  };
}

// 방 메타의 정원(없으면 기본값). 1~99로 제한.
function roomLimitOf(room) {
  const n = Number(room && room.limit);
  if (!Number.isFinite(n) || n < 1) return MAX_ROOM_LIMIT;
  return Math.min(99, Math.floor(n));
}

// ===== 채널 메시지 =====
function handleChannelMessage(client, message) {
  if (typeof message.type !== "string" || !message.type.startsWith("channel:")) return false;
  if (!client.userId) {
    send(client, { type: "channel-error", message: "로그인이 필요합니다." });
    return true;
  }
  switch (message.type) {
    case "channel:list":
      sendChannels(client);
      return true;
    case "channel:create": {
      const result = store.createChannel(client.userId, message.name);
      if (result.error) return channelError(client, result.error);
      logServer(`channel create name=${result.channel.name} invite=${result.channel.inviteCode}`, client);
      sendChannels(client);
      send(client, { type: "channel-selected", channelId: result.channel.id });
      // 관리자는 모든 채널을 보므로, 접속 중인 다른 관리자에게도 새 채널을 즉시 반영한다.
      notifyAdmins(client.id);
      return true;
    }
    case "channel:join": {
      // 초대 코드(6자리) 무차별 대입 방어: 로그인 시도와 같은 IP당 시도 상한을 쓴다.
      if (authRateLimited(client)) return channelError(client, "시도가 너무 많습니다. 잠시 후 다시 시도해 주세요.");
      // 새로 들어온 경우에만 로그를 남기기 위해 참가 전 멤버 여부를 확인한다.
      const target = store.getChannelByInvite(message.code);
      const wasMember = target ? store.isChannelMember(target.id, client.userId) : false;
      const result = store.joinChannelByCode(client.userId, message.code);
      if (result.error) return channelError(client, result.error);
      logServer(`channel join name=${result.channel.name}`, client);
      notifyChannelMembers(result.channel.id);
      if (!wasMember) logChannelEvent(result.channel.id, client, "member-join", {});
      send(client, { type: "channel-selected", channelId: result.channel.id });
      return true;
    }
    case "channel:leave": {
      const result = store.removeMember(message.channelId, client.userId);
      if (result.error) return channelError(client, result.error);
      forceLeaveChannelRooms(client, message.channelId);
      sendChannels(client);
      notifyChannelMembers(message.channelId);
      return true;
    }
    case "channel:rename":
      return ownerAction(client, message.channelId, () => {
        const r = store.renameChannel(message.channelId, message.name);
        if (r.error) return channelError(client, r.error);
        notifyChannelMembers(message.channelId);
        return true;
      });
    case "channel:delete":
      return ownerAction(client, message.channelId, () => {
        const channel = store.getChannel(message.channelId);
        if (!channel) return channelError(client, "채널을 찾을 수 없습니다.");
        // 다른 멤버가 남아 있으면 삭제 불가(창설자 혼자일 때만).
        if (channel.members.length > 1) {
          return channelError(client, "다른 멤버가 있는 채널은 삭제할 수 없습니다. 먼저 모두 내보내세요.");
        }
        const memberIds = channel.members.slice();
        // 채널 방들의 실시간 접속 종료
        for (const room of channel.rooms) evictRoom(room.id);
        store.deleteChannel(message.channelId);
        for (const c of clients.values()) {
          if (c.userId && memberIds.includes(c.userId)) sendChannels(c);
        }
        // 삭제한 본인(멤버가 아닌 관리자일 수 있음)과 다른 관리자 목록도 갱신
        sendChannels(client);
        notifyAdmins(client.id);
        return true;
      });
    case "channel:add-room":
      return ownerAction(client, message.channelId, () => {
        const r = store.addRoom(message.channelId, message.name, message.roomType, message.parentGroupId);
        if (r.error) return channelError(client, r.error);
        notifyChannelMembers(message.channelId);
        return true;
      });
    case "channel:add-room-group":
      return ownerAction(client, message.channelId, () => {
        const r = store.addRoomGroup(message.channelId, message.name, message.parentGroupId);
        if (r.error) return channelError(client, r.error);
        notifyChannelMembers(message.channelId);
        return true;
      });
    case "channel:rename-room-group":
      return ownerAction(client, message.channelId, () => {
        const r = store.renameRoomGroup(message.channelId, message.groupId, message.name);
        if (r.error) return channelError(client, r.error);
        notifyChannelMembers(message.channelId);
        return true;
      });
    case "channel:remove-room-group":
      return ownerAction(client, message.channelId, () => {
        const r = store.removeRoomGroup(message.channelId, message.groupId);
        if (r.error) return channelError(client, r.error);
        notifyChannelMembers(message.channelId);
        return true;
      });
    case "channel:reorder-room-layout":
      return ownerAction(client, message.channelId, () => {
        const r = store.reorderRoomLayout(message.channelId, message.layout);
        if (r.error) return channelError(client, r.error);
        notifyChannelMembers(message.channelId);
        return true;
      });
    case "channel:remove-room":
      return ownerAction(client, message.channelId, () => {
        const r = store.removeRoom(message.channelId, message.roomId);
        if (r.error) return channelError(client, r.error);
        evictRoom(message.roomId);
        notifyChannelMembers(message.channelId);
        return true;
      });
    case "channel:rename-room":
      return renameRoomAction(client, message.channelId, () => {
        const r = store.renameRoom(message.channelId, message.roomId, message.name);
        if (r.error) return channelError(client, r.error);
        notifyChannelMembers(message.channelId);
        return true;
      });
    case "channel:set-room-limit":
      return ownerAction(client, message.channelId, () => {
        const r = store.setRoomLimit(message.channelId, message.roomId, message.limit);
        if (r.error) return channelError(client, r.error);
        // 이미 열려 있는 실시간 방에도 새 정원을 반영한다.
        const live = rooms.get(message.roomId);
        if (live) live.limit = roomLimitOf(r.room);
        notifyChannelMembers(message.channelId);
        return true;
      });
    case "channel:set-room-readonly":
      return ownerAction(client, message.channelId, () => {
        const r = store.setRoomReadOnly(message.channelId, message.roomId, Boolean(message.value));
        if (r.error) return channelError(client, r.error);
        notifyChannelMembers(message.channelId);
        return true;
      });
    case "channel:room-stats":
      return ownerAction(client, message.channelId, () => {
        const found = store.findRoom(message.roomId);
        if (!found || found.channel.id !== message.channelId) return channelError(client, "방을 찾을 수 없습니다.");
        const snap = roomStatsSnapshot(message.roomId, found.room.type);
        send(client, { type: "channel:room-stats", roomId: message.roomId, roomType: found.room.type, totalMs: snap.totalMs, users: snap.users });
        return true;
      });
    case "channel:kick":
      return ownerAction(client, message.channelId, () => {
        const r = store.removeMember(message.channelId, message.userId);
        if (r.error) return channelError(client, r.error);
        // 쫓겨난 유저를 채널 방에서 강제로 내보내고, 그의 목록을 갱신한다.
        for (const c of clients.values()) {
          if (c.userId === message.userId) {
            forceLeaveChannelRooms(c, message.channelId);
            sendChannels(c);
          }
        }
        notifyChannelMembers(message.channelId);
        return true;
      });
    case "channel:set-manager":
      return creatorAction(client, message.channelId, () => {
        const r = store.setManager(message.channelId, message.userId, Boolean(message.value));
        if (r.error) return channelError(client, r.error);
        notifyChannelMembers(message.channelId);
        return true;
      });
    case "channel:set-icon":
      return ownerAction(client, message.channelId, () => {
        const r = store.setChannelIcon(message.channelId, message.icon);
        if (r.error) return channelError(client, r.error);
        notifyChannelMembers(message.channelId);
        return true;
      });
    case "channel:set-ai":
      return ownerAction(client, message.channelId, () => {
        const patch = {};
        if (typeof message.key === "string") patch.key = message.key.slice(0, 400);
        if (typeof message.model === "string") patch.model = message.model;
        store.setAiConfig(message.channelId, patch);
        notifyChannelMembers(message.channelId); // aiConfig 가 channelSummary 로 다시 나감
        // 이 채널 AI방을 보고 있는 사람에게 갱신된 설정을 즉시 반영
        const channel = store.getChannel(message.channelId);
        for (const room of channel?.rooms || []) {
          if (room.type === "ai") broadcastAi(room.id, { type: "ai:config", roomId: room.id, config: store.getAiConfig(message.channelId) });
        }
        return true;
      });
    case "channel:create-role":
      return ownerAction(client, message.channelId, () => {
        const r = store.createRole(message.channelId, message.name);
        if (r.error) return channelError(client, r.error);
        notifyChannelMembers(message.channelId);
        return true;
      });
    case "channel:update-role":
      return ownerAction(client, message.channelId, () => {
        const r = store.updateRole(message.channelId, message.roleId, {
          name: message.name, color: message.color, manageEmoji: message.manageEmoji,
          addEmoji: message.addEmoji, removeEmoji: message.removeEmoji,
          useEmoji: message.useEmoji, attachFile: message.attachFile,
          renameRoom: message.renameRoom, manageFont: message.manageFont,
        });
        if (r.error) return channelError(client, r.error);
        notifyChannelMembers(message.channelId);
        return true;
      });
    case "channel:set-perms":
      return ownerAction(client, message.channelId, () => {
        const r = store.setChannelPerms(message.channelId, {
          emojiUseRestricted: message.emojiUseRestricted,
          attachRestricted: message.attachRestricted,
        });
        if (r.error) return channelError(client, r.error);
        notifyChannelMembers(message.channelId);
        return true;
      });
    case "channel:set-user-perm":
      return ownerAction(client, message.channelId, () => {
        const r = store.setUserPerm(message.channelId, message.userId, message.cap, Boolean(message.value));
        if (r.error) return channelError(client, r.error);
        notifyChannelMembers(message.channelId);
        return true;
      });
    case "channel:delete-role":
      return ownerAction(client, message.channelId, () => {
        const r = store.deleteRole(message.channelId, message.roleId);
        if (r.error) return channelError(client, r.error);
        notifyChannelMembers(message.channelId);
        return true;
      });
    case "channel:set-role-member":
      return ownerAction(client, message.channelId, () => {
        const r = store.setRoleMember(message.channelId, message.roleId, message.userId, Boolean(message.value));
        if (r.error) return channelError(client, r.error);
        // 권한이 바뀐 유저의 방 목록(접근 가능 방)이 달라질 수 있으니 대상 유저도 강제 정리 후 갱신.
        refreshRoomAccess(message.channelId, message.userId);
        notifyChannelMembers(message.channelId);
        return true;
      });
    case "channel:set-room-perm":
      return ownerAction(client, message.channelId, () => {
        const value = message.value === null || message.value === undefined ? null : Boolean(message.value);
        const r = store.setRoomPerm(message.channelId, message.roomId, message.kind, message.targetId, message.perm, value);
        if (r.error) return channelError(client, r.error);
        // 접근 권한이 바뀌면 이미 방에 접속 중인, 이제 권한 없는 유저를 내보낸다.
        refreshRoomAccess(message.channelId);
        notifyChannelMembers(message.channelId);
        return true;
      });
    case "channel:clear-room-perm":
      return ownerAction(client, message.channelId, () => {
        const r = store.clearRoomPerm(message.channelId, message.roomId, message.kind, message.targetId);
        if (r.error) return channelError(client, r.error);
        refreshRoomAccess(message.channelId);
        notifyChannelMembers(message.channelId);
        return true;
      });
    case "channel:add-emoji":
      return emojiAddAction(client, message.channelId, () => {
        if (!store.isUploadOwner(message.url, client.userId)) return channelError(client, "직접 올린 이미지만 이모지로 등록할 수 있습니다.");
        const r = store.addEmoji(message.channelId, message.name, message.url);
        if (r.error) return channelError(client, r.error);
        logServer(`emoji add name=:${r.emoji.name}: channel=${message.channelId}`, client);
        notifyChannelMembers(message.channelId);
        return true;
      });
    case "channel:remove-emoji":
      return emojiRemoveAction(client, message.channelId, () => {
        const r = store.removeEmoji(message.channelId, message.emojiId);
        if (r.error) return channelError(client, r.error);
        notifyChannelMembers(message.channelId);
        return true;
      });
    case "channel:add-font":
      return fontManageAction(client, message.channelId, () => {
        if (!store.isUploadOwner(message.url, client.userId)) return channelError(client, "직접 올린 파일만 글꼴로 등록할 수 있습니다.");
        const r = store.addFont(message.channelId, message.name, message.url);
        if (r.error) return channelError(client, r.error);
        logServer(`font add name=${r.font.name} channel=${message.channelId}`, client);
        notifyChannelMembers(message.channelId);
        return true;
      });
    case "channel:set-font-meta":
      return fontManageAction(client, message.channelId, () => {
        const r = store.setFontMeta(message.channelId, message.fontId, { family: message.family, weightText: message.weightText });
        if (r.error) return channelError(client, r.error);
        logServer(`font meta name=${r.font.name} family=${r.font.family || ""} weight=${r.font.weightText || ""} channel=${message.channelId}`, client);
        notifyChannelMembers(message.channelId);
        return true;
      });
    case "channel:remove-font":
      return fontManageAction(client, message.channelId, () => {
        const r = store.removeFont(message.channelId, message.fontId);
        if (r.error) return channelError(client, r.error);
        notifyChannelMembers(message.channelId);
        return true;
      });
    default:
      return false;
  }
}

// 권한 변경 후, 해당 채널의 방에 접속(통화)해 있으나 이제 접근 권한이 없는 유저를 내보낸다.
// onlyUserId 를 주면 그 유저만 검사한다.
function refreshRoomAccess(channelId, onlyUserId = "") {
  const channel = store.getChannel(channelId);
  if (!channel) return;
  for (const c of clients.values()) {
    if (!c.userId || !c.roomId) continue;
    if (onlyUserId && c.userId !== onlyUserId) continue;
    const room = rooms.get(c.roomId);
    if (!room || room.channelId !== channelId) continue;
    if (!store.canAccessRoom(channelId, c.roomId, c.userId, c.isAdmin)) {
      leaveRoom(c, true);
    }
  }
}

function channelError(client, messageText) {
  send(client, { type: "channel-error", message: messageText });
  return true;
}

function ownerAction(client, channelId, fn) {
  if (!store.isChannelOwner(channelId, client.userId, client.isAdmin)) {
    return channelError(client, "대표자(또는 관리자)만 할 수 있습니다.");
  }
  return fn();
}

function creatorAction(client, channelId, fn) {
  if (!store.isChannelCreator(channelId, client.userId, client.isAdmin)) {
    return channelError(client, "채널 창설자(또는 관리자)만 할 수 있습니다.");
  }
  return fn();
}

// 이모지 추가(업로드): 대표·관리자 또는 addEmoji 역할 보유자만.
function emojiAddAction(client, channelId, fn) {
  if (!store.canAddEmoji(channelId, client.userId, client.isAdmin)) {
    return channelError(client, "이모지를 추가할 권한이 없습니다.");
  }
  return fn();
}
// 이모지 삭제: 대표·관리자 또는 removeEmoji 역할 보유자만.
function emojiRemoveAction(client, channelId, fn) {
  if (!store.canRemoveEmoji(channelId, client.userId, client.isAdmin)) {
    return channelError(client, "이모지를 삭제할 권한이 없습니다.");
  }
  return fn();
}
// 방 이름 변경: 대표·관리자 또는 renameRoom 역할 보유자만.
function renameRoomAction(client, channelId, fn) {
  if (!store.canRenameRoom(channelId, client.userId, client.isAdmin)) {
    return channelError(client, "방 이름을 변경할 권한이 없습니다.");
  }
  return fn();
}
// 공유 글꼴 업로드·삭제: 대표·관리자 또는 manageFont 역할 보유자만.
function fontManageAction(client, channelId, fn) {
  if (!store.canManageFont(channelId, client.userId, client.isAdmin)) {
    return channelError(client, "글꼴을 관리할 권한이 없습니다.");
  }
  return fn();
}

function sendChannels(client) {
  const channels = store.listChannelsForUser(client.userId, client.isAdmin).map(expandChannel);
  send(client, { type: "channels", channels, me: client.userId, isAdmin: Boolean(client.isAdmin) });
}

function expandChannel(summary) {
  const managerSet = new Set(summary.managerIds || []);
  return {
    ...summary,
    members: summary.memberIds.map((id) => {
      const u = store.findById(id);
      const base = u
        ? { id: u.id, displayName: u.displayName || u.username || `유저#${u.code}`, code: u.code, avatar: u.avatar, banner: u.banner || "", bannerGradient: u.bannerGradient || "", isAdmin: Boolean(u.isAdmin) }
        : { id, displayName: "(삭제된 계정)", code: "----", avatar: "", banner: "", bannerGradient: "", isAdmin: false };
      base.isManager = managerSet.has(id);
      base.isCreator = id === summary.ownerId;
      return base;
    }),
  };
}

function refreshChannelsForAll() {
  for (const c of clients.values()) if (c.userId) sendChannels(c);
}

// 채널 멤버(및 관리자) 중 접속자에게 채널 목록을 다시 보낸다.
function notifyChannelMembers(channelId) {
  // 멤버·권한이 바뀌었으니 강퇴되거나 권한을 잃은 연결이 보던 방의 실시간 전달부터 끊는다.
  for (const c of clients.values()) dropLostViews(c);
  const channel = store.getChannel(channelId);
  if (!channel) return;
  for (const c of clients.values()) {
    if (!c.userId) continue;
    if (c.isAdmin || channel.members.includes(c.userId)) sendChannels(c);
  }
}

function canViewRoom(client, roomId) {
  const found = client.userId ? store.findRoom(roomId) : null;
  return Boolean(found) &&
    store.isChannelMember(found.channel.id, client.userId, client.isAdmin) &&
    store.canAccessRoom(found.channel.id, roomId, client.userId, client.isAdmin);
}

// 메모·그림판·AI·채팅·로그 실시간 전달은 "지금 보고 있는 방" 기준이라, 강퇴·권한 회수·로그아웃 뒤에도
// 그 상태가 남아 있으면 계속 받게 된다. 볼 권한이 없어진 방에서는 내보낸다.
function dropLostViews(client) {
  const lost = (roomId) => Boolean(roomId) && !canViewRoom(client, roomId);
  if (lost(client.chatRoomId)) leaveChatView(client);
  if (lost(client.aiRoomId)) leaveAiView(client);
  if (lost(client.memoRoomId)) leaveMemo(client);
  if (lost(client.drawRoomId)) leaveDraw(client);
  if (lost(client.logRoomId)) {
    client.logRoomId = "";
    client.logChannelId = "";
  }
}

// 접속 중인 관리자 전원(선택적으로 한 명 제외)에게 채널 목록을 다시 보낸다.
// 관리자는 모든 채널을 볼 수 있으므로, 채널 생성/삭제 시 목록을 즉시 맞춘다.
function notifyAdmins(exceptClientId = "") {
  for (const c of clients.values()) {
    if (c.userId && c.isAdmin && c.id !== exceptClientId) sendChannels(c);
  }
}

// 특정 통화방의 모든 접속자를 강제로 내보낸다(방 삭제/채널 삭제 시).
function evictRoom(roomId) {
  const room = rooms.get(roomId);
  if (!room) return;
  for (const clientId of [...room.clients]) {
    const c = clients.get(clientId);
    if (c) {
      leaveRoom(c, true);
    }
  }
  rooms.delete(roomId);
}

// 특정 클라이언트가 해당 채널의 통화방에 있으면 내보낸다.
function forceLeaveChannelRooms(client, channelId) {
  if (!client.roomId) return;
  const room = rooms.get(client.roomId);
  if (room && room.channelId === channelId) {
    leaveRoom(client, true);
  }
}

// ===== 채팅 메시지 =====
const CHAT_TEXT_MAX = 4000;
const CHAT_FILES_MAX = 10;
const CHAT_SEARCH_QUERY_MAX = 200;
// 정규식 검색은 사용자가 준 패턴을 서버에서 돌리므로 ^(a+)+$ 같은 패턴 하나로 이벤트 루프가 몇 초~무한정 멈춘다(ReDoS).
// vm 타임아웃으로 실행을 끊고, 사용자당 간격을 둬 연속 요청으로 서버를 붙잡지 못하게 한다.
// ponytail: 계정을 여러 개 만들면 계정 수 × 100ms/초까지는 여전히 막을 수 있다. 문제되면 worker_threads 로 옮긴다.
const CHAT_REGEX_TIMEOUT_MS = 100;
const CHAT_REGEX_INTERVAL_MS = 1000;
const lastRegexSearchAt = new Map(); // userId -> 마지막 정규식 검색 시각
const CHAT_SEARCH_RESULT_MAX = 200;

// 방에 쓰기(채팅·메모편집·그리기)가 가능한지. 읽기 전용 방은 대표자만,
// 그 외에는 권한 시스템의 사용(use) 권한을 따른다. 대표자/관리자는 항상 허용.
function isRoomWritable(ctx, client) {
  if (ctx.room.readOnly && !store.isChannelOwner(ctx.channel.id, client.userId, client.isAdmin)) {
    return false;
  }
  return store.canUseRoom(ctx.channel.id, ctx.room.id, client.userId, client.isAdmin);
}

// 채팅방 보기를 그만둘 때(다른 방으로 갈아탐/닫기/연결종료) 시청시간 통계를 마감한다.
function leaveChatView(client) {
  const roomId = client.chatRoomId;
  if (!roomId) return;
  client.chatRoomId = "";
  if (client.userId && client.chatJoinedAt) addStat(roomId, client.userId, client.name, "viewMs", Date.now() - client.chatJoinedAt);
  client.chatJoinedAt = 0;
}

function handleChatMessage(client, message) {
  if (typeof message.type !== "string" || !message.type.startsWith("chat:")) return false;
  if (!client.userId) {
    send(client, { type: "chat-error", message: "로그인이 필요합니다." });
    return true;
  }

  switch (message.type) {
    case "chat:open": {
      const ctx = resolveChatRoom(client, message.roomId);
      if (!ctx) return true;
      if (client.chatRoomId && client.chatRoomId !== ctx.room.id) leaveChatView(client);
      client.chatRoomId = ctx.room.id;
      client.chatJoinedAt = Date.now();
      send(client, {
        type: "chat:history",
        roomId: ctx.room.id,
        messages: store.getMessages(ctx.room.id),
      });
      broadcastPresence(); // 이 방을 보고 있다고 다른 사람에게 알림
      return true;
    }
    case "chat:close": {
      leaveChatView(client);
      broadcastPresence();
      return true;
    }
    case "chat:send": {
      const ctx = resolveChatRoom(client, message.roomId);
      if (!ctx) return true;
      if (!isRoomWritable(ctx, client)) {
        send(client, { type: "chat-error", message: "읽기 전용 방입니다. 대표자만 작성할 수 있습니다." });
        return true;
      }
      const text = String(message.text || "").slice(0, CHAT_TEXT_MAX).replace(/\s+$/, "");
      const files = cleanChatFiles(message.files, client.userId);
      const mentions = cleanChatMentions(ctx.channel, message.mentions, text);
      if (!text && !files.length) {
        send(client, { type: "chat-error", message: "빈 메시지는 보낼 수 없습니다." });
        return true;
      }
      // 파일 첨부 권한
      if (files.length && !store.canAttach(ctx.channel.id, client.userId, client.isAdmin)) {
        send(client, { type: "chat-error", message: "파일을 첨부할 권한이 없습니다." });
        return true;
      }
      // 커스텀 이모지 사용 권한: 텍스트에 이 채널의 커스텀 이모지 토큰이 있으면 권한 필요
      if (text && !store.canUseEmoji(ctx.channel.id, client.userId, client.isAdmin)) {
        const emojis = (store.getChannel(ctx.channel.id)?.emojis) || [];
        if (emojis.some((e) => e && e.name && new RegExp(`:${e.name}:`).test(text))) {
          send(client, { type: "chat-error", message: "커스텀 이모지를 사용할 권한이 없습니다." });
          return true;
        }
      }
      const user = store.findById(client.userId);
      const msg = {
        id: crypto.randomBytes(8).toString("hex"),
        roomId: ctx.room.id,
        userId: client.userId,
        name: user ? user.displayName : client.name,
        code: user ? user.code : "",
        text,
        mentions,
        files,
        at: Date.now(),
      };
      store.addMessage(ctx.room.id, msg);
      broadcastChat(ctx.channel, ctx.room.id, { type: "chat:message", message: msg });
      if (text.length) addStat(ctx.room.id, client.userId, client.name, "charsTyped", text.length);
      addStat(ctx.room.id, client.userId, client.name, "messages", 1);
      const emojiCount = (text.match(/:[a-z0-9_]{2,32}:/gi) || []).length;
      if (emojiCount) addStat(ctx.room.id, client.userId, client.name, "emojis", emojiCount);
      if (files.length) addStat(ctx.room.id, client.userId, client.name, "files", files.length);
      const linkCount = (text.match(/https?:\/\/\S+/g) || []).length;
      if (linkCount) addStat(ctx.room.id, client.userId, client.name, "links", linkCount);
      return true;
    }
    case "chat:typing": {
      const ctx = resolveChatRoom(client, message.roomId);
      if (!ctx) return true;
      // 같은 방을 보고 있는 다른 사람에게만 입력중을 알린다.
      for (const c of clients.values()) {
        if (c.id === client.id || c.chatRoomId !== ctx.room.id) continue;
        send(c, { type: "chat:typing", roomId: ctx.room.id, userId: client.userId, name: client.name });
      }
      return true;
    }
    case "chat:delete": {
      const ctx = resolveChatRoom(client, message.roomId);
      if (!ctx) return true;
      const list = store.getMessages(ctx.room.id);
      const target = list.find((m) => m.id === message.msgId);
      if (!target) return true; // 이미 삭제됨
      // 대표자(또는 관리자)는 모든 메시지, 일반 유저는 본인 메시지만 삭제 가능.
      const isOwner = store.isChannelOwner(ctx.channel.id, client.userId, client.isAdmin);
      if (target.userId !== client.userId && !isOwner) {
        send(client, { type: "chat-error", message: "본인 메시지만 삭제할 수 있습니다." });
        return true;
      }
      store.deleteMessage(ctx.room.id, message.msgId);
      broadcastChat(ctx.channel, ctx.room.id, { type: "chat:deleted", roomId: ctx.room.id, msgId: message.msgId });
      return true;
    }
    case "chat:edit": {
      const ctx = resolveChatRoom(client, message.roomId);
      if (!ctx) return true;
      if (!isRoomWritable(ctx, client)) {
        send(client, { type: "chat-error", message: "읽기 전용 방입니다." });
        return true;
      }
      const text = String(message.text || "").slice(0, CHAT_TEXT_MAX).replace(/\s+$/, "");
      const mentions = cleanChatMentions(ctx.channel, message.mentions, text);
      if (!text) {
        send(client, { type: "chat-error", message: "빈 메시지로 수정할 수 없습니다." });
        return true;
      }
      // 커스텀 이모지 사용 권한 재확인(사용 제한 채널에서 우회 방지)
      if (!store.canUseEmoji(ctx.channel.id, client.userId, client.isAdmin)) {
        const emojis = (store.getChannel(ctx.channel.id)?.emojis) || [];
        if (emojis.some((e) => e && e.name && new RegExp(`:${e.name}:`).test(text))) {
          send(client, { type: "chat-error", message: "커스텀 이모지를 사용할 권한이 없습니다." });
          return true;
        }
      }
      const r = store.editMessage(ctx.room.id, message.msgId, client.userId, text, mentions);
      if (r.error) { send(client, { type: "chat-error", message: r.error }); return true; }
      broadcastChat(ctx.channel, ctx.room.id, {
        type: "chat:edited",
        roomId: ctx.room.id,
        msgId: message.msgId,
        text: r.message.text,
        mentions: r.message.mentions || [],
        editedAt: r.message.editedAt,
      });
      return true;
    }
    case "chat:search": {
      const ctx = resolveChatRoom(client, message.roomId);
      if (!ctx) return true;
      const q = String(message.q || "").slice(0, CHAT_SEARCH_QUERY_MAX);
      let matcher = null;
      let regex = null;
      if (q) {
        if (message.regex) {
          const now = Date.now();
          if (now - (lastRegexSearchAt.get(client.userId) || 0) < CHAT_REGEX_INTERVAL_MS) {
            send(client, { type: "chat-error", message: "정규식 검색은 잠시 후 다시 시도해 주세요." });
            return true;
          }
          lastRegexSearchAt.set(client.userId, now);
          try {
            regex = new RegExp(q, "iu");
          } catch {
            send(client, { type: "chat-error", message: "정규식이 올바르지 않습니다." });
            return true;
          }
        } else {
          const needle = q.toLowerCase();
          matcher = { test: (text) => text.toLowerCase().includes(needle) };
        }
      }
      const userId = String(message.userId || "");
      const from = Number(message.from) || 0;
      const to = Number(message.to) || 0;
      const targetRoomId = String(message.targetRoomId || "");
      if (!q && !userId && !from && !to) {
        send(client, { type: "chat:search-result", reqId: message.reqId, results: [], truncated: false });
        return true;
      }
      const targetRooms = ctx.channel.rooms.filter((r) =>
        r.type === "chat" &&
        (!targetRoomId || r.id === targetRoomId) &&
        store.canAccessRoom(ctx.channel.id, r.id, client.userId, client.isAdmin)
      );
      let results = [];
      for (const room of targetRooms) {
        for (const msg of store.getMessages(room.id)) {
          if (matcher && !matcher.test(msg.text || "")) continue;
          if (userId && msg.userId !== userId) continue;
          if (from && msg.at < from) continue;
          if (to && msg.at > to) continue;
          results.push({ ...msg, roomId: room.id, roomName: room.name });
        }
      }
      if (regex) {
        let hits;
        try {
          hits = vm.runInNewContext("texts.map((t) => re.test(t))", {
            texts: results.map((msg) => String(msg.text || "")),
            re: regex,
          }, { timeout: CHAT_REGEX_TIMEOUT_MS });
        } catch {
          send(client, { type: "chat-error", message: "정규식이 너무 복잡해 검색을 멈췄습니다." });
          return true;
        }
        results = results.filter((msg, index) => hits[index]);
      }
      results.sort((a, b) => b.at - a.at);
      send(client, {
        type: "chat:search-result",
        reqId: message.reqId,
        results: results.slice(0, CHAT_SEARCH_RESULT_MAX),
        truncated: results.length > CHAT_SEARCH_RESULT_MAX,
      });
      return true;
    }
    default:
      return false;
  }
}

const MENTION_BOUNDARY = "(?=$|[\\s.,!?…:;)\\]}>])";

function cleanChatMentions(channel, value, text) {
  const members = Array.isArray(channel?.members) ? channel.members : [];
  const src = String(text || "");
  // @everyone/@here 는 실제 멤버 목록으로 서버가 직접 확장한다(클라이언트 값은 신뢰하지 않음).
  if (new RegExp(`(^|[\\s([{])@everyone${MENTION_BOUNDARY}`, "iu").test(src)) {
    return members.slice(0, 500);
  }
  if (new RegExp(`(^|[\\s([{])@here${MENTION_BOUNDARY}`, "iu").test(src)) {
    const online = new Set(onlineUserIds());
    return members.filter((id) => online.has(id)).slice(0, 500);
  }
  if (!Array.isArray(value)) return [];
  const memberSet = new Set(members);
  const result = [];
  for (const raw of value) {
    const id = String(raw || "");
    const user = memberSet.has(id) ? store.findById(id) : null;
    const name = String(user?.displayName || "");
    const appears = name && new RegExp(`(^|[\\s([{])@${escapeRegex(name)}${MENTION_BOUNDARY}`, "u").test(src);
    if (appears && !result.includes(id)) result.push(id);
    if (result.length >= 50) break;
  }
  return result;
}

function escapeRegex(value) {
  return String(value || "").replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
}

// roomId 로 채팅방과 채널을 찾고 멤버십을 확인한다. 실패 시 에러 전송 후 null.
function resolveChatRoom(client, roomId) {
  const found = store.findRoom(String(roomId || ""));
  if (!found || found.room.type !== "chat") {
    send(client, { type: "chat-error", message: "채팅방을 찾지 못했습니다." });
    return null;
  }
  if (!store.isChannelMember(found.channel.id, client.userId, client.isAdmin)) {
    send(client, { type: "chat-error", message: "채널 멤버만 이용할 수 있습니다." });
    return null;
  }
  if (!store.canAccessRoom(found.channel.id, found.room.id, client.userId, client.isAdmin)) {
    send(client, { type: "chat-error", message: "이 방에 접근할 권한이 없습니다." });
    return null;
  }
  return found;
}

function cleanChatFiles(files, userId) {
  if (!Array.isArray(files)) return [];
  const out = [];
  for (const file of files.slice(0, CHAT_FILES_MAX)) {
    const url = String(file?.url || "");
    // 우리 업로드 엔드포인트가 발급한 경로 중 보낸 사람이 직접 올린 파일만 허용한다.
    if (!/^\/uploads\/[a-f0-9]{24}_[A-Za-z0-9._-]+$/.test(url)) continue;
    if (!store.isUploadOwner(url, userId)) continue;
    out.push({
      url,
      name: String(file?.name || "file").slice(0, 200),
      size: Number(file?.size) || 0,
      mime: String(file?.mime || "").slice(0, 100),
      kind: file?.kind === "image" ? "image" : "file",
    });
  }
  return out;
}

// 채널의 온라인 멤버(관리자 포함) 전원에게 채팅 이벤트를 보낸다.
// 채널 멤버 중 그 채팅방 접근 권한이 있는 사람에게만 보낸다(제한된 방 메시지가 다른 멤버에게 새지 않게).
function broadcastChat(channel, roomId, payload) {
  for (const c of clients.values()) {
    if (!c.userId) continue;
    if (store.isChannelMember(channel.id, c.userId, c.isAdmin) && store.canAccessRoom(channel.id, roomId, c.userId, c.isAdmin)) send(c, payload);
  }
}

// ===== AI방 (다같이 쓰는 AI 대화방) =====
// 각 사용자는 자기 입력창을 쓰고, 입력 중인 내용은 방의 다른 사람에게 미리보기로만 보인다(입력창을 공유하지 않음).
// 보낸 프롬프트와 AI 응답은 방 전원이 함께 본다.
// 세션(대화 스레드) + 방 메모리는 server-data/ai/<roomId>.json 에 저장되고, 입력 미리보기(draft)는 메모리에만 둔다.
const AI_TEXT_MAX = 4000;
const AI_CONTEXT_TURNS = 20; // Gemini 에 함께 보내는 최근 메시지 수(활성 세션)
const AI_TIMEOUT_MS = 60000;
const AI_IMG_MIME = { "image/png": ".png", "image/jpeg": ".jpg", "image/webp": ".webp" };
const AI_REF_MAX = 5; // 한 메시지에서 처리하는 #방 참조 최대 개수
const AI_ATTACH_MAX = 3; // 메시지 하나에 첨부 가능한 파일 수(클라 상한과 동일)
const AI_ATTACH_IMG_MAX = 4 * 1024 * 1024; // 이미지 첨부 원본 용량 상한 — base64 인플레이션(~33%) 감안해 요청이 안 커지게
const AI_ATTACH_TEXT_MAX = 8000; // 첨부 텍스트 파일에서 프롬프트에 끼워 넣는 글자 수 상한
// 모델이 참조된 방을 고칠 때 쓰는 지시 블록: ```accord:<memo|memo-append|chat> #방이름 \n 내용 ```
// 방 이름에 공백이 있을 수 있으므로 줄 끝까지 받고, refMap 키와 앞머리 매칭으로 실제 이름을 가려낸다.
const AI_ACTION_RE = /```accord:(memo|memo-append|chat)[ \t]+#([^#`\n]{1,40})[^\n]*\n([\s\S]*?)```/g;
const AI_ECHO_LINES = 12; // 적용한 내용을 채팅에 그대로 남길 줄 수 상한(문서 전체 교체면 통째로 쏟아지므로 자른다)

// 지시 블록을 지우기만 하면 "다음 내용을 추가했습니다." 뒤가 비어 답변이 잘린 것처럼 보인다.
// 실제로 쓴 내용을 그 자리에 남겨서 방 사람들이 무엇이 들어갔는지 바로 본다.
function echoAiBody(body) {
  const lines = String(body).split("\n");
  return lines.length > AI_ECHO_LINES ? `${lines.slice(0, AI_ECHO_LINES).join("\n")}\n…` : body;
}

const aiDrafts = new Map(); // roomId -> Map(userId -> { text, name, at })
const aiBusy = new Set();   // 응답 생성 중인 roomId (동시 요청/비용 방어)
const aiBusyUsers = new Set(); // 응답을 기다리는 요청자 userId (사용자당 동시 1건)
const AI_SESSIONS_MAX = 100; // AI방 하나에 만들 수 있는 대화 수(요청마다 파일 전체를 읽고 쓰므로 상한)

// 이 방에서 나(byId 제외) 말고 입력 중인 사람들의 미리보기 목록.
function aiDraftList(roomId, exceptId) {
  const m = aiDrafts.get(roomId);
  if (!m) return [];
  const out = [];
  for (const [uid, d] of m) {
    if (uid === exceptId || !d.text) continue;
    out.push({ byId: uid, byName: d.name || "", text: d.text });
  }
  return out;
}

function leaveAiView(client) {
  const roomId = client.aiRoomId;
  if (!roomId) return;
  client.aiRoomId = "";
  const m = aiDrafts.get(roomId);
  if (m && m.delete(client.userId)) {
    if (!m.size) aiDrafts.delete(roomId);
    // 자리를 뜬 사람의 "입력 중" 잔상을 즉시 지운다.
    broadcastAi(roomId, { type: "ai:draft", roomId, byId: client.userId, byName: client.name || "", text: "" });
  }
}

function resolveAiRoom(client, roomId) {
  const found = store.findRoom(String(roomId || ""));
  if (!found || found.room.type !== "ai") {
    send(client, { type: "ai:error", message: "AI방을 찾지 못했습니다." });
    return null;
  }
  if (!store.isChannelMember(found.channel.id, client.userId, client.isAdmin)) {
    send(client, { type: "ai:error", message: "채널 멤버만 이용할 수 있습니다." });
    return null;
  }
  if (!store.canAccessRoom(found.channel.id, found.room.id, client.userId, client.isAdmin)) {
    send(client, { type: "ai:error", message: "이 방에 접근할 권한이 없습니다." });
    return null;
  }
  return found;
}

function broadcastAi(roomId, payload) {
  for (const c of clients.values()) {
    if (c.aiRoomId === roomId && canViewRoom(c, roomId)) send(c, payload);
  }
}

// ai:state 를 방 전원에게, 각자 관점(writable·본인 제외 draft 목록)으로 보낸다.
function broadcastAiState(ctx, doc, messages) {
  for (const c of clients.values()) {
    if (c.aiRoomId === ctx.room.id && canViewRoom(c, ctx.room.id)) send(c, aiStatePayload(ctx, c, doc, messages));
  }
}

function aiSessionMetas(doc) {
  return doc.sessions.map((s) => ({ id: s.id, title: s.title || "새 대화", createdAt: s.createdAt || 0, count: (s.messages || []).length }));
}

function aiActiveSession(doc) {
  return doc.sessions.find((s) => s.id === doc.activeSessionId) || null;
}

// ai:state 공통 페이로드. messages 를 주면 그 목록을, 아니면 활성 세션 메시지를 담는다.
function aiStatePayload(ctx, client, doc, messages) {
  return {
    type: "ai:state",
    roomId: ctx.room.id,
    config: store.getAiConfig(ctx.channel.id),
    memory: doc.memory,
    settings: doc.settings,
    sessions: aiSessionMetas(doc),
    activeSessionId: doc.activeSessionId || "",
    messages: messages || (aiActiveSession(doc)?.messages ?? []),
    thinking: aiBusy.has(ctx.room.id),
    writable: isRoomWritable(ctx, client),
    drafts: aiDraftList(ctx.room.id, client.userId),
    files: aiFilesForClient(doc.files),
  };
}

// 추출된 본문(text)은 클라에 보내지 않는다(용량·정보 노출 방지) — 목록 표시에 필요한 메타데이터만.
function aiFilesForClient(files) {
  return (Array.isArray(files) ? files : []).map((f) => ({ id: f.id, name: f.name, mime: f.mime, size: f.size, url: f.url, addedAt: f.addedAt }));
}

function aiEnsureSession(doc) {
  let s = aiActiveSession(doc);
  if (!s) {
    s = { id: crypto.randomBytes(8).toString("hex"), title: "새 대화", createdAt: Date.now(), messages: [] };
    doc.sessions.push(s);
    doc.activeSessionId = s.id;
  }
  return s;
}

// Gemini generateContent 호출. { text, images:[{mime,dataB64}] } 반환.
// ponytail: 이미지 생성은 모델 ID 에 "image" 가 들어가면 responseModalities 로 IMAGE 를 요청하는 휴리스틱.
//           전용 토글이 필요해지면 그때 만든다.
async function callGemini({ apiKey, model, contents, system, thinking }) {
  if (typeof fetch !== "function") throw new Error("이 서버의 Node 버전이 낮습니다. Node 18 이상이 필요합니다.");
  // 키는 URL(프록시·에러 로그에 남기 쉬움) 대신 헤더로 보낸다.
  const url = `https://generativelanguage.googleapis.com/v1beta/models/${encodeURIComponent(model)}:generateContent`;
  const body = { contents };
  if (system) body.systemInstruction = { parts: [{ text: system }] };
  const gen = {};
  const isImageModel = /image/i.test(model);
  if (isImageModel) gen.responseModalities = ["TEXT", "IMAGE"];
  // 생각 수준: Gemini 2.5 계열(이미지 모델 제외)만 thinkingConfig 지원. auto = 모델 자동(미지정).
  if (/2\.5/.test(model) && !isImageModel && thinking && thinking !== "auto") {
    gen.thinkingConfig = { thinkingBudget: thinking === "off" ? 0 : 24576 };
  }
  if (Object.keys(gen).length) body.generationConfig = gen;
  // 이미지 생성처럼 오래 걸리는 요청에서 Gemini 가 DEADLINE_EXCEEDED(504)·5xx·429 를 간헐적으로 뱉는다 — 1회 재시도.
  // ponytail: 재시도 1번 고정. 최악의 경우 대기 시간이 AI_TIMEOUT_MS 의 2배(+백오프)까지 늘고 그동안 방이 aiBusy 로 잠긴다.
  const payload = JSON.stringify(body);
  let data;
  for (let attempt = 1; ; attempt++) {
    if (attempt > 1) await new Promise((r) => setTimeout(r, 1500));
    const ctrl = new AbortController();
    const timer = setTimeout(() => ctrl.abort(), AI_TIMEOUT_MS);
    let res;
    try {
      res = await fetch(url, {
        method: "POST",
        headers: { "content-type": "application/json", "x-goog-api-key": apiKey },
        body: payload,
        signal: ctrl.signal,
      });
    } catch (err) {
      clearTimeout(timer);
      if (err.name === "AbortError") throw new Error("AI 응답이 시간 내에 오지 않았습니다.");
      const detail = err?.cause?.code || err?.cause?.message || err?.code || err?.message || "unknown";
      console.error("[ai] fetch 실패:", detail, err?.cause || err);
      throw new Error(`AI 서버에 연결하지 못했습니다 (${detail})`);
    }
    // 본문을 받는 동안에도 타임아웃이 걸려 있어야 업스트림이 멈췄을 때 방이 aiBusy 로 영영 잠기지 않는다.
    data = await res.json().catch(() => ({}));
    clearTimeout(timer);
    if (ctrl.signal.aborted) throw new Error("AI 응답이 시간 내에 오지 않았습니다.");
    if (res.ok) break;
    const msg = data?.error?.message ? `Gemini 오류: ${data.error.message}` : `Gemini 오류 (HTTP ${res.status})`;
    if ((res.status >= 500 || res.status === 429) && attempt < 2) {
      console.warn(`[ai] ${msg} — 재시도`);
      continue;
    }
    throw new Error(msg);
  }
  const cand = data?.candidates?.[0];
  const parts = cand?.content?.parts || [];
  const text = parts.map((p) => p.text || "").join("").trim();
  const images = [];
  for (const p of parts) {
    const d = p.inlineData || p.inline_data;
    // mime 화이트리스트(png/jpeg/webp)로 좁히면 모델이 다른 mime(예: 파라미터 붙은 image/png;...)을 돌려줄 때
    // 조용히 걸러져 "이미지가 아예 안 왔다"처럼 보인다 — image/* 전체를 받고 저장 시 확장자만 기본값(.png)으로.
    if (d && d.data && /^image\//i.test(d.mimeType || d.mime_type || "")) {
      images.push({ mime: d.mimeType || d.mime_type, dataB64: d.data });
    }
  }
  const reason = data?.promptFeedback?.blockReason || cand?.finishReason;
  if (!text && !images.length) {
    throw new Error(reason ? `응답이 비어 있습니다 (${reason}).` : "빈 응답을 받았습니다.");
  }
  const imageMissing = isImageModel && !images.length;
  if (imageMissing) {
    // 이미지 모델인데 이미지가 안 왔을 때 원인 진단(실 키로만 재현 가능 — 사용자 테스트 시 로그 확인용).
    console.error("[ai] 이미지 모델 응답에 이미지 없음:", { reason, parts: parts.map((p) => Object.keys(p)) });
  }
  return { text, images, imageBlockReason: imageMissing ? reason : "" };
}

// 메시지에 첨부된 파일을 Gemini 콘텐츠에 태울 형태로 바꾼다. toGeminiContents(순수함수)는 안 건드리고
// 여기서 디스크를 읽어(이미지 base64 inlineData / 텍스트류는 프롬프트에 인용) contents 마지막 파트에 덧붙인다.
function buildAiAttachmentParts(files) {
  const imageParts = [];
  let extraText = "";
  for (const f of Array.isArray(files) ? files : []) {
    const filePath = store.getUploadPath(String(f.url || "").slice("/uploads/".length));
    if (!filePath) continue;
    if (/^image\//i.test(f.mime || "")) {
      try {
        // 크기부터 보고 읽는다(50MB 업로드를 통째로 메모리에 올리지 않게).
        if (fs.statSync(filePath).size <= AI_ATTACH_IMG_MAX) imageParts.push({ inlineData: { mimeType: f.mime, data: fs.readFileSync(filePath).toString("base64") } });
        else extraText += `\n[첨부 이미지 "${f.name}"는 용량이 커서 전달하지 못했습니다]`;
      } catch { /* 무시 */ }
    } else if (store.isAiTextyFile(f.mime, f.name)) {
      try {
        const text = fs.readFileSync(filePath, "utf8").slice(0, AI_ATTACH_TEXT_MAX);
        extraText += `\n\n[첨부 파일 "${f.name}"]\n${text}`;
      } catch { /* 무시 */ }
    } else {
      extraText += `\n[첨부 파일 "${f.name}"은 이 형식은 읽을 수 없어 이름만 전달합니다]`;
    }
  }
  return { imageParts, extraText };
}

// groupId 가 속한 최상위(맨 바깥) 그룹 id. 그룹 밖(채널 루트)이면 "".
// 순환 참조(있으면 안 되지만 방어적으로)는 만나는 즉시 "" 로 끊는다.
function topRoomGroupId(channel, groupId) {
  const groups = channel.roomGroups || [];
  const byId = new Map(groups.map((g) => [g.id, g]));
  const seen = new Set();
  let cur = String(groupId || "");
  while (cur) {
    if (seen.has(cur)) return "";
    seen.add(cur);
    const g = byId.get(cur);
    if (!g) return "";
    const parent = String(g.parentGroupId || "");
    if (!parent) return cur;
    cur = parent;
  }
  return "";
}

// 참조 후보: 이 채널의 memo/chat 방을 { 소문자 이름, 방 }으로, 긴 이름부터.
// 긴 것부터 봐야 "일반"과 "일반 공지"가 같이 있을 때 "#일반 공지"가 제대로 잡힌다.
// scoped=true(방 설정 기본값)면 AI방이 속한 최상위 그룹 밑의 방만 — 안 그러면 채널 전체에서
// 같은 이름의 방이 여러 그룹에 있을 때 엉뚱한 그룹의 방이 섞인다. scoped=false면 채널 전체 대상(끄면).
function aiRefCandidates(ctx, scoped) {
  const scopeRoot = scoped ? topRoomGroupId(ctx.channel, ctx.room.groupId) : "";
  return (ctx.channel.rooms || [])
    .filter((r) => (r.type === "memo" || r.type === "chat")
      && (!scopeRoot || topRoomGroupId(ctx.channel, r.groupId) === scopeRoot))
    .map((r) => ({ key: String(r.name || "").trim().toLowerCase(), room: r }))
    .filter((c) => c.key) // 빈 이름은 모든 #에 걸려버리므로 제외
    .sort((a, b) => b.key.length - a.key.length);
}

// str 앞머리와 일치하는 가장 긴 방 이름을 고른다. 정규식을 만들지 않으므로 "C++" 같은 이름도 안전.
function matchAiRefName(str, cands) {
  const low = String(str).toLowerCase();
  return cands.find((c) => low.startsWith(c.key)) || null;
}

// 사용자가 이번 메시지에서 #으로 지정한 memo/chat 방만 해석한다(모델이 지어낸 #는 못 건드림).
// 토큰을 잘라 이름과 맞추는 대신 아는 방 이름을 텍스트에 대조한다 —
// 그래야 "#자유 질문"처럼 공백 있는 이름도, "#회의록에"처럼 조사가 붙은 경우도 잡힌다.
function resolveAiRefs(text, ctx, client, scoped) {
  const cands = aiRefCandidates(ctx, scoped);
  const src = String(text);
  const map = new Map(); // 소문자 방이름 -> { room, type }
  const refs = [];
  for (let i = src.indexOf("#"); i >= 0 && refs.length < AI_REF_MAX; i = src.indexOf("#", i + 1)) {
    const hit = matchAiRefName(src.slice(i + 1), cands);
    if (!hit || map.has(hit.key)) continue;
    const room = hit.room;
    if (!store.canAccessRoom(ctx.channel.id, room.id, client.userId, client.isAdmin)) continue;
    const content = room.type === "memo"
      ? (store.getMemo(room.id).text || "")
      : store.getMessages(room.id, 60).map((m) => `${m.name || "?"}: ${m.text || ""}`).join("\n");
    map.set(hit.key, { key: hit.key, room, type: room.type });
    refs.push({ name: room.name, type: room.type, content });
  }
  return { map, refs };
}

// 라이브 메모(편집자 있음)면 OT op 로 반영, 아니면 파일에 직접 저장.
function applyAiMemoWrite(roomId, mode, body, client) {
  const live = memoDocs.get(roomId);
  const cur = live ? live.text : (store.getMemo(roomId).text || "");
  const addition = mode === "append" ? ((cur ? "\n" : "") + body) : body;
  const next = mode === "append" ? cur + addition : body;
  if (live) {
    const op = mode === "append"
      ? (cur.length ? [cur.length, addition] : [addition])
      : (cur.length ? [-cur.length, body] : [body]);
    live.history.push(op);
    live.text = next;
    const rev = live.history.length;
    for (const c of clients.values()) if (c.memoRoomId === roomId) send(c, { type: "memo:op", roomId, rev, ops: op, by: "" });
    scheduleMemoPersist(roomId, client.userId);
  } else {
    store.saveMemo(roomId, next, client.userId); // font 인자 생략 = 기존 글꼴 유지
  }
}

// 모델 응답의 accord: 지시 블록을 실행하고, 블록을 뺀 표시용 텍스트 + 결과 메모를 돌려준다.
function applyAiActions(replyText, refMap, ctx, client) {
  const notes = [];
  // 이번 메시지에서 실제로 해석된 방만 대상 — 모델이 안 지정된 방을 건드리지 못하게 하는 경계다.
  const refCands = [...refMap.values()].sort((a, b) => b.key.length - a.key.length);
  const display = String(replyText || "").replace(AI_ACTION_RE, (_m, kind, name, payload) => {
    const body = String(payload).replace(/\s+$/, "");
    const target = matchAiRefName(name, refCands);
    if (!target) { notes.push(`⚠️ #${name.trim()}: 이번 메시지에서 #로 지정한 방이 아니어서 건드리지 않았습니다.`); return ""; }
    const tctx = { channel: ctx.channel, room: target.room };
    if (!isRoomWritable(tctx, client)) { notes.push(`⚠️ #${target.room.name}: 쓰기 권한이 없어 건너뜀`); return ""; }
    try {
      if (kind === "chat") {
        if (target.type !== "chat") { notes.push(`⚠️ #${target.room.name}: 채팅방이 아님`); return ""; }
        const cu = store.findById(client.userId);
        const cmsg = {
          id: crypto.randomBytes(8).toString("hex"), roomId: target.room.id,
          userId: client.userId, name: cu ? cu.displayName : client.name, code: cu ? cu.code : "",
          text: `🤖 (AI방 요청) ${body}`.slice(0, 4000), mentions: [], files: [], at: Date.now(),
        };
        store.addMessage(target.room.id, cmsg);
        broadcastChat(ctx.channel, target.room.id, { type: "chat:message", message: cmsg });
        notes.push(`✅ #${target.room.name} 채팅에 메시지를 보냈습니다.`);
      } else {
        if (target.type !== "memo") { notes.push(`⚠️ #${target.room.name}: 메모장이 아님`); return ""; }
        applyAiMemoWrite(target.room.id, kind === "memo-append" ? "append" : "replace", body, client);
        notes.push(`✅ #${target.room.name} 메모장을 ${kind === "memo-append" ? "이어썼" : "수정했"}습니다.`);
      }
    } catch (e) {
      notes.push(`⚠️ #${target.room.name}: 적용 실패 (${(e && e.message) || e})`);
      return "";
    }
    return echoAiBody(body);
  }).trim();
  return { display, notes };
}

function handleAiMessage(client, message) {
  if (typeof message.type !== "string" || !message.type.startsWith("ai:")) return false;
  switch (message.type) {
    case "ai:open": {
      const ctx = resolveAiRoom(client, message.roomId);
      if (!ctx) return true;
      if (client.aiRoomId && client.aiRoomId !== ctx.room.id) leaveAiView(client);
      client.aiRoomId = ctx.room.id;
      const doc = store.getAiDoc(ctx.room.id);
      send(client, aiStatePayload(ctx, client, doc));
      broadcastPresence();
      return true;
    }
    case "ai:close": {
      leaveAiView(client);
      broadcastPresence();
      return true;
    }
    case "ai:draft": {
      const ctx = resolveAiRoom(client, message.roomId);
      if (!ctx) return true;
      const text = String(message.text || "").slice(0, AI_TEXT_MAX);
      let m = aiDrafts.get(ctx.room.id);
      if (text) {
        if (!m) { m = new Map(); aiDrafts.set(ctx.room.id, m); }
        m.set(client.userId, { text, name: client.name || "", at: Date.now() });
      } else if (m) {
        m.delete(client.userId);
        if (!m.size) aiDrafts.delete(ctx.room.id);
      }
      // 다른 사람에게만 내 입력 미리보기를 보낸다(입력창은 공유하지 않음).
      for (const c of clients.values()) {
        if (c.userId && c.userId !== client.userId && c.aiRoomId === ctx.room.id) {
          send(c, { type: "ai:draft", roomId: ctx.room.id, byId: client.userId, byName: client.name || "", text });
        }
      }
      return true;
    }
    case "ai:set-memory": {
      const ctx = resolveAiRoom(client, message.roomId);
      if (!ctx) return true;
      if (!isRoomWritable(ctx, client)) { send(client, { type: "ai:error", message: "읽기 전용 방입니다." }); return true; }
      const memory = store.setAiMemory(ctx.room.id, { prompt: message.prompt, notes: message.notes });
      broadcastAi(ctx.room.id, { type: "ai:memory", roomId: ctx.room.id, memory });
      return true;
    }
    case "ai:set-settings": {
      const ctx = resolveAiRoom(client, message.roomId);
      if (!ctx) return true;
      if (!isRoomWritable(ctx, client)) { send(client, { type: "ai:error", message: "읽기 전용 방입니다." }); return true; }
      const settings = store.setAiSettings(ctx.room.id, { model: message.model, thinking: message.thinking, refScope: message.refScope });
      broadcastAi(ctx.room.id, { type: "ai:settings", roomId: ctx.room.id, settings });
      return true;
    }
    case "ai:delete": {
      const ctx = resolveAiRoom(client, message.roomId);
      if (!ctx) return true;
      if (!isRoomWritable(ctx, client)) { send(client, { type: "ai:error", message: "읽기 전용 방입니다." }); return true; }
      if (aiBusy.has(ctx.room.id)) { send(client, { type: "ai:error", message: "AI 응답 중에는 대화를 삭제할 수 없습니다." }); return true; }
      const doc = store.getAiDoc(ctx.room.id);
      const idx = doc.sessions.findIndex((s) => s.id === String(message.sessionId || ""));
      if (idx < 0) { send(client, { type: "ai:error", message: "대화를 찾지 못했습니다." }); return true; }
      const [removed] = doc.sessions.splice(idx, 1);
      if (doc.activeSessionId === removed.id) {
        doc.activeSessionId = doc.sessions.length ? doc.sessions[doc.sessions.length - 1].id : "";
      }
      store.saveAiDoc(ctx.room.id, doc);
      broadcastAiState(ctx, doc);
      return true;
    }
    case "ai:new": {
      const ctx = resolveAiRoom(client, message.roomId);
      if (!ctx) return true;
      if (!isRoomWritable(ctx, client)) { send(client, { type: "ai:error", message: "읽기 전용 방입니다." }); return true; }
      const doc = store.getAiDoc(ctx.room.id);
      if (doc.sessions.length >= AI_SESSIONS_MAX) {
        send(client, { type: "ai:error", message: `대화는 최대 ${AI_SESSIONS_MAX}개까지 만들 수 있습니다. 안 쓰는 대화를 지워주세요.` });
        return true;
      }
      const s = { id: crypto.randomBytes(8).toString("hex"), title: "새 대화", createdAt: Date.now(), messages: [] };
      doc.sessions.push(s);
      doc.activeSessionId = s.id;
      store.saveAiDoc(ctx.room.id, doc);
      broadcastAiState(ctx, doc, []);
      return true;
    }
    case "ai:switch": {
      const ctx = resolveAiRoom(client, message.roomId);
      if (!ctx) return true;
      // 활성 대화는 방 전원이 공유하므로 읽기 전용 사용자가 바꾸지 못하게 한다.
      if (!isRoomWritable(ctx, client)) { send(client, { type: "ai:error", message: "읽기 전용 방입니다." }); return true; }
      const doc = store.getAiDoc(ctx.room.id);
      const target = doc.sessions.find((s) => s.id === String(message.sessionId || ""));
      if (!target) { send(client, { type: "ai:error", message: "대화를 찾지 못했습니다." }); return true; }
      doc.activeSessionId = target.id;
      store.saveAiDoc(ctx.room.id, doc);
      broadcastAiState(ctx, doc, target.messages);
      return true;
    }
    case "ai:add-file": {
      const ctx = resolveAiRoom(client, message.roomId);
      if (!ctx) return true;
      if (!isRoomWritable(ctx, client)) { send(client, { type: "ai:error", message: "읽기 전용 방입니다." }); return true; }
      if (!store.canAttach(ctx.channel.id, client.userId, client.isAdmin)) {
        send(client, { type: "ai:error", message: "파일을 첨부할 권한이 없습니다." });
        return true;
      }
      const url = String(message.url || "");
      if (!/^\/uploads\/[a-f0-9]{24}_[A-Za-z0-9._-]+$/.test(url) || !store.isUploadOwner(url, client.userId)) {
        send(client, { type: "ai:error", message: "잘못된 파일입니다." });
        return true;
      }
      const files = store.addAiFile(ctx.room.id, {
        url,
        name: String(message.name || "file").slice(0, 200),
        mime: String(message.mime || "").slice(0, 100),
        size: Number(message.size) || 0,
        addedBy: client.userId,
      });
      if (!files) {
        send(client, { type: "ai:error", message: `파일은 최대 ${store.AI_FILES_MAX}개까지 추가할 수 있습니다. 먼저 하나를 지워주세요.` });
        return true;
      }
      broadcastAi(ctx.room.id, { type: "ai:files", roomId: ctx.room.id, files: aiFilesForClient(files) });
      return true;
    }
    case "ai:remove-file": {
      const ctx = resolveAiRoom(client, message.roomId);
      if (!ctx) return true;
      if (!isRoomWritable(ctx, client)) { send(client, { type: "ai:error", message: "읽기 전용 방입니다." }); return true; }
      const files = store.removeAiFile(ctx.room.id, message.fileId);
      if (!files) { send(client, { type: "ai:error", message: "파일을 찾지 못했습니다." }); return true; }
      broadcastAi(ctx.room.id, { type: "ai:files", roomId: ctx.room.id, files: aiFilesForClient(files) });
      return true;
    }
    case "ai:send": {
      const ctx = resolveAiRoom(client, message.roomId);
      if (!ctx) return true;
      if (!isRoomWritable(ctx, client)) { send(client, { type: "ai:error", message: "읽기 전용 방입니다." }); return true; }
      const text = String(message.text || "").replace(/\s+$/, "").slice(0, AI_TEXT_MAX);
      const files = cleanChatFiles(message.files, client.userId).slice(0, AI_ATTACH_MAX);
      if (!text && !files.length) { send(client, { type: "ai:error", message: "빈 메시지는 보낼 수 없습니다." }); return true; }
      const secret = store.getAiSecret(ctx.channel.id);
      if (!secret || !secret.key) {
        send(client, { type: "ai:error", message: "AI API 키가 없습니다. 채널 관리 → AI방 설정에서 Gemini 키를 등록하세요." });
        return true;
      }
      if (files.length && !store.canAttach(ctx.channel.id, client.userId, client.isAdmin)) {
        send(client, { type: "ai:error", message: "파일을 첨부할 권한이 없습니다." });
        return true;
      }
      if (aiBusy.has(ctx.room.id)) { send(client, { type: "ai:error", message: "AI가 이미 응답 중입니다. 잠시 후 다시 시도하세요." }); return true; }
      // 한 사람이 여러 AI방에 동시에 요청을 걸어 채널 키 비용을 불리지 못하게 사용자당 1건만 허용한다.
      if (aiBusyUsers.has(client.userId)) { send(client, { type: "ai:error", message: "보낸 요청의 응답이 끝난 뒤 다시 시도하세요." }); return true; }

      const doc = store.getAiDoc(ctx.room.id);
      const session = aiEnsureSession(doc);
      const user = store.findById(client.userId);
      const userMsg = { role: "user", text, at: Date.now(), userId: client.userId, name: user ? user.displayName : client.name };
      if (files.length) userMsg.files = files;
      session.messages.push(userMsg);
      if (session.title === "새 대화") session.title = (text || files[0]?.name || "새 대화").slice(0, 40);
      store.saveAiDoc(ctx.room.id, doc);
      // 보낸 사람 본인의 입력 미리보기만 지운다.
      const dm = aiDrafts.get(ctx.room.id);
      if (dm) { dm.delete(client.userId); if (!dm.size) aiDrafts.delete(ctx.room.id); }
      broadcastAi(ctx.room.id, { type: "ai:message", roomId: ctx.room.id, sessionId: session.id, message: userMsg });
      broadcastAi(ctx.room.id, { type: "ai:draft", roomId: ctx.room.id, byId: client.userId, byName: client.name || "", text: "" });

      // 사용자가 #으로 지정한 방(메모장/채팅) 읽어서 문맥에 넣고, 나중에 수정 대상으로도 쓴다.
      const { map: refMap, refs } = resolveAiRefs(text, ctx, client, doc.settings.refScope);

      aiBusy.add(ctx.room.id);
      aiBusyUsers.add(client.userId);
      broadcastAi(ctx.room.id, { type: "ai:thinking", roomId: ctx.room.id, on: true });
      let model = doc.settings.model || secret.model || store.DEFAULT_AI_MODEL;
      // 자동 모델 선택: 그림 요청 같으면 이번 턴만 이미지 모델로. 방 설정(doc.settings.model)은 그대로 둔다.
      let autoNote = "";
      if (text && !/image/i.test(model) && store.aiWantsImage(text)) {
        model = store.AI_AUTO_IMAGE_MODEL;
        autoNote = `🎨 그림 요청으로 보고 ${model} 모델로 답합니다`;
      }
      let system = store.buildAiSystemInstruction(doc, store.getAiGlobalPrompt());
      if (refs.length) system += `\n\n${store.buildAiReferenceBlock(refs)}`;
      const contents = store.toGeminiContents(session.messages, AI_CONTEXT_TURNS);
      if (files.length) {
        // 방금 보낸 메시지(마지막 항목)에만 실제 파일 내용을 실어 보낸다(디스크 I/O라 순수함수 밖에서 처리).
        const { imageParts, extraText } = buildAiAttachmentParts(files);
        const last = contents[contents.length - 1];
        if (last) {
          if (extraText) last.parts.push({ text: extraText.trim() });
          last.parts.push(...imageParts);
        }
      }
      callGemini({ apiKey: secret.key, model, system, thinking: doc.settings.thinking, contents })
        .then((reply) => {
          const fresh = store.getAiDoc(ctx.room.id);
          const s = fresh.sessions.find((x) => x.id === session.id);
          if (!s) return;
          // 생성된 이미지는 세션 JSON 이 아니라 업로드 저장소에 두고, 메시지에는 URL 만 남긴다.
          const urls = [];
          for (const img of reply.images || []) {
            try {
              const saved = store.saveUpload({ buffer: Buffer.from(img.dataB64, "base64"), name: `ai${AI_IMG_MIME[img.mime] || ".png"}`, mime: img.mime });
              urls.push(`/uploads/${saved.fileName}`);
            } catch (e) { console.error("[ai] 이미지 저장 실패:", e?.message || e); }
          }
          // accord: 지시 블록 실행(#으로 지정한 방만) 후, 블록을 뺀 텍스트 + 결과 요약을 남긴다.
          const { display, notes } = applyAiActions(reply.text, refMap, ctx, client);
          let outText = display;
          if (autoNote) notes.unshift(autoNote);
          if (reply.imageBlockReason) notes.push(`⚠️ 이미지가 생성되지 않았습니다 (사유: ${reply.imageBlockReason})`);
          if (notes.length) outText += `${outText ? "\n\n" : ""}> ${notes.join("\n> ")}`;
          const aiMsg = { role: "model", text: outText, at: Date.now(), model };
          if (urls.length) aiMsg.images = urls;
          s.messages.push(aiMsg);
          store.saveAiDoc(ctx.room.id, fresh);
          broadcastAi(ctx.room.id, { type: "ai:message", roomId: ctx.room.id, sessionId: s.id, message: aiMsg });
          broadcastAi(ctx.room.id, { type: "ai:sessions", roomId: ctx.room.id, sessions: aiSessionMetas(fresh), activeSessionId: fresh.activeSessionId });
        })
        .catch((err) => {
          broadcastAi(ctx.room.id, { type: "ai:error", roomId: ctx.room.id, message: String(err && err.message || err || "AI 응답 실패") });
        })
        .finally(() => {
          aiBusy.delete(ctx.room.id);
          aiBusyUsers.delete(client.userId);
          broadcastAi(ctx.room.id, { type: "ai:thinking", roomId: ctx.room.id, on: false });
        });
      return true;
    }
    default:
      return false;
  }
}

// ===== 공동 메모장 (OT 실시간 협업) =====
// 방별 메모 문서를 메모리에 두고 OT로 동시편집을 병합한다. history는 서버 실행 중에만 유지되고
// 텍스트는 디바운스로 파일에 저장된다(서버 재시작 시 파일에서 재적재, rev는 0부터).
const memoDocs = new Map(); // roomId -> { text, history:[], cursors:Map(clientId->cursor), saveTimer }
const MEMO_PERSIST_DEBOUNCE = 1500;

const MEMO_FONT_KEYS = new Set(["default", "sans", "serif", "round", "hand"]);
// 내장 글꼴 키, 업로드 글꼴 키(custom:<id>), 또는 굵기 변형을 묶은 패밀리 키(custom-family:<slug>[@weight])만 허용.
// 지워진 글꼴이면 클라이언트가 기본 스택으로 자연스럽게 대체하므로 존재 여부까지는 검사하지 않는다.
function cleanMemoFont(font) {
  const f = String(font || "");
  if (MEMO_FONT_KEYS.has(f)) return f;
  if (/^custom:[a-f0-9]{4,32}$/.test(f)) return f;
  if (/^custom-family:[a-z0-9가-힣-]{1,60}(@[0-9]{3})?$/.test(f)) return f;
  return "default";
}

function getMemoDoc(roomId) {
  let d = memoDocs.get(roomId);
  if (!d) {
    const saved = store.getMemo(roomId);
    d = { text: saved.text || "", font: cleanMemoFont(saved.font), history: [], cursors: new Map(), saveTimer: 0 };
    memoDocs.set(roomId, d);
  }
  return d;
}

function scheduleMemoPersist(roomId, userId) {
  const d = memoDocs.get(roomId);
  if (!d) return;
  if (d.saveTimer) clearTimeout(d.saveTimer);
  d.saveTimer = setTimeout(() => {
    d.saveTimer = 0;
    store.saveMemo(roomId, d.text, userId, d.font);
  }, MEMO_PERSIST_DEBOUNCE);
}

function flushMemoPersist(roomId, userId) {
  const d = memoDocs.get(roomId);
  if (!d) return;
  if (d.saveTimer) { clearTimeout(d.saveTimer); d.saveTimer = 0; }
  store.saveMemo(roomId, d.text, userId || "", d.font);
}

function memoViewerCount(roomId) {
  let n = 0;
  for (const c of clients.values()) if (c.memoRoomId === roomId) n++;
  return n;
}

// 클라이언트가 메모방 보기를 그만둘 때(닫기/연결종료) 정리.
function leaveMemo(client) {
  const roomId = client.memoRoomId;
  if (!roomId) return;
  client.memoRoomId = "";
  if (client.userId && client.memoJoinedAt) addStat(roomId, client.userId, client.name, "viewMs", Date.now() - client.memoJoinedAt);
  client.memoJoinedAt = 0;
  const d = memoDocs.get(roomId);
  if (d) {
    d.cursors.delete(client.id);
    for (const c of clients.values()) {
      if (c.memoRoomId === roomId) send(c, { type: "memo:cursor-leave", roomId, clientId: client.id });
    }
    if (memoViewerCount(roomId) === 0) {
      flushMemoPersist(roomId, client.userId);
      memoDocs.delete(roomId); // 아무도 안 보면 메모리에서 내림(다음 open 시 파일에서 재적재)
    }
  }
}

function handleMemoMessage(client, message) {
  if (typeof message.type !== "string" || !message.type.startsWith("memo:")) return false;
  if (!client.userId) {
    send(client, { type: "memo-error", message: "로그인이 필요합니다." });
    return true;
  }

  switch (message.type) {
    case "memo:open": {
      const ctx = resolveMemoRoom(client, message.roomId);
      if (!ctx) return true;
      // 다른 메모방을 보다가 바로 이 방으로 갈아탄 경우, 이전 방에 내 원격 커서가 남지 않도록 먼저 정리한다.
      if (client.memoRoomId && client.memoRoomId !== ctx.room.id) leaveMemo(client);
      client.memoRoomId = ctx.room.id;
      client.memoJoinedAt = Date.now();
      const d = getMemoDoc(ctx.room.id);
      const cursors = [...d.cursors.values()].filter((cur) => cur.clientId !== client.id);
      send(client, { type: "memo:state", roomId: ctx.room.id, text: d.text, rev: d.history.length, cursors, font: d.font });
      broadcastPresence(); // 이 방을 보고 있다고 다른 사람에게 알림
      return true;
    }
    case "memo:close": {
      leaveMemo(client);
      broadcastPresence();
      return true;
    }
    case "memo:font": {
      const ctx = resolveMemoRoom(client, message.roomId);
      if (!ctx) return true;
      if (!isRoomWritable(ctx, client)) {
        send(client, { type: "memo-error", message: "읽기 전용 메모입니다. 대표자만 편집할 수 있습니다." });
        return true;
      }
      const d = getMemoDoc(ctx.room.id);
      d.font = cleanMemoFont(message.font);
      scheduleMemoPersist(ctx.room.id, client.userId);
      const payload = { type: "memo:font", roomId: ctx.room.id, font: d.font, by: client.id };
      for (const c of clients.values()) {
        if (c.memoRoomId === ctx.room.id) send(c, payload);
      }
      return true;
    }
    case "memo:op": {
      const ctx = resolveMemoRoom(client, message.roomId);
      if (!ctx) return true;
      if (!isRoomWritable(ctx, client)) {
        send(client, { type: "memo-error", message: "읽기 전용 메모입니다. 대표자만 편집할 수 있습니다." });
        return true;
      }
      const d = getMemoDoc(ctx.room.id);
      let o = message.ops;
      if (!Array.isArray(o)) return true;
      const baseRev = Math.max(0, Math.min(d.history.length, Number(message.rev) || 0));
      try {
        for (let i = baseRev; i < d.history.length; i++) o = ot.transform(o, d.history[i], "right");
        d.text = ot.apply(d.text, o);
      } catch (err) {
        send(client, { type: "memo-error", message: "동기화 오류가 발생했습니다. 새로고침 해주세요." });
        return true;
      }
      d.history.push(o);
      const rev = d.history.length;
      const delta = memoOpDelta(o);
      if (delta.charsTyped) addStat(ctx.room.id, client.userId, client.name, "charsTyped", delta.charsTyped);
      if (delta.charsDeleted) addStat(ctx.room.id, client.userId, client.name, "charsDeleted", delta.charsDeleted);
      if (delta.linesTyped) addStat(ctx.room.id, client.userId, client.name, "linesTyped", delta.linesTyped);
      scheduleMemoPersist(ctx.room.id, client.userId);
      // 키 입력마다가 아니라, 편집 세션당 한 번꼴로만 로그를 남긴다(2분 스로틀).
      if (logThrottleOk(`memo-edit:${ctx.room.id}:${client.userId}`, 120000)) {
        logChannelEvent(ctx.channel.id, client, "memo-edit", { roomName: ctx.room.name });
      }
      const payload = { type: "memo:op", roomId: ctx.room.id, rev, ops: o, by: client.id };
      for (const c of clients.values()) {
        if (c.memoRoomId === ctx.room.id) send(c, payload); // 발신자 포함(ack 겸용)
      }
      return true;
    }
    case "memo:cursor": {
      const ctx = resolveMemoRoom(client, message.roomId);
      if (!ctx) return true;
      const d = getMemoDoc(ctx.room.id);
      const pos = Math.max(0, Number(message.pos) || 0);
      const sel = Number.isFinite(Number(message.sel)) ? Math.max(0, Number(message.sel)) : pos;
      const cur = { clientId: client.id, userId: client.userId, name: client.name, pos, sel };
      d.cursors.set(client.id, cur);
      for (const c of clients.values()) {
        if (c.id === client.id || c.memoRoomId !== ctx.room.id) continue;
        send(c, { type: "memo:cursor", roomId: ctx.room.id, ...cur });
      }
      return true;
    }
    default:
      return false;
  }
}

function resolveMemoRoom(client, roomId) {
  const found = store.findRoom(String(roomId || ""));
  if (!found || found.room.type !== "memo") {
    send(client, { type: "memo-error", message: "메모장을 찾지 못했습니다." });
    return null;
  }
  if (!store.isChannelMember(found.channel.id, client.userId, client.isAdmin)) {
    send(client, { type: "memo-error", message: "채널 멤버만 이용할 수 있습니다." });
    return null;
  }
  if (!store.canAccessRoom(found.channel.id, found.room.id, client.userId, client.isAdmin)) {
    send(client, { type: "memo-error", message: "이 방에 접근할 권한이 없습니다." });
    return null;
  }
  return found;
}

// ===== 공동 그림판 =====
// 방별 캔버스 문서를 메모리에 두고, stroke/레이어 변경을 그리는 사람 전원에게 브로드캐스트한다.
// 텍스트 메모(OT)와 달리 그림은 append-only(획 추가) + 레이어 조작이라 last-write 병합이 필요 없다.
// 늦게 들어온 사람은 draw:open 시 전체 문서를 받아 그대로 리플레이한다.
const drawDocs = new Map(); // roomId -> { doc, saveTimer }
const DRAW_PERSIST_DEBOUNCE = 2000;

function getDrawDoc(roomId) {
  let d = drawDocs.get(roomId);
  if (!d) {
    d = { doc: store.getDraw(roomId), saveTimer: 0, cursors: new Map() };
    drawDocs.set(roomId, d);
  }
  return d;
}

function scheduleDrawPersist(roomId) {
  const d = drawDocs.get(roomId);
  if (!d) return;
  if (d.saveTimer) clearTimeout(d.saveTimer);
  d.saveTimer = setTimeout(() => {
    d.saveTimer = 0;
    store.saveDraw(roomId, d.doc);
  }, DRAW_PERSIST_DEBOUNCE);
}

function flushDrawPersist(roomId) {
  const d = drawDocs.get(roomId);
  if (!d) return;
  if (d.saveTimer) { clearTimeout(d.saveTimer); d.saveTimer = 0; }
  store.saveDraw(roomId, d.doc);
}

function drawViewerCount(roomId) {
  let n = 0;
  for (const c of clients.values()) if (c.drawRoomId === roomId) n++;
  return n;
}

// 그리는 사람 전원(옵션으로 발신자 제외)에게 전달.
function broadcastDraw(roomId, payload, exceptId) {
  for (const c of clients.values()) {
    if (c.drawRoomId !== roomId) continue;
    if (exceptId && c.id === exceptId) continue;
    send(c, payload);
  }
}

function leaveDraw(client) {
  const roomId = client.drawRoomId;
  if (!roomId) return;
  client.drawRoomId = "";
  if (client.userId && client.drawJoinedAt) addStat(roomId, client.userId, client.name, "viewMs", Date.now() - client.drawJoinedAt);
  client.drawJoinedAt = 0;
  const d = drawDocs.get(roomId);
  if (d && d.cursors.delete(client.id)) {
    broadcastDraw(roomId, { type: "draw:cursor-leave", roomId, clientId: client.id });
  }
  if (drawViewerCount(roomId) === 0) {
    flushDrawPersist(roomId);
    drawDocs.delete(roomId); // 아무도 안 보면 메모리에서 내림(다음 open 시 파일에서 재적재)
  }
}

function drawNum(value, fallback) {
  const n = Number(value);
  return Number.isFinite(n) ? n : fallback;
}

function drawClampNum(value, min, max, fallback) {
  const n = Number(value);
  if (!Number.isFinite(n)) return fallback;
  return Math.max(min, Math.min(max, n));
}

function cleanDrawColor(value) {
  const s = String(value || "").slice(0, 32);
  if (/^#[0-9a-fA-F]{3,8}$/.test(s) || /^rgba?\([\d.,\s]+\)$/.test(s)) return s;
  return "#000000";
}

// 신뢰할 수 없는 stroke를 정규화. 실패하면 null.
function sanitizeStroke(raw, authorId) {
  if (!raw || typeof raw !== "object") return null;
  const id = String(raw.id || "").slice(0, 64);
  if (!id) return null;
  if (raw.tool === "image") {
    const src = String(raw.src || "");
    if (!src.startsWith("data:image/") || src.length > 6000000) return null;
    return {
      id, tool: "image", by: authorId, src,
      x: drawNum(raw.x, 0), y: drawNum(raw.y, 0),
      w: Math.max(1, drawNum(raw.w, 100)), h: Math.max(1, drawNum(raw.h, 100)),
    };
  }
  const tool = raw.tool === "eraser" ? "eraser" : "pen";
  const src = Array.isArray(raw.points) ? raw.points.slice(0, 8000) : [];
  const points = [];
  for (const p of src) {
    if (!Array.isArray(p)) continue;
    points.push([drawNum(p[0], 0), drawNum(p[1], 0)]);
  }
  if (!points.length) return null;
  return {
    id, tool, by: authorId,
    color: cleanDrawColor(raw.color),
    size: drawClampNum(raw.size, 1, 300, 4),
    points,
  };
}

function findDrawLayer(doc, layerId) {
  return doc.layers.find((l) => l.id === String(layerId || ""));
}

const DRAW_WRITE_TYPES = new Set([
  "draw:stroke", "draw:undo", "draw:clear", "draw:resize",
  "draw:layer-add", "draw:layer-remove", "draw:layer-update", "draw:layer-reorder",
  "draw:layer-replace",
]);

function handleDrawMessage(client, message) {
  if (typeof message.type !== "string" || !message.type.startsWith("draw:")) return false;
  if (!client.userId) {
    send(client, { type: "draw-error", message: "로그인이 필요합니다." });
    return true;
  }

  // 읽기 전용 그림판이면 대표자가 아닌 사람의 쓰기 동작을 막는다(열람/상태 수신은 허용).
  if (DRAW_WRITE_TYPES.has(message.type)) {
    const ctx = resolveDrawRoom(client, message.roomId);
    if (!ctx) return true;
    if (!isRoomWritable(ctx, client)) {
      send(client, { type: "draw-error", message: "읽기 전용 그림판입니다. 대표자만 그릴 수 있습니다." });
      return true;
    }
  }

  switch (message.type) {
    case "draw:open": {
      const ctx = resolveDrawRoom(client, message.roomId);
      if (!ctx) return true;
      const wasViewing = client.drawRoomId === ctx.room.id;
      client.drawRoomId = ctx.room.id;
      client.drawJoinedAt = Date.now();
      const d = getDrawDoc(ctx.room.id);
      const cursors = [...d.cursors.values()].filter((cur) => cur.clientId !== client.id);
      send(client, { type: "draw:state", roomId: ctx.room.id, doc: d.doc, cursors });
      // 재접속/재열기 도배를 막기 위해 30초 스로틀. 이미 보던 방을 다시 열면 기록 안 함.
      if (!wasViewing && logThrottleOk(`draw-join:${ctx.room.id}:${client.userId}`, 30000)) {
        logChannelEvent(ctx.channel.id, client, "draw-join", { roomName: ctx.room.name });
      }
      if (!wasViewing) broadcastPresence(); // 이 방을 보고 있다고 다른 사람에게 알림
      return true;
    }
    case "draw:close": {
      leaveDraw(client);
      broadcastPresence();
      return true;
    }
    case "draw:stroke": {
      const ctx = resolveDrawRoom(client, message.roomId);
      if (!ctx) return true;
      const d = getDrawDoc(ctx.room.id);
      const layer = findDrawLayer(d.doc, message.layerId);
      if (!layer) return true;
      const stroke = sanitizeStroke(message.stroke, client.userId);
      if (!stroke) return true;
      layer.strokes.push(stroke);
      scheduleDrawPersist(ctx.room.id);
      broadcastDraw(ctx.room.id, { type: "draw:stroke", roomId: ctx.room.id, layerId: layer.id, stroke }, client.id);
      return true;
    }
    case "draw:undo": {
      const ctx = resolveDrawRoom(client, message.roomId);
      if (!ctx) return true;
      const d = getDrawDoc(ctx.room.id);
      const strokeId = String(message.strokeId || "");
      for (const layer of d.doc.layers) {
        const idx = layer.strokes.findIndex((s) => s.id === strokeId && s.by === client.userId);
        if (idx >= 0) {
          layer.strokes.splice(idx, 1);
          scheduleDrawPersist(ctx.room.id);
          broadcastDraw(ctx.room.id, { type: "draw:remove", roomId: ctx.room.id, strokeId });
          break;
        }
      }
      return true;
    }
    case "draw:clear": {
      const ctx = resolveDrawRoom(client, message.roomId);
      if (!ctx) return true;
      const d = getDrawDoc(ctx.room.id);
      const layerId = String(message.layerId || "");
      if (layerId === "*") {
        for (const layer of d.doc.layers) layer.strokes = [];
      } else {
        const layer = findDrawLayer(d.doc, layerId);
        if (!layer) return true;
        layer.strokes = [];
      }
      scheduleDrawPersist(ctx.room.id);
      broadcastDraw(ctx.room.id, { type: "draw:clear", roomId: ctx.room.id, layerId }, client.id);
      return true;
    }
    case "draw:resize": {
      const ctx = resolveDrawRoom(client, message.roomId);
      if (!ctx) return true;
      const d = getDrawDoc(ctx.room.id);
      d.doc.width = drawClampNum(message.width, 200, 4000, d.doc.width);
      d.doc.height = drawClampNum(message.height, 200, 4000, d.doc.height);
      scheduleDrawPersist(ctx.room.id);
      broadcastDraw(ctx.room.id, { type: "draw:resize", roomId: ctx.room.id, width: d.doc.width, height: d.doc.height }, client.id);
      return true;
    }
    case "draw:layer-add": {
      const ctx = resolveDrawRoom(client, message.roomId);
      if (!ctx) return true;
      const d = getDrawDoc(ctx.room.id);
      if (d.doc.layers.length >= 20) { send(client, { type: "draw-error", message: "레이어는 최대 20개입니다." }); return true; }
      const raw = message.layer || {};
      const id = String(raw.id || "").slice(0, 32) || `L${Date.now().toString(36)}`;
      if (findDrawLayer(d.doc, id)) return true;
      const layer = { id, name: String(raw.name || `레이어 ${d.doc.layers.length + 1}`).slice(0, 40), visible: true, strokes: [] };
      d.doc.layers.push(layer);
      scheduleDrawPersist(ctx.room.id);
      broadcastDraw(ctx.room.id, { type: "draw:layer-add", roomId: ctx.room.id, layer }, client.id);
      return true;
    }
    case "draw:layer-remove": {
      const ctx = resolveDrawRoom(client, message.roomId);
      if (!ctx) return true;
      const d = getDrawDoc(ctx.room.id);
      if (d.doc.layers.length <= 1) { send(client, { type: "draw-error", message: "최소 한 개의 레이어가 필요합니다." }); return true; }
      const layerId = String(message.layerId || "");
      const before = d.doc.layers.length;
      d.doc.layers = d.doc.layers.filter((l) => l.id !== layerId);
      if (d.doc.layers.length === before) return true;
      scheduleDrawPersist(ctx.room.id);
      broadcastDraw(ctx.room.id, { type: "draw:layer-remove", roomId: ctx.room.id, layerId }, client.id);
      return true;
    }
    case "draw:layer-update": {
      const ctx = resolveDrawRoom(client, message.roomId);
      if (!ctx) return true;
      const d = getDrawDoc(ctx.room.id);
      const layer = findDrawLayer(d.doc, message.layerId);
      if (!layer) return true;
      if (typeof message.visible === "boolean") layer.visible = message.visible;
      if (typeof message.locked === "boolean") layer.locked = message.locked;
      if (typeof message.name === "string") layer.name = message.name.slice(0, 40) || layer.name;
      scheduleDrawPersist(ctx.room.id);
      broadcastDraw(ctx.room.id, { type: "draw:layer-update", roomId: ctx.room.id, layerId: layer.id, visible: layer.visible, locked: layer.locked, name: layer.name }, client.id);
      return true;
    }
    case "draw:layer-replace": {
      // 레이어의 모든 획을 통째로 교체(이동/크기 변형 확정용). 신뢰할 수 없는 획을 정규화한다.
      const ctx = resolveDrawRoom(client, message.roomId);
      if (!ctx) return true;
      const d = getDrawDoc(ctx.room.id);
      const layer = findDrawLayer(d.doc, message.layerId);
      if (!layer) return true;
      const src = Array.isArray(message.strokes) ? message.strokes.slice(0, 20000) : [];
      const cleaned = [];
      for (const raw of src) {
        const s = sanitizeStroke(raw, raw && raw.by ? String(raw.by).slice(0, 64) : client.userId);
        if (s) cleaned.push(s);
      }
      layer.strokes = cleaned;
      scheduleDrawPersist(ctx.room.id);
      broadcastDraw(ctx.room.id, { type: "draw:layer-replace", roomId: ctx.room.id, layerId: layer.id, strokes: cleaned }, client.id);
      return true;
    }
    case "draw:layer-reorder": {
      const ctx = resolveDrawRoom(client, message.roomId);
      if (!ctx) return true;
      const d = getDrawDoc(ctx.room.id);
      const order = Array.isArray(message.order) ? message.order.map(String) : [];
      const map = new Map(d.doc.layers.map((l) => [l.id, l]));
      const reordered = [];
      for (const id of order) if (map.has(id)) { reordered.push(map.get(id)); map.delete(id); }
      for (const l of map.values()) reordered.push(l); // 누락된 레이어는 뒤에 유지
      if (reordered.length !== d.doc.layers.length) return true;
      d.doc.layers = reordered;
      scheduleDrawPersist(ctx.room.id);
      broadcastDraw(ctx.room.id, { type: "draw:layer-reorder", roomId: ctx.room.id, order: d.doc.layers.map((l) => l.id) }, client.id);
      return true;
    }
    case "draw:cursor": {
      // 실시간 커서/그리는 위치 공유(비영속). 발신자를 제외한 열람자에게 그대로 릴레이한다.
      const ctx = resolveDrawRoom(client, message.roomId);
      if (!ctx) return true;
      if (client.drawRoomId !== ctx.room.id) return true; // 열람 중일 때만
      const d = getDrawDoc(ctx.room.id);
      const cur = {
        clientId: client.id,
        name: client.name || "게스트",
        x: drawNum(message.x, 0),
        y: drawNum(message.y, 0),
        tool: String(message.tool || "pen").slice(0, 12),
        color: cleanDrawColor(message.color),
        size: drawClampNum(message.size, 1, 300, 4),
        drawing: Boolean(message.drawing),
        active: message.active !== false,
      };
      d.cursors.set(client.id, cur);
      broadcastDraw(ctx.room.id, { type: "draw:cursor", roomId: ctx.room.id, ...cur }, client.id);
      return true;
    }
    case "draw:cursor-leave": {
      const roomId = client.drawRoomId;
      if (!roomId) return true;
      const d = drawDocs.get(roomId);
      if (d && d.cursors.delete(client.id)) {
        broadcastDraw(roomId, { type: "draw:cursor-leave", roomId, clientId: client.id }, client.id);
      }
      return true;
    }
    default:
      return false;
  }
}

function resolveDrawRoom(client, roomId) {
  const found = store.findRoom(String(roomId || ""));
  if (!found || found.room.type !== "draw") {
    send(client, { type: "draw-error", message: "그림판을 찾지 못했습니다." });
    return null;
  }
  if (!store.isChannelMember(found.channel.id, client.userId, client.isAdmin)) {
    send(client, { type: "draw-error", message: "채널 멤버만 이용할 수 있습니다." });
    return null;
  }
  if (!store.canAccessRoom(found.channel.id, found.room.id, client.userId, client.isAdmin)) {
    send(client, { type: "draw-error", message: "이 방에 접근할 권한이 없습니다." });
    return null;
  }
  return found;
}

// ===== 전역 로그 =====
// 채널 단위 이벤트 타임라인(통화 입/퇴장·그림판 참여·메모 편집·채널 참여). 방이 아니라 채널에 종속되므로
// 로그방이 여러 개여도 같은 피드를 본다. 이벤트마다 파일에 append 하고, 그 채널의 로그방을 보고 있는
// 클라이언트에게만 실시간 전달한다(안 보는 사람은 다음에 열 때 전체 history 를 받는다).
const LOG_THROTTLE = new Map(); // key -> lastTs. 연속 이벤트(편집·재접속) 도배 방지.

// windowMs 안에 같은 key 이벤트가 또 오면 false(기록 생략), 아니면 true 로 통과시키고 시각을 갱신.
function logThrottleOk(key, windowMs) {
  const now = Date.now();
  const last = LOG_THROTTLE.get(key) || 0;
  if (now - last < windowMs) return false;
  LOG_THROTTLE.set(key, now);
  return true;
}

function logChannelEvent(channelId, actor, type, extra = {}) {
  if (!channelId || !type) return;
  const user = actor && actor.userId ? store.findById(actor.userId) : null;
  const entry = {
    id: crypto.randomBytes(6).toString("hex"),
    type,
    at: Date.now(),
    userId: actor ? actor.userId : "",
    name: user ? (user.displayName || user.username || "") : (actor ? actor.name : ""),
    ...extra,
  };
  store.appendChannelLog(channelId, entry);
  for (const c of clients.values()) {
    if (c.logChannelId === channelId) send(c, { type: "log:entry", channelId, entry });
  }
}

function resolveLogRoom(client, roomId) {
  const found = store.findRoom(String(roomId || ""));
  if (!found || found.room.type !== "log") {
    send(client, { type: "log-error", message: "로그방을 찾지 못했습니다." });
    return null;
  }
  if (!store.isChannelMember(found.channel.id, client.userId, client.isAdmin)) {
    send(client, { type: "log-error", message: "채널 멤버만 이용할 수 있습니다." });
    return null;
  }
  if (!store.canAccessRoom(found.channel.id, found.room.id, client.userId, client.isAdmin)) {
    send(client, { type: "log-error", message: "로그방에 접근할 권한이 없습니다." });
    return null;
  }
  return found;
}

function handleLogMessage(client, message) {
  if (typeof message.type !== "string" || !message.type.startsWith("log:")) return false;
  if (!client.userId) {
    send(client, { type: "log-error", message: "로그인이 필요합니다." });
    return true;
  }
  switch (message.type) {
    case "log:open": {
      const ctx = resolveLogRoom(client, message.roomId);
      if (!ctx) return true;
      client.logRoomId = ctx.room.id;
      client.logChannelId = ctx.channel.id;
      send(client, {
        type: "log:history",
        roomId: ctx.room.id,
        channelId: ctx.channel.id,
        entries: store.getChannelLog(ctx.channel.id),
      });
      broadcastPresence(); // 이 방을 보고 있다고 다른 사람에게 알림
      return true;
    }
    case "log:close": {
      client.logRoomId = "";
      client.logChannelId = "";
      broadcastPresence();
      return true;
    }
    default:
      return false;
  }
}

// ===== 다이렉트 메시지(1:1 DM) =====
// 채널과 무관한 개인 대화. 유저 코드(#XXXX)로 상대를 찾고, 대화별 파일에 영속한다.
const DM_TEXT_MAX = 4000;

// DM 상대에게 보여줄 공개 정보(email 등 민감정보 제외).
function dmUserView(user) {
  if (!user) return null;
  return { id: user.id, displayName: user.displayName || user.username || `유저#${user.code}`, code: user.code, avatar: user.avatar || "", banner: user.banner || "", bannerGradient: user.bannerGradient || "" };
}

// 특정 userId 로 로그인한 모든 접속에 전달(같은 계정 여러 탭 대응).
function deliverToUser(userId, payload) {
  if (!userId) return;
  for (const c of clients.values()) if (c.userId === userId) send(c, payload);
}

// 스레드마다 상대 유저 정보를 붙여서 반환.
function dmThreadsFor(userId) {
  return store.listDmThreads(userId).map((t) => {
    const otherId = (t.users || []).find((u) => u !== userId) || "";
    const other = store.findById(otherId);
    return {
      id: t.id,
      userId: otherId,
      partner: other ? dmUserView(other) : { id: otherId, displayName: "(삭제된 계정)", code: "----", avatar: "", banner: "", bannerGradient: "" },
      lastAt: t.lastAt || 0,
      lastText: t.lastText || "",
      lastFrom: t.lastFrom || "",
    };
  });
}

function sendDmThreads(userId) {
  const threads = dmThreadsFor(userId);
  deliverToUser(userId, { type: "dm:threads", threads });
}

function handleDmMessage(client, message) {
  if (typeof message.type !== "string" || !message.type.startsWith("dm:")) return false;
  if (!client.userId) {
    send(client, { type: "dm-error", message: "로그인이 필요합니다." });
    return true;
  }
  switch (message.type) {
    case "dm:list": {
      send(client, { type: "dm:threads", threads: dmThreadsFor(client.userId) });
      return true;
    }
    case "dm:find": {
      const user = store.findByCode(message.code);
      if (!user) {
        send(client, { type: "dm-error", action: "find", message: "해당 코드의 유저를 찾지 못했습니다." });
        return true;
      }
      if (user.id === client.userId) {
        send(client, { type: "dm-error", action: "find", message: "자기 자신에게는 보낼 수 없습니다." });
        return true;
      }
      send(client, { type: "dm:user", user: dmUserView(user) });
      return true;
    }
    case "dm:open": {
      const partner = store.findById(String(message.userId || ""));
      if (!partner || partner.id === client.userId) {
        send(client, { type: "dm-error", message: "상대를 찾지 못했습니다." });
        return true;
      }
      client.dmUserId = partner.id;
      send(client, {
        type: "dm:history",
        userId: partner.id,
        partner: dmUserView(partner),
        messages: store.getDmMessages(client.userId, partner.id),
      });
      return true;
    }
    case "dm:close": {
      client.dmUserId = "";
      return true;
    }
    case "dm:send": {
      const partner = store.findById(String(message.userId || ""));
      if (!partner || partner.id === client.userId) {
        send(client, { type: "dm-error", message: "상대를 찾지 못했습니다." });
        return true;
      }
      const text = String(message.text || "").slice(0, DM_TEXT_MAX).replace(/\s+$/, "");
      if (!text) {
        send(client, { type: "dm-error", message: "빈 메시지는 보낼 수 없습니다." });
        return true;
      }
      const me = store.findById(client.userId);
      const msg = {
        id: crypto.randomBytes(8).toString("hex"),
        userId: client.userId,
        name: me ? me.displayName : client.name,
        code: me ? me.code : "",
        text,
        at: Date.now(),
      };
      const res = store.addDmMessage(client.userId, partner.id, msg);
      if (res.error) {
        send(client, { type: "dm-error", message: res.error });
        return true;
      }
      const payload = { type: "dm:message", users: [client.userId, partner.id], message: msg };
      deliverToUser(client.userId, payload);
      deliverToUser(partner.id, payload);
      sendDmThreads(client.userId);
      sendDmThreads(partner.id);
      return true;
    }
    case "dm:delete": {
      const partner = store.findById(String(message.userId || ""));
      if (!partner) return true;
      const list = store.getDmMessages(client.userId, partner.id);
      const target = list.find((m) => m.id === message.msgId);
      if (!target) return true; // 이미 삭제됨
      if (target.userId !== client.userId) {
        send(client, { type: "dm-error", message: "본인 메시지만 삭제할 수 있습니다." });
        return true;
      }
      store.deleteDmMessage(client.userId, partner.id, message.msgId);
      const payload = { type: "dm:deleted", users: [client.userId, partner.id], msgId: message.msgId };
      deliverToUser(client.userId, payload);
      deliverToUser(partner.id, payload);
      return true;
    }
    default:
      return false;
  }
}

// klipy/tenor/giphy 같은 gif 페이지 링크의 og:image를 대신 가져와 클라이언트에 알려준다.
// 리다이렉트는 SSRF 우회에 쓰일 수 있어 따라가지 않고, 응답 크기·시간도 제한한다.
function fetchLinkPreviewImage(res, rawUrl) {
  let target;
  try {
    target = new URL(rawUrl);
  } catch {
    sendJson(res, 400, { error: "invalid url" });
    return;
  }
  if (target.protocol !== "https:" || target.port || !LINK_PREVIEW_HOSTS.has(target.hostname.toLowerCase())) {
    sendJson(res, 400, { error: "unsupported host" });
    return;
  }
  const upstreamReq = https.get(
    target,
    { timeout: LINK_PREVIEW_TIMEOUT_MS, headers: { "user-agent": "Mozilla/5.0 (compatible; AccordLinkPreview/1.0)" } },
    (upstream) => {
      if (upstream.statusCode !== 200) {
        upstream.resume();
        sendJson(res, 502, { error: "upstream error" });
        return;
      }
      let body = "";
      let bytes = 0;
      let done = false;
      const finish = () => {
        if (done) return;
        done = true;
        sendJson(res, 200, { image: extractOgImage(body) });
      };
      upstream.setEncoding("utf8");
      upstream.on("data", (chunk) => {
        if (done) return;
        bytes += Buffer.byteLength(chunk);
        if (bytes > LINK_PREVIEW_MAX_BYTES) {
          upstream.destroy();
          finish();
          return;
        }
        body += chunk;
      });
      upstream.on("end", finish);
      upstream.on("error", () => {
        if (!done) sendJson(res, 502, { error: "fetch failed" });
      });
    }
  );
  upstreamReq.on("timeout", () => upstreamReq.destroy());
  upstreamReq.on("error", () => {
    if (!res.headersSent) sendJson(res, 502, { error: "fetch failed" });
  });
}

function extractOgImage(html) {
  const match =
    html.match(/<meta[^>]+(?:property|name)=["'](?:og:image|twitter:image)["'][^>]+content=["']([^"']+)["']/i) ||
    html.match(/<meta[^>]+content=["']([^"']+)["'][^>]+(?:property|name)=["'](?:og:image|twitter:image)["']/i);
  const image = match ? match[1] : "";
  return /^https?:\/\//i.test(image) ? image : "";
}

function sendJson(res, status, payload) {
  sendCors(res, status, {
    "content-type": "application/json; charset=utf-8",
    "cache-control": "no-store",
  });
  res.end(JSON.stringify(payload));
}

function sendText(res, status, text) {
  sendCors(res, status, { "content-type": "text/plain; charset=utf-8" });
  res.end(text);
}

function sendCors(res, status, headers = {}) {
  res.writeHead(status, {
    "access-control-allow-origin": "*",
    "access-control-allow-methods": "GET, POST, OPTIONS",
    "access-control-allow-headers": "content-type, x-file-name, x-auth-token",
    // 기본 보안 헤더: MIME 스니핑 방지 · 클릭재킹(iframe 삽입) 방지 · 리퍼러 미전송.
    "x-content-type-options": "nosniff",
    "x-frame-options": "DENY",
    "referrer-policy": "no-referrer",
    // 스크립트는 우리 서버 파일만 실행한다(렌더러에 XSS 구멍이 생겨도 인라인 스크립트·javascript: 링크는 막힘).
    "content-security-policy": "script-src 'self'; object-src 'none'; base-uri 'none'; frame-ancestors 'none'",
    ...headers,
  });
}

function getContentType(filePath) {
  const ext = path.extname(filePath).toLowerCase();
  return {
    ".html": "text/html; charset=utf-8",
    ".css": "text/css; charset=utf-8",
    ".js": "application/javascript; charset=utf-8",
    ".json": "application/json; charset=utf-8",
    ".svg": "image/svg+xml",
    ".png": "image/png",
    ".ico": "image/x-icon",
    // 업로드 파일용
    ".jpg": "image/jpeg",
    ".jpeg": "image/jpeg",
    ".gif": "image/gif",
    ".webp": "image/webp",
    ".bmp": "image/bmp",
    ".mp4": "video/mp4",
    ".webm": "video/webm",
    ".mov": "video/quicktime",
    ".mp3": "audio/mpeg",
    ".wav": "audio/wav",
    ".ogg": "audio/ogg",
    ".m4a": "audio/mp4",
    ".pdf": "application/pdf",
    ".txt": "text/plain; charset=utf-8",
    ".zip": "application/zip",
    ".ttf": "font/ttf",
    ".otf": "font/otf",
    ".woff": "font/woff",
    ".woff2": "font/woff2",
  }[ext] || "application/octet-stream";
}

function getIceServers() {
  const servers = [];
  const stunUrls = splitUrlList(process.env.STUN_URLS || "stun:stun.l.google.com:19302,stun:stun.cloudflare.com:3478");
  if (stunUrls.length) servers.push({ urls: stunUrls.length === 1 ? stunUrls[0] : stunUrls });

  const turnUrls = splitUrlList(process.env.TURN_URLS || process.env.TURN_URL || process.env.TURNS_URL || "");
  if (turnUrls.length) {
    servers.push({
      urls: turnUrls.length === 1 ? turnUrls[0] : turnUrls,
      username: process.env.TURN_USERNAME || "",
      credential: process.env.TURN_CREDENTIAL || "",
    });
  }
  return servers;
}

function hasTurnServer() {
  return splitUrlList(process.env.TURN_URLS || process.env.TURN_URL || process.env.TURNS_URL || "").length > 0;
}

function hasStunServer() {
  return splitUrlList(process.env.STUN_URLS || "stun:stun.l.google.com:19302,stun:stun.cloudflare.com:3478").length > 0;
}

function splitUrlList(value) {
  return String(value || "")
    .split(/[,\s]+/)
    .map((item) => item.trim())
    .filter(Boolean);
}

function printTurnStatus() {
  const stunUrls = splitUrlList(process.env.STUN_URLS || "stun:stun.l.google.com:19302,stun:stun.cloudflare.com:3478");
  const turnUrls = splitUrlList(process.env.TURN_URLS || process.env.TURN_URL || process.env.TURNS_URL || "");
  console.log(`ICE: STUN ${stunUrls.length ? stunUrls.join(", ") : "none"}`);
  if (turnUrls.length) {
    console.log(`ICE: TURN ${turnUrls.join(", ")} username=${process.env.TURN_USERNAME ? "set" : "empty"} credential=${process.env.TURN_CREDENTIAL ? "set" : "empty"}`);
    const privateTurn = turnUrls.filter((url) => /(?:^|[:/@])(?:192\.168\.|10\.|172\.(?:1[6-9]|2\d|3[01])\.)/.test(url));
    if (privateTurn.length) {
      console.log("경고: TURN 주소가 사설 IP입니다. 외부(친구) 클라이언트는 relay 후보를 만들 수 없어 연결이 실패합니다.");
      console.log("  공인 IP로 재설정: TURN_HOST=<공인IP> ./scripts/mac/setup-turn-mac.sh 실행 후 서버 재시작");
      console.log("  공유기 포트포워딩 필요: 3478/TCP+UDP, relay 49160-49200/TCP+UDP → Mac");
    }
    return;
  }
  console.log("ICE: TURN not configured.");
  console.log("Windows/Parallels/external clients can fail without TURN.");
  console.log("Run start-server-mac.command on the Mac server, or create server.env with:");
  console.log("  TURN_URLS=turn:YOUR_MAC_HOST:3478?transport=udp,turn:YOUR_MAC_HOST:3478?transport=tcp");
  console.log("  TURN_USERNAME=your-user");
  console.log("  TURN_CREDENTIAL=your-password");
  console.log("  STUN_URLS=stun:stun.l.google.com:19302,stun:stun.cloudflare.com:3478");
}

function loadServerEnvFiles() {
  for (const fileName of ["server.env", ".env"]) {
    const filePath = path.join(__dirname, fileName);
    if (!fs.existsSync(filePath)) continue;
    const lines = fs.readFileSync(filePath, "utf8").split(/\r?\n/);
    for (const line of lines) {
      const trimmed = line.trim();
      if (!trimmed || trimmed.startsWith("#")) continue;
      const match = trimmed.match(/^([A-Za-z_][A-Za-z0-9_]*)=(.*)$/);
      if (!match || Object.prototype.hasOwnProperty.call(process.env, match[1])) continue;
      process.env[match[1]] = unquoteEnvValue(match[2].trim());
    }
  }
}

function unquoteEnvValue(value) {
  if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) {
    return value.slice(1, -1);
  }
  return value;
}

function loadTlsOptions() {
  try {
    if (!fs.existsSync(CERT_FILE) || !fs.existsSync(KEY_FILE)) createCertificate();
    return {
      cert: fs.readFileSync(CERT_FILE),
      key: fs.readFileSync(KEY_FILE),
    };
  } catch {
    return null;
  }
}

function createCertificate() {
  fs.mkdirSync(CERT_DIR, { recursive: true });
  fs.mkdirSync(path.dirname(KEY_FILE), { recursive: true });
  const configPath = path.join(CERT_DIR, "openssl.cnf");
  const hosts = ["localhost", "127.0.0.1", "::1", getLanIp()].filter(Boolean);
  const altNames = hosts
    .map((host, index) => {
      const key = /^\d{1,3}(\.\d{1,3}){3}$/.test(host) || host.includes(":") ? "IP" : "DNS";
      return `${key}.${index + 1} = ${host}`;
    })
    .join("\n");

  fs.writeFileSync(configPath, [
    "[req]",
    "default_bits = 2048",
    "prompt = no",
    "default_md = sha256",
    "distinguished_name = dn",
    "x509_extensions = v3_req",
    "[dn]",
    "CN = Accord Local",
    "[v3_req]",
    "subjectAltName = @alt_names",
    "[alt_names]",
    altNames,
    "",
  ].join("\n"));

  const result = spawnSync("openssl", [
    "req",
    "-x509",
    "-newkey",
    "rsa:2048",
    "-nodes",
    "-days",
    "3650",
    "-keyout",
    KEY_FILE,
    "-out",
    CERT_FILE,
    "-config",
    configPath,
  ], { stdio: "ignore" });

  if (result.status !== 0) {
    throw new Error("openssl certificate generation failed");
  }
}

function getLanIp() {
  for (const interfaces of Object.values(os.networkInterfaces())) {
    for (const item of interfaces || []) {
      if (item.family === "IPv4" && !item.internal) return item.address;
    }
  }
  return "";
}

function getLanUrl(protocol, port) {
  const ip = getLanIp();
  return ip ? `${protocol}://${ip}:${port}` : "";
}

function cleanHost(value) {
  return String(value || "").trim().replace(/^https?:\/\//i, "").replace(/\/.*$/, "");
}

function cleanPublicUrl(value, host, port) {
  const raw = String(value || "").trim();
  if (raw) return raw.replace(/\/$/, "");
  if (!host) return "";
  return `https://${host.replace(/:\d+$/, "")}:${port}`;
}