korean-law-mcp 4.9.2 → 4.9.4

package/build/lib/annex-canonical.d.ts

@@ -0,0 +1,39 @@
+/**
+ * 별표 정본 링크 해석 (#77)
+ *
+ * 법제처 licbyl 검색 인덱스(lawSearch target=licbyl)의 별표 파일링크는 별표 파일
+ * 재업로드를 늦게 반영해 구본(결함본)을 가리킬 수 있다. 실증: 「각급 법원의 설치와
+ * 관할구역에 관한 법률」 별표3 — licbyl 링크는 2026-03-17 개정(인천고등법원 신설
+ * 재편)에서 서울고법 블록의 인천 삭제만 반영되고 인천고법 블록 추가가 누락된
+ * 결함 파일을 가리켰고, 현행 본문(lawService target=law)의 별표단위 링크가 정본.
+ * 개정으로 신설된 별표(별표11 해사국제상사법원)는 licbyl 목록에 아예 없었다.
+ *
+ * 따라서 법령(law) 타입 별표 추출 시 현행 본문의 별표단위 링크를 우선 사용하고,
+ * 조회 실패 시 licbyl 링크로 폴백한다.
+ */
+import type { LawApiClient } from "./api-client.js";
+export interface LawAnnexUnit {
+    /** 별표번호(4) + 가지번호(2) — licbyl 별표번호와 같은 6자리 코드 */
+    code6: string;
+    /** 별표구분: "별표" | "서식" 등 */
+    kind: string;
+    title: string;
+    hwpLink?: string;
+    pdfLink?: string;
+}
+/** lawService(target=law) JSON 응답에서 별표단위 목록 추출 (순수 함수) */
+export declare function parseLawAnnexUnits(jsonText: string): LawAnnexUnit[];
+/**
+ * 별표단위 후보 선택.
+ * code6(licbyl 매칭 항목의 별표번호)이 있으면 그것으로, 없으면 selector 후보 집합으로
+ * 매칭한다. 같은 번호에 별표/서식이 공존하면 kind(licbyl 별표종류) → knd 의도 →
+ * 별표 우선 순으로 고른다.
+ */
+export declare function pickAnnexUnit(units: LawAnnexUnit[], opts: {
+    code6?: string;
+    kind?: string;
+    selectorCandidates?: Set<string>;
+    knd?: string;
+}): LawAnnexUnit | undefined;
+/** 현행 법령 본문에서 별표단위 목록 조회 */
+export declare function fetchLawAnnexUnits(apiClient: LawApiClient, mst: string, apiKey?: string): Promise<LawAnnexUnit[]>;

package/build/lib/annex-canonical.js

@@ -0,0 +1,78 @@
+/**
+ * 별표 정본 링크 해석 (#77)
+ *
+ * 법제처 licbyl 검색 인덱스(lawSearch target=licbyl)의 별표 파일링크는 별표 파일
+ * 재업로드를 늦게 반영해 구본(결함본)을 가리킬 수 있다. 실증: 「각급 법원의 설치와
+ * 관할구역에 관한 법률」 별표3 — licbyl 링크는 2026-03-17 개정(인천고등법원 신설
+ * 재편)에서 서울고법 블록의 인천 삭제만 반영되고 인천고법 블록 추가가 누락된
+ * 결함 파일을 가리켰고, 현행 본문(lawService target=law)의 별표단위 링크가 정본.
+ * 개정으로 신설된 별표(별표11 해사국제상사법원)는 licbyl 목록에 아예 없었다.
+ *
+ * 따라서 법령(law) 타입 별표 추출 시 현행 본문의 별표단위 링크를 우선 사용하고,
+ * 조회 실패 시 licbyl 링크로 폴백한다.
+ */
+/** 링크 필드가 배열(이미지 다페이지 등)로 올 수 있어 첫 값만 취한다 */
+const firstLink = (v) => {
+    const raw = Array.isArray(v) ? v[0] : v;
+    const s = raw == null ? "" : String(raw).trim();
+    return s ? s : undefined;
+};
+/** lawService(target=law) JSON 응답에서 별표단위 목록 추출 (순수 함수) */
+export function parseLawAnnexUnits(jsonText) {
+    let json;
+    try {
+        json = JSON.parse(jsonText);
+    }
+    catch {
+        return [];
+    }
+    const raw = json?.법령?.별표?.별표단위;
+    const units = raw == null ? [] : Array.isArray(raw) ? raw : [raw];
+    return units
+        .map((u) => ({
+        code6: String(u.별표번호 ?? "").trim().padStart(4, "0") +
+            String(u.별표가지번호 ?? "0").trim().padStart(2, "0"),
+        kind: String(u.별표구분 ?? ""),
+        title: String(u.별표제목 ?? ""),
+        hwpLink: firstLink(u.별표서식파일링크),
+        pdfLink: firstLink(u.별표서식PDF파일링크),
+    }))
+        .filter((u) => (u.hwpLink || u.pdfLink) && u.code6 !== "000000");
+}
+/**
+ * 별표단위 후보 선택.
+ * code6(licbyl 매칭 항목의 별표번호)이 있으면 그것으로, 없으면 selector 후보 집합으로
+ * 매칭한다. 같은 번호에 별표/서식이 공존하면 kind(licbyl 별표종류) → knd 의도 →
+ * 별표 우선 순으로 고른다.
+ */
+export function pickAnnexUnit(units, opts) {
+    const code6 = (opts.code6 || "").trim();
+    const candidates = code6
+        ? units.filter((u) => u.code6 === code6)
+        : opts.selectorCandidates
+            ? units.filter((u) => opts.selectorCandidates.has(u.code6))
+            : [];
+    if (candidates.length === 0)
+        return undefined;
+    if (candidates.length === 1)
+        return candidates[0];
+    if (opts.kind) {
+        const same = candidates.find((u) => u.kind === opts.kind);
+        if (same)
+            return same;
+    }
+    const wantForm = opts.knd === "2" || opts.knd === "4";
+    return (candidates.find((u) => (wantForm ? /서식/.test(u.kind) : /별표/.test(u.kind))) ||
+        candidates[0]);
+}
+/** 현행 법령 본문에서 별표단위 목록 조회 */
+export async function fetchLawAnnexUnits(apiClient, mst, apiKey) {
+    const text = await apiClient.fetchApi({
+        endpoint: "lawService.do",
+        target: "law",
+        type: "JSON",
+        extraParams: { MST: mst },
+        apiKey,
+    });
+    return parseLawAnnexUnits(text);
+}

package/build/lib/external-https-proxy.js

@@ -21,10 +21,16 @@ export function getExternalHttpsProxyConfig() {
     const proxyAuthorization = username
         ? `Basic ${Buffer.from(`${username}:${password}`).toString("base64")}`
         : undefined;
+    // TLS 검증 비활성화는 진단용 임시 우회다. 운영(NODE_ENV=production)에서는
+    // 무시하고 항상 검증한다 — 끄면 프록시 구간이 중간자 공격에 무방비가 된다.
+    const disableTls = process.env.LAW_EXTERNAL_TLS_REJECT_UNAUTHORIZED === "0";
+    if (disableTls && process.env.NODE_ENV === "production") {
+        console.error("⚠️  LAW_EXTERNAL_TLS_REJECT_UNAUTHORIZED=0 은 운영 환경에서 무시됩니다 (TLS 검증 유지).");
+    }
     return {
         host: proxyUrl.hostname,
         port: proxyUrl.port ? Number(proxyUrl.port) : 80,
-        rejectUnauthorized: process.env.LAW_EXTERNAL_TLS_REJECT_UNAUTHORIZED !== "0",
+        rejectUnauthorized: !disableTls || process.env.NODE_ENV === "production",
         proxyAuthorization,
     };
 }

package/build/lib/law-antibot.js

@@ -70,9 +70,15 @@ export async function followLawAntibot(response, originalUrl, headers, timeout,
         if (!path)
             return hopped ? current : null;
         // path는 보통 절대경로(/DRF/...). 원본 URL의 origin에 붙인다.
+        // path가 절대 URL이면 base가 무시되므로, 홉 대상이 원본과 같은 호스트인지
+        // 반드시 확인한다 — 아니면 응답 하나로 임의 호스트 요청을 유도할 수 있다.
         let nextUrl;
         try {
-            nextUrl = new URL(path, originalUrl).toString();
+            const parsed = new URL(path, originalUrl);
+            if (parsed.hostname !== new URL(originalUrl).hostname) {
+                return hopped ? current : null;
+            }
+            nextUrl = parsed.toString();
         }
         catch {
             return hopped ? current : null;

package/build/server/http-server.js

@@ -6,11 +6,24 @@
  * 참고: @modelcontextprotocol/sdk/examples/server/simpleStatelessStreamableHttp.js
  */
 import express from "express";
+import { timingSafeEqual } from "node:crypto";
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
 import { requestContext } from "../lib/session-state.js";
 import { maskSensitiveUrl } from "../lib/fetch-with-retry.js";
 import { TOOL_COUNTS } from "../tool-registry.js";
 import { VERSION } from "../version.js";
+/** 타이밍 공격 내성 문자열 비교 (길이가 달라도 throw하지 않음) */
+function safeEqual(a, b) {
+    const bufA = Buffer.from(a);
+    const bufB = Buffer.from(b);
+    if (bufA.length !== bufB.length)
+        return false;
+    return timingSafeEqual(bufA, bufB);
+}
+/** `Authorization: Bearer x` → `x` (Bearer 접두사가 없으면 원문) */
+function bearerValue(raw) {
+    return raw ? raw.replace(/^Bearer\s+/i, "") : "";
+}
 /**
  * 에러 메시지에서 민감 정보(API 키 포함 URL) scrub.
  * MCP 응답/서버 로그 양쪽에 적용되어야 함.
@@ -45,6 +58,80 @@ export async function startHTTPServer(createServer, port) {
             next();
         });
     }
+    // ── Origin 검증 (DNS rebinding 방어) ──────────────────────────────────────
+    // MCP 명세는 로컬/원격 HTTP 트랜스포트에 Origin 검증을 요구한다. 브라우저가 심은
+    // Origin을 그대로 통과시키면, 사용자가 악성 페이지를 여는 것만으로 그 페이지가
+    // 이 서버를 대신 호출하고 응답까지 읽어갈 수 있다(CORS가 '*'면 특히).
+    // 정책: Origin 헤더가 없는 요청(일반 MCP 클라이언트·서버간 호출)은 그대로 통과.
+    //       Origin이 있으면 ALLOWED_ORIGINS 화이트리스트에 있어야 한다.
+    //       CORS_ORIGIN을 명시적으로 설정한 경우 그 값도 허용 목록으로 취급한다.
+    const corsOriginConfigured = process.env.CORS_ORIGIN !== undefined;
+    const corsOrigin = process.env.CORS_ORIGIN || "*";
+    const allowedOrigins = (process.env.ALLOWED_ORIGINS || "")
+        .split(",")
+        .map(o => o.trim())
+        .filter(Boolean);
+    if (!corsOriginConfigured && allowedOrigins.length === 0) {
+        console.error("ℹ️  ALLOWED_ORIGINS 미설정 — Origin 헤더가 붙은 브라우저 요청은 차단됩니다 (DNS rebinding 방어). 웹 클라이언트를 쓰려면 ALLOWED_ORIGINS를 설정하세요.");
+    }
+    /** 이 Origin을 허용할지 판정. 반환값은 응답에 실을 ACAO 값(null이면 거부) */
+    function resolveOrigin(origin) {
+        if (!origin)
+            return corsOrigin; // 브라우저가 아닌 클라이언트
+        if (allowedOrigins.includes(origin))
+            return origin;
+        if (allowedOrigins.length === 0 && corsOriginConfigured) {
+            if (corsOrigin === "*")
+                return "*";
+            if (corsOrigin === origin)
+                return origin;
+        }
+        return null;
+    }
+    app.use((req, res, next) => {
+        if (req.path === "/health" || req.path === "/")
+            return next();
+        const origin = req.headers.origin;
+        const allowed = resolveOrigin(origin);
+        if (allowed === null) {
+            res.status(403).json({
+                jsonrpc: "2.0",
+                error: { code: -32000, message: "Origin not allowed." },
+                id: null,
+            });
+            return;
+        }
+        res.header("Access-Control-Allow-Origin", allowed);
+        if (allowed !== "*")
+            res.header("Vary", "Origin");
+        next();
+    });
+    // ── 접근 인증 (MCP_AUTH_TOKEN 설정 시에만 활성) ────────────────────────────
+    // 폐쇄망·사내망 배포처럼 서버 자체에 접근 통제가 필요한 환경에서 설정한다.
+    // 미설정이면 기존처럼 공개 동작 (법제처 API 키는 인가 수단이 아니다).
+    const authToken = process.env.MCP_AUTH_TOKEN || "";
+    if (!authToken) {
+        console.error("⚠️  MCP_AUTH_TOKEN 미설정 — /mcp 엔드포인트에 접근 인증이 없습니다. 폐쇄망/사내 배포에서는 반드시 설정하세요.");
+    }
+    app.use((req, res, next) => {
+        if (!authToken)
+            return next();
+        if (req.method === "OPTIONS")
+            return next(); // 프리플라이트는 인증 헤더를 못 싣는다
+        if (req.path === "/health" || req.path === "/")
+            return next();
+        const presented = req.headers["x-mcp-token"] ||
+            bearerValue(req.headers["authorization"]);
+        if (!presented || !safeEqual(presented, authToken)) {
+            res.status(401).json({
+                jsonrpc: "2.0",
+                error: { code: -32001, message: "Unauthorized." },
+                id: null,
+            });
+            return;
+        }
+        next();
+    });
     app.use(express.json({ limit: process.env.MCP_BODY_LIMIT || "100kb" }));
     // Rate Limiting (RATE_LIMIT_RPM 환경변수, 기본: 60 req/min per IP)
     const rateLimitRpm = parseInt(process.env.RATE_LIMIT_RPM || "60", 10);
@@ -93,15 +180,10 @@ export async function startHTTPServer(createServer, port) {
             }
         }, 5 * 60 * 1000).unref();
     }
-    // CORS 및 보안 헤더 설정 (CORS_ORIGIN 미설정 시 경고)
-    const corsOrigin = process.env.CORS_ORIGIN || "*";
-    if (corsOrigin === "*") {
-        console.error("⚠️  CORS_ORIGIN 미설정 — 모든 도메인 허용 중. 프로덕션에서는 CORS_ORIGIN 환경변수를 설정하세요.");
-    }
+    // 보안 헤더 (Access-Control-Allow-Origin은 위 Origin 검증 미들웨어가 설정)
     app.use((req, res, next) => {
-        res.header("Access-Control-Allow-Origin", corsOrigin);
         res.header("Access-Control-Allow-Methods", "GET, POST, DELETE, OPTIONS");
-        res.header("Access-Control-Allow-Headers", "Content-Type, mcp-session-id, last-event-id");
+        res.header("Access-Control-Allow-Headers", "Content-Type, mcp-session-id, last-event-id, apikey, x-api-key, x-mcp-token, authorization");
         res.header("X-Content-Type-Options", "nosniff");
         res.header("X-Frame-Options", "DENY");
         res.header("Referrer-Policy", "strict-origin-when-cross-origin");
@@ -152,14 +234,19 @@ export async function startHTTPServer(createServer, port) {
     // POST /mcp - stateless 요청 처리
     app.post("/mcp", async (req, res) => {
         // Extract API key: header > URL query
-        // 쿼리스트링 키는 프록시/엣지 액세스 로그에 평문으로 남으므로 헤더 사용 권장 (하위호환용 유지)
+        // 쿼리스트링 키는 프록시/엣지 액세스 로그에 평문으로 남으므로 헤더 사용 권장.
+        // ALLOW_QUERY_API_KEY=0 으로 쿼리 경로를 차단할 수 있다 (폐쇄망 권장).
+        // 인증이 켜진 경우 Authorization 헤더는 접근 토큰이므로 법제처 키로 오인하면 안 된다.
+        const authHeader = bearerValue(req.headers["authorization"]);
+        const authHeaderIsAccessToken = Boolean(authToken) && authHeader && safeEqual(authHeader, authToken);
+        const queryKey = process.env.ALLOW_QUERY_API_KEY === "0" ? undefined : req.query.oc;
         const apiKey = req.headers["apikey"] ||
             req.headers["law_oc"] ||
             req.headers["law-oc"] ||
             req.headers["x-api-key"] ||
-            req.headers["authorization"]?.replace(/^Bearer\s+/i, "") ||
+            (authHeaderIsAccessToken ? undefined : authHeader || undefined) ||
             req.headers["x-law-oc"] ||
-            req.query.oc;
+            queryKey;
         // 자체 키 없는 요청은 서버 LAW_OC로 폴백 — 전역 상한 적용
         // initialize/tools/list 등 핸드셰이크는 법제처 쿼터를 안 쓰므로 tools/call만 게이트
         // (핸드셰이크까지 429로 막으면 claude.ai 커넥터가 도구 목록 자체를 못 싣는다)
@@ -230,6 +317,23 @@ export async function startHTTPServer(createServer, port) {
             id: null
         });
     });
+    // 최종 에러 핸들러 — Express 기본 핸들러는 스택 트레이스와 설치 경로를 그대로
+    // 본문에 실어 보낸다(NODE_ENV 미설정 시). body-parser의 413/400도 여기로 온다.
+    app.use((err, _req, res, _next) => {
+        const status = typeof err?.status === "number" ? err.status : 500;
+        const scrubbed = scrubError(err);
+        console.error(`[express] ${status} ${scrubbed.message}`);
+        if (res.headersSent)
+            return;
+        res.status(status).json({
+            jsonrpc: "2.0",
+            error: {
+                code: status === 413 ? -32600 : -32603,
+                message: status === 413 ? "Request entity too large." : "Internal server error",
+            },
+            id: null,
+        });
+    });
     // 서버 시작 (0.0.0.0으로 바인딩하여 외부 접속 허용)
     const expressServer = app.listen(port, "0.0.0.0", () => {
         console.error(`✓ Korean Law MCP server (HTTP stateless) listening on port ${port}`);

package/build/setup.js

@@ -5,7 +5,7 @@
  * API 키를 입력받고, 선택한 AI 클라이언트 설정 파일에 MCP 서버를 자동 등록합니다.
  */
 import { createInterface } from "node:readline/promises";
-import { readFile, writeFile, mkdir } from "node:fs/promises";
+import { readFile, writeFile, mkdir, chmod } from "node:fs/promises";
 import { existsSync } from "node:fs";
 import { resolve, dirname } from "node:path";
 import { homedir, platform } from "node:os";
@@ -87,7 +87,13 @@ async function writeJsonFile(path, data) {
     if (!existsSync(dir)) {
         await mkdir(dir, { recursive: true });
     }
-    await writeFile(path, JSON.stringify(data, null, 2) + "\n", "utf-8");
+    // 설정 파일에는 LAW_OC가 평문으로 들어간다 → 소유자만 읽도록 제한.
+    // mode 옵션은 새로 만들 때만 먹으므로, 기존 파일에는 chmod로 다시 적용한다.
+    await writeFile(path, JSON.stringify(data, null, 2) + "\n", { encoding: "utf-8", mode: 0o600 });
+    try {
+        await chmod(path, 0o600);
+    }
+    catch { /* 권한 변경 실패는 설치를 막지 않는다 (Windows 등) */ }
 }
 function buildServerEntry(apiKey, lawApiProtocol = getLawApiProtocol()) {
     const env = {};

package/build/tools/annex.js

@@ -7,6 +7,7 @@ import { parseAnnexFile } from "../lib/annex-file-parser.js";
 import { truncateResponse, MAX_RESPONSE_SIZE } from "../lib/schemas.js";
 import { formatToolError, notFoundResponse } from "../lib/errors.js";
 import { getLawSiteBaseUrl } from "../lib/law-url-config.js";
+import { fetchLawAnnexUnits, pickAnnexUnit } from "../lib/annex-canonical.js";
 const LAW_BASE_URL = getLawSiteBaseUrl();
 export const GetAnnexesSchema = z.object({
     lawName: z.string().describe("법령명 (예: '관세법'). 별표를 바로 지정하려면 '... 별표4' 또는 '... 별표1의2'처럼 함께 입력 가능"),
@@ -113,7 +114,7 @@ export async function getAnnexes(apiClient, input) {
         const filtered = filterByRelatedLawName(annexList, normalizedLawName);
         // 별표 선택값 지정 시 → 해당 별표 파일 다운로드 + 텍스트 추출
         if (annexSelector) {
-            return await extractAnnexContent(filtered, annexSelector, normalizedLawName, input.knd);
+            return await extractAnnexContent(apiClient, filtered, annexSelector, normalizedLawName, lawType, input);
         }
         // 별표 선택값 미지정 → 기존 목록 반환
         return formatAnnexList(filtered, lawType, input, normalizedLawName);
@@ -123,9 +124,39 @@ export async function getAnnexes(apiClient, input) {
     }
 }
 // ─── 별표 텍스트 추출 ─────────────────────────────────
-async function extractAnnexContent(annexList, annexSelector, normalizedLawName, knd) {
+async function extractAnnexContent(apiClient, annexList, annexSelector, normalizedLawName, lawType, input) {
+    const knd = input.knd;
     // bylSeq / annexNo / lawName 내 힌트로 유연 매칭 (별표/서식 구분 위해 knd 전달)
-    const matched = findMatchingAnnex(annexList, annexSelector, knd);
+    let matched = findMatchingAnnex(annexList, annexSelector, knd);
+    // 법령은 현행 본문(lawService)의 별표단위 링크를 정본으로 우선 사용 (#77 — licbyl
+    // 인덱스가 구본/결함 파일을 가리키거나 신설 별표를 누락하는 사례). 실패 시 licbyl 폴백.
+    if (lawType === "law") {
+        const mst = matched?.관련법령일련번호 || annexList[0]?.관련법령일련번호;
+        if (mst) {
+            try {
+                const units = await fetchLawAnnexUnits(apiClient, String(mst), input.apiKey);
+                const unit = pickAnnexUnit(units, {
+                    code6: matched?.별표번호 ? String(matched.별표번호).trim() : undefined,
+                    kind: matched?.별표종류 ? String(matched.별표종류) : undefined,
+                    selectorCandidates: matched ? undefined : buildSelectorCandidates(annexSelector),
+                    knd,
+                });
+                if (unit) {
+                    matched = {
+                        ...(matched ?? {}),
+                        별표번호: matched?.별표번호 || unit.code6,
+                        별표명: matched?.별표명 || unit.title,
+                        별표종류: matched?.별표종류 || unit.kind,
+                        별표서식파일링크: unit.hwpLink || matched?.별표서식파일링크,
+                        별표서식PDF파일링크: unit.pdfLink || matched?.별표서식PDF파일링크,
+                    };
+                }
+            }
+            catch {
+                // 정본 조회 실패 → licbyl 링크로 진행
+            }
+        }
+    }
     if (!matched) {
         const availableBylSeq = annexList.map((a) => a.별표번호).filter(Boolean).slice(0, 20).join(", ");
         return notFoundResponse(`별표 선택값 "${annexSelector}"에 해당하는 항목을 찾을 수 없습니다. (법령: ${normalizedLawName})`, [

package/build/tools/precedents.js

@@ -261,10 +261,17 @@ async function fetchManualRedirect(url, proxyConfig) {
         location: response.headers.get("location"),
     };
 }
+/** 판례 본문 fallback 경로에서 따라가도 되는 호스트 (법제처·국세청만) */
+function isAllowedFallbackHost(hostname) {
+    return /(^|\.)law\.go\.kr$/i.test(hostname) || /(^|\.)nts\.go\.kr$/i.test(hostname);
+}
 async function resolveTaxlawDetailUrl(iframeUrl) {
     let currentUrl = iframeUrl;
     const proxyConfig = getExternalHttpsProxyConfig();
     for (let redirectCount = 0; redirectCount < 3; redirectCount++) {
+        if (!isAllowedFallbackHost(new URL(currentUrl).hostname)) {
+            throw new Error("precedent fallback redirect target is not an allowed host");
+        }
         const iframeResponse = await fetchManualRedirect(currentUrl, proxyConfig);
         const location = iframeResponse.location;
         if (!location) {
@@ -272,6 +279,9 @@ async function resolveTaxlawDetailUrl(iframeUrl) {
         }
         const nextUrl = normalizeUrl(location, currentUrl);
         const parsedNextUrl = new URL(nextUrl);
+        if (!isAllowedFallbackHost(parsedNextUrl.hostname)) {
+            throw new Error("precedent fallback redirect target is not an allowed host");
+        }
         if (parsedNextUrl.searchParams.get("ntstDcmId")) {
             return nextUrl;
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "korean-law-mcp",
-  "version": "4.9.2",
+  "version": "4.9.4",
   "description": "법제처 42개 API → 9개 MCP 도구. 법령·판례·조례·조약 + 다단계 리서치(legal_research, 8 task) + 정밀분석(legal_analysis: 인용검증·판례생사·행위시법·영향그래프) + 시점 비교(time_travel) + 상황별 5단계 안내(action_plan) + 국세청 해석례(nts)",
   "type": "module",
   "main": "build/index.js",
@@ -60,7 +60,7 @@
     "commander": "^14.0.3",
     "dotenv": "^17.3.1",
     "express": "^5.2.1",
-    "kordoc": "^4.2.0",
+    "kordoc": "^4.5.0",
     "pdfjs-dist": "^5.5.207",
     "zod": "^4.0.0"
   },
@@ -73,7 +73,10 @@
     "vitest": "^4.1.9"
   },
   "overrides": {
-    "hono": "^4.12.29"
+    "hono": "^4.12.29",
+    "sharp": "^0.35.3",
+    "adm-zip": "^0.6.0",
+    "onnxruntime-node": "^1.27.0"
   },
   "files": [
     "build",