korean-law-mcp 2.1.0 → 2.1.2

package/build/index.js

@@ -10,11 +10,6 @@ import { registerTools } from "./tool-registry.js";
 import { startHTTPServer } from "./server/http-server.js";
 // API 클라이언트 초기화
 const LAW_OC = process.env.LAW_OC || "";
-if (!LAW_OC) {
-    console.error("⚠️  LAW_OC 환경변수 미설정. STDIO 모드에서는 API 호출이 실패합니다.");
-    console.error("   API 키 발급: https://open.law.go.kr/LSO/openApi/guideResult.do");
-    console.error("   HTTP 모드에서는 클라이언트가 헤더로 API 키를 제공할 수 있습니다.");
-}
 const apiClient = new LawApiClient({ apiKey: LAW_OC });
 // MCP 서버 생성
 const server = new Server({
@@ -41,7 +36,6 @@ async function main() {
         // STDIO 모드 (기본)
         const transport = new StdioServerTransport();
         await server.connect(transport);
-        console.error("Korean Law MCP server running on stdio");
     }
 }
 main().catch((error) => {

package/build/lib/api-client.js

@@ -70,13 +70,13 @@ export class LawApiClient {
             type: "JSON",
         });
         if (params.mst)
-            apiParams.append("MST", params.mst);
+            apiParams.append("MST", String(params.mst));
         if (params.lawId)
-            apiParams.append("ID", params.lawId);
+            apiParams.append("ID", String(params.lawId));
         if (params.jo)
-            apiParams.append("JO", params.jo);
+            apiParams.append("JO", String(params.jo));
         if (params.efYd)
-            apiParams.append("efYd", params.efYd);
+            apiParams.append("efYd", String(params.efYd));
         const url = `${LAW_API_BASE}/lawService.do?${apiParams.toString()}`;
         const response = await fetchWithRetry(url);
         this.throwIfError(response, "getLawText");
@@ -115,13 +115,13 @@ export class LawApiClient {
             type: "XML",
         });
         if (params.mst)
-            apiParams.append("MST", params.mst);
+            apiParams.append("MST", String(params.mst));
         if (params.lawId)
-            apiParams.append("ID", params.lawId);
+            apiParams.append("ID", String(params.lawId));
         if (params.ld)
-            apiParams.append("LD", params.ld);
+            apiParams.append("LD", String(params.ld));
         if (params.ln)
-            apiParams.append("LN", params.ln);
+            apiParams.append("LN", String(params.ln));
         const url = `${LAW_API_BASE}/lawService.do?${apiParams.toString()}`;
         const response = await fetchWithRetry(url);
         this.throwIfError(response, "compareOldNew");
@@ -138,9 +138,9 @@ export class LawApiClient {
             knd: params.knd || "2",
         });
         if (params.mst)
-            apiParams.append("MST", params.mst);
+            apiParams.append("MST", String(params.mst));
         if (params.lawId)
-            apiParams.append("ID", params.lawId);
+            apiParams.append("ID", String(params.lawId));
         const url = `${LAW_API_BASE}/lawService.do?${apiParams.toString()}`;
         const response = await fetchWithRetry(url);
         this.throwIfError(response, "getThreeTier");
@@ -273,17 +273,17 @@ export class LawApiClient {
             type: "XML",
         });
         if (params.lawId)
-            apiParams.append("ID", params.lawId);
+            apiParams.append("ID", String(params.lawId));
         if (params.jo)
-            apiParams.append("JO", params.jo);
+            apiParams.append("JO", String(params.jo));
         if (params.regDt)
-            apiParams.append("regDt", params.regDt);
+            apiParams.append("regDt", String(params.regDt));
         if (params.fromRegDt)
-            apiParams.append("fromRegDt", params.fromRegDt);
+            apiParams.append("fromRegDt", String(params.fromRegDt));
         if (params.toRegDt)
-            apiParams.append("toRegDt", params.toRegDt);
+            apiParams.append("toRegDt", String(params.toRegDt));
         if (params.org)
-            apiParams.append("org", params.org);
+            apiParams.append("org", String(params.org));
         if (params.page)
             apiParams.append("page", params.page.toString());
         const url = `${LAW_API_BASE}/lawSearch.do?${apiParams.toString()}`;
@@ -302,7 +302,7 @@ export class LawApiClient {
         });
         if (params.extraParams) {
             for (const [key, value] of Object.entries(params.extraParams)) {
-                apiParams.append(key, value);
+                apiParams.append(key, String(value));
             }
         }
         const url = `${LAW_API_BASE}/${params.endpoint}?${apiParams.toString()}`;

package/build/server/http-server.js

@@ -27,7 +27,7 @@ export async function startHTTPServer(server, port) {
                 deleteSession(sessionId);
             }
         }
-    }, 5 * 60 * 1000);
+    }, 5 * 60 * 1000).unref();
     // Rate Limiting (RATE_LIMIT_RPM 환경변수, 기본: 60 req/min per IP)
     const rateLimitRpm = parseInt(process.env.RATE_LIMIT_RPM || "60", 10);
     const rateBuckets = new Map();
@@ -56,7 +56,7 @@ export async function startHTTPServer(server, port) {
                 if (now >= bucket.resetAt)
                     rateBuckets.delete(ip);
             }
-        }, 5 * 60 * 1000);
+        }, 5 * 60 * 1000).unref();
     }
     // CORS 및 보안 헤더 설정
     const corsOrigin = process.env.CORS_ORIGIN || "*";

package/build/server/sse-server.js

@@ -75,17 +75,20 @@ export async function startSSEServer(server, port) {
             }
             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) => {
-                        // 세션 수 제한
-                        if (Object.keys(transports).length >= MAX_SESSIONS) {
-                            console.error(`Max sessions (${MAX_SESSIONS}) reached, rejecting new session`);
-                            return;
-                        }
-                        console.error(`Session initialized: ${newSessionId}`);
                         transports[newSessionId] = { transport, lastAccess: Date.now() };
                     }
                 });

package/build/tools/admin-rule.js

@@ -3,6 +3,7 @@
  */
 import { z } from "zod";
 import { DOMParser } from "@xmldom/xmldom";
+import { truncateResponse } from "../lib/schemas.js";
 // search_admin_rule 스키마
 export const SearchAdminRuleSchema = z.object({
     query: z.string().describe("검색할 행정규칙명"),
@@ -61,7 +62,7 @@ export async function searchAdminRule(apiClient, input) {
         return {
             content: [{
                     type: "text",
-                    text: resultText
+                    text: truncateResponse(resultText)
                 }]
         };
     }
@@ -115,7 +116,7 @@ export async function getAdminRule(apiClient, input) {
                 return {
                     content: [{
                             type: "text",
-                            text: resultText
+                            text: truncateResponse(resultText)
                         }]
                 };
             }
@@ -157,7 +158,7 @@ export async function getAdminRule(apiClient, input) {
             return {
                 content: [{
                         type: "text",
-                        text: resultText
+                        text: truncateResponse(resultText)
                     }]
             };
         }
@@ -197,7 +198,7 @@ export async function getAdminRule(apiClient, input) {
         return {
             content: [{
                     type: "text",
-                    text: resultText
+                    text: truncateResponse(resultText)
                 }]
         };
     }

package/build/tools/annex.js

@@ -23,16 +23,22 @@ export async function getAnnexes(apiClient, input) {
         // 법제처 API는 결과 1건일 때 배열 대신 단일 객체를 반환하므로 정규화
         const toArray = (v) => v == null ? [] : Array.isArray(v) ? v : [v];
         const parseAnnexResponse = (jsonText) => {
-            const json = JSON.parse(jsonText);
-            const adminResult = json?.admRulBylSearch;
-            const licResult = json?.licBylSearch;
-            if (adminResult?.admbyl)
-                return { list: toArray(adminResult.admbyl), type: "admin" };
-            if (licResult?.ordinbyl)
-                return { list: toArray(licResult.ordinbyl), type: "ordinance" };
-            if (licResult?.licbyl)
-                return { list: toArray(licResult.licbyl), type: "law" };
-            return { list: [], type: "law" };
+            try {
+                const json = JSON.parse(jsonText);
+                const adminResult = json?.admRulBylSearch;
+                const licResult = json?.licBylSearch;
+                if (adminResult?.admbyl)
+                    return { list: toArray(adminResult.admbyl), type: "admin" };
+                if (licResult?.ordinbyl)
+                    return { list: toArray(licResult.ordinbyl), type: "ordinance" };
+                if (licResult?.licbyl)
+                    return { list: toArray(licResult.licbyl), type: "law" };
+                return { list: [], type: "law" };
+            }
+            catch {
+                // JSON 파싱 실패 (HTML 에러 페이지 등) → 빈 배열 반환하여 fallback 진행
+                return { list: [], type: "law" };
+            }
         };
         // 1차: 원래 법령명 + knd 필터
         const result1 = parseAnnexResponse(await apiClient.getAnnexes({
@@ -64,6 +70,30 @@ export async function getAnnexes(apiClient, input) {
                 lawType = result3.type;
             }
         }
+        // 4차: "규정" 타입은 licbyl과 admbyl 양쪽에 존재 가능 → admin fallback
+        if (annexList.length === 0 && /규정/.test(normalizedLawName)) {
+            try {
+                const adminText = await apiClient.fetchApi({
+                    endpoint: "lawSearch.do",
+                    target: "admbyl",
+                    type: "JSON",
+                    extraParams: {
+                        query: normalizedLawName,
+                        search: "2",
+                        display: "100",
+                    },
+                    apiKey: input.apiKey,
+                });
+                const result4 = parseAnnexResponse(adminText);
+                if (result4.list.length > 0) {
+                    annexList = result4.list;
+                    lawType = "admin";
+                }
+            }
+            catch {
+                // admin fallback 실패 → 무시하고 진행
+            }
+        }
         if (annexList.length === 0) {
             return {
                 content: [{ type: "text", text: `"${normalizedLawName}"에 대한 별표/서식이 없습니다.` }]

package/build/tools/batch-articles.js

@@ -26,7 +26,7 @@ export const GetBatchArticlesSchema = z.object({
  * 단일 법령에서 조문 추출
  */
 async function fetchArticlesForLaw(apiClient, lawReq, efYd, apiKey) {
-    const cacheKey = `lawtext:${lawReq.mst || lawReq.lawId}:full:${efYd || 'current'}`;
+    const cacheKey = `batch:${lawReq.mst || lawReq.lawId}:full:${efYd || 'current'}`;
     let fullLawData;
     const cached = lawCache.get(cacheKey);
     if (cached) {

package/build/tools/chains.js

@@ -34,36 +34,60 @@ handler, apiClient, input) {
         return { text: `오류: ${e instanceof Error ? e.message : String(e)}`, isError: true };
     }
 }
+/** 법령명이 아닌 부가 키워드 제거 (법제처 lawSearch API는 법령명 검색이므로) */
+const NON_LAW_NAME_RE = /\s*(과태료|절차|비용|처벌|기준|허가|신청|부과|근거|위반|방법|요건|조건|처분|수수료|신고|등록|면허|인가|승인|취소|정지|벌칙|벌금|과징금|이행강제금|시정명령|체계|구조|3단|판례|해석|개정|별표|시행령|시행규칙|서식|수입|수출|통관|반환|납부|감면|면제|제한|금지|의무|권리|자격|종류|기간|대상|범위|적용)\s*/g;
+function stripNonLawKeywords(query) {
+    return query.replace(NON_LAW_NAME_RE, " ").trim();
+}
+/** XML에서 법령 정보 파싱 */
+function parseLawXml(xmlText, max) {
+    const lawRegex = /<law[^>]*>([\s\S]*?)<\/law>/g;
+    const results = [];
+    let match;
+    while ((match = lawRegex.exec(xmlText)) !== null && results.length < max) {
+        const content = match[1];
+        const lawName = extractTag(content, "법령명한글");
+        if (!lawName)
+            continue; // 빈 법령명 제외
+        results.push({
+            lawName,
+            lawId: extractTag(content, "법령ID"),
+            mst: extractTag(content, "법령일련번호"),
+            lawType: extractTag(content, "법령구분명"),
+        });
+    }
+    return results;
+}
 async function findLaws(apiClient, query, apiKey, max = 3) {
+    // 1차: 원본 쿼리로 검색
+    let results = [];
     try {
         const xmlText = await apiClient.searchLaw(query, apiKey);
-        const lawRegex = /<law[^>]*>([\s\S]*?)<\/law>/g;
-        const results = [];
-        let match;
-        while ((match = lawRegex.exec(xmlText)) !== null && results.length < max) {
-            const content = match[1];
-            results.push({
-                lawName: extractTag(content, "법령명한글"),
-                lawId: extractTag(content, "법령ID"),
-                mst: extractTag(content, "법령일련번호"),
-                lawType: extractTag(content, "법령구분명"),
-            });
-        }
-        // 쿼리와 법령명 관련도 기반 정렬 (정확 매칭 > 부분 매칭 > 나머지)
-        if (results.length > 1) {
-            const queryWords = query.replace(/\s*(시행령|시행규칙|별표|판례|개정|체계|3단|구조|절차|비용|처벌|기준|허가|신청)\s*/g, " ")
-                .trim().split(/\s+/).filter(w => w.length > 0);
-            results.sort((a, b) => {
-                const scoreA = scoreLawRelevance(a.lawName, query, queryWords);
-                const scoreB = scoreLawRelevance(b.lawName, query, queryWords);
-                return scoreB - scoreA;
-            });
+        results = parseLawXml(xmlText, max);
+    }
+    catch { /* 2차 시도로 진행 */ }
+    // 2차: 결과 없으면 부가 키워드 제거 후 재시도
+    if (results.length === 0) {
+        const stripped = stripNonLawKeywords(query);
+        if (stripped && stripped !== query) {
+            try {
+                const xmlText = await apiClient.searchLaw(stripped, apiKey);
+                results = parseLawXml(xmlText, max);
+            }
+            catch { /* 빈 결과 반환 */ }
         }
-        return results;
     }
-    catch {
-        return [];
+    // 쿼리와 법령명 관련도 기반 정렬 (정확 매칭 > 부분 매칭 > 나머지)
+    if (results.length > 1) {
+        const queryWords = query.replace(NON_LAW_NAME_RE, " ")
+            .trim().split(/\s+/).filter(w => w.length > 0);
+        results.sort((a, b) => {
+            const scoreA = scoreLawRelevance(a.lawName, query, queryWords);
+            const scoreB = scoreLawRelevance(b.lawName, query, queryWords);
+            return scoreB - scoreA;
+        });
     }
+    return results;
 }
 /** 쿼리 대비 법령명 관련도 점수 (높을수록 관련) */
 function scoreLawRelevance(lawName, query, queryWords) {
@@ -98,6 +122,13 @@ function detectExpansions(query) {
         exp.push("interpretation");
     return exp;
 }
+/** 조례 쿼리에서 지역명·조례 키워드 제거 → 상위법 검색용 */
+function stripOrdinanceKeywords(query) {
+    return query
+        .replace(/(?:서울|부산|대구|인천|광주|대전|울산|세종|경기|강원|충북|충남|전북|전남|경북|경남|제주)(?:시|도|특별시|광역시|특별자치시|특별자치도)?/g, "")
+        .replace(/\s*(조례|규칙|자치법규)\s*/g, " ")
+        .trim();
+}
 function detectDomain(query) {
     if (/관세|수출|수입|통관|FTA|원산지/.test(query))
         return "customs";
@@ -334,9 +365,9 @@ export const chainOrdinanceCompareSchema = z.object({
 export async function chainOrdinanceCompare(apiClient, input) {
     try {
         const parts = [`═══ 조례 비교 연구: ${input.query} ═══`];
-        // Step 1: 상위 법령 확인
-        const parentQuery = input.parentLaw || input.query;
-        const laws = await findLaws(apiClient, parentQuery, input.apiKey, 2);
+        // Step 1: 상위 법령 확인 (조례/지역명은 법령 검색에서 제거)
+        const parentQuery = input.parentLaw || stripOrdinanceKeywords(input.query);
+        const laws = parentQuery ? await findLaws(apiClient, parentQuery, input.apiKey, 2) : [];
         if (laws.length > 0) {
             const p = laws[0];
             parts.push(sec("상위 법령", `${p.lawName} (${p.lawType}) | MST: ${p.mst}`));
@@ -345,8 +376,9 @@ export async function chainOrdinanceCompare(apiClient, input) {
             if (!threeTier.isError)
                 parts.push(sec("위임 체계 (법률·시행령·시행규칙)", threeTier.text));
         }
-        // Step 2: 조례 검색 (타 지자체)
-        const ordinances = await callTool(searchOrdinance, apiClient, { query: input.query, display: 20, apiKey: input.apiKey });
+        // Step 2: 조례 검색 — "조례"/"규칙" 제거 (이미 조례 DB에서 검색하므로)
+        const ordinanceQuery = input.query.replace(/\s*(조례|규칙|자치법규)\s*/g, " ").trim() || input.query;
+        const ordinances = await callTool(searchOrdinance, apiClient, { query: ordinanceQuery, display: 20, apiKey: input.apiKey });
         if (!ordinances.isError)
             parts.push(sec("전국 자치법규 검색 결과", ordinances.text));
         // 키워드 확장

package/build/tools/comparison.js

@@ -3,6 +3,7 @@
  */
 import { z } from "zod";
 import { DOMParser } from "@xmldom/xmldom";
+import { truncateResponse } from "../lib/schemas.js";
 export const CompareOldNewSchema = z.object({
     mst: z.string().optional().describe("법령일련번호"),
     lawId: z.string().optional().describe("법령ID"),
@@ -94,7 +95,7 @@ export async function compareOldNew(apiClient, input) {
         return {
             content: [{
                     type: "text",
-                    text: resultText
+                    text: truncateResponse(resultText)
                 }]
         };
     }

package/build/tools/english-law.js

@@ -94,11 +94,11 @@ export async function getEnglishLawText(apiClient, args) {
         }
         const extraParams = {};
         if (args.lawId)
-            extraParams.ID = args.lawId;
+            extraParams.ID = String(args.lawId);
         if (args.mst)
-            extraParams.MST = args.mst;
+            extraParams.MST = String(args.mst);
         if (args.lawName)
-            extraParams.LM = args.lawName;
+            extraParams.LM = String(args.lawName);
         const responseText = await apiClient.fetchApi({
             endpoint: "lawService.do",
             target: "elaw",

package/build/tools/historical-law.js

@@ -105,8 +105,9 @@ export async function getHistoricalLaw(apiClient, args) {
         output += `  제개정구분: ${basic.제개정구분명 || basic.제개정구분 || "N/A"}\n`;
         output += `  소관부처: ${basic.소관부처명 || basic.소관부처 || "N/A"}\n\n`;
         // Extract articles
-        const articles = law.조문 || [];
-        if (Array.isArray(articles) && articles.length > 0) {
+        const rawArticles = law.조문;
+        const articles = rawArticles == null ? [] : Array.isArray(rawArticles) ? rawArticles : [rawArticles];
+        if (articles.length > 0) {
             if (args.jo) {
                 // Filter to specific article
                 const joCode = parseJoNumber(args.jo);

package/build/tools/knowledge-base.js

@@ -316,9 +316,9 @@ export async function getRelatedLaws(apiClient, args) {
             display: (args.display || 20).toString(),
         };
         if (args.lawId)
-            extraParams.ID = args.lawId;
+            extraParams.ID = String(args.lawId);
         if (args.lawName)
-            extraParams.query = args.lawName;
+            extraParams.query = String(args.lawName);
         let xmlText;
         try {
             xmlText = await apiClient.fetchApi({

package/build/tools/law-system-tree.js

@@ -14,11 +14,11 @@ export async function getLawSystemTree(apiClient, args) {
         }
         const extraParams = {};
         if (args.lawId)
-            extraParams.ID = args.lawId;
+            extraParams.ID = String(args.lawId);
         if (args.mst)
-            extraParams.MST = args.mst;
+            extraParams.MST = String(args.mst);
         if (args.lawName)
-            extraParams.LM = args.lawName;
+            extraParams.LM = String(args.lawName);
         const responseText = await apiClient.fetchApi({
             endpoint: "lawService.do",
             target: "lsStmd",
@@ -48,7 +48,7 @@ export async function getLawSystemTree(apiClient, args) {
         output += `  법령구분: ${lawType}\n`;
         output += `  제개정: ${revision}\n`;
         output += `  시행일자: ${formatDateDot(basicInfo.시행일자)}\n`;
-        output += `  공포일자: ${formatDateDot(basicInfo.공포일자)} (제${basicInfo.공포번호}호)\n\n`;
+        output += `  공포일자: ${formatDateDot(basicInfo.공포일자)}${basicInfo.공포번호 ? ` (제${basicInfo.공포번호}호)` : ""}\n\n`;
         // Law hierarchy (상하위법)
         output += `📊 법령 체계:\n\n`;
         const hierarchy = tree.상하위법 || {};

package/build/tools/ordinance.js

@@ -3,6 +3,7 @@
  */
 import { z } from "zod";
 import { cleanHtml } from "../lib/article-parser.js";
+import { truncateResponse } from "../lib/schemas.js";
 export const GetOrdinanceSchema = z.object({
     ordinSeq: z.string().describe("자치법규 일련번호"),
     apiKey: z.string().optional().describe("API 키")
@@ -80,7 +81,7 @@ export async function getOrdinance(apiClient, input) {
         return {
             content: [{
                     type: "text",
-                    text: resultText
+                    text: truncateResponse(resultText)
                 }]
         };
     }

package/build/tools/search.js

@@ -4,6 +4,7 @@
 import { z } from "zod";
 import { DOMParser } from "@xmldom/xmldom";
 import { lawCache } from "../lib/cache.js";
+import { truncateResponse } from "../lib/schemas.js";
 export const SearchLawSchema = z.object({
     query: z.string().describe("검색할 법령명 (예: '관세법', 'fta특례법', '화관법')"),
     display: z.number().optional().default(20).describe("최대 결과 개수"),
@@ -53,11 +54,12 @@ export async function searchLaw(apiClient, input) {
         }
         resultText += `\n💡 특정 조문을 조회하려면 get_law_text Tool을 사용하세요.`;
         // Cache the result (1 hour TTL)
-        lawCache.set(cacheKey, resultText, 60 * 60 * 1000);
+        const truncated = truncateResponse(resultText);
+        lawCache.set(cacheKey, truncated, 60 * 60 * 1000);
         return {
             content: [{
                     type: "text",
-                    text: resultText
+                    text: truncated
                 }]
         };
     }

package/package.json

@@ -1,9 +1,28 @@
 {
   "name": "korean-law-mcp",
-  "version": "2.1.0",
+  "version": "2.1.2",
   "description": "국가법령정보센터 API 기반 MCP 서버 - 한국 법령 조회·비교 도구",
   "type": "module",
   "main": "build/index.js",
+  "types": "build/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./build/index.d.ts",
+      "import": "./build/index.js"
+    },
+    "./lib/*": {
+      "types": "./build/lib/*.d.ts",
+      "import": "./build/lib/*.js"
+    },
+    "./tools/*": {
+      "types": "./build/tools/*.d.ts",
+      "import": "./build/tools/*.js"
+    },
+    "./server/*": {
+      "types": "./build/server/*.d.ts",
+      "import": "./build/server/*.js"
+    }
+  },
   "bin": {
     "korean-law-mcp": "build/index.js",
     "korean-law": "build/cli.js"