@yoonion/mimi-seed-mcp 0.21.1 → 0.21.2

package/README.md

@@ -128,7 +128,7 @@ export ANTHROPIC_API_KEY=sk-ant-...
 ---
 
 <!-- generated:readme-tools-heading:start — edit scripts/docs-spec.mjs, then npm run plugin:sync -->
-## 제공 도구 (150+ 개 · 22개 영역)
+## 제공 도구 (150+ 개 · 23개 영역)
 <!-- generated:readme-tools-heading:end -->
 
 <!-- generated:readme-tools-table:start — edit scripts/docs-spec.mjs, then npm run plugin:sync -->
@@ -142,6 +142,7 @@ export ANTHROPIC_API_KEY=sk-ant-...
 | Jenkins (크리덴셜 + 잡 + 빌드) | 13 | `jenkins_create_credential` / `jenkins_upload_keystore` / `jenkins_create_job` / `jenkins_update_job` / `jenkins_trigger_build` |
 | GA4 (Google Analytics 4) | 8 | `ga4_create_property` / `ga4_create_data_stream` / `ga4_plan_bigquery_link` / `ga4_create_bigquery_link` / `ga4_run_report` |
 | Search Console | 6 | `gsc_inspect_url` / `gsc_search_analytics` / `gsc_submit_sitemap` |
+| 네이버 서치어드바이저 | 2 | `naver_check_page` / `naver_indexnow_submit` |
 | Google Ads | 6 | `googleads_list_campaigns` / `googleads_get_uac_report` / `googleads_get_campaign_report` |
 | Facebook | 6 | `facebook_post_photo` / `facebook_post_multi_photo` / `facebook_list_pages` |
 | Google Cloud IAM | 5 | `iam_create_service_account` / `iam_create_key` / `iam_add_iam_policy_binding` |

package/assets/agent-guide.md

@@ -78,7 +78,7 @@ row for the job; batching two rows in one `select:` call is fine.
 | App Store weekly growth insight | `select:appstore_get_weekly_insight,appstore_get_sales_report` |
 | AdMob | `select:admob_list_accounts,admob_list_apps,admob_create_app,admob_create_ad_unit,admob_list_ad_units,admob_get_today_earnings,admob_get_report` |
 | Google Ads (UAC) | `select:googleads_config_status,googleads_save_config,googleads_list_accessible_customers,googleads_list_campaigns,googleads_get_campaign_report,googleads_get_uac_report` |
-| Search Console | `select:gsc_list_sites,gsc_list_sitemaps,gsc_get_sitemap,gsc_submit_sitemap,gsc_inspect_url,gsc_search_analytics` |
+| Search indexing (Search Console / Naver) | `select:gsc_list_sites,gsc_list_sitemaps,gsc_get_sitemap,gsc_submit_sitemap,gsc_inspect_url,gsc_search_analytics,naver_check_page,naver_indexnow_submit` |
 | Social posting (Facebook / Instagram / Threads) | `select:facebook_current_config,facebook_save_config,facebook_list_pages,facebook_get_page,facebook_post_photo,facebook_post_multi_photo,instagram_save_config,instagram_get_account,instagram_post_image,instagram_post_carousel,threads_current_config,threads_save_config,threads_refresh_token,threads_get_account,threads_post,threads_post_video,threads_post_carousel` |
 | TikTok Business video publish | `select:tiktok_business_auth_status,tiktok_business_get_account,tiktok_business_get_video_settings,tiktok_business_plan_video_post,tiktok_business_publish_video,tiktok_business_get_publish_status,tiktok_business_list_publish_audits` |
 | Jenkins credentials + jobs | `select:jenkins_status,jenkins_save_config,jenkins_list_credentials,jenkins_create_credential,jenkins_delete_credential,jenkins_upload_keystore,jenkins_upload_playstore_sa,jenkins_list_jobs,jenkins_get_job_config,jenkins_create_job,jenkins_update_job` |

package/dist/lib/tool-registrar.js

@@ -44,6 +44,7 @@ const BRAND_PREFIXES = [
     ['bigquery_', 'BigQuery'],
     ['ga4_', 'GA4'],
     ['gsc_', 'Search Console'],
+    ['naver_', 'Naver'],
     ['googleads_', 'Google Ads'],
     ['facebook_', 'Facebook'],
     ['instagram_', 'Instagram'],
@@ -55,7 +56,7 @@ const BRAND_PREFIXES = [
     ['android_', 'Android'],
 ];
 const WORD_CASE = {
-    iap: 'IAP', ios: 'iOS', sa: 'SA', url: 'URL', uac: 'UAC', ai: 'AI', iam: 'IAM', ga4: 'GA4',
+    iap: 'IAP', ios: 'iOS', sa: 'SA', url: 'URL', uac: 'UAC', ai: 'AI', iam: 'IAM', ga4: 'GA4', indexnow: 'IndexNow',
     playstore: 'Play Store', appstore: 'App Store', bigquery: 'BigQuery', youtube: 'YouTube',
 };
 /** `playstore_submit_release` → `Play Store: Submit release`. */

package/dist/naver/robots.d.ts

@@ -0,0 +1,44 @@
+/**
+ * robots.txt 해석 (RFC 9309) — 네이버 검색로봇(Yeti)이 한 경로를 긁을 수 있는지 판정한다.
+ *
+ * 순수 함수만 둔다(네트워크 없음). 판정 규칙:
+ *  - 크롤러 토큰과 같은 `User-agent` 그룹이 있으면 그 그룹(여러 개면 합친다)만, 없으면 `*` 그룹을 쓴다.
+ *    `Yeti` 그룹이 따로 있으면 `*` 의 규칙은 Yeti 에게 **적용되지 않는다** — 흔한 오해다.
+ *    `User-agent: Yeti/1.1` 처럼 버전이 붙어도 제품 토큰(`[A-Za-z_-]+`)만 비교한다.
+ *  - 규칙은 가장 긴 패턴이 이기고, 길이가 같으면 allow 가 이긴다. `*` 와 닫는 `$` 를 지원한다.
+ *  - 값이 빈 `Disallow:` 는 규칙이 아니다(전부 허용).
+ *  - 비교 전에 패턴과 경로를 같은 퍼센트 인코딩으로 맞춘다 — `Disallow: /블로그` 는 `/%EB%B8%94…` 를 막는다.
+ *
+ * 매칭은 정규식이 아니라 선형 와일드카드 매처다. robots.txt 는 **점검 대상 사이트가 쓴 입력**이라
+ * `/*a*a*a…b` 같은 패턴으로 정규식 백트래킹을 폭발시켜 stdio 서버 전체를 멈출 수 있다.
+ */
+export declare const NAVER_CRAWLER_TOKEN = "yeti";
+export interface RobotsRule {
+    allow: boolean;
+    pattern: string;
+}
+export interface RobotsGroup {
+    agents: string[];
+    rules: RobotsRule[];
+}
+export interface ParsedRobots {
+    groups: RobotsGroup[];
+    sitemaps: string[];
+}
+export interface RobotsVerdict {
+    allowed: boolean;
+    /** 판정에 쓴 그룹 — 'yeti' 전용, '*', 또는 해당 그룹 없음. */
+    group: 'crawler' | 'wildcard' | 'none';
+    /** 판정을 결정한 규칙. 없으면 기본 허용. */
+    matchedRule?: RobotsRule;
+}
+export declare function parseRobots(text: string): ParsedRobots;
+/** 비ASCII 는 UTF-8 퍼센트 인코딩, 기존 `%xx` 는 대문자 16진수로 — 패턴과 경로를 같은 표기로 맞춘다. */
+export declare function normalizeRobotsPath(value: string): string;
+/**
+ * `*`(0자 이상)와 닫는 `$`(끝 고정)만 있는 와일드카드 매칭. 앞쪽은 항상 고정(접두어 매칭).
+ * 투 포인터 백트래킹이라 최악 O(패턴 × 경로) — 정규식처럼 지수적으로 터지지 않는다.
+ */
+export declare function robotsPatternMatches(pattern: string, path: string): boolean;
+/** `path` 는 경로 + 쿼리(`/a?b=1`). 크롤러 토큰은 소문자로 비교한다. */
+export declare function isAllowed(robots: ParsedRobots, path: string, crawler?: string): RobotsVerdict;

package/dist/naver/robots.js

@@ -0,0 +1,126 @@
+/**
+ * robots.txt 해석 (RFC 9309) — 네이버 검색로봇(Yeti)이 한 경로를 긁을 수 있는지 판정한다.
+ *
+ * 순수 함수만 둔다(네트워크 없음). 판정 규칙:
+ *  - 크롤러 토큰과 같은 `User-agent` 그룹이 있으면 그 그룹(여러 개면 합친다)만, 없으면 `*` 그룹을 쓴다.
+ *    `Yeti` 그룹이 따로 있으면 `*` 의 규칙은 Yeti 에게 **적용되지 않는다** — 흔한 오해다.
+ *    `User-agent: Yeti/1.1` 처럼 버전이 붙어도 제품 토큰(`[A-Za-z_-]+`)만 비교한다.
+ *  - 규칙은 가장 긴 패턴이 이기고, 길이가 같으면 allow 가 이긴다. `*` 와 닫는 `$` 를 지원한다.
+ *  - 값이 빈 `Disallow:` 는 규칙이 아니다(전부 허용).
+ *  - 비교 전에 패턴과 경로를 같은 퍼센트 인코딩으로 맞춘다 — `Disallow: /블로그` 는 `/%EB%B8%94…` 를 막는다.
+ *
+ * 매칭은 정규식이 아니라 선형 와일드카드 매처다. robots.txt 는 **점검 대상 사이트가 쓴 입력**이라
+ * `/*a*a*a…b` 같은 패턴으로 정규식 백트래킹을 폭발시켜 stdio 서버 전체를 멈출 수 있다.
+ */
+export const NAVER_CRAWLER_TOKEN = 'yeti';
+/** `Yeti/1.1 (+…)` → `yeti`. `*` 는 그대로. */
+function agentToken(value) {
+    if (value.startsWith('*'))
+        return '*';
+    return (/^[a-z_-]+/i.exec(value)?.[0] ?? value).toLowerCase();
+}
+export function parseRobots(text) {
+    const groups = [];
+    const sitemaps = [];
+    let current = null;
+    // 연속된 User-agent 줄은 한 그룹을 공유한다. 규칙이 나온 뒤의 User-agent 는 새 그룹.
+    let collectingAgents = false;
+    for (const raw of (text.charCodeAt(0) === 0xfeff ? text.slice(1) : text).split(/\r\n|\r|\n/)) {
+        const hash = raw.indexOf('#');
+        const line = (hash === -1 ? raw : raw.slice(0, hash)).trim();
+        const sep = line.indexOf(':');
+        if (sep <= 0)
+            continue;
+        const field = line.slice(0, sep).trim().toLowerCase();
+        const value = line.slice(sep + 1).trim();
+        if (field === 'sitemap') {
+            if (value)
+                sitemaps.push(value);
+            continue;
+        }
+        if (field === 'user-agent') {
+            if (!current || !collectingAgents) {
+                current = { agents: [], rules: [] };
+                groups.push(current);
+            }
+            current.agents.push(agentToken(value));
+            collectingAgents = true;
+            continue;
+        }
+        if (field === 'allow' || field === 'disallow') {
+            collectingAgents = false;
+            if (!current || !value)
+                continue; // 그룹 밖 규칙, 빈 Disallow 는 무시
+            current.rules.push({ allow: field === 'allow', pattern: value });
+        }
+    }
+    return { groups, sitemaps };
+}
+/** 비ASCII 는 UTF-8 퍼센트 인코딩, 기존 `%xx` 는 대문자 16진수로 — 패턴과 경로를 같은 표기로 맞춘다. */
+export function normalizeRobotsPath(value) {
+    return value
+        .replace(/%[0-9a-f]{2}/gi, (m) => m.toUpperCase())
+        .replace(/[\u0080-￿]+/g, (chunk) => {
+        try {
+            return encodeURIComponent(chunk);
+        }
+        catch {
+            return chunk; // 짝 없는 서로게이트 — 그대로 둔다
+        }
+    });
+}
+/**
+ * `*`(0자 이상)와 닫는 `$`(끝 고정)만 있는 와일드카드 매칭. 앞쪽은 항상 고정(접두어 매칭).
+ * 투 포인터 백트래킹이라 최악 O(패턴 × 경로) — 정규식처럼 지수적으로 터지지 않는다.
+ */
+export function robotsPatternMatches(pattern, path) {
+    const anchored = pattern.endsWith('$');
+    // `$` 가 없으면 접두어 매칭 = 끝에 `*` 가 붙은 것과 같다.
+    const p = anchored ? pattern.slice(0, -1) : `${pattern}*`;
+    let i = 0;
+    let j = 0;
+    let star = -1;
+    let mark = 0;
+    while (i < path.length) {
+        if (j < p.length && p[j] === '*') {
+            star = j++;
+            mark = i;
+        }
+        else if (j < p.length && p[j] === path[i]) {
+            i++;
+            j++;
+        }
+        else if (star !== -1) {
+            j = star + 1;
+            i = ++mark;
+        }
+        else {
+            return false;
+        }
+    }
+    while (j < p.length && p[j] === '*')
+        j++;
+    return j === p.length;
+}
+/** `path` 는 경로 + 쿼리(`/a?b=1`). 크롤러 토큰은 소문자로 비교한다. */
+export function isAllowed(robots, path, crawler = NAVER_CRAWLER_TOKEN) {
+    const token = crawler.toLowerCase();
+    const own = robots.groups.filter((g) => g.agents.includes(token));
+    const wildcard = robots.groups.filter((g) => g.agents.includes('*'));
+    const [groups, group] = own.length > 0
+        ? [own, 'crawler']
+        : wildcard.length > 0 ? [wildcard, 'wildcard'] : [[], 'none'];
+    const target = normalizeRobotsPath(path);
+    let best;
+    let bestLength = -1;
+    for (const rule of groups.flatMap((g) => g.rules)) {
+        const pattern = normalizeRobotsPath(rule.pattern);
+        if (!robotsPatternMatches(pattern, target))
+            continue;
+        if (pattern.length > bestLength || (pattern.length === bestLength && rule.allow && !best?.allow)) {
+            best = rule;
+            bestLength = pattern.length;
+        }
+    }
+    return { allowed: best ? best.allow : true, group, ...(best ? { matchedRule: best } : {}) };
+}

package/dist/naver/tools.d.ts

@@ -0,0 +1,127 @@
+import { type RobotsVerdict } from './robots.js';
+/**
+ * 네이버 서치어드바이저 — 검색 노출·색인 도구.
+ *
+ * 서치어드바이저에는 **공개 웹마스터 API 가 없다**(사이트 등록·사이트맵/RSS 제출·리포트는 콘솔 전용).
+ * 자동화할 수 있는 면은 두 가지뿐이라 그것만 다룬다:
+ *  - IndexNow: 네이버가 참여 엔진이다. 새/수정/삭제 URL 을 즉시 알린다. 인증 = 사이트에 올린 키 파일.
+ *  - 크롤러 관점 점검: 네이버 검색로봇(Yeti)이 보는 robots.txt·상태 코드·리다이렉트·메타 태그를 확인한다.
+ * 어느 쪽도 `~/.mimi-seed/` 자격증명을 쓰지 않는다.
+ *
+ * 점검 대상 사이트의 응답(HTML·robots.txt·헤더)은 **적대적 입력**으로 다룬다: 본문은 상한까지만 읽고,
+ * 파싱은 선형 스캔으로만 한다. 정규식 백트래킹이나 무한 버퍼링 한 번이면 stdio 서버 전체가 멈춘다.
+ */
+/** 네이버가 공개한 검색로봇 User-Agent. UA 로 봇을 막는 서버를 잡아내려고 그대로 보낸다. */
+export declare const YETI_USER_AGENT = "Mozilla/5.0 (compatible; Yeti/1.1; +https://naver.me/spd)";
+/** indexnow.org/searchengines.json 에 등록된 네이버 엔드포인트. */
+export declare const NAVER_INDEXNOW_ENDPOINT = "https://searchadvisor.naver.com/indexnow";
+/** IndexNow 프로토콜: POST 1회 최대 URL 수. */
+export declare const INDEXNOW_MAX_URLS = 10000;
+/** IndexNow 프로토콜: 8–128자, 영문·숫자·대시. */
+export declare const INDEXNOW_KEY_PATTERN: RegExp;
+/** RFC 9309: 크롤러는 robots.txt 를 최소 500 KiB 까지 해석해야 한다. 그 이상은 버린다. */
+export declare const ROBOTS_MAX_BYTES: number;
+/** HTML 은 이만큼만 읽는다 — head·본문 추정에는 충분하고 메모리는 묶인다. */
+export declare const HTML_MAX_BYTES: number;
+/**
+ * 응답 본문을 `maxBytes` 까지만 읽고 나머지는 끊는다. 인코딩은 content-type 의 charset
+ * (EUC-KR 등 레거시 한국어 페이지 포함), 모르면 UTF-8. BOM 은 TextDecoder 가 벗긴다.
+ */
+export declare function readCapped(res: Response, maxBytes: number): Promise<{
+    text: string;
+    truncated: boolean;
+}>;
+export interface PageHead {
+    title?: string;
+    description?: string;
+    canonical?: string;
+    /** `<base href>` — 상대 canonical 을 풀 때 쓴다. */
+    base?: string;
+    lang?: string;
+    og: {
+        title?: string;
+        description?: string;
+        image?: string;
+        url?: string;
+    };
+    /** `<meta name="robots">` 와 `<meta name="yeti">` 의 지시어(소문자). */
+    robots: string[];
+    naverSiteVerification: boolean;
+    /** script/style 을 뺀 원본 HTML 의 보이는 글자 수. */
+    textLength: number;
+    scriptCount: number;
+}
+export declare function decodeEntities(value: string): string;
+/** 속성 문자열 파서. HTML 처럼 같은 이름은 **처음 것**이 이긴다. */
+export declare function parseAttrs(src: string): Record<string, string>;
+export declare function parseHead(html: string): PageHead;
+export interface XRobots {
+    /** 이 크롤러에 확실히 적용되는 지시어. */
+    applies: string[];
+    /**
+     * 다른 봇 접두어(`googlebot: …`) 뒤에 콤마로 이어진 지시어. 같은 헤더의 연속이면 그 봇 전용이지만,
+     * 헤더가 여러 개면 fetch 가 `, ` 로 합쳐 버려 **접두어 없는 별도 헤더**였을 수도 있다 — 구분할 수 없다.
+     */
+    ambiguous: string[];
+}
+/**
+ * `X-Robots-Tag` 에서 이 크롤러에 적용되는 지시어를 뽑는다.
+ * UA 접두어가 없는 지시어는 모두에게, `yeti: …` 는 Yeti 에게, `googlebot: …` 은 건너뛴다.
+ */
+export declare function xRobotsDirectives(header: string | null, crawler?: string): XRobots;
+/** HTTP `Link: <…>; rel="canonical"` 헤더의 대상. */
+export declare function linkHeaderCanonical(header: string | null): string | undefined;
+export type IssueLevel = 'error' | 'warn' | 'info';
+export interface PageIssue {
+    level: IssueLevel;
+    code: string;
+    message: string;
+}
+export interface RedirectHop {
+    url: string;
+    status: number;
+    location: string;
+}
+export interface PageCheck {
+    url: string;
+    finalUrl: string;
+    status: number;
+    contentType: string | null;
+    redirects: RedirectHop[];
+    robotsTxt: {
+        url: string;
+        status: number | null;
+        verdict: RobotsVerdict | null;
+        sitemaps: string[];
+    };
+    directives: {
+        meta: string[];
+        header: string[];
+        headerAmbiguous: string[];
+    };
+    head: PageHead | null;
+    issues: PageIssue[];
+    summary: Record<IssueLevel, number>;
+}
+/** 네이버 검색로봇(Yeti) 관점에서 URL 1개를 점검한다. 쓰기 없음. */
+export declare function checkPage(input: string): Promise<PageCheck>;
+export interface IndexNowInput {
+    urls: string[];
+    key: string;
+    /** 키 파일이 사이트 루트(`/<key>.txt`)가 아닐 때만. */
+    keyLocation?: string;
+}
+export interface IndexNowResult {
+    endpoint: string;
+    status: number;
+    host: string;
+    keyLocation: string;
+    submitted: number;
+}
+/**
+ * 네이버 IndexNow 로 URL 변경을 알린다.
+ *
+ * 보내기 전에 키 파일을 직접 받아 key 와 같은지 확인한다 — 틀린 키는 엔드포인트가 403 만 돌려주고,
+ * 같은 호스트에 틀린 키로 반복 제출하면 스팸 판정 위험만 커진다. 같은 URL 재제출은 안전하다.
+ */
+export declare function submitIndexNow({ urls, key, keyLocation }: IndexNowInput): Promise<IndexNowResult>;

package/dist/naver/tools.js

@@ -0,0 +1,612 @@
+import { fetchWithTimeout } from '../lib/http.js';
+import { encodePathSegment } from '../lib/url-path.js';
+import { isAllowed, parseRobots } from './robots.js';
+/**
+ * 네이버 서치어드바이저 — 검색 노출·색인 도구.
+ *
+ * 서치어드바이저에는 **공개 웹마스터 API 가 없다**(사이트 등록·사이트맵/RSS 제출·리포트는 콘솔 전용).
+ * 자동화할 수 있는 면은 두 가지뿐이라 그것만 다룬다:
+ *  - IndexNow: 네이버가 참여 엔진이다. 새/수정/삭제 URL 을 즉시 알린다. 인증 = 사이트에 올린 키 파일.
+ *  - 크롤러 관점 점검: 네이버 검색로봇(Yeti)이 보는 robots.txt·상태 코드·리다이렉트·메타 태그를 확인한다.
+ * 어느 쪽도 `~/.mimi-seed/` 자격증명을 쓰지 않는다.
+ *
+ * 점검 대상 사이트의 응답(HTML·robots.txt·헤더)은 **적대적 입력**으로 다룬다: 본문은 상한까지만 읽고,
+ * 파싱은 선형 스캔으로만 한다. 정규식 백트래킹이나 무한 버퍼링 한 번이면 stdio 서버 전체가 멈춘다.
+ */
+/** 네이버가 공개한 검색로봇 User-Agent. UA 로 봇을 막는 서버를 잡아내려고 그대로 보낸다. */
+export const YETI_USER_AGENT = 'Mozilla/5.0 (compatible; Yeti/1.1; +https://naver.me/spd)';
+/** Yeti UA 가 거절됐을 때 "UA 차단인가"를 가르는 비교용 브라우저 UA. */
+const BROWSER_USER_AGENT = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0 Safari/537.36';
+/** indexnow.org/searchengines.json 에 등록된 네이버 엔드포인트. */
+export const NAVER_INDEXNOW_ENDPOINT = 'https://searchadvisor.naver.com/indexnow';
+/** IndexNow 프로토콜: POST 1회 최대 URL 수. */
+export const INDEXNOW_MAX_URLS = 10_000;
+/** IndexNow 프로토콜: 8–128자, 영문·숫자·대시. */
+export const INDEXNOW_KEY_PATTERN = /^[A-Za-z0-9-]{8,128}$/;
+const MAX_REDIRECTS = 5;
+/** RFC 9309: 크롤러는 robots.txt 를 최소 500 KiB 까지 해석해야 한다. 그 이상은 버린다. */
+export const ROBOTS_MAX_BYTES = 500 * 1024;
+/** HTML 은 이만큼만 읽는다 — head·본문 추정에는 충분하고 메모리는 묶인다. */
+export const HTML_MAX_BYTES = 4 * 1024 * 1024;
+/** 원본 HTML 의 보이는 글자 수가 이보다 적으면 JS 렌더링 의존으로 본다. */
+const THIN_TEXT_CHARS = 200;
+function parseHttpUrl(value, label) {
+    let url;
+    try {
+        url = new URL(value.trim());
+    }
+    catch {
+        throw new Error(`${label}: 올바른 절대 URL 이 아닙니다 — ${JSON.stringify(value)}`);
+    }
+    if (url.protocol !== 'http:' && url.protocol !== 'https:') {
+        throw new Error(`${label}: http(s) URL 만 받습니다 — ${JSON.stringify(value)}`);
+    }
+    url.hash = '';
+    return url;
+}
+/**
+ * 응답 본문을 `maxBytes` 까지만 읽고 나머지는 끊는다. 인코딩은 content-type 의 charset
+ * (EUC-KR 등 레거시 한국어 페이지 포함), 모르면 UTF-8. BOM 은 TextDecoder 가 벗긴다.
+ */
+export async function readCapped(res, maxBytes) {
+    const reader = res.body?.getReader();
+    if (!reader)
+        return { text: '', truncated: false };
+    const chunks = [];
+    let size = 0;
+    let truncated = false;
+    for (;;) {
+        const { done, value } = await reader.read();
+        if (done)
+            break;
+        if (size + value.byteLength > maxBytes) {
+            chunks.push(value.subarray(0, maxBytes - size));
+            size = maxBytes;
+            truncated = true;
+            await reader.cancel();
+            break;
+        }
+        chunks.push(value);
+        size += value.byteLength;
+    }
+    const bytes = new Uint8Array(size);
+    let offset = 0;
+    for (const chunk of chunks) {
+        bytes.set(chunk, offset);
+        offset += chunk.byteLength;
+    }
+    const charset = /charset\s*=\s*"?([^";\s]+)/i.exec(res.headers.get('content-type') ?? '')?.[1];
+    let decoder;
+    try {
+        decoder = new TextDecoder(charset ?? 'utf-8');
+    }
+    catch {
+        decoder = new TextDecoder('utf-8');
+    }
+    return { text: decoder.decode(bytes), truncated };
+}
+const NAMED_ENTITIES = { amp: '&', lt: '<', gt: '>', quot: '"', apos: "'", nbsp: ' ' };
+function codePoint(value, raw) {
+    return Number.isInteger(value) && value >= 0 && value <= 0x10ffff ? String.fromCodePoint(value) : raw;
+}
+export function decodeEntities(value) {
+    return value.replace(/&(#x[0-9a-f]{1,8}|#\d{1,10}|[a-z]{2,6});/gi, (raw, body) => {
+        if (body[0] === '#') {
+            const hex = body[1] === 'x' || body[1] === 'X';
+            return codePoint(parseInt(body.slice(hex ? 2 : 1), hex ? 16 : 10), raw);
+        }
+        return NAMED_ENTITIES[body.toLowerCase()] ?? raw;
+    });
+}
+const isSpace = (c) => c === ' ' || c === '\n' || c === '\t' || c === '\r' || c === '\f';
+/** 속성 문자열 파서. HTML 처럼 같은 이름은 **처음 것**이 이긴다. */
+export function parseAttrs(src) {
+    const out = {};
+    const n = src.length;
+    let i = 0;
+    while (i < n) {
+        while (i < n && (isSpace(src[i]) || src[i] === '/'))
+            i++;
+        const nameStart = i;
+        while (i < n && !isSpace(src[i]) && src[i] !== '=' && src[i] !== '/')
+            i++;
+        if (i === nameStart) {
+            i++;
+            continue;
+        }
+        const name = src.slice(nameStart, i).toLowerCase();
+        let j = i;
+        while (j < n && isSpace(src[j]))
+            j++;
+        let value = '';
+        if (src[j] === '=') {
+            j++;
+            while (j < n && isSpace(src[j]))
+                j++;
+            const quote = src[j];
+            if (quote === '"' || quote === "'") {
+                const end = src.indexOf(quote, j + 1);
+                value = src.slice(j + 1, end === -1 ? n : end);
+                i = end === -1 ? n : end + 1;
+            }
+            else {
+                const start = j;
+                while (j < n && !isSpace(src[j]))
+                    j++;
+                value = src.slice(start, j);
+                i = j;
+            }
+        }
+        if (!(name in out))
+            out[name] = decodeEntities(value);
+    }
+    return out;
+}
+/** 내용을 태그로 해석하지 않는 요소 — 닫는 태그까지 통째로 건너뛴다. */
+const RAW_TEXT = new Set(['script', 'style', 'noscript', 'template', 'textarea', 'title']);
+/**
+ * 한 번 훑는 토크나이저. 모든 탐색은 앞으로만 가는 indexOf 라 입력 길이에 선형이다.
+ * 주석·script 는 등장 순서대로 건너뛰므로, script 안의 `<!--` 가 뒤쪽 진짜 메타를 삼키지 않는다.
+ */
+function tokenize(html) {
+    const lower = html.toLowerCase();
+    const tags = [];
+    const allText = [];
+    const bodyText = [];
+    let inBody = false;
+    let title;
+    let scriptCount = 0;
+    const n = html.length;
+    let i = 0;
+    const pushText = (t) => {
+        allText.push(t);
+        if (inBody)
+            bodyText.push(t);
+    };
+    while (i < n) {
+        const lt = html.indexOf('<', i);
+        if (lt === -1) {
+            pushText(html.slice(i));
+            break;
+        }
+        if (lt > i)
+            pushText(html.slice(i, lt));
+        if (html.startsWith('<!--', lt)) {
+            const end = html.indexOf('-->', lt + 4);
+            i = end === -1 ? n : end + 3;
+            continue;
+        }
+        const head = /^<(\/?)([a-zA-Z][a-zA-Z0-9:-]*)/.exec(html.slice(lt, lt + 64));
+        if (!head) {
+            if (html[lt + 1] === '!' || html[lt + 1] === '?') {
+                const end = html.indexOf('>', lt);
+                i = end === -1 ? n : end + 1;
+            }
+            else {
+                pushText('<');
+                i = lt + 1;
+            }
+            continue;
+        }
+        // 태그 끝: 따옴표 밖의 첫 `>`. 따옴표는 `=` 바로 뒤에서만 값의 시작이다.
+        let j = lt + head[0].length;
+        let quote = null;
+        let prev = '';
+        while (j < n) {
+            const c = html[j];
+            if (quote) {
+                if (c === quote)
+                    quote = null;
+            }
+            else if ((c === '"' || c === "'") && prev === '=') {
+                quote = c;
+            }
+            else if (c === '>') {
+                break;
+            }
+            if (!isSpace(c))
+                prev = c;
+            j++;
+        }
+        if (j >= n)
+            break; // 닫히지 않은 태그 — 나머지는 해석하지 않는다
+        const name = head[2].toLowerCase();
+        const closing = head[1] === '/';
+        i = j + 1;
+        if (closing)
+            continue;
+        tags.push({ name, attrs: parseAttrs(html.slice(lt + head[0].length, j)) });
+        if (name === 'body')
+            inBody = true;
+        if (RAW_TEXT.has(name)) {
+            if (name === 'script')
+                scriptCount++;
+            const close = lower.indexOf("</" + name, i);
+            const end = close === -1 ? n : close;
+            if (name === 'title' && title === undefined)
+                title = html.slice(i, end);
+            i = end;
+        }
+    }
+    return { tags, title, bodyText, allText, scriptCount };
+}
+function splitDirectives(content) {
+    return content.split(',').map((d) => d.trim().toLowerCase()).filter(Boolean);
+}
+export function parseHead(html) {
+    const { tags, title, bodyText, allText, scriptCount } = tokenize(html);
+    const head = { og: {}, robots: [], naverSiteVerification: false, textLength: 0, scriptCount };
+    const set = (key, value) => {
+        if (head[key] === undefined && value)
+            head[key] = value;
+    };
+    const setOg = (key, value) => {
+        if (head.og[key] === undefined && value)
+            head.og[key] = value;
+    };
+    if (title !== undefined)
+        head.title = decodeEntities(title).replace(/\s+/g, ' ').trim() || undefined;
+    for (const { name, attrs } of tags) {
+        if (name === 'html')
+            set('lang', attrs.lang?.trim());
+        else if (name === 'base')
+            set('base', attrs.href?.trim());
+        else if (name === 'link') {
+            if (attrs.rel?.toLowerCase().split(/\s+/).includes('canonical'))
+                set('canonical', attrs.href?.trim());
+        }
+        else if (name === 'meta' && attrs.content !== undefined) {
+            const content = attrs.content.trim();
+            // `<meta name="description" property="og:description" content="…">` 처럼 한 태그가 둘 다일 수 있다.
+            for (const key of new Set([attrs.name, attrs.property].filter(Boolean).map((k) => k.toLowerCase()))) {
+                if (key === 'description')
+                    set('description', content);
+                else if (key === 'robots' || key === 'yeti')
+                    head.robots.push(...splitDirectives(content));
+                else if (key === 'naver-site-verification')
+                    head.naverSiteVerification ||= content.length > 0;
+                else if (key === 'og:title')
+                    setOg('title', content);
+                else if (key === 'og:description')
+                    setOg('description', content);
+                else if (key === 'og:image')
+                    setOg('image', content);
+                else if (key === 'og:url')
+                    setOg('url', content);
+            }
+        }
+    }
+    const text = (tags.some((t) => t.name === 'body') ? bodyText : allText).join(' ');
+    head.textLength = decodeEntities(text).replace(/\s+/g, ' ').trim().length;
+    return head;
+}
+/** 값이 있는 지시어(`max-snippet: 50`)의 이름 — `googlebot: noindex` 의 UA 접두어와 구분한다. */
+const VALUE_DIRECTIVES = new Set(['unavailable_after', 'max-snippet', 'max-image-preview', 'max-video-preview']);
+/**
+ * `X-Robots-Tag` 에서 이 크롤러에 적용되는 지시어를 뽑는다.
+ * UA 접두어가 없는 지시어는 모두에게, `yeti: …` 는 Yeti 에게, `googlebot: …` 은 건너뛴다.
+ */
+export function xRobotsDirectives(header, crawler = 'yeti') {
+    const out = { applies: [], ambiguous: [] };
+    if (!header)
+        return out;
+    let scope = null;
+    for (const part of header.split(',')) {
+        let directive = part.trim();
+        const scoped = /^([a-z0-9_-]+)\s*:\s*(.*)$/i.exec(directive);
+        let explicit = false;
+        if (scoped && !VALUE_DIRECTIVES.has(scoped[1].toLowerCase())) {
+            scope = scoped[1].toLowerCase();
+            directive = scoped[2].trim();
+            explicit = true;
+        }
+        if (!directive)
+            continue;
+        const d = directive.toLowerCase();
+        if (scope === null || scope === crawler)
+            out.applies.push(d);
+        else if (!explicit)
+            out.ambiguous.push(d);
+    }
+    return out;
+}
+/** HTTP `Link: <…>; rel="canonical"` 헤더의 대상. */
+export function linkHeaderCanonical(header) {
+    if (!header)
+        return undefined;
+    for (const m of header.matchAll(/<([^>]*)>([^,<]*)/g)) {
+        if (/\brel\s*=\s*"?[^";,]*\bcanonical\b/i.test(m[2]))
+            return m[1].trim();
+    }
+    return undefined;
+}
+async function fetchRobots(origin) {
+    const url = `${origin}/robots.txt`;
+    try {
+        const res = await fetchWithTimeout(url, { headers: { 'user-agent': YETI_USER_AGENT } });
+        if (res.ok) {
+            const { text } = await readCapped(res, ROBOTS_MAX_BYTES);
+            return { url, status: res.status, unreachable: false, parsed: parseRobots(text) };
+        }
+        await res.body?.cancel();
+        // 4xx = robots.txt 없음 → 전부 허용. 5xx·429 = 접근 불가 → 전부 차단으로 취급.
+        return {
+            url, status: res.status, unreachable: res.status >= 500 || res.status === 429, parsed: { groups: [], sitemaps: [] },
+        };
+    }
+    catch (err) {
+        return {
+            url, status: null, unreachable: true, parsed: { groups: [], sitemaps: [] },
+            error: err instanceof Error ? err.message : String(err),
+        };
+    }
+}
+/** 네이버 검색로봇(Yeti) 관점에서 URL 1개를 점검한다. 쓰기 없음. */
+export async function checkPage(input) {
+    const start = parseHttpUrl(input, 'url');
+    const issues = [];
+    const add = (level, code, message) => issues.push({ level, code, message });
+    const accept = 'text/html,application/xhtml+xml;q=0.9,*/*;q=0.8';
+    const headers = { 'user-agent': YETI_USER_AGENT, accept };
+    // 리다이렉트를 직접 따라가며 체인을 남긴다 — 302 로 옮긴 페이지는 원래 URL 이 색인에 남기 쉽다.
+    const redirects = [];
+    let current = start;
+    let res;
+    /** 체인이 끝나지 않고 멈췄다(순환·깨진 Location) — 마지막 응답은 3xx 라 읽을 페이지가 없다. */
+    let stopped = false;
+    for (;;) {
+        res = await fetchWithTimeout(current, { headers, redirect: 'manual' });
+        const location = res.headers.get('location');
+        if (res.status < 300 || res.status >= 400 || !location)
+            break;
+        await res.body?.cancel();
+        let next;
+        try {
+            next = new URL(location, current);
+        }
+        catch {
+            stopped = true;
+            add('error', 'redirect_invalid', `${current.href} 의 Location 헤더가 URL 이 아니다: ${JSON.stringify(location)}`);
+            break;
+        }
+        next.hash = '';
+        redirects.push({ url: current.href, status: res.status, location: next.href });
+        if (redirects.length > MAX_REDIRECTS || redirects.some((hop) => hop.url === next.href)) {
+            stopped = true;
+            add('error', 'redirect_loop', `리다이렉트가 ${redirects.length}번 이어지거나 순환한다 — 크롤러는 중간에 포기한다.`);
+            break;
+        }
+        current = next;
+    }
+    const temporary = redirects.filter((hop) => hop.status !== 301 && hop.status !== 308);
+    if (temporary.length > 0) {
+        add('warn', 'redirect_temporary', `임시 리다이렉트(${temporary.map((h) => h.status).join(', ')})가 있다 — 영구 이전이면 301/308 로 바꿔야 새 URL 이 색인된다.`);
+    }
+    if (current.protocol !== 'https:')
+        add('warn', 'not_https', '최종 URL 이 https 가 아니다.');
+    // robots.txt — 시작 URL, 중간 경유지, 최종 URL 모두 Yeti 가 긁을 수 있어야 끝까지 따라간다.
+    const robotsCache = new Map();
+    const robotsFor = (origin) => {
+        let pending = robotsCache.get(origin);
+        if (!pending) {
+            pending = fetchRobots(origin);
+            robotsCache.set(origin, pending);
+        }
+        return pending;
+    };
+    const hops = new Map([[start.href, start]]);
+    for (const hop of redirects)
+        hops.set(hop.location, new URL(hop.location));
+    const finalRobots = await robotsFor(current.origin);
+    let finalVerdict = null;
+    const unreachableReported = new Set();
+    for (const target of hops.values()) {
+        const robots = await robotsFor(target.origin);
+        if (robots.unreachable) {
+            if (!unreachableReported.has(robots.url)) {
+                unreachableReported.add(robots.url);
+                add('error', 'robots_unreachable', `${robots.url} 를 읽지 못했다(${robots.status ?? robots.error}) — 크롤러는 이 경우 사이트 전체를 막힌 것으로 본다.`);
+            }
+            continue;
+        }
+        const verdict = isAllowed(robots.parsed, target.pathname + target.search);
+        if (target.href === current.href)
+            finalVerdict = verdict;
+        if (!verdict.allowed) {
+            const via = verdict.group === 'crawler' ? 'User-agent: Yeti' : 'User-agent: *';
+            add('error', 'robots_blocked', `robots.txt 가 Yeti 의 ${target.href} 수집을 막는다 (${via} → Disallow: ${verdict.matchedRule?.pattern}).`);
+        }
+    }
+    if (!finalRobots.unreachable && finalRobots.parsed.sitemaps.length === 0) {
+        add('info', 'no_sitemap_in_robots', 'robots.txt 에 Sitemap: 선언이 없다. 서치어드바이저 콘솔(요청 → 사이트맵 제출)에도 따로 제출해 두는 게 좋다.');
+    }
+    if (res.status !== 200) {
+        add('error', 'http_status', `최종 응답이 ${res.status} 다 — 200 이 아니면 색인되지 않는다.`);
+        if (!stopped) {
+            // Yeti UA 만 막히는가? WAF 는 IP 가 네이버가 아닌 "가짜 Yeti" 를 거르기도 해서, 진짜 Yeti 는 통과할 수 있다.
+            try {
+                const probe = await fetchWithTimeout(current, { headers: { 'user-agent': BROWSER_USER_AGENT, accept }, redirect: 'manual' });
+                await probe.body?.cancel();
+                if (probe.status === 200) {
+                    add('warn', 'ua_blocked', `Yeti UA 로는 ${res.status}, 브라우저 UA 로는 200 이다 — 서버/WAF 가 봇 UA 를 막거나, 네이버 IP 가 아닌 Yeti 를 거르는 것일 수 있다. ` +
+                        '진짜 Yeti 의 수집 결과는 서치어드바이저 콘솔(수집 현황·웹 페이지 최적화)에서 확인해.');
+                }
+            }
+            catch {
+                // 비교 요청 실패는 진단을 바꾸지 않는다.
+            }
+        }
+    }
+    const contentType = res.headers.get('content-type');
+    const xRobots = xRobotsDirectives(res.headers.get('x-robots-tag'));
+    let head = null;
+    if (stopped) {
+        // 마지막 3xx 의 본문은 이미 버렸다 — 파싱할 페이지가 없다.
+    }
+    else if (contentType && /html/i.test(contentType)) {
+        const { text, truncated } = await readCapped(res, HTML_MAX_BYTES);
+        head = parseHead(text);
+        if (truncated)
+            add('info', 'html_truncated', `HTML 이 ${HTML_MAX_BYTES / 1024 / 1024} MiB 를 넘어 앞부분만 점검했다.`);
+    }
+    else {
+        await res.body?.cancel();
+        add('warn', 'not_html', `HTML 이 아니다(content-type: ${contentType ?? '없음'}) — 메타 태그 점검을 건너뛴다.`);
+    }
+    const blocks = (list) => list.includes('noindex') || list.includes('none');
+    const sources = [
+        ...(blocks(xRobots.applies) ? ['X-Robots-Tag'] : []),
+        ...(blocks(head?.robots ?? []) ? ['meta robots/yeti'] : []),
+    ];
+    if (sources.length > 0)
+        add('error', 'noindex', `noindex 지시어가 있다 (${sources.join(', ')}) — 검색에 나오지 않는다.`);
+    else if (blocks(xRobots.ambiguous)) {
+        add('warn', 'noindex_ambiguous', `X-Robots-Tag 의 noindex 가 다른 봇 접두어 뒤에 이어져 있다(${res.headers.get('x-robots-tag')}). ` +
+            'X-Robots-Tag 헤더가 여러 줄이면 이 noindex 는 Yeti 에게도 적용된다 — 서버 설정을 확인해.');
+    }
+    if ([...xRobots.applies, ...(head?.robots ?? [])].includes('nofollow')) {
+        add('warn', 'nofollow', 'nofollow 지시어가 있다 — 이 페이지의 링크를 따라가지 않는다.');
+    }
+    if (head) {
+        const canonicalRaw = head.canonical ?? linkHeaderCanonical(res.headers.get('link'));
+        if (canonicalRaw) {
+            let base = current;
+            try {
+                if (head.base)
+                    base = new URL(head.base, current);
+            }
+            catch {
+                // 깨진 <base href> 는 무시하고 문서 URL 기준으로 푼다.
+            }
+            let canonical = null;
+            try {
+                canonical = new URL(canonicalRaw, base);
+                canonical.hash = '';
+            }
+            catch {
+                add('warn', 'canonical_invalid', `canonical 값이 URL 이 아니다: ${JSON.stringify(canonicalRaw)}`);
+            }
+            if (canonical && canonical.href !== current.href) {
+                add('warn', 'canonical_mismatch', `정규 URL 이 다른 주소(${canonical.href})를 가리킨다 — 이 URL 대신 그쪽이 색인된다.`);
+            }
+        }
+        else {
+            add('info', 'no_canonical', '<link rel="canonical"> 이 없다 — 파라미터 붙은 중복 URL 이 따로 색인될 수 있다.');
+        }
+        if (!head.title)
+            add('warn', 'no_title', '<title> 이 없거나 비었다.');
+        if (!head.description)
+            add('warn', 'no_description', '<meta name="description"> 이 없다 — 검색 결과 요약문으로 쓰인다.');
+        const og = head.og;
+        const missingOg = ['title', 'description', 'image'].filter((k) => !og[k]);
+        if (missingOg.length > 0) {
+            add('warn', 'og_missing', `Open Graph 태그가 빠졌다: ${missingOg.map((k) => `og:${k}`).join(', ')} — 서치어드바이저가 권장하는 제목·요약·대표 이미지 정보다.`);
+        }
+        if (head.textLength < THIN_TEXT_CHARS && head.scriptCount > 0) {
+            add('warn', 'thin_html', `원본 HTML 의 본문이 ${head.textLength}자뿐이다 — JS 로 그리는 페이지면 크롤러에 빈 문서로 보일 수 있다. 서버 렌더링(SSR/SSG)이 가장 안전하다.`);
+        }
+        if (!head.lang)
+            add('info', 'no_lang', '<html lang> 이 없다.');
+        if (!head.naverSiteVerification) {
+            add('info', 'no_site_verification', 'naver-site-verification 메타 태그가 없다 — HTML 파일 방식으로 소유 확인했다면 무시해도 된다.');
+        }
+    }
+    const summary = { error: 0, warn: 0, info: 0 };
+    for (const issue of issues)
+        summary[issue.level] += 1;
+    return {
+        url: start.href,
+        finalUrl: current.href,
+        status: res.status,
+        contentType,
+        redirects,
+        robotsTxt: {
+            url: finalRobots.url,
+            status: finalRobots.status,
+            verdict: finalVerdict,
+            sitemaps: finalRobots.parsed.sitemaps,
+        },
+        directives: { meta: head?.robots ?? [], header: xRobots.applies, headerAmbiguous: xRobots.ambiguous },
+        head,
+        issues,
+        summary,
+    };
+}
+const INDEXNOW_STATUS = {
+    400: '요청 형식이 잘못됐다(400).',
+    403: '키가 유효하지 않다(403) — 키 파일 내용이 key 와 정확히 같은지, 파일이 공개로 열리는지 확인해.',
+    422: 'URL 이 host 나 키 파일 위치와 맞지 않는다(422) — URL 은 키 파일과 같은 스킴·호스트, 같은 디렉터리 이하여야 한다.',
+    429: '너무 자주 보냈다(429) — 스팸으로 볼 수 있으니 한참 뒤에 다시 보내. 자동 재시도는 하지 않았다.',
+};
+/**
+ * 네이버 IndexNow 로 URL 변경을 알린다.
+ *
+ * 보내기 전에 키 파일을 직접 받아 key 와 같은지 확인한다 — 틀린 키는 엔드포인트가 403 만 돌려주고,
+ * 같은 호스트에 틀린 키로 반복 제출하면 스팸 판정 위험만 커진다. 같은 URL 재제출은 안전하다.
+ */
+export async function submitIndexNow({ urls, key, keyLocation }) {
+    if (!INDEXNOW_KEY_PATTERN.test(key)) {
+        throw new Error('key 는 8–128자의 영문·숫자·대시(-)여야 합니다.');
+    }
+    // 정규화(호스트 소문자·# 제거) 뒤에 중복을 없앤다 — 입력 문자열 기준이면 같은 URL 이 여러 번 나간다.
+    const byHref = new Map();
+    for (const raw of urls) {
+        if (!raw.trim())
+            continue;
+        const url = parseHttpUrl(raw, 'urls');
+        byHref.set(url.href, url);
+    }
+    const parsed = [...byHref.values()];
+    if (parsed.length === 0)
+        throw new Error('urls 가 비었습니다.');
+    if (parsed.length > INDEXNOW_MAX_URLS)
+        throw new Error(`한 번에 최대 ${INDEXNOW_MAX_URLS}개까지 보낼 수 있습니다.`);
+    // IndexNow 의 범위는 URL 접두어다 — 호스트만이 아니라 스킴까지 같아야 한다.
+    const origin = parsed[0].origin;
+    const foreign = parsed.find((u) => u.origin !== origin);
+    if (foreign) {
+        throw new Error(`모든 URL 은 같은 스킴·호스트여야 합니다 — ${origin} 와 ${foreign.origin} 가 섞였습니다. 나눠서 보내세요.`);
+    }
+    const keyUrl = keyLocation
+        ? parseHttpUrl(keyLocation, 'keyLocation')
+        : new URL(`/${encodePathSegment(key)}.txt`, origin);
+    if (keyUrl.origin !== origin) {
+        throw new Error(`keyLocation 은 제출 URL 과 같은 스킴·호스트(${origin})에 있어야 합니다.`);
+    }
+    const keyDir = keyUrl.pathname.slice(0, keyUrl.pathname.lastIndexOf('/') + 1);
+    const outside = parsed.find((u) => !u.pathname.startsWith(keyDir));
+    if (outside) {
+        throw new Error(`키 파일 디렉터리(${keyDir}) 밖의 URL 은 보낼 수 없습니다 — ${outside.href}`);
+    }
+    // 사전 확인: 키 파일이 리다이렉트 없이 200 으로, 내용이 key 그대로 열려야 한다.
+    const keyRes = await fetchWithTimeout(keyUrl, { redirect: 'manual' });
+    let keyBody = '';
+    if (keyRes.status === 200)
+        keyBody = (await readCapped(keyRes, 4096)).text.trim();
+    else
+        await keyRes.body?.cancel();
+    if (keyRes.status !== 200 || keyBody !== key) {
+        const why = keyRes.status !== 200 ? `응답 ${keyRes.status}` : '파일 내용이 key 와 다름';
+        throw new Error([
+            `키 파일 확인 실패: ${keyUrl.href} (${why}). 아무것도 제출하지 않았습니다.`,
+            `→ 사이트에 ${keyUrl.pathname} 파일을 올리고 내용으로 key 한 줄만 넣으세요 (UTF-8, 리다이렉트 없이 200).`,
+            '   정적 사이트는 보통 public/ (또는 static/) 폴더 루트에 두면 됩니다.',
+        ].join('\n'));
+    }
+    // 429 도 재시도하지 않는다 — IndexNow 의 429 는 "스팸 의심"이라 연타가 상황을 악화시킨다.
+    const res = await fetchWithTimeout(NAVER_INDEXNOW_ENDPOINT, {
+        method: 'POST',
+        headers: { 'content-type': 'application/json; charset=utf-8' },
+        body: JSON.stringify({
+            host: keyUrl.host,
+            key,
+            ...(keyLocation ? { keyLocation: keyUrl.href } : {}),
+            urlList: parsed.map((u) => u.href),
+        }),
+    }, { maxAttempts: 1 });
+    const detail = (await readCapped(res, 2048)).text.trim().slice(0, 300);
+    if (res.status === 200 || res.status === 202) {
+        return { endpoint: NAVER_INDEXNOW_ENDPOINT, status: res.status, host: keyUrl.host, keyLocation: keyUrl.href, submitted: parsed.length };
+    }
+    throw new Error(`네이버 IndexNow 제출 실패: ${INDEXNOW_STATUS[res.status] ?? `HTTP ${res.status}`}${detail ? `\n응답: ${detail}` : ''}`);
+}

package/dist/registers/naver.d.ts

@@ -0,0 +1,2 @@
+import type { ToolRegistrar } from '../lib/tool-registrar.js';
+export declare function registerNaverTools(server: ToolRegistrar): void;

package/dist/registers/naver.js

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+import * as naver from '../naver/tools.js';
+import { jsonResult, textResult } from '../lib/mcp-response.js';
+export function registerNaverTools(server) {
+    server.tool('naver_check_page', '네이버 검색로봇(Yeti) 관점에서 URL 1개의 색인 가능성 점검 — 리다이렉트 체인(301/302), robots.txt 의 Yeti 허용 여부, 상태 코드, noindex(meta robots/yeti·X-Robots-Tag), canonical, title·description·Open Graph, JS 렌더링 의존(원본 HTML 본문 부족), naver-site-verification. issues 를 error/warn/info 로 반환. 서치어드바이저에는 공개 API 가 없어 콘솔의 수집 현황 대신 이걸로 진단한다. 인증 불필요.', {
+        url: z.string().describe('점검할 전체 URL (예: https://example.com/post/1)'),
+    }, async ({ url }) => jsonResult(await naver.checkPage(url)));
+    server.tool('naver_indexnow_submit', "네이버 IndexNow 로 새로 만들거나 수정·삭제한 URL 을 즉시 알려 수집을 앞당긴다 (IndexNow 참여 엔진끼리 공유됨). 사전 조건: 사이트 루트에 '<key>.txt' 파일(내용 = key 한 줄)을 공개로 올려 둘 것 — 제출 전에 이 파일을 직접 확인하고, 틀리면 아무것도 보내지 않는다. URL 은 모두 같은 호스트, 1회 최대 10,000개. 같은 URL 재제출은 안전. 사이트맵·RSS 제출은 API 가 없어 서치어드바이저 콘솔에서 해야 한다.", {
+        urls: z.array(z.string()).min(1).max(naver.INDEXNOW_MAX_URLS).describe('알릴 전체 URL 목록 (같은 호스트)'),
+        key: z.string().regex(naver.INDEXNOW_KEY_PATTERN).describe('IndexNow 키 — 8–128자 영문·숫자·대시. 없으면 32자 16진수 등으로 새로 만들어 키 파일부터 배포'),
+        keyLocation: z.string().optional().describe('키 파일이 루트(/<key>.txt)가 아닐 때의 전체 URL. 이 경우 URL 은 그 디렉터리 이하만 가능'),
+    }, async ({ urls, key, keyLocation }) => {
+        const r = await naver.submitIndexNow({ urls, key, keyLocation });
+        return textResult([
+            `✅ 네이버 IndexNow 제출 완료 (HTTP ${r.status}${r.status === 202 ? ' — 접수됨, 키 검증 대기' : ''}).`,
+            `  호스트: ${r.host} · URL ${r.submitted}개 · 키 파일: ${r.keyLocation}`,
+            '',
+            '수집 여부는 서치어드바이저 콘솔(요청 → 웹 페이지 수집 / 리포트)에서 확인해. 제출은 수집을 앞당길 뿐 색인을 보장하지 않아 — naver_check_page 로 막는 요소가 없는지 먼저 봐.',
+        ]);
+    });
+}

package/dist/server.js

@@ -15,6 +15,7 @@ import { registerThreadsTools } from './registers/threads.js';
 import { registerFacebookTools } from './registers/facebook.js';
 import { registerGoogleAdsTools } from './registers/googleads.js';
 import { registerGscTools } from './registers/gsc.js';
+import { registerNaverTools } from './registers/naver.js';
 import { registerGa4Tools } from './registers/ga4.js';
 import { registerJenkinsTools } from './registers/jenkins.js';
 import { registerAndroidTools } from './registers/android.js';
@@ -63,6 +64,7 @@ export function buildServer(version, options = {}) {
     registerFacebookTools(registrar);
     registerGoogleAdsTools(registrar);
     registerGscTools(registrar);
+    registerNaverTools(registrar);
     registerGa4Tools(registrar);
     registerJenkinsTools(registrar);
     registerAndroidTools(registrar);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yoonion/mimi-seed-mcp",
-  "version": "0.21.1",
+  "version": "0.21.2",
   "description": "Mimi Seed MCP server — Firebase + AdMob + Google Play + App Store management for Claude Code / Codex / Cursor / any MCP client.",
   "type": "module",
   "imports": {

package/tool-manifest.json

@@ -1,6 +1,6 @@
 {
   "$comment": "등록된 MCP 도구 + 도메인 메타데이터(label·credential·summary) + 도구 분류(write·destructive·local·idempotent → MCP annotations·confirm 가드) + toolset 그룹·폐기 별칭의 SSOT (src/lib/tool-registrar.ts 가 읽는다). src/__tests__/tool-manifest.test.ts 가 실제 서버 등록 목록과 diff 하고 메타데이터 정합성을 검사한다. 도구 추가/삭제/개명 시 이 파일을 함께 갱신할 것 — 산문 문서에는 정확한 개수를 쓰지 말고 이 파일을 가리킬 것. mimi-seed://tools/catalog 리소스가 이 파일을 그대로 서빙한다.",
-  "total": 245,
+  "total": 247,
   "alwaysOn": [
     "auth",
     "checks"
@@ -507,6 +507,24 @@
         "gsc_submit_sitemap"
       ]
     },
+    "naver": {
+      "label": "Naver Search Advisor",
+      "credential": "없음 (IndexNow 키 파일)",
+      "summary": "Yeti 크롤러 관점 색인 점검·IndexNow URL 제출",
+      "tools": [
+        "naver_check_page",
+        "naver_indexnow_submit"
+      ],
+      "write": [
+        "naver_indexnow_submit"
+      ],
+      "destructive": [],
+      "ownGate": [],
+      "local": [],
+      "idempotent": [
+        "naver_indexnow_submit"
+      ]
+    },
     "iam": {
       "label": "Google Cloud IAM",
       "credential": "Google OAuth",