수신 문자 자동응답 만들기: MESSAGE_RECEIVED 웹훅과 LLM

export KAT_API_KEY="콘솔에서 발급받은 키"

curl -s -X POST "https://studio-gateway.zerocall.kr/webhook" \
  -H "x-api-key: $KAT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"eventType":"MESSAGE_RECEIVED","url":"https://hooks.example.com/webhook/message"}'

// server.js — 수신 문자 자동응답 (Node.js 18+, Express 4)
const express = require('express');
const { businessState } = require('./hours');
const { buildReply } = require('./reply');

const BASE_URL = 'https://studio-gateway.zerocall.kr';
const API_KEY = process.env.KAT_API_KEY;

async function kat(method, path, body) {
  const res = await fetch(`${BASE_URL}${path}`, {
    method,
    headers: { 'x-api-key': API_KEY, 'Content-Type': 'application/json' },
    body: body ? JSON.stringify(body) : undefined,
  });
  const json = await res.json().catch(() => ({}));
  if (!res.ok || json.code !== '0') throw new Error(`${res.status} ${json.code} ${json.message}`);
  return json.result;
}

const handled = new Set(); // 처리한 chatId (운영에서는 Redis·DB에 만료 시간과 함께 저장)

const app = express();
app.use(express.json());

app.post('/webhook/message', (req, res) => {
  res.sendStatus(200); // 무엇보다 먼저 응답

  const { eventType, data } = req.body || {};
  if (eventType !== 'MESSAGE_RECEIVED' || !data?.chatId || !data.chatRoomId) return;
  if (handled.has(data.chatId)) return; // 같은 수신 메시지는 한 번만
  handled.add(data.chatId);

  setImmediate(() => {
    autoReply(data).catch((err) => console.error('[auto-reply]', data.chatId, err));
  });
});

app.listen(process.env.PORT || 3000);

// hours.js — 한국 시간 기준 영업 상태 판단
const OPEN = { start: 9 * 60, end: 18 * 60 }; // 09:00 ~ 18:00
const LUNCH = { start: 12 * 60, end: 13 * 60 }; // 12:00 ~ 13:00
const HOLIDAYS = new Set(['2026-12-25', '2027-01-01']); // 휴무일은 직접 관리

const fmt = new Intl.DateTimeFormat('en-US', {
  timeZone: 'Asia/Seoul',
  year: 'numeric', month: '2-digit', day: '2-digit',
  weekday: 'short', hour: '2-digit', minute: '2-digit', hourCycle: 'h23',
});

function seoulParts(date) {
  const p = Object.fromEntries(fmt.formatToParts(date).map((x) => [x.type, x.value]));
  return {
    ymd: `${p.year}-${p.month}-${p.day}`,
    weekday: p.weekday, // Mon ~ Sun
    minutes: Number(p.hour) * 60 + Number(p.minute),
  };
}

function businessState(date = new Date()) {
  const { ymd, weekday, minutes } = seoulParts(date);
  if (HOLIDAYS.has(ymd) || weekday === 'Sat' || weekday === 'Sun') return 'CLOSED_DAY';
  if (minutes < OPEN.start || minutes >= OPEN.end) return 'AFTER_HOURS';
  if (minutes >= LUNCH.start && minutes < LUNCH.end) return 'LUNCH';
  return 'OPEN';
}

module.exports = { businessState };

// reply.js — 답장 문안 만들기
const TEMPLATES = {
  LUNCH: '점심시간(12:00~13:00)이라 13시 이후 순서대로 답변드리겠습니다.',
  AFTER_HOURS: '영업시간(평일 09:00~18:00)이 지나 다음 영업일 오전에 답변드리겠습니다.',
  CLOSED_DAY: '오늘은 휴무일입니다. 다음 영업일 오전에 순서대로 답변드리겠습니다.',
};
const HANDOFF_WORDS = ['상담원', '직원', '사람이랑', '전화 주세요'];

// 사용하는 LLM API로 바꿔 끼우는 자리 (시스템 지침 + 대화 이력 → 답장 문자열)
async function callLLM({ system, messages }) {
  throw new Error('LLM 연동을 구현하세요');
}

// 일반적인 문자 바이트 계산(영문·숫자 1바이트, 한글 2바이트)에 따른 근사치
function smsBytes(text) {
  let n = 0;
  for (const ch of text) n += ch.charCodeAt(0) <= 0x7f ? 1 : 2;
  return n;
}

async function buildReply({ state, content, history }) {
  if (state !== 'OPEN') return { text: TEMPLATES[state], source: 'template' };
  if (HANDOFF_WORDS.some((w) => content.includes(w))) {
    return { text: '담당 직원이 확인 후 이 번호로 연락드리겠습니다.', source: 'handoff' };
  }
  try {
    const text = await Promise.race([
      callLLM({
        system:
          '매장 문자 상담 도우미입니다. 존댓말로 두 문장 이내로 답하세요. ' +
          '예약 확정, 가격 약속, 개인정보 요청은 하지 말고 직원이 확인 후 연락한다고 안내하세요.',
        messages: [...history, { role: 'user', content }],
      }),
      new Promise((_, reject) => setTimeout(() => reject(new Error('LLM timeout')), 8000)),
    ]);
    const clean = String(text).trim();
    // 90바이트를 넘으면 LMS로 나가므로 길이를 기록해 두고 지침을 조정한다
    return { text: clean.slice(0, 300), source: 'llm', bytes: smsBytes(clean) };
  } catch (err) {
    return { text: '문의 감사합니다. 확인 후 곧 답변드리겠습니다.', source: 'fallback' };
  }
}

module.exports = { buildReply };

// server.js (이어서)
const lastTemplateAt = new Map(); // chatRoomId -> 마지막 고정 안내 시각
const recentReplies = new Map(); // chatRoomId -> 최근 자동 답장 시각들

async function loadHistory(chatRoomId, currentChatId) {
  const page = await kat('GET', `/chat?chatRoomId=${encodeURIComponent(chatRoomId)}&size=10`);
  return (page.data || [])
    .filter((m) => m.id !== currentChatId && m.content)
    .sort((a, b) => a.sequence - b.sequence)
    .map((m) => ({ role: m.senderType === 'GUEST' ? 'user' : 'assistant', content: m.content }));
}

function allowReply(chatRoomId, now = Date.now()) {
  const windowMs = 10 * 60 * 1000;
  const recent = (recentReplies.get(chatRoomId) || []).filter((t) => now - t < windowMs);
  if (recent.length >= 3) return false; // 10분에 3번까지만 자동 답장
  recent.push(now);
  recentReplies.set(chatRoomId, recent);
  return true;
}

async function autoReply(data) {
  const content = (data.content || '').trim();
  if (!content) return; // 이미지만 온 문자 등은 직원이 확인

  const state = businessState(new Date(data.receivedAt || Date.now()));
  if (state === 'OPEN') {
    if (!allowReply(data.chatRoomId)) return;
  } else {
    const last = lastTemplateAt.get(data.chatRoomId) || 0;
    if (Date.now() - last < 12 * 60 * 60 * 1000) return; // 고정 안내는 12시간에 한 번
    lastTemplateAt.set(data.chatRoomId, Date.now());
  }

  const history = state === 'OPEN' ? await loadHistory(data.chatRoomId, data.chatId) : [];
  const reply = await buildReply({ state, content, history });

  const chat = await kat('POST', '/chat', {
    chatRoomId: data.chatRoomId,
    content: reply.text,
    externalMessageId: `auto-${data.chatId}`,
  });
  console.log('자동 답장', data.chatRoomId, reply.source, chat.chatId, chat.chatType);

  if (reply.source === 'handoff') {
    // 예: 사내 메신저로 담당 직원에게 알림
  }
}