@yoonion/mimi-seed-mcp 0.3.26 → 0.3.27

package/dist/appstore/errors.d.ts

@@ -0,0 +1,45 @@
+/**
+ * App Store Connect API 에러 친절화.
+ *
+ * Apple은 표준 JSON 에러 응답을 내려준다:
+ *   { "errors": [{ "code": "...", "title": "...", "detail": "...",
+ *                  "source": { "pointer": "/data/attributes/whatsNew" } }] }
+ *
+ * 실제 거부 사례에서 자주 만나는 코드별 hint 를 첨가해
+ * "App Store API 409: { errors: [...] }" 같은 raw dump 대신
+ * 무엇을 고쳐야 하는지 즉시 보이게 한다.
+ *
+ * 비표준 body (HTML, plain text, 빈 응답 등) 는 폴백으로 원본 보존.
+ */
+/** Apple JSON Error response 구조 (단일 errors 배열). */
+interface AppleError {
+    id?: string;
+    code?: string;
+    status?: string;
+    title?: string;
+    detail?: string;
+    source?: {
+        pointer?: string;
+        parameter?: string;
+    };
+}
+/** Apple 표준 에러 응답 파싱 시도. 실패하면 null 반환. */
+declare function parseAppleErrorBody(body: string): AppleError[] | null;
+/** 단일 Apple error → 한 줄 사람용 표기. */
+declare function formatAppleError(e: AppleError): string;
+/**
+ * App Store API 응답 (status + raw body) 을 친절한 Error 로 변환.
+ *
+ * - 표준 Apple JSON: `App Store API {status}: [CODE] detail @ pointer 💡 hint` 형식.
+ *   여러 errors 가 있으면 줄바꿈으로 나열.
+ * - 비표준 body: 기존 형식(`App Store API {status}: {body}`) 그대로 보존.
+ *
+ * `Error.cause` 에 원본 `{ status, body, parsedErrors }` 첨부 — 호출자가 코드별 분기 필요 시 사용.
+ */
+export declare function friendlyAppStoreError(status: number, body: string): Error;
+export declare const __testing: {
+    CODE_HINTS: Record<string, string>;
+    parseAppleErrorBody: typeof parseAppleErrorBody;
+    formatAppleError: typeof formatAppleError;
+};
+export {};

package/dist/appstore/errors.js

@@ -0,0 +1,88 @@
+/**
+ * App Store Connect API 에러 친절화.
+ *
+ * Apple은 표준 JSON 에러 응답을 내려준다:
+ *   { "errors": [{ "code": "...", "title": "...", "detail": "...",
+ *                  "source": { "pointer": "/data/attributes/whatsNew" } }] }
+ *
+ * 실제 거부 사례에서 자주 만나는 코드별 hint 를 첨가해
+ * "App Store API 409: { errors: [...] }" 같은 raw dump 대신
+ * 무엇을 고쳐야 하는지 즉시 보이게 한다.
+ *
+ * 비표준 body (HTML, plain text, 빈 응답 등) 는 폴백으로 원본 보존.
+ */
+/** Apple 에러 코드 → 친절한 hint (실측 거부 사례 기반). */
+const CODE_HINTS = {
+    // What's New / localization 텍스트 검증 실패
+    INVALID_CHARACTERS: 'HTML 태그·금지 문자가 포함됐어요. 제출 전 lib/text-validators.ts 로 사전 검증 권장.',
+    // 버전 상태가 편집 불가 (READY_FOR_SALE / WAITING_FOR_REVIEW 등)
+    ENTITY_STATE_INVALID: '버전 상태가 편집 가능 단계가 아니에요 (이미 심사중/출시됨). 새 versionString 으로 appstore_create_version 필요할 수 있어요.',
+    // 필수 필드 누락
+    ENTITY_ERROR_ATTRIBUTE_REQUIRED: '필수 필드가 빠졌어요 — source.pointer 위치 확인.',
+    // 길이 / 형식 위반
+    ENTITY_ERROR_ATTRIBUTE_INVALID: '필드 값이 정책 위반(길이/형식). source.pointer 위치 확인.',
+    // 빌드 attach 시 빌드를 못 찾음
+    NOT_FOUND: '대상 리소스를 찾을 수 없어요 — id/versionId/buildId 가 유효한지, 동일 앱 소속인지 확인.',
+    // 권한 부족 (API Key role 문제)
+    FORBIDDEN_ERROR: 'API Key 권한 부족 — App Store Connect > Users and Access 에서 키 role 확인.',
+    // submit 직후 cancel 시도 (큐 진입 후)
+    STATE_ERROR: '현재 상태에서 허용되지 않는 작업. cancel_review 라면 큐 진입 후라서 불가 — 새 versionString 으로 우회.',
+};
+/** Apple 표준 에러 응답 파싱 시도. 실패하면 null 반환. */
+function parseAppleErrorBody(body) {
+    if (!body)
+        return null;
+    try {
+        const parsed = JSON.parse(body);
+        if (Array.isArray(parsed?.errors) && parsed.errors.length > 0) {
+            return parsed.errors;
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+/** 단일 Apple error → 한 줄 사람용 표기. */
+function formatAppleError(e) {
+    const code = e.code ?? 'UNKNOWN';
+    const detail = e.detail ?? e.title ?? '(no detail)';
+    const pointer = e.source?.pointer ?? e.source?.parameter;
+    const hint = e.code ? CODE_HINTS[e.code] : undefined;
+    const parts = [`[${code}] ${detail}`];
+    if (pointer)
+        parts.push(`@ ${pointer}`);
+    if (hint)
+        parts.push(`\n  💡 ${hint}`);
+    return parts.join(' ');
+}
+/**
+ * App Store API 응답 (status + raw body) 을 친절한 Error 로 변환.
+ *
+ * - 표준 Apple JSON: `App Store API {status}: [CODE] detail @ pointer 💡 hint` 형식.
+ *   여러 errors 가 있으면 줄바꿈으로 나열.
+ * - 비표준 body: 기존 형식(`App Store API {status}: {body}`) 그대로 보존.
+ *
+ * `Error.cause` 에 원본 `{ status, body, parsedErrors }` 첨부 — 호출자가 코드별 분기 필요 시 사용.
+ */
+export function friendlyAppStoreError(status, body) {
+    const errors = parseAppleErrorBody(body);
+    let message;
+    if (errors) {
+        const formatted = errors.map(formatAppleError).join('\n');
+        message = `App Store API ${status}:\n${formatted}`;
+    }
+    else {
+        message = `App Store API ${status}: ${body}`;
+    }
+    const err = new Error(message);
+    // 원본 보존 — 호출자 코드별 retry 분기용.
+    err.cause = { status, body, parsedErrors: errors ?? undefined };
+    return err;
+}
+// ── 테스트용 export ────────────────────────────────────────────
+export const __testing = {
+    CODE_HINTS,
+    parseAppleErrorBody,
+    formatAppleError,
+};

package/dist/appstore/tools.d.ts

@@ -26,6 +26,29 @@ export declare function attachBuildToVersion(versionId: string, buildId: string)
     buildId: string;
     ok: boolean;
 }>;
+/**
+ * 가장 최신 VALID 빌드를 자동으로 찾아 versionId 에 attach.
+ *
+ * 흐름:
+ *   1. versionId → appId 역추적 (`getVersionAppAndPlatform`).
+ *   2. `listBuilds(appId)` 로 최근 10개 빌드 조회 (sort: uploadedDate desc).
+ *   3. `processingState === 'VALID'` 필터.
+ *   4. `minBuildNumber` 옵션 있으면 buildNumber 숫자 기준 필터.
+ *   5. buildNumber 숫자 최대값으로 정렬 → 1개 선택.
+ *   6. attach.
+ *
+ * 사용처: 1.4.x 같은 매 배포마다 `appstore_list_builds` → 수동 탐색 → `appstore_attach_build` 의
+ * 3-step 을 한 번에 줄임. 실수로 PROCESSING 중인 빌드를 attach 해서 심사 제출 시점에 깨지는
+ * 케이스도 차단.
+ */
+export declare function attachLatestValidBuild(versionId: string, opts?: {
+    minBuildNumber?: number;
+}): Promise<{
+    versionId: string;
+    attachedBuildId: string;
+    buildNumber: string;
+    uploadedDate?: string;
+}>;
 export declare function getVersionLocalizations(versionId: string): Promise<any>;
 export interface LocalizationUpdateFields {
     whatsNew?: string;
@@ -80,6 +103,31 @@ export interface ListCustomerReviewsOptions {
 }
 export declare function listCustomerReviews(appId: string, opts?: ListCustomerReviewsOptions): Promise<any>;
 export declare function createReviewResponse(reviewId: string, responseBody: string): Promise<any>;
+/**
+ * submit_for_review dry-run 프리뷰 — 비가역 제출 직전 사용자 확인용.
+ *
+ * 1.4.x 배포 사고 누적: submit 직후 cancel_review 가 큐 진입으로 막혀 새 versionString
+ * bump 으로 우회해야 하는 케이스가 반복됨 (reference_appstore_cancel_review_window).
+ * 호출자가 의도한 그 버전·빌드인지 미리 보여줘서 잘못된 versionId 제출 차단.
+ */
+export declare function buildSubmitForReviewPreview(versionId: string): Promise<{
+    versionId: string;
+    versionString?: string;
+    state?: string;
+    appId: string;
+    platform: string;
+    attachedBuild?: {
+        id: string;
+        buildNumber?: string;
+        uploadedDate?: string;
+        processingState?: string;
+    };
+    whatsNewByLocale: Array<{
+        locale: string;
+        excerpt: string;
+        length: number;
+    }>;
+}>;
 export declare function submitVersionForReview(versionId: string): Promise<{
     submissionId: string;
     appId: string;

package/dist/appstore/tools.js

@@ -1,4 +1,5 @@
 import { getAuthHeaders } from './auth.js';
+import { friendlyAppStoreError } from './errors.js';
 /**
  * App Store Connect API v1 래퍼
  * https://developer.apple.com/documentation/appstoreconnectapi
@@ -24,7 +25,7 @@ export async function apiGet(path, params) {
     const res = await fetch(url.toString(), { headers });
     if (!res.ok) {
         const body = await res.text();
-        throw new Error(`App Store API ${res.status}: ${body}`);
+        throw friendlyAppStoreError(res.status, body);
     }
     return res.json();
 }
@@ -44,7 +45,7 @@ async function apiPatch(path, body) {
     });
     if (!res.ok) {
         const text = await res.text();
-        throw new Error(`App Store API ${res.status}: ${text}`);
+        throw friendlyAppStoreError(res.status, text);
     }
     // 204 No Content 가능
     const text = await res.text();
@@ -66,7 +67,7 @@ async function apiPost(path, body) {
     });
     if (!res.ok) {
         const text = await res.text();
-        throw new Error(`App Store API ${res.status}: ${text}`);
+        throw friendlyAppStoreError(res.status, text);
     }
     // 201 Created — 본문에 created entity. 일부 엔드포인트는 204
     const text = await res.text();
@@ -147,6 +148,51 @@ export async function attachBuildToVersion(versionId, buildId) {
     });
     return { versionId, buildId, ok: true };
 }
+/**
+ * 가장 최신 VALID 빌드를 자동으로 찾아 versionId 에 attach.
+ *
+ * 흐름:
+ *   1. versionId → appId 역추적 (`getVersionAppAndPlatform`).
+ *   2. `listBuilds(appId)` 로 최근 10개 빌드 조회 (sort: uploadedDate desc).
+ *   3. `processingState === 'VALID'` 필터.
+ *   4. `minBuildNumber` 옵션 있으면 buildNumber 숫자 기준 필터.
+ *   5. buildNumber 숫자 최대값으로 정렬 → 1개 선택.
+ *   6. attach.
+ *
+ * 사용처: 1.4.x 같은 매 배포마다 `appstore_list_builds` → 수동 탐색 → `appstore_attach_build` 의
+ * 3-step 을 한 번에 줄임. 실수로 PROCESSING 중인 빌드를 attach 해서 심사 제출 시점에 깨지는
+ * 케이스도 차단.
+ */
+export async function attachLatestValidBuild(versionId, opts) {
+    const { appId } = await getVersionAppAndPlatform(versionId);
+    const builds = (await listBuilds(appId));
+    const valid = builds.filter((b) => b.processingState === 'VALID');
+    if (valid.length === 0) {
+        throw new Error(`appId=${appId} 에 VALID 빌드가 없어요 (최근 ${builds.length}개 확인). 빌드 PROCESSING 완료 대기 필요.`);
+    }
+    let candidates = valid;
+    if (opts?.minBuildNumber !== undefined) {
+        const min = opts.minBuildNumber;
+        candidates = valid.filter((b) => Number(b.version) >= min);
+        if (candidates.length === 0) {
+            throw new Error(`minBuildNumber=${min} 이상 VALID 빌드가 없어요. VALID 빌드: ${valid.map((b) => b.version).join(', ')}`);
+        }
+    }
+    // buildNumber 가 숫자 문자열이라는 가정 (TestFlight 표준). NaN 은 -Infinity 처리해 뒤로.
+    candidates.sort((a, b) => {
+        const an = Number(a.version);
+        const bn = Number(b.version);
+        return (isNaN(bn) ? -Infinity : bn) - (isNaN(an) ? -Infinity : an);
+    });
+    const target = candidates[0];
+    await attachBuildToVersion(versionId, target.id);
+    return {
+        versionId,
+        attachedBuildId: target.id,
+        buildNumber: target.version,
+        uploadedDate: target.uploadedDate,
+    };
+}
 // ─── 로컬라이제이션 (메타데이터) ───
 export async function getVersionLocalizations(versionId) {
     const data = await apiGet(`/appStoreVersions/${versionId}/appStoreVersionLocalizations`, {
@@ -426,6 +472,52 @@ async function isVersionAttached(submissionId, versionId) {
     const items = (data?.data ?? []);
     return items.some((it) => it?.relationships?.appStoreVersion?.data?.id === versionId);
 }
+/**
+ * submit_for_review dry-run 프리뷰 — 비가역 제출 직전 사용자 확인용.
+ *
+ * 1.4.x 배포 사고 누적: submit 직후 cancel_review 가 큐 진입으로 막혀 새 versionString
+ * bump 으로 우회해야 하는 케이스가 반복됨 (reference_appstore_cancel_review_window).
+ * 호출자가 의도한 그 버전·빌드인지 미리 보여줘서 잘못된 versionId 제출 차단.
+ */
+export async function buildSubmitForReviewPreview(versionId) {
+    const { appId, platform } = await getVersionAppAndPlatform(versionId);
+    // 버전 메타: versionString + state
+    const versionData = await apiGet(`/appStoreVersions/${versionId}`, {
+        'fields[appStoreVersions]': 'versionString,appStoreState',
+    }).catch(() => null);
+    const versionString = versionData?.data?.attributes?.versionString;
+    const state = versionData?.data?.attributes?.appStoreState;
+    // attached build
+    let attachedBuild;
+    const build = await apiGet(`/appStoreVersions/${versionId}/build`, {
+        'fields[builds]': 'version,uploadedDate,processingState',
+    }).catch(() => null);
+    if (build?.data?.id) {
+        attachedBuild = {
+            id: build.data.id,
+            buildNumber: build.data.attributes?.version,
+            uploadedDate: build.data.attributes?.uploadedDate,
+            processingState: build.data.attributes?.processingState,
+        };
+    }
+    const localizations = (await getVersionLocalizations(versionId).catch(() => []));
+    const whatsNewByLocale = localizations
+        .filter((l) => typeof l.whatsNew === 'string' && l.whatsNew.length > 0)
+        .map((l) => ({
+        locale: l.locale,
+        length: l.whatsNew.length,
+        excerpt: l.whatsNew.length > 200 ? `${l.whatsNew.slice(0, 200)}…` : l.whatsNew,
+    }));
+    return {
+        versionId,
+        versionString,
+        state,
+        appId,
+        platform,
+        attachedBuild,
+        whatsNewByLocale,
+    };
+}
 export async function submitVersionForReview(versionId) {
     const { appId, platform } = await getVersionAppAndPlatform(versionId);
     // 1. CREATED 상태의 reviewSubmission이 있으면 재사용, 없으면 새로 생성

package/dist/auth/google-auth.d.ts

@@ -11,6 +11,13 @@ export declare function getStoredCredentials(): {
 } | null;
 export declare function saveCredentials(clientId: string, clientSecret: string): void;
 export declare function getStoredTokens(): StoredTokens | null;
+/**
+ * tokens.json mtime — 마지막 refresh 시각의 근사값.
+ * (saveTokens 가 매번 writeFileSync 으로 갱신하므로 mtime ≈ 마지막 갱신/저장.)
+ * Google refresh_token 은 7일(미인증 앱) ~ 6개월(인증 앱) 미사용 시 revoke 됨.
+ * auth_status 응답 enrichment 에 사용.
+ */
+export declare function getTokensLastRefreshMs(): number | null;
 export declare function createOAuth2Client(clientId: string, clientSecret: string): import("google-auth-library").OAuth2Client;
 /**
  * Get authenticated OAuth2 client.
@@ -59,4 +66,9 @@ export type RefreshStatus = {
  *
  * MCP 도구와 CLI 양쪽에서 공유.
  */
+/**
+ * 사전 갱신 마진. 기존 60_000(1분)에서 300_000(5분)으로 상향 — Google OAuth access_token 의
+ * 통상 lifetime 이 1h 이므로, 5분 마진으로 매 도구 호출 시 만료 임박 시 사전 갱신해
+ * "토큰 만료 → 도구 fail → 재호출" 의 단절 마찰 제거. 5분 마진은 평균 도구 작업 시간을 흡수.
+ */
 export declare function ensureFreshAccessToken(marginMs?: number): Promise<RefreshStatus>;

package/dist/auth/google-auth.js

@@ -60,6 +60,27 @@ export function getStoredTokens() {
         return null;
     }
 }
+/**
+ * tokens.json mtime — 마지막 refresh 시각의 근사값.
+ * (saveTokens 가 매번 writeFileSync 으로 갱신하므로 mtime ≈ 마지막 갱신/저장.)
+ * Google refresh_token 은 7일(미인증 앱) ~ 6개월(인증 앱) 미사용 시 revoke 됨.
+ * auth_status 응답 enrichment 에 사용.
+ */
+export function getTokensLastRefreshMs() {
+    const pathToRead = fs.existsSync(TOKEN_PATH)
+        ? TOKEN_PATH
+        : fs.existsSync(LEGACY_TOKEN_PATH)
+            ? LEGACY_TOKEN_PATH
+            : null;
+    if (!pathToRead)
+        return null;
+    try {
+        return fs.statSync(pathToRead).mtimeMs;
+    }
+    catch {
+        return null;
+    }
+}
 function saveTokens(tokens) {
     ensureDir();
     fs.writeFileSync(TOKEN_PATH, JSON.stringify(tokens, null, 2), { mode: 0o600 });
@@ -189,13 +210,13 @@ export function startAuth(clientId, clientSecret, options = {}) {
                 };
                 saveTokens(stored);
                 res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
-                res.end(`
-          <html><body style="font-family:system-ui;display:flex;justify-content:center;align-items:center;height:100vh;margin:0">
-            <div style="text-align:center">
-              <h1>✅ Mimi Seed 인증 완료!</h1>
-              <p>이 창을 닫고 Claude Code로 돌아가세요.</p>
-            </div>
-          </body></html>
+                res.end(`
+          <html><body style="font-family:system-ui;display:flex;justify-content:center;align-items:center;height:100vh;margin:0">
+            <div style="text-align:center">
+              <h1>✅ Mimi Seed 인증 완료!</h1>
+              <p>이 창을 닫고 Claude Code로 돌아가세요.</p>
+            </div>
+          </body></html>
         `);
                 server.close();
                 activeAuthServer = null;
@@ -253,7 +274,12 @@ export async function login(clientId, clientSecret) {
  *
  * MCP 도구와 CLI 양쪽에서 공유.
  */
-export async function ensureFreshAccessToken(marginMs = 60_000) {
+/**
+ * 사전 갱신 마진. 기존 60_000(1분)에서 300_000(5분)으로 상향 — Google OAuth access_token 의
+ * 통상 lifetime 이 1h 이므로, 5분 마진으로 매 도구 호출 시 만료 임박 시 사전 갱신해
+ * "토큰 만료 → 도구 fail → 재호출" 의 단절 마찰 제거. 5분 마진은 평균 도구 작업 시간을 흡수.
+ */
+export async function ensureFreshAccessToken(marginMs = 300_000) {
     const tokens = getStoredTokens();
     if (!tokens) {
         return {

package/dist/lib/text-validators.d.ts

@@ -0,0 +1,34 @@
+/**
+ * 릴리스 노트 / What's New 텍스트 사전 검증.
+ *
+ * 스토어 측 거부 패턴(HTML 마크업, 길이 초과, 백슬래시 가격 표기 등)을
+ * API 호출 전에 잡아 round-trip 낭비와 무지한 재시도를 차단.
+ *
+ * 모든 detection 은 정규식 기반 단순 휴리스틱 — false positive 최소화를
+ * 위해 실측으로 거부된 패턴만 포함한다.
+ */
+export type ValidationCode = "HTML_TAG" | "LENGTH_EXCEEDED" | "BACKSLASH_PRICE";
+export interface ValidationIssue {
+    code: ValidationCode;
+    message: string;
+    /** 0-based 문자 인덱스. LENGTH_EXCEEDED 에는 없음. */
+    position?: number;
+    /** 문제 구간 ±10자 잘라낸 문자열 (HTML/BACKSLASH 위치 표시용). */
+    excerpt?: string;
+}
+export interface ValidationResult {
+    ok: boolean;
+    issues: ValidationIssue[];
+}
+/** App Store What's New 검증 — 길이(≤4000) + HTML 태그 거부. */
+export declare function validateAppStoreWhatsNew(text: string): ValidationResult;
+/** Play release notes 검증 — 길이(≤500) + HTML + 백슬래시 가격. */
+export declare function validatePlayReleaseNotes(text: string): ValidationResult;
+/** 사용자 친화 메시지로 포맷. MCP 도구가 거부 응답에 그대로 노출. */
+export declare function formatIssuesForUser(issues: ValidationIssue[]): string;
+export declare const __testing: {
+    MAX_APPSTORE_WHATSNEW: number;
+    MAX_PLAY_RELEASE_NOTES: number;
+    HTML_TAG_PATTERN: RegExp;
+    BACKSLASH_PRICE_PATTERN: RegExp;
+};

package/dist/lib/text-validators.js

@@ -0,0 +1,106 @@
+/**
+ * 릴리스 노트 / What's New 텍스트 사전 검증.
+ *
+ * 스토어 측 거부 패턴(HTML 마크업, 길이 초과, 백슬래시 가격 표기 등)을
+ * API 호출 전에 잡아 round-trip 낭비와 무지한 재시도를 차단.
+ *
+ * 모든 detection 은 정규식 기반 단순 휴리스틱 — false positive 최소화를
+ * 위해 실측으로 거부된 패턴만 포함한다.
+ */
+// ── 한계값 (스토어 정책 SSOT) ─────────────────────────────────────
+const MAX_APPSTORE_WHATSNEW = 4000;
+const MAX_PLAY_RELEASE_NOTES = 500;
+// ── 패턴 ──────────────────────────────────────────────────────────
+// HTML 태그: <br>, </tag>, <a href="…"> 모두 매칭. Apple/Play 둘 다 마크업 거부.
+const HTML_TAG_PATTERN = /<\/?[a-zA-Z][^>]*>/g;
+// Play Store 가 홍보 정책으로 거부한 실측 사례: 본문에 '\5000원' 같이
+// 역슬래시 + 숫자 + (선택적 통화 단위) 패턴 (memory: reference_appstore_whatsnew_blacklist).
+const BACKSLASH_PRICE_PATTERN = /\\\d[\d,]*(?:원|won|krw)?/gi;
+// ── 헬퍼 ──────────────────────────────────────────────────────────
+function makeExcerpt(text, pos, radius = 10) {
+    const start = Math.max(0, pos - radius);
+    const end = Math.min(text.length, pos + radius);
+    const left = start > 0 ? "…" : "";
+    const right = end < text.length ? "…" : "";
+    return `${left}${text.slice(start, end)}${right}`;
+}
+function lintHtmlTags(text) {
+    const issues = [];
+    HTML_TAG_PATTERN.lastIndex = 0;
+    let m;
+    while ((m = HTML_TAG_PATTERN.exec(text)) !== null) {
+        issues.push({
+            code: "HTML_TAG",
+            message: `HTML 태그 '${m[0]}' 가 포함됐어요 — App Store / Play 모두 마크업 거부`,
+            position: m.index,
+            excerpt: makeExcerpt(text, m.index),
+        });
+        // 무한루프 방어 (제로폭 매치는 사실상 발생 안 하지만 안전망)
+        if (m.index === HTML_TAG_PATTERN.lastIndex)
+            HTML_TAG_PATTERN.lastIndex++;
+    }
+    return issues;
+}
+function lintLength(text, limit, label) {
+    if (text.length <= limit)
+        return [];
+    return [
+        {
+            code: "LENGTH_EXCEEDED",
+            message: `${label} 길이 ${text.length}자 — ${limit}자 이하로 줄여주세요`,
+        },
+    ];
+}
+function lintBackslashPrice(text) {
+    const issues = [];
+    BACKSLASH_PRICE_PATTERN.lastIndex = 0;
+    let m;
+    while ((m = BACKSLASH_PRICE_PATTERN.exec(text)) !== null) {
+        issues.push({
+            code: "BACKSLASH_PRICE",
+            message: `'${m[0]}' 처럼 역슬래시 + 숫자(가격) 표기는 Play Store 가 홍보 정책으로 거부할 수 있어요`,
+            position: m.index,
+            excerpt: makeExcerpt(text, m.index),
+        });
+        if (m.index === BACKSLASH_PRICE_PATTERN.lastIndex)
+            BACKSLASH_PRICE_PATTERN.lastIndex++;
+    }
+    return issues;
+}
+// ── public API ────────────────────────────────────────────────────
+/** App Store What's New 검증 — 길이(≤4000) + HTML 태그 거부. */
+export function validateAppStoreWhatsNew(text) {
+    const issues = [
+        ...lintLength(text, MAX_APPSTORE_WHATSNEW, "App Store What's New"),
+        ...lintHtmlTags(text),
+    ];
+    return { ok: issues.length === 0, issues };
+}
+/** Play release notes 검증 — 길이(≤500) + HTML + 백슬래시 가격. */
+export function validatePlayReleaseNotes(text) {
+    const issues = [
+        ...lintLength(text, MAX_PLAY_RELEASE_NOTES, "Play release notes"),
+        ...lintHtmlTags(text),
+        ...lintBackslashPrice(text),
+    ];
+    return { ok: issues.length === 0, issues };
+}
+/** 사용자 친화 메시지로 포맷. MCP 도구가 거부 응답에 그대로 노출. */
+export function formatIssuesForUser(issues) {
+    if (issues.length === 0)
+        return "검증 통과";
+    return issues
+        .map((i) => {
+        const loc = i.position !== undefined ? ` (pos ${i.position})` : "";
+        const ex = i.excerpt ? ` — 근처: ${JSON.stringify(i.excerpt)}` : "";
+        return `[${i.code}] ${i.message}${loc}${ex}`;
+    })
+        .join("\n");
+}
+// 테스트용 export (한계값 단언)
+export const __testing = {
+    MAX_APPSTORE_WHATSNEW,
+    MAX_PLAY_RELEASE_NOTES,
+    HTML_TAG_PATTERN,
+    BACKSLASH_PRICE_PATTERN,
+};

package/dist/registers/appstore.js

@@ -4,6 +4,7 @@ import * as appstoreScreenshots from '../appstore/screenshots.js';
 import { createAppleOneTimePurchase, createAppleSubscription, updateAppleProduct, deleteAppleProduct, listAppleProducts, } from '@onesub/providers';
 import { requireAppStoreCreds } from '../helpers.js';
 import { buildAppStoreReleasePlan } from '../checks/plan.js';
+import { validateAppStoreWhatsNew, formatIssuesForUser } from '../lib/text-validators.js';
 export function registerAppstoreTools(server) {
     server.tool('appstore_list_apps', 'App Store Connect 앱 목록 조회', {}, async () => {
         const apps = await appstore.listApps();
@@ -80,6 +81,25 @@ export function registerAppstoreTools(server) {
             ],
         };
     });
+    server.tool('appstore_attach_latest_build', [
+        'App Store 버전에 최신 VALID 빌드를 자동으로 attach — list_builds → 필터 → attach 의 3-step 을 1회로 단축.',
+        '내부: versionId 로 appId 역추적 → listBuilds 에서 processingState=VALID 만 필터 → buildNumber 숫자 최대값 선택 → attach.',
+        'PROCESSING 중인 빌드를 실수로 attach 해서 심사 제출 시 깨지는 케이스를 차단.',
+        'minBuildNumber 옵션으로 floor 지정 가능 (예: 1.4.x 빌드만 attach).',
+    ].join(' '), {
+        versionId: z.string().describe('App Store 버전 ID (appstore_create_version 또는 list_versions 결과)'),
+        minBuildNumber: z.number().int().optional().describe('attach 후보 최소 buildNumber (예: 186 — 이전 빌드 무시)'),
+    }, async ({ versionId, minBuildNumber }) => {
+        const result = await appstore.attachLatestValidBuild(versionId, { minBuildNumber });
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `✅ 최신 VALID 빌드 #${result.buildNumber} (id=${result.attachedBuildId}) 가 버전 ${versionId} 에 연결됐어.\n\n${JSON.stringify(result, null, 2)}`,
+                },
+            ],
+        };
+    });
     server.tool('appstore_get_metadata', 'App Store 버전 메타데이터 (설명문, 키워드, What\'s New)', { versionId: z.string().describe('버전 ID') }, async ({ versionId }) => {
         const localizations = await appstore.getVersionLocalizations(versionId);
         return { content: [{ type: 'text', text: JSON.stringify(localizations, null, 2) }] };
@@ -97,6 +117,19 @@ export function registerAppstoreTools(server) {
         if (Object.keys(cleaned).length === 0) {
             throw new Error('수정할 필드를 하나 이상 지정해줘 (whatsNew, description, keywords, promotionalText, supportUrl, marketingUrl).');
         }
+        // whatsNew 가 포함될 때만 사전 lint — 다른 필드(description/keywords)는 별도 정책.
+        if (typeof cleaned.whatsNew === 'string') {
+            const validation = validateAppStoreWhatsNew(cleaned.whatsNew);
+            if (!validation.ok) {
+                return {
+                    content: [{
+                            type: 'text',
+                            text: `❌ whatsNew 사전 검증 실패 — API 호출 안 함\n\n${formatIssuesForUser(validation.issues)}\n\n수정 후 다시 호출해주세요.`,
+                        }],
+                    isError: true,
+                };
+            }
+        }
         const result = await appstore.updateVersionLocalization(localizationId, cleaned);
         return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
     });
@@ -139,6 +172,17 @@ export function registerAppstoreTools(server) {
         locale: z.string().describe('로캘 (예: ko, en-US, ja)'),
         whatsNew: z.string().describe("'이 버전의 새로운 기능' 텍스트 (4000자 이내)"),
     }, async ({ versionId, locale, whatsNew }) => {
+        // ── 사전 lint — Apple 409 INVALID_CHARACTERS 등 round-trip 낭비 차단.
+        const validation = validateAppStoreWhatsNew(whatsNew);
+        if (!validation.ok) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: `❌ What's New 사전 검증 실패 — API 호출 안 함\n\n${formatIssuesForUser(validation.issues)}\n\n수정 후 다시 호출해주세요.`,
+                    }],
+                isError: true,
+            };
+        }
         const result = await appstore.updateVersionWhatsNew(versionId, locale, { whatsNew });
         return { content: [{ type: 'text', text: `✅ ${locale} 로캘의 What's New가 업데이트됐어.\n\n${JSON.stringify(result, null, 2)}` }] };
     });
@@ -431,11 +475,44 @@ export function registerAppstoreTools(server) {
         '내부 흐름: POST /reviewSubmissions(또는 CREATED 상태 재사용) → POST /reviewSubmissionItems(version attach) → PATCH submitted=true.',
         'appId와 platform은 versionId에서 자동 조회 — 별도 입력 불필요.',
         '⚠️ 비가역 작업: 제출 후엔 Apple 심사가 시작되며, 메타데이터/스크린샷/빌드를 더 못 바꿈 (REJECTED/METADATA_REJECTED 시 다시 편집 가능).',
+        '안전 가드: confirm 생략/false 시 dry-run preview 만 반환 (versionString·빌드·whatsNew 발췌). 실제 제출은 confirm: true 로 재호출.',
         '사전 조건: 버전이 PREPARE_FOR_SUBMISSION 또는 DEVELOPER_REJECTED 상태, 빌드 attached, 모든 필수 메타데이터 채워짐.',
         'appstore_check_submission_risks로 사전 점검 권장.',
     ].join(' '), {
         versionId: z.string().describe('App Store 버전 ID (appstore_list_versions 결과)'),
-    }, async ({ versionId }) => {
+        confirm: z.boolean().optional().describe('true 명시 시에만 실제 심사 제출. 생략/false 면 dry-run preview 만 반환 (비가역 사고 차단).'),
+    }, async ({ versionId, confirm }) => {
+        if (!confirm) {
+            // ── dry-run preview — versionString·빌드·whatsNew 발췌를 사용자에게 보여주고 재호출 유도.
+            const preview = await appstore.buildSubmitForReviewPreview(versionId);
+            const lines = [];
+            lines.push('🛑 심사 제출 dry-run — 아직 실제 제출 안 함.');
+            lines.push('');
+            lines.push(`  versionId    : ${preview.versionId}`);
+            lines.push(`  versionString: ${preview.versionString ?? '(조회 실패)'}`);
+            lines.push(`  state        : ${preview.state ?? '(조회 실패)'}`);
+            lines.push(`  appId        : ${preview.appId}`);
+            lines.push(`  platform     : ${preview.platform}`);
+            if (preview.attachedBuild) {
+                lines.push(`  attachedBuild: #${preview.attachedBuild.buildNumber ?? '?'} (id=${preview.attachedBuild.id}, state=${preview.attachedBuild.processingState ?? '?'})`);
+            }
+            else {
+                lines.push(`  attachedBuild: ⚠️ 미연결 — appstore_attach_latest_build 필요`);
+            }
+            if (preview.whatsNewByLocale.length === 0) {
+                lines.push(`  whatsNew     : ⚠️ 등록된 로컬라이제이션 없음`);
+            }
+            else {
+                lines.push(`  whatsNew     :`);
+                for (const wn of preview.whatsNewByLocale) {
+                    lines.push(`    [${wn.locale}] (${wn.length}자) "${wn.excerpt}"`);
+                }
+            }
+            lines.push('');
+            lines.push('실제 제출하려면 같은 versionId 로 `confirm: true` 옵션을 추가해 재호출하세요.');
+            lines.push('⚠️ 제출 후엔 cancel_review 가 큐 진입(WAITING_FOR_REVIEW) 시점에 막힐 수 있어요 (실측: 1.4.2→3, 1.4.5→6).');
+            return { content: [{ type: 'text', text: lines.join('\n') }] };
+        }
         const result = await appstore.submitVersionForReview(versionId);
         return { content: [{ type: 'text', text: `✅ 버전 ${versionId} 심사 제출 완료 (state: ${result.state}). App Store Connect에서 진행 상태 확인 가능.\n\n${JSON.stringify(result, null, 2)}` }] };
     });

package/dist/registers/auth.js

@@ -1,5 +1,31 @@
 import { getMcpOAuthClient } from '../auth/constants.js';
-import { startAuth, ensureFreshAccessToken } from '../auth/google-auth.js';
+import { startAuth, ensureFreshAccessToken, getTokensLastRefreshMs } from '../auth/google-auth.js';
+/**
+ * tokens.json mtime → "Nd Hh ago" 형식 문자열 + 재인증 권고.
+ * Google 정책: 7일 미사용 시 미인증 앱 refresh_token revoke 가능.
+ * 14일 초과 시 강한 권고, 7일~14일 부드러운 안내.
+ */
+function formatLastRefreshHint(lastMs) {
+    if (lastMs === null)
+        return { label: '(파일 mtime 조회 실패)' };
+    const ageMs = Date.now() - lastMs;
+    const days = Math.floor(ageMs / 86_400_000);
+    const hours = Math.floor((ageMs % 86_400_000) / 3_600_000);
+    const label = days > 0 ? `${days}d ${hours}h 전 갱신` : `${hours}h 전 갱신`;
+    if (days >= 14) {
+        return {
+            label,
+            recommendation: `⚠️ 14일 이상 미사용 — Google 정책상 refresh_token revoke 위험. 안전을 위해 'mimi_seed_auth_start' 로 재인증 권장.`,
+        };
+    }
+    if (days >= 7) {
+        return {
+            label,
+            recommendation: `ℹ️ 7일 이상 미사용 — 한 번 더 갱신하지 않으면 곧 revoke 가능. 다음 도구 호출이 자동 갱신해주지만, 장기 미사용 예정이면 미리 인증 갱신 권장.`,
+        };
+    }
+    return { label };
+}
 export function registerAuthTools(server) {
     server.tool('mimi_seed_auth_start', [
         'Google OAuth 로그인 링크를 발급하고 백그라운드 콜백 서버를 시작.',
@@ -28,6 +54,9 @@ export function registerAuthTools(server) {
     });
     server.tool('mimi_seed_auth_status', 'Mimi Seed MCP 인증 상태 확인 (만료 시 refresh_token으로 자동 갱신 시도)', {}, async () => {
         const r = await ensureFreshAccessToken();
+        const refreshHint = formatLastRefreshHint(getTokensLastRefreshMs());
+        const refreshLine = `   마지막 갱신: ${refreshHint.label}`;
+        const recommendation = refreshHint.recommendation ? `\n\n${refreshHint.recommendation}` : '';
         switch (r.status) {
             case 'unauthenticated':
                 return {
@@ -40,14 +69,19 @@ export function registerAuthTools(server) {
                 };
             case 'fresh': {
                 const min = Math.round(r.msUntilExpiry / 60000);
-                return { content: [{ type: 'text', text: `✅ 인증 유효 (${min}분 남음).` }] };
+                return {
+                    content: [{
+                            type: 'text',
+                            text: `✅ 인증 유효 (${min}분 남음).\n${refreshLine}${recommendation}`,
+                        }],
+                };
             }
             case 'refreshed': {
                 const min = Math.round(r.msUntilExpiry / 60000);
                 return {
                     content: [{
                             type: 'text',
-                            text: `✅ 토큰 만료 → refresh_token으로 자동 갱신 완료 (${min}분 남음).`,
+                            text: `✅ 토큰 만료 → refresh_token으로 자동 갱신 완료 (${min}분 남음).\n${refreshLine}${recommendation}`,
                         }],
                 };
             }
@@ -59,6 +93,7 @@ export function registerAuthTools(server) {
                                 `   코드: ${r.error.code}\n` +
                                 `   ${r.error.message}\n` +
                                 (r.error.hint ? `   → ${r.error.hint}\n` : '') +
+                                `${refreshLine}\n` +
                                 '\n터미널에서 재로그인:\n  npx -y @yoonion/mimi-seed-mcp mimi-seed-auth',
                         }],
                 };

package/dist/registers/checks.js

@@ -1,7 +1,9 @@
 import { z } from 'zod';
 import { checkPlayStoreRisks, checkAppStoreRisks, formatRisks } from '../checks/risks.js';
 import { validateAppStoreScreenshots, validatePlayStoreScreenshots, formatValidationResults } from '../checks/screenshots.js';
-import { requireAuth } from '../helpers.js';
+import { requireAuth, requirePlayStoreAuth } from '../helpers.js';
+import * as appstore from '../appstore/tools.js';
+import * as playstore from '../playstore/tools.js';
 export function registerChecksTools(server) {
     server.tool('playstore_check_submission_risks', [
         'Google Play 제출 전 위험 요소를 자동으로 점검합니다.',
@@ -53,4 +55,90 @@ export function registerChecksTools(server) {
             return { content: [{ type: 'text', text }] };
         }
     });
+    server.tool('release_status', [
+        '양 스토어의 동일 버전 상태를 한 번에 조회 — 1.4.x 배포 시 "Play 는 production?", "ASC 는 심사중?" 을',
+        'list_versions + list_tracks 2회 호출 + grep 으로 합치던 멘탈 부담을 단일 응답으로 줄임.',
+        'App Store: appId 가 있을 때 listVersions 에서 version 일치 항목의 state/releaseType/attached build/createdDate.',
+        'Play Store: packageName 이 있을 때 listTracks 에서 동일 versionName 또는 versionCode 가 있는 모든 트랙의 status/versionCodes.',
+        'appId 또는 packageName 둘 다 비어 있으면 에러. 둘 중 하나만 줘도 그 스토어 상태만 조회 가능.',
+    ].join(' '), {
+        version: z.string().describe('조회할 버전명 (예: "1.4.9"). App Store versionString + Play release.name 매칭에 사용.'),
+        appId: z.string().optional().describe('App Store appId (appstore_list_apps 결과). 없으면 App Store 영역 skip.'),
+        packageName: z.string().optional().describe('Play 패키지명 (예: gg.pryzm.coffee). 없으면 Play 영역 skip.'),
+    }, async ({ version, appId, packageName }) => {
+        if (!appId && !packageName) {
+            throw new Error('appId 또는 packageName 중 최소 하나는 지정해야 해요.');
+        }
+        let appStoreSection = null;
+        if (appId) {
+            try {
+                const versions = (await appstore.listVersions(appId));
+                const match = versions.find((v) => v.version === version);
+                if (match) {
+                    // attached build 조회 — listBuilds 까지 가지 않고 단일 versionId 의 build 만.
+                    // appstore.tools.ts 의 attachBuildToVersion 인접 헬퍼는 외부 노출 X — 여기서는
+                    // listBuilds(appId) 의 최근 10개에서 매칭 추정. 일치하는 buildNumber 가 없어도 무방.
+                    const builds = (await appstore.listBuilds(appId).catch(() => []));
+                    appStoreSection = {
+                        versionId: match.id,
+                        version: match.version,
+                        state: match.state,
+                        releaseType: match.releaseType,
+                        createdDate: match.createdDate,
+                        recentBuilds: builds.slice(0, 3).map((b) => ({
+                            id: b.id,
+                            buildNumber: b.version,
+                            processingState: b.processingState,
+                        })),
+                    };
+                }
+                else {
+                    appStoreSection = {
+                        found: false,
+                        available: versions.slice(0, 10).map((v) => ({ version: v.version, state: v.state })),
+                    };
+                }
+            }
+            catch (e) {
+                appStoreSection = { error: e instanceof Error ? e.message : String(e) };
+            }
+        }
+        // ── Play Store ────────────────────────────────────────
+        let playStoreSection = null;
+        if (packageName) {
+            try {
+                const auth = requirePlayStoreAuth(packageName);
+                const tracks = await playstore.listTracks(auth, packageName);
+                // 트랙별로 version 이 매칭되는 release 찾기.
+                //   match 기준: release.name === version (보통 "1.4.9" 또는 "1.4.9 (373)")
+                //   완전 일치가 없으면 prefix 매칭으로 폴백 (releaseName 표기 변동성 흡수).
+                const byTrack = {};
+                for (const t of tracks) {
+                    const exact = t.releases.find((r) => r.name === version);
+                    const prefix = exact ?? t.releases.find((r) => typeof r.name === 'string' && r.name?.startsWith(`${version} `));
+                    if (prefix) {
+                        byTrack[t.track ?? 'unknown'] = {
+                            releaseName: prefix.name,
+                            status: prefix.status,
+                            versionCodes: prefix.versionCodes,
+                        };
+                    }
+                }
+                playStoreSection = Object.keys(byTrack).length > 0
+                    ? byTrack
+                    : {
+                        found: false,
+                        available: tracks.map((t) => ({
+                            track: t.track,
+                            releases: t.releases.map((r) => ({ name: r.name, status: r.status })),
+                        })),
+                    };
+            }
+            catch (e) {
+                playStoreSection = { error: e instanceof Error ? e.message : String(e) };
+            }
+        }
+        const result = { version, appStore: appStoreSection, playStore: playStoreSection };
+        return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+    });
 }

package/dist/registers/playstore.js

@@ -4,6 +4,7 @@ import { saveServiceAccountJsonForPackage, listRegisteredServiceAccounts, delete
 import { createGoogleOneTimePurchase, createGoogleSubscription, updateGoogleProduct, deleteGoogleProduct, listGoogleProducts, } from '@onesub/providers';
 import { requirePlayStoreAuth, requireServiceAccountJson } from '../helpers.js';
 import { buildPlayStoreReleasePlan } from '../checks/plan.js';
+import { validatePlayReleaseNotes, formatIssuesForUser } from '../lib/text-validators.js';
 export function registerPlaystoreTools(server) {
     server.tool('playstore_get_app', 'Google Play 앱 상세 정보 조회', { packageName: z.string().describe('패키지명 (예: com.findthem.app)') }, async ({ packageName }) => {
         const auth = requirePlayStoreAuth(packageName);
@@ -81,19 +82,73 @@ export function registerPlaystoreTools(server) {
         language: z.string().describe('언어 코드 (예: ko-KR, en-US)'),
         text: z.string().describe('릴리스 노트 본문 (500자 이내)'),
     }, async ({ packageName, track, versionCode, language, text }) => {
+        // ── 사전 lint — 500자 / HTML / 역슬래시 가격(\5000원) round-trip 차단.
+        const validation = validatePlayReleaseNotes(text);
+        if (!validation.ok) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: `❌ 릴리스 노트 사전 검증 실패 — API 호출 안 함\n\n${formatIssuesForUser(validation.issues)}\n\n수정 후 다시 호출해주세요.`,
+                    }],
+                isError: true,
+            };
+        }
         const auth = requirePlayStoreAuth(packageName);
         const result = await playstore.updateReleaseNotes(auth, packageName, track, versionCode, language, text);
         return { content: [{ type: 'text', text: `✅ ${packageName} ${track} v${versionCode} ${language} 노트 반영\n\n${JSON.stringify(result, null, 2)}` }] };
     });
-    server.tool('playstore_update_latest_release_notes', "Google Play 트랙의 최신 릴리스(versionCode 최대) '최근 변경사항' 업데이트 — versionCode를 모를 때 편의용", {
+    server.tool('playstore_update_latest_release_notes', [
+        "Google Play 트랙의 최신 릴리스(versionCode 최대) '최근 변경사항' 업데이트 — versionCode를 모를 때 편의용.",
+        '⚠️ 지정한 단일 트랙에만 적용 — 다른 트랙에는 자동 복사되지 않음 (Google Play 정책: promote_release 시점에 노트 캐리됨).',
+        '동일 노트를 여러 트랙에 즉시 반영하려면 syncTracks 옵션 사용 — 지정 트랙들에 대해 순차로 같은 노트 적용.',
+    ].join(' '), {
         packageName: z.string().describe('패키지명'),
-        track: z.enum(['production', 'beta', 'alpha', 'internal']).describe('릴리스 트랙'),
+        track: z.enum(['production', 'beta', 'alpha', 'internal']).describe('1차 적용 트랙'),
         language: z.string().describe('언어 코드 (예: ko-KR)'),
         text: z.string().describe('릴리스 노트 본문 (500자 이내)'),
-    }, async ({ packageName, track, language, text }) => {
+        syncTracks: z.array(z.enum(['production', 'beta', 'alpha', 'internal']))
+            .optional()
+            .describe('추가로 동일 노트 적용할 트랙 배열 (예: ["production"]). 지정 시 1차 track 반영 후 순차 동기화.'),
+    }, async ({ packageName, track, language, text, syncTracks }) => {
+        const validation = validatePlayReleaseNotes(text);
+        if (!validation.ok) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: `❌ 릴리스 노트 사전 검증 실패 — API 호출 안 함\n\n${formatIssuesForUser(validation.issues)}\n\n수정 후 다시 호출해주세요.`,
+                    }],
+                isError: true,
+            };
+        }
         const auth = requirePlayStoreAuth(packageName);
-        const result = await playstore.updateLatestReleaseNotes(auth, packageName, track, language, text);
-        return { content: [{ type: 'text', text: `✅ ${packageName} ${track} (versionCodes=${JSON.stringify(result.updatedVersionCodes)}) ${language} 노트 반영\n\n${JSON.stringify(result, null, 2)}` }] };
+        // 1차 적용 + 결과 누적.
+        const primaryResult = await playstore.updateLatestReleaseNotes(auth, packageName, track, language, text);
+        const lines = [
+            `✅ ${packageName} ${track} (versionCodes=${JSON.stringify(primaryResult.updatedVersionCodes)}) ${language} 노트 반영`,
+        ];
+        const allResults = { [track]: primaryResult };
+        // 추가 트랙 — 1차와 중복은 skip. 한 트랙 실패해도 나머지 트랙은 계속 시도.
+        if (syncTracks && syncTracks.length > 0) {
+            const targets = syncTracks.filter((t) => t !== track);
+            for (const t of targets) {
+                try {
+                    const r = await playstore.updateLatestReleaseNotes(auth, packageName, t, language, text);
+                    allResults[t] = r;
+                    lines.push(`  ↳ sync ${t} (versionCodes=${JSON.stringify(r.updatedVersionCodes)}) 반영`);
+                }
+                catch (e) {
+                    const msg = e instanceof Error ? e.message : String(e);
+                    allResults[t] = { error: msg };
+                    lines.push(`  ↳ sync ${t} 실패: ${msg}`);
+                }
+            }
+        }
+        return {
+            content: [{
+                    type: 'text',
+                    text: `${lines.join('\n')}\n\n${JSON.stringify(allResults, null, 2)}`,
+                }],
+        };
     });
     server.tool('playstore_list_reviews', 'Google Play 리뷰 목록 조회', { packageName: z.string().describe('패키지명') }, async ({ packageName }) => {
         const auth = requirePlayStoreAuth(packageName);

package/package.json

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