@yoonion/mimi-seed-mcp 0.13.3 → 0.13.5

package/dist/appstore/http.d.ts

@@ -0,0 +1,5 @@
+export declare const V1_BASE = "https://api.appstoreconnect.apple.com/v1";
+export declare const V2_BASE = "https://api.appstoreconnect.apple.com/v2";
+export type AppStoreProductType = 'subscription' | 'consumable' | 'non_consumable';
+export declare function authHeadersOrThrow(): Promise<Record<string, string>>;
+export declare function apiRequest<T>(base: string, resourcePath: string, authHeaders: Record<string, string>, init: RequestInit): Promise<T>;

package/dist/appstore/http.js

@@ -0,0 +1,28 @@
+import { getAuthHeaders } from './auth.js';
+import { friendlyAppStoreError } from './errors.js';
+export const V1_BASE = 'https://api.appstoreconnect.apple.com/v1';
+export const V2_BASE = 'https://api.appstoreconnect.apple.com/v2';
+export async function authHeadersOrThrow() {
+    const headers = await getAuthHeaders();
+    if (!headers) {
+        throw new Error([
+            '❌ App Store Connect 인증이 필요해.',
+            '',
+            '터미널에서 실행:',
+            '  npx -p @yoonion/mimi-seed-mcp mimi-seed-appstore-auth',
+        ].join('\n'));
+    }
+    return headers;
+}
+export async function apiRequest(base, resourcePath, authHeaders, init) {
+    const response = await fetch(`${base}${resourcePath}`, {
+        ...init,
+        headers: { ...authHeaders, ...(init.headers ?? {}) },
+    });
+    if (!response.ok) {
+        const body = await response.text();
+        throw friendlyAppStoreError(response.status, body);
+    }
+    const text = await response.text();
+    return (text ? JSON.parse(text) : { ok: true });
+}

package/dist/appstore/product-localization.d.ts

@@ -0,0 +1,35 @@
+import type { AppStoreProductType } from './http.js';
+export interface ProductLocalization {
+    id: string;
+    locale: string;
+    name?: string;
+    description?: string;
+    state?: string;
+}
+/** 상품에 등록된 현지화 목록. */
+export declare function listProductLocalizations(args: {
+    internalId: string;
+    productType: AppStoreProductType;
+}): Promise<ProductLocalization[]>;
+/**
+ * 로케일 하나를 upsert 한다 — 있으면 PATCH, 없으면 POST.
+ *
+ * 호출자가 "이미 있나?"를 먼저 묻지 않아도 되게 한 건 의도적이다. 같은 값을 두 번
+ * 넣어도 409 로 깨지지 않아야 재시도가 안전하다.
+ */
+export declare function upsertProductLocalization(args: {
+    internalId: string;
+    productType: AppStoreProductType;
+    locale: string;
+    name?: string;
+    description?: string;
+}): Promise<ProductLocalization & {
+    created: boolean;
+}>;
+/** 로케일 하나를 삭제한다. */
+export declare function deleteProductLocalization(args: {
+    localizationId: string;
+    productType: AppStoreProductType;
+}): Promise<{
+    localizationId: string;
+}>;

package/dist/appstore/product-localization.js

@@ -0,0 +1,105 @@
+import { V1_BASE, V2_BASE, apiRequest, authHeadersOrThrow } from './http.js';
+function localizationResource(productType) {
+    if (productType === 'subscription') {
+        return {
+            type: 'subscriptionLocalizations',
+            path: '/subscriptionLocalizations',
+            relationship: 'subscription',
+            relatedType: 'subscriptions',
+            listBase: V1_BASE,
+            listPath: (internalId) => `/subscriptions/${internalId}/subscriptionLocalizations`,
+        };
+    }
+    return {
+        type: 'inAppPurchaseLocalizations',
+        path: '/inAppPurchaseLocalizations',
+        relationship: 'inAppPurchaseV2',
+        relatedType: 'inAppPurchases',
+        // 일회성 IAP 는 v2 리소스라 목록만 v2 에서 읽는다. 쓰기는 v1 이다.
+        listBase: V2_BASE,
+        listPath: (internalId) => `/inAppPurchases/${internalId}/inAppPurchaseLocalizations`,
+    };
+}
+function toLocalization(item) {
+    return {
+        id: item.id,
+        locale: item.attributes?.locale ?? '',
+        name: item.attributes?.name,
+        description: item.attributes?.description,
+        state: item.attributes?.state,
+    };
+}
+/** 상품에 등록된 현지화 목록. */
+export async function listProductLocalizations(args) {
+    const { internalId, productType } = args;
+    const resource = localizationResource(productType);
+    const authHeaders = await authHeadersOrThrow();
+    const result = await apiRequest(resource.listBase, `${resource.listPath(internalId)}?limit=200`, authHeaders, { method: 'GET' });
+    return (result.data ?? []).map(toLocalization);
+}
+/**
+ * 로케일 하나를 upsert 한다 — 있으면 PATCH, 없으면 POST.
+ *
+ * 호출자가 "이미 있나?"를 먼저 묻지 않아도 되게 한 건 의도적이다. 같은 값을 두 번
+ * 넣어도 409 로 깨지지 않아야 재시도가 안전하다.
+ */
+export async function upsertProductLocalization(args) {
+    const { internalId, productType, locale, name, description } = args;
+    if (!name && description === undefined) {
+        throw new Error('name 또는 description 중 하나는 있어야 해.');
+    }
+    const resource = localizationResource(productType);
+    const authHeaders = await authHeadersOrThrow();
+    const existing = (await listProductLocalizations({ internalId, productType }))
+        .find((item) => item.locale.toLowerCase() === locale.toLowerCase());
+    if (existing) {
+        // 넘긴 필드만 보낸다 — description 을 생략한 호출이 기존 설명을 지우면 안 된다.
+        const attributes = {};
+        if (name !== undefined)
+            attributes.name = name;
+        if (description !== undefined)
+            attributes.description = description;
+        const updated = await apiRequest(V1_BASE, `${resource.path}/${existing.id}`, authHeaders, {
+            method: 'PATCH',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ data: { type: resource.type, id: existing.id, attributes } }),
+        });
+        return {
+            ...toLocalization(updated.data ?? { id: existing.id }),
+            locale: updated.data?.attributes?.locale ?? existing.locale,
+            created: false,
+        };
+    }
+    if (!name) {
+        throw new Error(`새 로케일(${locale})을 만들려면 name 이 필요해.`);
+    }
+    const attributes = { locale, name };
+    if (description !== undefined)
+        attributes.description = description;
+    const created = await apiRequest(V1_BASE, resource.path, authHeaders, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+            data: {
+                type: resource.type,
+                attributes,
+                relationships: {
+                    [resource.relationship]: { data: { type: resource.relatedType, id: internalId } },
+                },
+            },
+        }),
+    });
+    return {
+        ...toLocalization(created.data ?? { id: '' }),
+        locale: created.data?.attributes?.locale ?? locale,
+        created: true,
+    };
+}
+/** 로케일 하나를 삭제한다. */
+export async function deleteProductLocalization(args) {
+    const { localizationId, productType } = args;
+    const resource = localizationResource(productType);
+    const authHeaders = await authHeadersOrThrow();
+    await apiRequest(V1_BASE, `${resource.path}/${localizationId}`, authHeaders, { method: 'DELETE' });
+    return { localizationId };
+}

package/dist/appstore/product-review.d.ts

@@ -1,4 +1,5 @@
-export type AppStoreProductType = 'subscription' | 'consumable' | 'non_consumable';
+export type { AppStoreProductType } from './http.js';
+import type { AppStoreProductType } from './http.js';
 /** 기존 IAP/구독 상품의 App Review 노트를 수정한다. */
 export declare function updateProductReviewNote(args: {
     internalId: string;

package/dist/appstore/product-review.js

@@ -1,34 +1,7 @@
 import crypto from 'node:crypto';
 import fs from 'node:fs';
 import path from 'node:path';
-import { getAuthHeaders } from './auth.js';
-import { friendlyAppStoreError } from './errors.js';
-const V1_BASE = 'https://api.appstoreconnect.apple.com/v1';
-const V2_BASE = 'https://api.appstoreconnect.apple.com/v2';
-async function authHeadersOrThrow() {
-    const headers = await getAuthHeaders();
-    if (!headers) {
-        throw new Error([
-            '❌ App Store Connect 인증이 필요해.',
-            '',
-            '터미널에서 실행:',
-            '  npx -p @yoonion/mimi-seed-mcp mimi-seed-appstore-auth',
-        ].join('\n'));
-    }
-    return headers;
-}
-async function apiRequest(base, resourcePath, authHeaders, init) {
-    const response = await fetch(`${base}${resourcePath}`, {
-        ...init,
-        headers: { ...authHeaders, ...(init.headers ?? {}) },
-    });
-    if (!response.ok) {
-        const body = await response.text();
-        throw friendlyAppStoreError(response.status, body);
-    }
-    const text = await response.text();
-    return (text ? JSON.parse(text) : { ok: true });
-}
+import { V1_BASE, V2_BASE, apiRequest, authHeadersOrThrow } from './http.js';
 function productResource(productType) {
     if (productType === 'subscription') {
         return { base: V1_BASE, type: 'subscriptions', path: '/subscriptions' };

package/dist/appstore/tools.d.ts

@@ -1,3 +1,4 @@
+import type { AppStoreProductType } from './http.js';
 export declare function apiGet(path: string, params?: Record<string, string>): Promise<any>;
 export interface AppStoreVerifyResult {
     ok: boolean;
@@ -167,6 +168,20 @@ export declare function submitVersionForReview(versionId: string): Promise<{
     itemAttached: boolean;
     state: any;
 }>;
+export declare function addProductToReviewSubmission(args: {
+    appId: string;
+    internalId: string;
+    productType: AppStoreProductType;
+    platform?: string;
+}): Promise<{
+    submissionId: string;
+    appId: string;
+    platform: string;
+    internalId: string;
+    productType: AppStoreProductType;
+    reusedSubmission: boolean;
+    itemAttached: boolean;
+}>;
 export declare function cancelVersionReview(versionId: string): Promise<{
     submissionId: string;
     previousState: string;

package/dist/appstore/tools.js

@@ -650,6 +650,64 @@ export async function submitVersionForReview(versionId) {
         state: submitted?.data?.attributes?.state ?? 'WAITING_FOR_REVIEW',
     };
 }
+// ─── IAP/구독을 심사 제출 묶음에 추가 ───
+//
+// App Store Connect 웹의 "심사에 추가" 버튼과 같은 동작이다. 제출하지는 않는다 —
+// 항목만 담고, 실제 제출은 submitVersionForReview 가 한다.
+//
+// 이게 왜 별도로 필요한가: 어떤 앱의 **첫 소모성 IAP** 는 앱 버전과 같은 묶음으로만
+// 심사에 넣을 수 있다. IAP 만 담긴 초안은 "심사에 제출할 수 없음" 으로 막힌다.
+// 그래서 순서가 중요하다 — IAP 를 전부 담은 뒤 버전을 제출해야 한 번에 나간다.
+function productReviewItemRelationship(productType) {
+    if (productType === 'subscription') {
+        return { key: 'subscription', type: 'subscriptions' };
+    }
+    return { key: 'inAppPurchaseV2', type: 'inAppPurchases' };
+}
+export async function addProductToReviewSubmission(args) {
+    const { appId, internalId, productType } = args;
+    const platform = args.platform ?? 'IOS';
+    const relationship = productReviewItemRelationship(productType);
+    let submissionId = await findOpenReviewSubmission(appId, platform);
+    const reusedSubmission = Boolean(submissionId);
+    if (!submissionId) {
+        const created = await apiPost('/reviewSubmissions', {
+            data: {
+                type: 'reviewSubmissions',
+                attributes: { platform },
+                relationships: { app: { data: { type: 'apps', id: appId } } },
+            },
+        });
+        submissionId = created?.data?.id;
+        if (!submissionId) {
+            throw new Error(`reviewSubmission 생성 응답에 id가 없어: ${JSON.stringify(created)}`);
+        }
+    }
+    // 같은 상품을 두 번 담으면 Apple 이 409 를 준다. 재시도가 안전하도록 먼저 확인한다.
+    const items = await apiGet(`/reviewSubmissions/${submissionId}/items`, { limit: '50' });
+    const rows = (items?.data ?? []);
+    const alreadyAttached = rows.some((row) => row?.relationships?.[relationship.key]?.data?.id === internalId);
+    if (!alreadyAttached) {
+        await apiPost('/reviewSubmissionItems', {
+            data: {
+                type: 'reviewSubmissionItems',
+                relationships: {
+                    reviewSubmission: { data: { type: 'reviewSubmissions', id: submissionId } },
+                    [relationship.key]: { data: { type: relationship.type, id: internalId } },
+                },
+            },
+        });
+    }
+    return {
+        submissionId,
+        appId,
+        platform,
+        internalId,
+        productType,
+        reusedSubmission,
+        itemAttached: !alreadyAttached,
+    };
+}
 // ─── 심사 철회 (Cancel Review) ───
 // WAITING_FOR_REVIEW 상태의 reviewSubmission에만 적용 가능.
 // IN_REVIEW 진입 후에는 Apple API가 거부함 (409).

package/dist/playstore/tools.d.ts

@@ -127,6 +127,40 @@ export declare function listSubscriptions(auth: OAuth2Client | JWT, packageName:
     basePlans: import("googleapis").androidpublisher_v3.Schema$BasePlan[] | undefined;
     listings: import("googleapis").androidpublisher_v3.Schema$SubscriptionListing[] | undefined;
 }[]>;
+export interface ProductListingInput {
+    languageCode: string;
+    title?: string;
+    description?: string;
+    /** 구독 전용. 최대 4개. */
+    benefits?: string[];
+}
+interface StoredListing {
+    languageCode?: string | null;
+    title?: string | null;
+    description?: string | null;
+    benefits?: string[] | null;
+}
+export declare function updateOneTimeProductListings(auth: OAuth2Client | JWT, packageName: string, productId: string, listings: ProductListingInput[]): Promise<{
+    productId: string;
+    created: string[];
+    updated: string[];
+    listings: StoredListing[];
+}>;
+export declare function updateSubscriptionListings(auth: OAuth2Client | JWT, packageName: string, productId: string, listings: ProductListingInput[]): Promise<{
+    productId: string;
+    created: string[];
+    updated: string[];
+    listings: StoredListing[];
+}>;
+export declare function updatePurchaseOptionState(auth: OAuth2Client | JWT, packageName: string, productId: string, purchaseOptionId: string, action: 'activate' | 'deactivate'): Promise<{
+    productId: string;
+    purchaseOptionId: string;
+    action: "activate" | "deactivate";
+    states: {
+        purchaseOptionId: string | undefined;
+        state: string | undefined;
+    }[];
+}>;
 export type ServiceAccountVerifyResult = {
     ok: true;
     clientEmail: string;
@@ -138,3 +172,4 @@ export type ServiceAccountVerifyResult = {
     message: string;
 };
 export declare function verifyServiceAccountJson(serviceAccountJson: string, packageName: string): Promise<ServiceAccountVerifyResult>;
+export {};

package/dist/playstore/tools.js

@@ -493,6 +493,111 @@ export async function listSubscriptions(auth, packageName) {
         listings: s.listings,
     }));
 }
+// ─── 인앱 상품 / 구독 현지화 ───
+//
+// Play 는 상품 현지화를 listings 배열로 들고 있고, patch 의 updateMask=listings 는
+// **배열을 통째로 갈아끼운다**. 그래서 넘긴 로케일만 실으면 나머지 언어가 조용히
+// 사라진다 — 반드시 현재 값을 읽어 병합한 뒤 써야 한다.
+//
+// regionsVersion.version 은 patch 의 필수 쿼리다. 빼면 400 이다.
+const REGIONS_VERSION = '2022/02';
+/**
+ * 들어온 로케일만 덮어쓰고 나머지는 보존한다.
+ * 새 로케일은 title 이 있어야 만든다 — Play 가 title 없는 listing 을 거부한다.
+ */
+function mergeListings(current, incoming, opts) {
+    const merged = current.map((item) => ({ ...item }));
+    const created = [];
+    const updated = [];
+    for (const next of incoming) {
+        const found = merged.find((item) => (item.languageCode ?? '').toLowerCase() === next.languageCode.toLowerCase());
+        const target = found ?? { languageCode: next.languageCode };
+        if (!found) {
+            if (!next.title) {
+                throw new Error(`새 로케일(${next.languageCode})을 만들려면 title 이 필요해.`);
+            }
+            merged.push(target);
+            created.push(next.languageCode);
+        }
+        else {
+            updated.push(next.languageCode);
+        }
+        if (next.title !== undefined)
+            target.title = next.title;
+        if (next.description !== undefined)
+            target.description = next.description;
+        if (next.benefits !== undefined) {
+            if (!opts.allowBenefits) {
+                throw new Error('benefits 는 구독 상품에만 쓸 수 있어.');
+            }
+            target.benefits = next.benefits;
+        }
+    }
+    return { merged, created, updated };
+}
+export async function updateOneTimeProductListings(auth, packageName, productId, listings) {
+    const current = await publisher().monetization.onetimeproducts.get({
+        auth, packageName, productId,
+    });
+    const { merged, created, updated } = mergeListings((current.data?.listings ?? []), listings, { allowBenefits: false });
+    const res = await publisher().monetization.onetimeproducts.patch({
+        auth,
+        packageName,
+        productId,
+        updateMask: 'listings',
+        'regionsVersion.version': REGIONS_VERSION,
+        requestBody: { listings: merged },
+    });
+    return {
+        productId,
+        created,
+        updated,
+        listings: (res.data?.listings ?? merged),
+    };
+}
+export async function updateSubscriptionListings(auth, packageName, productId, listings) {
+    const current = await publisher().monetization.subscriptions.get({
+        auth, packageName, productId,
+    });
+    const { merged, created, updated } = mergeListings((current.data?.listings ?? []), listings, { allowBenefits: true });
+    const res = await publisher().monetization.subscriptions.patch({
+        auth,
+        packageName,
+        productId,
+        updateMask: 'listings',
+        'regionsVersion.version': REGIONS_VERSION,
+        requestBody: { listings: merged },
+    });
+    return {
+        productId,
+        created,
+        updated,
+        listings: (res.data?.listings ?? merged),
+    };
+}
+// ─── 구매 옵션 상태 (DRAFT ↔ ACTIVE) ───
+//
+// 상품을 만들어도 구매 옵션이 DRAFT 면 앱에서 가격이 안 내려온다.
+// Play Console 의 "활성화" 토글이 이 API 다.
+export async function updatePurchaseOptionState(auth, packageName, productId, purchaseOptionId, action) {
+    const key = action === 'activate'
+        ? 'activatePurchaseOptionRequest'
+        : 'deactivatePurchaseOptionRequest';
+    const res = await publisher().monetization.onetimeproducts.purchaseOptions.batchUpdateStates({
+        auth,
+        packageName,
+        productId,
+        requestBody: {
+            requests: [{ [key]: { packageName, productId, purchaseOptionId } }],
+        },
+    });
+    const products = (res.data?.oneTimeProducts ?? []);
+    const states = products.flatMap((p) => (p.purchaseOptions ?? []).map((o) => ({
+        purchaseOptionId: o.purchaseOptionId,
+        state: o.state,
+    })));
+    return { productId, purchaseOptionId, action, states };
+}
 export async function verifyServiceAccountJson(serviceAccountJson, packageName) {
     let parsed;
     try {

package/dist/registers/appstore.js

@@ -2,6 +2,7 @@ import { z } from 'zod';
 import * as appstore from '../appstore/tools.js';
 import * as appstoreScreenshots from '../appstore/screenshots.js';
 import * as appstoreProductReview from '../appstore/product-review.js';
+import * as appstoreProductLocalization from '../appstore/product-localization.js';
 import { createAppleOneTimePurchase, createAppleSubscription, updateAppleProduct, deleteAppleProduct, listAppleProducts, } from '@onesub/providers';
 import { requireAppStoreCreds } from '../helpers.js';
 import { buildAppStoreReleasePlan } from '../checks/plan.js';
@@ -489,6 +490,64 @@ export function registerAppstoreTools(server) {
                 }],
         };
     });
+    server.tool('appstore_list_product_localizations', 'App Store IAP/구독 상품의 현지화(표시 이름·설명) 목록 조회. locale / name / description / state 반환.', {
+        appId: z.string().describe('App Store 앱 ID (숫자형, appstore_list_apps 결과)'),
+        productId: z.string().describe('상품 ID (appstore_list_products 결과)'),
+        productType: z.enum(['subscription', 'consumable', 'non_consumable']).describe('상품 유형'),
+    }, async ({ appId, productId, productType }) => {
+        const creds = requireAppStoreCreds();
+        const products = await listAppleProducts({
+            appId, keyId: creds.keyId, issuerId: creds.issuerId, privateKey: creds.privateKey,
+        });
+        const product = products.find((item) => item.productId === productId && item.type === productType);
+        if (!product) {
+            return { content: [{ type: 'text', text: `상품을 찾을 수 없음: ${productId} (${productType})` }] };
+        }
+        const localizations = await appstoreProductLocalization.listProductLocalizations({
+            internalId: product.internalId,
+            productType,
+        });
+        return { content: [{ type: 'text', text: JSON.stringify(localizations, null, 2) }] };
+    });
+    server.tool('appstore_update_product_localization', 'App Store IAP/구독 상품의 현지화(표시 이름·설명)를 로케일 단위로 upsert — 있으면 수정, 없으면 생성. ' +
+        '현지화가 비면 상품이 MISSING_METADATA 에서 안 풀려 심사에 넣을 수 없다 (리뷰 노트·스크린샷과는 별개 리소스). ' +
+        'locale 은 App Store 표기(ko, en-US, ja, zh-Hant)를 쓴다. name 30자 / description 45자 제한.', {
+        appId: z.string().describe('App Store 앱 ID (숫자형, appstore_list_apps 결과)'),
+        productId: z.string().describe('상품 ID (appstore_list_products 결과)'),
+        productType: z.enum(['subscription', 'consumable', 'non_consumable']).describe('상품 유형'),
+        locale: z.string().describe('로케일 (예: ko, en-US, ja, zh-Hant)'),
+        name: z.string().max(30).optional().describe('표시 이름 (30자 이하). 새 로케일 생성 시 필수'),
+        description: z.string().max(45).optional().describe('설명 (45자 이하). 생략하면 기존 값 유지'),
+    }, async ({ appId, productId, productType, locale, name, description }) => {
+        const creds = requireAppStoreCreds();
+        const products = await listAppleProducts({
+            appId, keyId: creds.keyId, issuerId: creds.issuerId, privateKey: creds.privateKey,
+        });
+        const product = products.find((item) => item.productId === productId && item.type === productType);
+        if (!product) {
+            return { content: [{ type: 'text', text: `상품을 찾을 수 없음: ${productId} (${productType})` }] };
+        }
+        const result = await appstoreProductLocalization.upsertProductLocalization({
+            internalId: product.internalId,
+            productType,
+            locale,
+            name,
+            description,
+        });
+        return {
+            content: [{
+                    type: 'text',
+                    text: [
+                        `✓ 현지화 ${result.created ? '생성' : '수정'} 완료`,
+                        `productId: ${productId}`,
+                        `locale: ${result.locale}`,
+                        result.name ? `name: ${result.name}` : '',
+                        result.description ? `description: ${result.description}` : '',
+                        result.state ? `state: ${result.state}` : '',
+                    ].filter(Boolean).join('\n'),
+                }],
+        };
+    });
     server.tool('appstore_upload_product_review_screenshot', '기존 App Store IAP/구독 상품의 심사용 스크린샷을 reserve → upload → commit. 상품당 1장, 절대 파일 경로 필요.', {
         appId: z.string().describe('App Store 앱 ID (숫자형, appstore_list_apps 결과)'),
         productId: z.string().describe('상품 ID (appstore_list_products 결과)'),
@@ -523,7 +582,46 @@ export function registerAppstoreTools(server) {
                 }],
         };
     });
-    server.tool('appstore_update_product', 'App Store IAP 상품의 reference name 변경. productId / 유형은 변경 불가.', {
+    server.tool('appstore_add_product_to_review', 'App Store IAP/구독을 심사 제출 묶음에 담는다 — App Store Connect 웹의 "심사에 추가" 버튼과 같다. ' +
+        '담기만 하고 제출하지는 않는다 (제출은 appstore_submit_for_review). ' +
+        '⚠️ 그 앱의 첫 소모성 IAP 는 앱 버전과 같은 묶음으로만 심사에 넣을 수 있다 — IAP 를 전부 담은 뒤 버전을 제출해야 한 번에 나간다. ' +
+        '상품 상태가 READY_TO_SUBMIT 이어야 한다 (MISSING_METADATA 면 appstore_update_product_localization 먼저).', {
+        appId: z.string().describe('App Store 앱 ID (숫자형, appstore_list_apps 결과)'),
+        productId: z.string().describe('상품 ID (appstore_list_products 결과)'),
+        productType: z.enum(['subscription', 'consumable', 'non_consumable']).describe('상품 유형'),
+        platform: z.enum(['IOS', 'MAC_OS', 'TV_OS', 'VISION_OS']).default('IOS').optional()
+            .describe('플랫폼 (기본 IOS)'),
+    }, async ({ appId, productId, productType, platform }) => {
+        const creds = requireAppStoreCreds();
+        const products = await listAppleProducts({
+            appId, keyId: creds.keyId, issuerId: creds.issuerId, privateKey: creds.privateKey,
+        });
+        const product = products.find((item) => item.productId === productId && item.type === productType);
+        if (!product) {
+            return { content: [{ type: 'text', text: `상품을 찾을 수 없음: ${productId} (${productType})` }] };
+        }
+        const result = await appstore.addProductToReviewSubmission({
+            appId,
+            internalId: product.internalId,
+            productType,
+            platform,
+        });
+        return {
+            content: [{
+                    type: 'text',
+                    text: [
+                        result.itemAttached ? '✓ 심사 묶음에 추가됨' : '이미 묶음에 들어 있음 (변경 없음)',
+                        `productId: ${productId}`,
+                        `submissionId: ${result.submissionId}`,
+                        `기존 묶음 재사용: ${result.reusedSubmission}`,
+                        '',
+                        '제출은 아직 안 됐다. 담을 상품을 전부 담은 뒤 appstore_submit_for_review 로 버전과 함께 제출한다.',
+                    ].join('\n'),
+                }],
+        };
+    });
+    server.tool('appstore_update_product', 'App Store IAP 상품의 reference name 변경. productId / 유형은 변경 불가. ' +
+        '스토어에 보이는 표시 이름·설명은 appstore_update_product_localization 을 쓴다.', {
         appId: z.string().optional().describe('App Store 앱 ID'),
         bundleId: z.string().optional().describe('번들 ID (appId 대신 사용 가능)'),
         productId: z.string().describe('상품 ID'),

package/dist/registers/playstore.js

@@ -595,7 +595,79 @@ export function registerPlaystoreTools(server) {
         const products = await listGoogleProducts({ packageName, serviceAccountKey: json });
         return { content: [{ type: 'text', text: JSON.stringify(products, null, 2) }] };
     });
-    server.tool('playstore_update_product', 'Google Play IAP 상품의 표시 이름 변경 (현재 name 필드만 수정 가능). productId / type / 가격은 변경 불가.', {
+    server.tool('playstore_update_product_listing', 'Google Play 인앱 상품(소모성/비소모성)의 언어별 제목·설명을 갱신. 넘긴 로케일만 덮어쓰고 나머지 언어는 보존한다. ' +
+        '리스팅이 없는 언어의 사용자에게는 앱 기본 언어 리스팅이 대신 보인다 — 번역을 넣어야 그 나라 결제창이 그 나라 말로 나온다. ' +
+        '구독은 playstore_update_subscription_listing 을 쓴다.', {
+        packageName: z.string().describe('패키지명'),
+        productId: z.string().describe('상품 ID (playstore_list_inapp_products 결과)'),
+        listings: z.array(z.object({
+            languageCode: z.string().describe('언어 코드 (예: ko-KR, en-US, ja-JP, zh-TW)'),
+            title: z.string().max(55).optional().describe('제목 (55자 이하). 새 언어 추가 시 필수'),
+            description: z.string().max(200).optional().describe('설명 (200자 이하)'),
+        })).min(1).describe('갱신할 언어별 리스팅'),
+    }, async ({ packageName, productId, listings }) => {
+        const auth = requirePlayStoreAuth(packageName);
+        const result = await playstore.updateOneTimeProductListings(auth, packageName, productId, listings);
+        return {
+            content: [{
+                    type: 'text',
+                    text: [
+                        `✓ ${productId} 리스팅 갱신`,
+                        result.created.length ? `추가된 언어: ${result.created.join(', ')}` : '',
+                        result.updated.length ? `수정된 언어: ${result.updated.join(', ')}` : '',
+                        `현재 언어: ${result.listings.map((l) => l.languageCode).join(', ')}`,
+                    ].filter(Boolean).join('\n'),
+                }],
+        };
+    });
+    server.tool('playstore_update_subscription_listing', 'Google Play 구독 상품의 언어별 제목·설명·혜택(benefits)을 갱신. 넘긴 로케일만 덮어쓰고 나머지 언어는 보존한다. ' +
+        'benefits 는 스토어 구매창에 불릿으로 나오는 항목이라 한 줄에 몰아넣지 말고 항목을 나눠 넣는다 (최대 4개).', {
+        packageName: z.string().describe('패키지명'),
+        productId: z.string().describe('구독 상품 ID (playstore_list_subscriptions 결과)'),
+        listings: z.array(z.object({
+            languageCode: z.string().describe('언어 코드 (예: ko-KR, en-US, ja-JP, zh-TW)'),
+            title: z.string().max(55).optional().describe('제목 (55자 이하). 새 언어 추가 시 필수'),
+            description: z.string().max(200).optional().describe('설명 (200자 이하)'),
+            benefits: z.array(z.string().max(40)).max(4).optional()
+                .describe('혜택 항목 (각 40자 이하, 최대 4개). 생략하면 기존 값 유지'),
+        })).min(1).describe('갱신할 언어별 리스팅'),
+    }, async ({ packageName, productId, listings }) => {
+        const auth = requirePlayStoreAuth(packageName);
+        const result = await playstore.updateSubscriptionListings(auth, packageName, productId, listings);
+        return {
+            content: [{
+                    type: 'text',
+                    text: [
+                        `✓ ${productId} 구독 리스팅 갱신`,
+                        result.created.length ? `추가된 언어: ${result.created.join(', ')}` : '',
+                        result.updated.length ? `수정된 언어: ${result.updated.join(', ')}` : '',
+                        `현재 언어: ${result.listings.map((l) => l.languageCode).join(', ')}`,
+                    ].filter(Boolean).join('\n'),
+                }],
+        };
+    });
+    server.tool('playstore_update_product_state', 'Google Play 인앱 상품의 구매 옵션을 활성화/비활성화 — Play Console 의 DRAFT → 활성 토글. ' +
+        'DRAFT 인 상품은 가격이 앱에 안 내려오므로 만들고 활성화하지 않으면 상점 화면이 비어 보인다. ' +
+        'purchaseOptionId 는 playstore_list_inapp_products 의 purchaseOptions[].purchaseOptionId (보통 "base").', {
+        packageName: z.string().describe('패키지명'),
+        productId: z.string().describe('상품 ID'),
+        purchaseOptionId: z.string().default('base').describe('구매 옵션 ID (기본 "base")'),
+        action: z.enum(['activate', 'deactivate']).describe('활성화 / 비활성화'),
+    }, async ({ packageName, productId, purchaseOptionId, action }) => {
+        const auth = requirePlayStoreAuth(packageName);
+        const result = await playstore.updatePurchaseOptionState(auth, packageName, productId, purchaseOptionId, action);
+        const states = result.states.length
+            ? result.states.map((s) => `${s.purchaseOptionId}: ${s.state}`).join(', ')
+            : '(응답에 상태 없음 — playstore_list_inapp_products 로 확인)';
+        return {
+            content: [{
+                    type: 'text',
+                    text: `✓ ${productId} / ${purchaseOptionId} ${action}\n${states}`,
+                }],
+        };
+    });
+    server.tool('playstore_update_product', 'Google Play IAP 상품의 표시 이름 변경 (현재 name 필드만 수정 가능). productId / type / 가격은 변경 불가. ' +
+        '언어별 제목·설명은 playstore_update_product_listing / playstore_update_subscription_listing 을 쓴다.', {
         packageName: z.string().describe('패키지명'),
         productId: z.string().describe('상품 ID'),
         productType: z.enum(['subscription', 'consumable', 'non_consumable']).describe('상품 유형'),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yoonion/mimi-seed-mcp",
-  "version": "0.13.3",
+  "version": "0.13.5",
   "description": "Mimi Seed MCP server — Firebase + AdMob + Google Play + App Store management for Claude Code / Codex / Cursor / any MCP client.",
   "type": "module",
   "bin": {
@@ -61,7 +61,7 @@
   "dependencies": {
     "@anthropic-ai/sdk": "^0.52.0",
     "@modelcontextprotocol/sdk": "^1.12.1",
-    "@onesub/providers": "^0.2.0",
+    "@onesub/providers": "^0.4.0",
     "googleapis": "^171.4.0",
     "jose": "^5.10.0",
     "open": "^10.1.0",

package/tool-manifest.json

@@ -1,6 +1,6 @@
 {
   "$comment": "등록된 MCP 도구 + 도메인 메타데이터(label·credential·summary)의 SSOT. src/__tests__/tool-manifest.test.ts 가 실제 서버 등록 목록과 diff 하고 메타데이터 정합성을 검사한다. 도구 추가/삭제/개명 시 이 파일을 함께 갱신할 것 — 산문 문서에는 정확한 개수를 쓰지 말고 이 파일을 가리킬 것. mimi-seed://tools/catalog 리소스가 이 파일을 그대로 서빙한다.",
-  "total": 177,
+  "total": 183,
   "domains": {
     "admob": {
       "label": "AdMob",
@@ -68,7 +68,10 @@
         "appstore_create_subscription",
         "appstore_list_products",
         "appstore_update_product_review_note",
+        "appstore_list_product_localizations",
+        "appstore_update_product_localization",
         "appstore_upload_product_review_screenshot",
+        "appstore_add_product_to_review",
         "appstore_update_product",
         "appstore_delete_product",
         "appstore_plan_release",
@@ -273,6 +276,9 @@
         "playstore_submit_release",
         "playstore_promote_release",
         "playstore_list_products",
+        "playstore_update_product_listing",
+        "playstore_update_subscription_listing",
+        "playstore_update_product_state",
         "playstore_update_product",
         "playstore_delete_product",
         "setup_playstore_connection"