korean-law-mcp 4.4.1 → 4.4.2

package/build/lib/api-client.js

@@ -233,8 +233,8 @@ export class LawApiClient {
         if (/시행령|시행규칙/.test(lawName)) {
             return 'law';
         }
-        // 행정규칙: 훈령, 예규, 고시, 지침, 내규
-        if (/훈령|예규|고시|지침|내규/.test(lawName)) {
+        // 행정규칙: 훈령, 예규, 고시, 지침, 내규, 세칙 (규정/규칙 단독은 시행규칙 오분류 위험 → 4차 fallback에 위임)
+        if (/훈령|예규|고시|지침|내규|세칙/.test(lawName)) {
             return 'admin';
         }
         // 일반 법령 (법, 규정 등)

package/build/server/sse-server.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Streamable HTTP 서버 - 리모트 배포용 (MCP 2025-03-26 스펙 준수)
+ */
+import type { Server } from "@modelcontextprotocol/sdk/server/index.js";
+export declare function startSSEServer(server: Server, port: number): Promise<void>;

package/build/server/sse-server.js

@@ -0,0 +1,232 @@
+/**
+ * Streamable HTTP 서버 - 리모트 배포용 (MCP 2025-03-26 스펙 준수)
+ */
+import express from "express";
+import { randomUUID } from "node:crypto";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { InMemoryEventStore } from "@modelcontextprotocol/sdk/examples/shared/inMemoryEventStore.js";
+import { isInitializeRequest } from "@modelcontextprotocol/sdk/types.js";
+import { sessionStore, setSessionApiKey, deleteSession } from "../lib/session-state.js";
+import { VERSION } from "../version.js";
+export async function startSSEServer(server, port) {
+    const app = express();
+    const transports = {};
+    // JSON 파싱 미들웨어 (크기 제한 명시)
+    app.use(express.json({ limit: "100kb" }));
+    // 유휴 세션 정리 (30분)
+    const SESSION_IDLE_TIMEOUT = 30 * 60 * 1000;
+    const MAX_SESSIONS = 100;
+    setInterval(() => {
+        const now = Date.now();
+        for (const sid of Object.keys(transports)) {
+            const session = transports[sid];
+            if (session.lastAccess && now - session.lastAccess > SESSION_IDLE_TIMEOUT) {
+                try {
+                    session.transport.close();
+                }
+                catch { /* ignore */ }
+                delete transports[sid];
+                deleteSession(sid);
+            }
+        }
+    }, 5 * 60 * 1000).unref();
+    // CORS 및 보안 헤더 설정
+    const corsOrigin = process.env.CORS_ORIGIN || "*";
+    app.use((req, res, next) => {
+        res.header("Access-Control-Allow-Origin", corsOrigin);
+        res.header("Access-Control-Allow-Methods", "GET, POST, DELETE, OPTIONS, HEAD");
+        res.header("Access-Control-Allow-Headers", "Content-Type, Accept, Authorization, Mcp-Protocol-Version, mcp-protocol-version, Mcp-Session-Id, mcp-session-id, Last-Event-ID, last-event-id, Traceparent, Tracestate");
+        res.header("Access-Control-Expose-Headers", "Mcp-Session-Id, Content-Type, Mcp-Protocol-Version, Traceparent, Tracestate");
+        res.header("Access-Control-Max-Age", "86400");
+        // Security headers (http-server.ts와 동일)
+        res.header("X-Content-Type-Options", "nosniff");
+        res.header("X-Frame-Options", "DENY");
+        res.header("Referrer-Policy", "strict-origin-when-cross-origin");
+        res.header("Mcp-Protocol-Version", "2025-03-26");
+        if (req.method === "OPTIONS") {
+            return res.sendStatus(200);
+        }
+        next();
+    });
+    // 헬스체크 엔드포인트
+    app.get("/", (req, res) => {
+        res.json({
+            name: "Korean Law MCP Server",
+            version: VERSION,
+            status: "running",
+            protocol: "streamable-http",
+            endpoints: {
+                mcp: "/mcp",
+                health: "/health"
+            }
+        });
+    });
+    app.get("/health", (req, res) => {
+        res.json({ status: "ok", timestamp: new Date().toISOString() });
+    });
+    // MCP POST 엔드포인트 (초기화 및 요청 처리)
+    app.post("/mcp", async (req, res) => {
+        const sessionId = req.headers["mcp-session-id"];
+        // API 키 추출 (http-server.ts와 동일 패턴)
+        const apiKeyFromHeader = req.headers["apikey"] ||
+            req.headers["law_oc"] ||
+            req.headers["law-oc"] ||
+            req.headers["LAW_OC"] ||
+            req.headers["x-api-key"] ||
+            req.headers["authorization"]?.replace(/^Bearer\s+/i, "") ||
+            req.headers["x-law-oc"];
+        if (sessionId) {
+            console.error(`Received MCP request for session: ${sessionId.slice(0, 8)}...`);
+        }
+        else {
+            console.error("New MCP request (no session ID)");
+        }
+        try {
+            let transport;
+            if (sessionId && transports[sessionId]) {
+                // 기존 세션 재사용 + 접근 시각 갱신
+                ;
+                transports[sessionId].lastAccess = Date.now();
+                transport = transports[sessionId].transport;
+                // API 키 업데이트 (헤더에서 제공된 경우)
+                if (apiKeyFromHeader) {
+                    setSessionApiKey(sessionId, apiKeyFromHeader);
+                }
+                // AsyncLocalStorage로 세션 ID 격리 (동시 요청 안전)
+                await sessionStore.run(sessionId, async () => {
+                    await transport.handleRequest(req, res, req.body);
+                });
+                return;
+            }
+            else if (!sessionId && isInitializeRequest(req.body)) {
+                // 새 세션 초기화
+                // 세션 수 제한 — transport 생성 전에 체크하여 리소스 누수 방지
+                if (Object.keys(transports).length >= MAX_SESSIONS) {
+                    res.status(503).json({
+                        jsonrpc: "2.0",
+                        error: { code: -32000, message: `Max sessions (${MAX_SESSIONS}) reached. Try again later.` },
+                        id: null,
+                    });
+                    return;
+                }
+                const eventStore = new InMemoryEventStore();
+                transport = new StreamableHTTPServerTransport({
+                    sessionIdGenerator: () => randomUUID(),
+                    eventStore,
+                    onsessioninitialized: (newSessionId) => {
+                        transports[newSessionId] = { transport, lastAccess: Date.now() };
+                        if (apiKeyFromHeader) {
+                            setSessionApiKey(newSessionId, apiKeyFromHeader);
+                        }
+                    }
+                });
+                // 세션 종료 시 정리
+                transport.onclose = () => {
+                    const sid = transport.sessionId;
+                    if (sid && transports[sid]) {
+                        console.error(`Transport closed for session ${sid.slice(0, 8)}...`);
+                        delete transports[sid];
+                        deleteSession(sid);
+                    }
+                };
+                // 서버 연결
+                await server.connect(transport);
+                await transport.handleRequest(req, res, req.body);
+                return;
+            }
+            else {
+                // 잘못된 요청
+                res.status(400).json({
+                    jsonrpc: "2.0",
+                    error: {
+                        code: -32000,
+                        message: "Invalid request: missing session ID or not an initialization request"
+                    },
+                    id: null
+                });
+                return;
+            }
+        }
+        catch (error) {
+            console.error("Error handling MCP POST request:", error);
+            if (!res.headersSent) {
+                res.status(500).json({
+                    jsonrpc: "2.0",
+                    error: {
+                        code: -32603,
+                        message: "Internal server error"
+                    },
+                    id: null
+                });
+            }
+        }
+    });
+    // MCP GET 엔드포인트 (SSE 스트림)
+    app.get("/mcp", async (req, res) => {
+        const sessionId = req.headers["mcp-session-id"];
+        if (!sessionId || !transports[sessionId]) {
+            res.status(400).send("Invalid or missing session ID");
+            return;
+        }
+        const lastEventId = req.headers["last-event-id"];
+        if (lastEventId) {
+            console.error(`Client reconnecting with Last-Event-ID: ${lastEventId}`);
+        }
+        else {
+            console.error(`Establishing SSE stream for session ${sessionId.slice(0, 8)}...`);
+        }
+        try {
+            const transport = transports[sessionId].transport;
+            await transport.handleRequest(req, res);
+        }
+        catch (error) {
+            console.error("[GET /mcp] Error:", error);
+            if (!res.headersSent) {
+                res.status(500).send("Internal server error");
+            }
+        }
+    });
+    // MCP DELETE 엔드포인트 (세션 종료)
+    app.delete("/mcp", async (req, res) => {
+        const sessionId = req.headers["mcp-session-id"];
+        if (!sessionId || !transports[sessionId]) {
+            res.status(400).send("Invalid or missing session ID");
+            return;
+        }
+        console.error(`Session termination request for ${sessionId.slice(0, 8)}...`);
+        try {
+            const transport = transports[sessionId].transport;
+            await transport.handleRequest(req, res);
+            delete transports[sessionId];
+            deleteSession(sessionId);
+            console.error(`Session removed: ${sessionId.slice(0, 8)}...`);
+        }
+        catch (error) {
+            console.error("Error handling session termination:", error);
+            if (!res.headersSent) {
+                res.status(500).send("Error processing session termination");
+            }
+        }
+    });
+    // 서버 시작
+    app.listen(port, "0.0.0.0", () => {
+        console.error(`✓ Korean Law MCP server (Streamable HTTP) listening on port ${port}`);
+        console.error(`✓ MCP endpoint: http://0.0.0.0:${port}/mcp`);
+        console.error(`✓ Health check: http://0.0.0.0:${port}/health`);
+    });
+    // 종료 처리
+    process.on("SIGINT", async () => {
+        console.error("Shutting down server...");
+        for (const sessionId in transports) {
+            try {
+                await transports[sessionId].transport.close();
+                delete transports[sessionId];
+                deleteSession(sessionId);
+            }
+            catch (error) {
+                console.error(`Error closing transport ${sessionId}:`, error);
+            }
+        }
+        process.exit(0);
+    });
+}

package/build/tools/annex.js

@@ -9,7 +9,7 @@ import { formatToolError, notFoundResponse } from "../lib/errors.js";
 import { getLawSiteBaseUrl } from "../lib/law-url-config.js";
 const LAW_BASE_URL = getLawSiteBaseUrl();
 export const GetAnnexesSchema = z.object({
-    lawName: z.string().describe("법령명 (예: '관세법'). 별표를 바로 지정하려면 '... 별표4'처럼 함께 입력 가능"),
+    lawName: z.string().describe("법령명 (예: '관세법'). 별표를 바로 지정하려면 '... 별표4' 또는 '... 별표1의2'처럼 함께 입력 가능"),
     knd: z.enum(["1", "2", "3", "4", "5"]).optional().describe("1=별표, 2=서식, 3=부칙별표, 4=부칙서식, 5=전체"),
     bylSeq: z.string().optional().describe("별표번호 (예: '000300'). 지정 시 해당 별표 파일을 다운로드하여 텍스트로 추출"),
     annexNo: z.string().optional().describe("별표 번호 (예: '4', '별표4', '제4호'). bylSeq 대체 입력"),
@@ -29,8 +29,9 @@ export async function getAnnexes(apiClient, input) {
                 const json = JSON.parse(jsonText);
                 const adminResult = json?.admRulBylSearch;
                 const licResult = json?.licBylSearch;
-                if (adminResult?.admbyl)
-                    return { list: toArray(adminResult.admbyl), type: "admin" };
+                // 법제처 행정규칙 별표 응답의 배열 키는 admrulbyl (admbyl 아님). 구버전 호환 위해 admbyl도 폴백.
+                if (adminResult?.admrulbyl ?? adminResult?.admbyl)
+                    return { list: toArray(adminResult.admrulbyl ?? adminResult.admbyl), type: "admin" };
                 if (licResult?.ordinbyl)
                     return { list: toArray(licResult.ordinbyl), type: "ordinance" };
                 if (licResult?.licbyl)
@@ -109,7 +110,7 @@ export async function getAnnexes(apiClient, input) {
         const filtered = filterByRelatedLawName(annexList, normalizedLawName);
         // 별표 선택값 지정 시 → 해당 별표 파일 다운로드 + 텍스트 추출
         if (annexSelector) {
-            return await extractAnnexContent(filtered, annexSelector, normalizedLawName);
+            return await extractAnnexContent(filtered, annexSelector, normalizedLawName, input.knd);
         }
         // 별표 선택값 미지정 → 기존 목록 반환
         return formatAnnexList(filtered, lawType, input, normalizedLawName);
@@ -119,9 +120,9 @@ export async function getAnnexes(apiClient, input) {
     }
 }
 // ─── 별표 텍스트 추출 ─────────────────────────────────
-async function extractAnnexContent(annexList, annexSelector, normalizedLawName) {
-    // bylSeq / annexNo / lawName 내 힌트로 유연 매칭
-    const matched = findMatchingAnnex(annexList, annexSelector);
+async function extractAnnexContent(annexList, annexSelector, normalizedLawName, knd) {
+    // bylSeq / annexNo / lawName 내 힌트로 유연 매칭 (별표/서식 구분 위해 knd 전달)
+    const matched = findMatchingAnnex(annexList, annexSelector, knd);
     if (!matched) {
         const availableBylSeq = annexList.map((a) => a.별표번호).filter(Boolean).slice(0, 20).join(", ");
         return notFoundResponse(`별표 선택값 "${annexSelector}"에 해당하는 항목을 찾을 수 없습니다. (법령: ${normalizedLawName})`, [
@@ -219,8 +220,9 @@ function formatAnnexList(annexList, lawType, input, normalizedLawName) {
         else if (lawType === "admin") {
             if (annex.관련행정규칙명)
                 resultText += `   행정규칙: ${annex.관련행정규칙명}\n`;
-            if (annex.소관부처)
-                resultText += `   소관부처: ${annex.소관부처}\n`;
+            const dept = annex.소관부처명 || annex.소관부처;
+            if (dept)
+                resultText += `   소관부처: ${dept}\n`;
         }
         else {
             if (annex.관련법령명)
@@ -245,24 +247,45 @@ function extractParentLawName(lawName) {
 }
 function parseLawNameAndHint(lawName) {
     const trimmedLawName = lawName.trim();
-    const annexHintMatch = trimmedLawName.match(/\[?\s*(별표|서식)\s*(?:제)?\s*(\d{1,6})\s*(?:호)?\s*\]?/);
+    // "별표1", "별표 제1호", "별표 1의2"(= 별표 제1호의2) 모두 매칭. 의-번호는 별도 캡처해 법령명에 남지 않게 한다.
+    const annexHintMatch = trimmedLawName.match(/\[?\s*(별표|서식)\s*(?:제)?\s*(\d{1,6})\s*(?:호)?\s*(?:의\s*(\d{1,2}))?\s*\]?/);
     if (!annexHintMatch) {
         return { normalizedLawName: trimmedLawName };
     }
-    const parsedAnnexNo = Number.parseInt(annexHintMatch[2], 10);
+    const mainNo = Number.parseInt(annexHintMatch[2], 10);
+    const subNo = annexHintMatch[3] ? Number.parseInt(annexHintMatch[3], 10) : null;
     const normalizedLawName = trimmedLawName
         .replace(annexHintMatch[0], " ")
         .replace(/\s+/g, " ")
         .trim();
+    if (Number.isNaN(mainNo)) {
+        return { normalizedLawName: normalizedLawName || trimmedLawName };
+    }
+    // 의-번호가 있으면 법제처 별표번호 6자리 코드(AAAABB)로 변환 (별표 1의2 → "000102").
+    // 없으면 기존 동작 유지(정수 문자열 → buildSelectorCandidates가 6자리 코드 후보 생성).
+    const annexNo = subNo != null
+        ? String(mainNo).padStart(4, "0") + String(subNo).padStart(2, "0")
+        : String(mainNo);
     return {
         normalizedLawName: normalizedLawName || trimmedLawName,
-        annexNo: Number.isNaN(parsedAnnexNo) ? undefined : String(parsedAnnexNo)
+        annexNo
     };
 }
-function findMatchingAnnex(annexList, annexSelector) {
+/**
+ * 별표 선택값으로 항목 매칭.
+ *
+ * 자치법규 등에서 [별표 N]과 [별지 제N호서식]이 동일 별표번호(bylSeq)를 공유하는 경우가
+ * 있어, 번호만으로 find() 하면 목록 순서상 먼저 오는 항목(주로 서식)이 잘못 선택된다.
+ * (예: 서울특별시 건축 조례 — [별표4] 대지안의 공지기준 / [별지 제4호서식] 공개공지 관리대장이
+ *  모두 별표번호 000400을 가짐.)
+ * 따라서 번호가 일치하는 후보를 모두 모은 뒤, knd(별표/서식 의도)로 별표종류를 구분해
+ * 올바른 항목을 고른다. knd 미지정 시 표(별표)를 서식보다 우선한다.
+ */
+function findMatchingAnnex(annexList, annexSelector, knd) {
     const selectorCandidates = buildSelectorCandidates(annexSelector);
     const selectorNumbers = extractSelectorNumbers(annexSelector);
-    return annexList.find((annex) => {
+    // 번호/제목으로 매칭되는 후보 "전체" 수집 (find → filter)
+    const matches = annexList.filter((annex) => {
         const annexNum = String(annex.별표번호 || "").trim();
         const annexTitle = String(annex.별표명 || "");
         if (annexNum && selectorCandidates.has(annexNum)) {
@@ -270,6 +293,23 @@ function findMatchingAnnex(annexList, annexSelector) {
         }
         return selectorNumbers.some((num) => titleMatchesAnnexNumber(annexTitle, num));
     });
+    if (matches.length === 0)
+        return undefined;
+    if (matches.length === 1)
+        return matches[0];
+    // 별표번호 충돌 → 별표종류("별표"/"서식")로 구분
+    const isForm = (a) => /서식/.test(String(a.별표종류 || ""));
+    const isTable = (a) => /별표/.test(String(a.별표종류 || ""));
+    if (knd === "2" || knd === "4") {
+        // 서식을 명시적으로 요청
+        return matches.find(isForm) || matches[0];
+    }
+    if (knd === "1" || knd === "3") {
+        // 별표를 명시적으로 요청
+        return matches.find(isTable) || matches[0];
+    }
+    // knd 미지정/전체(5): 표(별표)를 서식보다 우선
+    return matches.find(isTable) || matches[0];
 }
 function buildSelectorCandidates(selector) {
     const candidates = new Set();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "korean-law-mcp",
-  "version": "4.4.1",
+  "version": "4.4.2",
   "description": "법제처 42개 API → 9개 MCP 도구. 법령·판례·조례·조약 + 다단계 리서치(legal_research, 8 task) + 정밀분석(legal_analysis: 인용검증·판례생사·행위시법·영향그래프) + 시점 비교(time_travel) + 상황별 5단계 안내(action_plan) + 국세청 해석례(nts)",
   "type": "module",
   "main": "build/index.js",