@yoonion/mimi-seed-mcp 0.3.4 → 0.3.6

package/README.md

@@ -56,6 +56,7 @@ export ANTHROPIC_API_KEY=sk-ant-...
 | Firebase | `firebase_list_projects` / `firebase_create_android_app` / `firebase_get_android_config` / `firebase_enable_service` |
 | AdMob | `admob_list_apps` / `admob_create_ad_unit` / `admob_get_today_earnings` / `admob_get_report` |
 | Google Play | `playstore_list_tracks` / `playstore_update_listing` / `playstore_replace_images` / `playstore_reply_review` / `playstore_verify_service_account` |
+| 인앱 결제 | `playstore_create_onetime_product` / `playstore_create_subscription` / `appstore_create_inapp_purchase` / `appstore_create_subscription` |
 | Google Cloud IAM | `iam_list_service_accounts` / `iam_create_service_account` / `iam_list_keys` / `iam_create_key` / `iam_add_iam_policy_binding` |
 | App Store Connect | `appstore_list_apps` / `appstore_list_builds` / `appstore_upload_screenshot` / `appstore_update_whats_new` |
 | 제출 위험 점검 | `playstore_check_submission_risks` / `appstore_check_submission_risks` |

package/dist/appstore/tools.d.ts

@@ -55,3 +55,69 @@ export declare function submitVersionForReview(versionId: string): Promise<{
     itemAttached: boolean;
     state: any;
 }>;
+export type AppleIapType = 'CONSUMABLE' | 'NON_CONSUMABLE' | 'NON_RENEWING_SUBSCRIPTION';
+export interface CreateInAppPurchaseInput {
+    appId: string;
+    productId: string;
+    referenceName: string;
+    inAppPurchaseType: AppleIapType;
+    reviewNote?: string;
+    familySharable?: boolean;
+    locale?: string;
+    displayName: string;
+    description: string;
+    priceUsd: number;
+    baseTerritory?: string;
+    autoSubmit?: boolean;
+}
+export type FailedStep = 'localization' | 'priceSchedule' | 'submission';
+interface CreatedIapSummary {
+    iapId: string;
+    productId: string;
+    state?: string;
+    localizationId?: string;
+    priceScheduleId?: string;
+    submissionId?: string;
+    submissionState?: string;
+    failedStep?: FailedStep;
+    error?: string;
+    priceMatchWarning?: string;
+    consoleUrl: string;
+}
+export declare function createInAppPurchase(input: CreateInAppPurchaseInput): Promise<CreatedIapSummary>;
+export interface CreateSubscriptionGroupInput {
+    appId: string;
+    referenceName: string;
+}
+export interface CreateSubscriptionInput {
+    appId: string;
+    groupReferenceName: string;
+    productId: string;
+    referenceName: string;
+    subscriptionPeriod: 'ONE_WEEK' | 'ONE_MONTH' | 'TWO_MONTHS' | 'THREE_MONTHS' | 'SIX_MONTHS' | 'ONE_YEAR';
+    reviewNote?: string;
+    familySharable?: boolean;
+    groupLevel?: number;
+    locale?: string;
+    displayName: string;
+    description: string;
+    priceUsd: number;
+    baseTerritory?: string;
+    autoSubmit?: boolean;
+}
+interface CreatedSubscriptionSummary {
+    subscriptionId: string;
+    groupId: string;
+    productId: string;
+    state?: string;
+    localizationId?: string;
+    pricesCreated?: boolean;
+    submissionId?: string;
+    submissionState?: string;
+    failedStep?: FailedStep;
+    error?: string;
+    priceMatchWarning?: string;
+    consoleUrl: string;
+}
+export declare function createAutoRenewableSubscription(input: CreateSubscriptionInput): Promise<CreatedSubscriptionSummary>;
+export {};

package/dist/appstore/tools.js

@@ -374,3 +374,302 @@ export async function submitVersionForReview(versionId) {
         state: submitted?.data?.attributes?.state ?? 'WAITING_FOR_REVIEW',
     };
 }
+// ─── 인앱 구매 (IAP) 생성 ───
+// 2023년 출시된 IAP v2 API (POST /v2/inAppPurchases) 사용.
+// 흐름: (1) IAP draft 생성 → (2) 로컬라이제이션 → (3) priceSchedule → (4) submission(선택).
+// 가격은 territory별 pricePoint ID 기반 — IAP를 만든 뒤 GET /pricePoints로 조회해 매칭.
+// 자동 제출(submission)은 권장 가이드라인 (스크린샷·리뷰 노트 등)이 충족돼야 통과.
+const IAP_V2_BASE = 'https://api.appstoreconnect.apple.com/v2';
+async function apiPostV2(path, body) {
+    const headers = getAuthHeaders();
+    if (!headers) {
+        throw new Error('App Store Connect 인증 필요 — npx -p @yoonion/mimi-seed-mcp mimi-seed-appstore-auth');
+    }
+    const res = await fetch(`${IAP_V2_BASE}${path}`, {
+        method: 'POST',
+        headers: { ...headers, 'Content-Type': 'application/json' },
+        body: JSON.stringify(body),
+    });
+    if (!res.ok) {
+        const text = await res.text();
+        throw new Error(`App Store v2 ${res.status}: ${text}`);
+    }
+    const text = await res.text();
+    return text ? JSON.parse(text) : { ok: true };
+}
+async function findClosestPricePoint(resourceUrl, territory, targetPrice) {
+    // resourceUrl 예: '/inAppPurchases/{id}/pricePoints' 또는 '/subscriptions/{id}/pricePoints'
+    const data = await apiGet(resourceUrl, {
+        'filter[territory]': territory,
+        'limit': '200',
+    });
+    const points = (data?.data ?? []);
+    let best = null;
+    let bestDiff = Infinity;
+    for (const p of points) {
+        const priceStr = p.attributes?.customerPrice;
+        if (!priceStr)
+            continue;
+        const price = parseFloat(priceStr);
+        if (Number.isNaN(price))
+            continue;
+        const diff = Math.abs(price - targetPrice);
+        if (diff < bestDiff) {
+            bestDiff = diff;
+            best = { id: p.id, customerPrice: price };
+        }
+    }
+    return best;
+}
+const PRICE_MATCH_WARN_THRESHOLD = 0.10;
+function priceMatchWarning(targetPrice, matched) {
+    const diff = Math.abs(matched - targetPrice);
+    if (diff < PRICE_MATCH_WARN_THRESHOLD)
+        return undefined;
+    return `요청 $${targetPrice} → 매칭 $${matched.toFixed(2)} (Apple tier 제약). 의도와 다르면 Console에서 수정.`;
+}
+export async function createInAppPurchase(input) {
+    const locale = input.locale ?? 'en-US';
+    const baseTerritory = input.baseTerritory ?? 'USA';
+    // 1) IAP draft 생성 (v2 endpoint)
+    const created = await apiPostV2('/inAppPurchases', {
+        data: {
+            type: 'inAppPurchases',
+            attributes: {
+                name: input.referenceName,
+                productId: input.productId,
+                inAppPurchaseType: input.inAppPurchaseType,
+                reviewNote: input.reviewNote,
+                familySharable: input.familySharable ?? false,
+            },
+            relationships: {
+                app: { data: { type: 'apps', id: input.appId } },
+            },
+        },
+    });
+    const iapId = created?.data?.id;
+    if (!iapId)
+        throw new Error(`IAP 생성 응답에 id 없음: ${JSON.stringify(created)}`);
+    const consoleUrl = `https://appstoreconnect.apple.com/apps/${input.appId}/distribution/iaps/${iapId}`;
+    const summary = {
+        iapId,
+        productId: input.productId,
+        state: created?.data?.attributes?.state,
+        consoleUrl,
+    };
+    // 2) 로컬라이제이션
+    try {
+        const loc = await apiPost('/inAppPurchaseLocalizations', {
+            data: {
+                type: 'inAppPurchaseLocalizations',
+                attributes: {
+                    locale,
+                    name: input.displayName,
+                    description: input.description,
+                },
+                relationships: {
+                    inAppPurchaseV2: { data: { type: 'inAppPurchases', id: iapId } },
+                },
+            },
+        });
+        summary.localizationId = loc?.data?.id;
+    }
+    catch (err) {
+        summary.failedStep = 'localization';
+        summary.error = err.message;
+        return summary;
+    }
+    // 3) priceSchedule (territory pricePoint 매칭 후 생성)
+    try {
+        const matched = await findClosestPricePoint(`/inAppPurchases/${iapId}/pricePoints`, baseTerritory, input.priceUsd);
+        if (!matched) {
+            summary.failedStep = 'priceSchedule';
+            summary.error = `${baseTerritory}에서 가격 point를 찾지 못함 — Console에서 수동 설정 필요.`;
+            return summary;
+        }
+        summary.priceMatchWarning = priceMatchWarning(input.priceUsd, matched.customerPrice);
+        const priceRefId = '${INAPP_PRICE}';
+        const sched = await apiPost('/inAppPurchasePriceSchedules', {
+            data: {
+                type: 'inAppPurchasePriceSchedules',
+                relationships: {
+                    inAppPurchase: { data: { type: 'inAppPurchases', id: iapId } },
+                    baseTerritory: { data: { type: 'territories', id: baseTerritory } },
+                    manualPrices: { data: [{ type: 'inAppPurchasePrices', id: priceRefId }] },
+                },
+            },
+            included: [
+                {
+                    type: 'inAppPurchasePrices',
+                    id: priceRefId,
+                    attributes: { startDate: null },
+                    relationships: {
+                        inAppPurchasePricePoint: {
+                            data: { type: 'inAppPurchasePricePoints', id: matched.id },
+                        },
+                        inAppPurchaseV2: { data: { type: 'inAppPurchases', id: iapId } },
+                        territory: { data: { type: 'territories', id: baseTerritory } },
+                    },
+                },
+            ],
+        });
+        summary.priceScheduleId = sched?.data?.id;
+    }
+    catch (err) {
+        summary.failedStep = 'priceSchedule';
+        summary.error = err.message;
+        return summary;
+    }
+    // 4) 자동 제출 (옵션) — 실패해도 draft는 유지
+    if (input.autoSubmit !== false) {
+        try {
+            const sub = await apiPost('/inAppPurchaseSubmissions', {
+                data: {
+                    type: 'inAppPurchaseSubmissions',
+                    relationships: {
+                        inAppPurchaseV2: { data: { type: 'inAppPurchases', id: iapId } },
+                    },
+                },
+            });
+            summary.submissionId = sub?.data?.id;
+            summary.submissionState = sub?.data?.attributes?.state ?? 'WAITING_FOR_REVIEW';
+        }
+        catch (err) {
+            summary.failedStep = 'submission';
+            summary.error = err.message;
+        }
+    }
+    return summary;
+}
+async function findOrCreateSubscriptionGroup(appId, referenceName) {
+    // 기존 그룹 검색
+    const existing = await apiGet(`/apps/${appId}/subscriptionGroups`, {
+        'fields[subscriptionGroups]': 'referenceName',
+        'limit': '200',
+    });
+    const found = (existing?.data ?? []).find((g) => g.attributes?.referenceName === referenceName);
+    if (found)
+        return found.id;
+    const created = await apiPost('/subscriptionGroups', {
+        data: {
+            type: 'subscriptionGroups',
+            attributes: { referenceName },
+            relationships: {
+                app: { data: { type: 'apps', id: appId } },
+            },
+        },
+    });
+    const id = created?.data?.id;
+    if (!id)
+        throw new Error(`subscriptionGroup 생성 실패: ${JSON.stringify(created)}`);
+    return id;
+}
+export async function createAutoRenewableSubscription(input) {
+    const locale = input.locale ?? 'en-US';
+    const baseTerritory = input.baseTerritory ?? 'USA';
+    // 1) group 찾거나 생성
+    const groupId = await findOrCreateSubscriptionGroup(input.appId, input.groupReferenceName);
+    // 2) subscription draft 생성
+    // groupLevel은 그룹 내 unique여야 함 — 미지정 시 attribute 자체를 안 보내고 Apple이 자동 부여하게.
+    const subAttributes = {
+        name: input.referenceName,
+        productId: input.productId,
+        subscriptionPeriod: input.subscriptionPeriod,
+        familySharable: input.familySharable ?? false,
+    };
+    if (input.reviewNote !== undefined)
+        subAttributes.reviewNote = input.reviewNote;
+    if (input.groupLevel !== undefined)
+        subAttributes.groupLevel = input.groupLevel;
+    const created = await apiPost('/subscriptions', {
+        data: {
+            type: 'subscriptions',
+            attributes: subAttributes,
+            relationships: {
+                group: { data: { type: 'subscriptionGroups', id: groupId } },
+            },
+        },
+    });
+    const subscriptionId = created?.data?.id;
+    if (!subscriptionId) {
+        throw new Error(`subscription 생성 응답에 id 없음: ${JSON.stringify(created)}`);
+    }
+    const consoleUrl = `https://appstoreconnect.apple.com/apps/${input.appId}/distribution/subscriptions/${subscriptionId}`;
+    const summary = {
+        subscriptionId,
+        groupId,
+        productId: input.productId,
+        state: created?.data?.attributes?.state,
+        consoleUrl,
+    };
+    // 3) localization
+    try {
+        const loc = await apiPost('/subscriptionLocalizations', {
+            data: {
+                type: 'subscriptionLocalizations',
+                attributes: {
+                    locale,
+                    name: input.displayName,
+                    description: input.description,
+                },
+                relationships: {
+                    subscription: { data: { type: 'subscriptions', id: subscriptionId } },
+                },
+            },
+        });
+        summary.localizationId = loc?.data?.id;
+    }
+    catch (err) {
+        summary.failedStep = 'localization';
+        summary.error = err.message;
+        return summary;
+    }
+    // 4) price (subscriptionPrices — IAP의 priceSchedule보다 단순)
+    try {
+        const matched = await findClosestPricePoint(`/subscriptions/${subscriptionId}/pricePoints`, baseTerritory, input.priceUsd);
+        if (!matched) {
+            summary.failedStep = 'priceSchedule';
+            summary.error = `${baseTerritory}에서 가격 point를 찾지 못함 — Console에서 수동 설정 필요.`;
+            return summary;
+        }
+        summary.priceMatchWarning = priceMatchWarning(input.priceUsd, matched.customerPrice);
+        await apiPost('/subscriptionPrices', {
+            data: {
+                type: 'subscriptionPrices',
+                relationships: {
+                    subscription: { data: { type: 'subscriptions', id: subscriptionId } },
+                    subscriptionPricePoint: {
+                        data: { type: 'subscriptionPricePoints', id: matched.id },
+                    },
+                    territory: { data: { type: 'territories', id: baseTerritory } },
+                },
+            },
+        });
+        summary.pricesCreated = true;
+    }
+    catch (err) {
+        summary.failedStep = 'priceSchedule';
+        summary.error = err.message;
+        return summary;
+    }
+    // 5) auto-submit
+    if (input.autoSubmit !== false) {
+        try {
+            const sub = await apiPost('/subscriptionSubmissions', {
+                data: {
+                    type: 'subscriptionSubmissions',
+                    relationships: {
+                        subscription: { data: { type: 'subscriptions', id: subscriptionId } },
+                    },
+                },
+            });
+            summary.submissionId = sub?.data?.id;
+            summary.submissionState = sub?.data?.attributes?.state ?? 'WAITING_FOR_REVIEW';
+        }
+        catch (err) {
+            summary.failedStep = 'submission';
+            summary.error = err.message;
+        }
+    }
+    return summary;
+}

package/dist/index.js

@@ -371,6 +371,111 @@ server.tool('playstore_list_subscriptions', 'Google Play 구독 상품 목록',
     const subs = await playstore.listSubscriptions(auth, packageName);
     return { content: [{ type: 'text', text: JSON.stringify(subs, null, 2) }] };
 });
+server.tool('playstore_create_onetime_product', [
+    'Google Play에 일회성 인앱 상품을 생성/갱신 (upsert).',
+    '이미 같은 productId가 있으면 listings·가격을 덮어씀. 가격은 USD 기준 + EUR 자동 환산 + newRegionsConfig로 신규 지역 자동 사용.',
+    'Play Console 권한: "Manage store presence" 필요. 활성화는 Console에서 별도 토글.',
+].join(' '), {
+    packageName: z.string().describe('패키지명 (예: com.example.app)'),
+    productId: z
+        .string()
+        .describe('상품 ID (소문자/숫자/언더스코어/점, 예: premium_unlock). 한 번 정하면 변경 불가.'),
+    title: z.string().describe('상품 제목 (최대 55자)'),
+    description: z.string().describe('상품 설명 (최대 200자)'),
+    priceUsd: z.number().describe('USD 가격 (예: 4.99)'),
+    languageCode: z.string().optional().describe('listing 언어 (기본 en-US)'),
+    purchaseOptionId: z.string().optional().describe('구매 옵션 ID (기본 default-buy)'),
+    legacyCompatible: z
+        .boolean()
+        .optional()
+        .describe('구 PBL 클라이언트 호환 (기본 true)'),
+    newRegionsPricing: z
+        .object({
+        usdPrice: z.number().describe('Play가 신규 지역 launch 시 사용할 USD 가격'),
+        eurPrice: z.number().describe('Play가 신규 지역 launch 시 사용할 EUR 가격'),
+    })
+        .optional()
+        .describe('신규 출시 지역에서 자동 사용할 가격 (선택). 미지정 시 신규 지역 OFF.'),
+}, async (args) => {
+    const auth = requireAuth();
+    const result = await playstore.createOnetimeProduct(auth, args);
+    return {
+        content: [
+            {
+                type: 'text',
+                text: [
+                    `✓ Play 일회성 상품 upsert 완료`,
+                    `productId: ${args.productId}`,
+                    `price: $${args.priceUsd} (US)`,
+                    args.newRegionsPricing
+                        ? `신규 지역: $${args.newRegionsPricing.usdPrice} / €${args.newRegionsPricing.eurPrice}`
+                        : '신규 지역: OFF (newRegionsPricing 미지정)',
+                    '⚠ 기존에 다국어/다지역 등록된 상품이면 listings·purchaseOptions가 통째 교체됨.',
+                    '',
+                    'Play Console에서 활성화 확인:',
+                    `https://play.google.com/console/u/0/developers/-/app/-/managed-products?package=${encodeURIComponent(args.packageName)}`,
+                    '',
+                    '응답:',
+                    JSON.stringify(result, null, 2),
+                ].join('\n'),
+            },
+        ],
+    };
+});
+server.tool('playstore_create_subscription', [
+    'Google Play에 자동 갱신 구독을 생성하고 baseplan을 활성화.',
+    '구독 셸 생성 → baseplan(가격·주기) 추가 → 자동 활성화 (autoActivate=false면 draft).',
+    '이미 같은 productId가 있으면 listings 갱신 + 동일 basePlanId가 있으면 baseplan 생성 단계 skip.',
+].join(' '), {
+    packageName: z.string().describe('패키지명'),
+    productId: z
+        .string()
+        .describe('구독 상품 ID (소문자/숫자/언더스코어/점, 1-40자, 예: premium_monthly)'),
+    title: z.string().describe('구독 제목'),
+    description: z.string().describe('구독 설명'),
+    benefits: z.array(z.string()).optional().describe('혜택 bullet 리스트 (선택)'),
+    languageCode: z.string().optional().describe('기본 en-US'),
+    basePlanId: z
+        .string()
+        .optional()
+        .describe('베이스플랜 ID (소문자/숫자/하이픈, 기본은 billingPeriod로 추론: P1M→monthly, P1Y→yearly)'),
+    billingPeriod: z
+        .enum(['P1W', 'P1M', 'P3M', 'P6M', 'P1Y'])
+        .describe('청구 주기 (ISO 8601: P1M=월, P1Y=년)'),
+    priceUsd: z.number().describe('USD 가격'),
+    gracePeriod: z
+        .enum(['P0D', 'P3D', 'P7D', 'P14D', 'P30D'])
+        .optional()
+        .describe('결제 실패 시 유예 기간 (기본 P7D)'),
+    autoActivate: z
+        .boolean()
+        .optional()
+        .describe('생성 후 baseplan 자동 활성화 (기본 true). false면 Console에서 수동 활성화.'),
+    newRegionsPricing: z
+        .object({
+        usdPrice: z.number(),
+        eurPrice: z.number(),
+    })
+        .optional()
+        .describe('신규 출시 지역 자동 가격 (선택). 미지정 시 신규 지역엔 노출 안 됨.'),
+}, async (args) => {
+    const auth = requireAuth();
+    const result = await playstore.createSubscription(auth, args);
+    const lines = [
+        `✓ Play 구독 생성 완료`,
+        `productId: ${result.productId}`,
+        `basePlanId: ${result.basePlanId} (${args.billingPeriod}, $${args.priceUsd})`,
+        result.activated
+            ? `✓ baseplan 활성화됨 (state=${result.basePlanState ?? 'ACTIVE'})`
+            : result.activateError
+                ? `⚠ baseplan 자동 활성화 실패: ${result.activateError}\n  → Console에서 수동 활성화 필요.`
+                : `⏸ baseplan은 draft 상태 (autoActivate=false). Console에서 활성화 필요.`,
+        '',
+        'Play Console:',
+        `https://play.google.com/console/u/0/developers/-/app/-/subscriptions?package=${encodeURIComponent(args.packageName)}`,
+    ];
+    return { content: [{ type: 'text', text: lines.join('\n') }] };
+});
 server.tool('playstore_verify_service_account', [
     "서비스 계정 JSON이 주어진 packageName에 대해 Play Developer API 호출 가능한지 + 'View financial data' 권한까지 있는지 검증.",
     'onesub 같은 서버가 Play 영수증을 백그라운드로 검증하려면 OAuth 토큰 대신 서비스 계정 JSON이 필요 — 이 도구로 붙여넣기 전에 유효성 확인.',
@@ -688,6 +793,119 @@ server.tool('appstore_reply_review', [
     const result = await appstore.createReviewResponse(reviewId, responseBody);
     return { content: [{ type: 'text', text: `✅ 리뷰 ${reviewId}에 답변 등록됐어.\n\n${JSON.stringify(result, null, 2)}` }] };
 });
+// --- App Store IAP / 구독 생성 ---
+server.tool('appstore_create_inapp_purchase', [
+    'App Store에 일회성 인앱 구매(IAP)를 생성 — type: CONSUMABLE / NON_CONSUMABLE / NON_RENEWING_SUBSCRIPTION.',
+    '내부 흐름: POST /v2/inAppPurchases(draft) → POST /v1/inAppPurchaseLocalizations(displayName/description) → priceSchedule(매칭되는 pricePoint) → submission(autoSubmit=true 시).',
+    'autoSubmit이 실패해도 draft + 로컬라이제이션 + 가격은 유지됨. 어디까지 진행됐는지 응답에 표시.',
+    '제출이 막히는 흔한 이유: 리뷰 노트 부족 / 스크린샷 미첨부 / 부모 앱 메타데이터 미완 — 그땐 콘솔 링크로 이동해 마무리.',
+].join(' '), {
+    appId: z.string().describe('App Store 앱 ID (appstore_list_apps 결과의 id, 숫자형)'),
+    productId: z
+        .string()
+        .describe('상품 ID (글로벌 unique 권장: 예 com.example.coins_100)'),
+    referenceName: z.string().describe('내부 식별 이름 (Console 표시용)'),
+    inAppPurchaseType: z
+        .enum(['CONSUMABLE', 'NON_CONSUMABLE', 'NON_RENEWING_SUBSCRIPTION'])
+        .describe('IAP 유형'),
+    displayName: z.string().describe('사용자 노출 이름 (최대 30자)'),
+    description: z.string().describe('사용자 노출 설명 (최대 45자)'),
+    priceUsd: z.number().describe('USD 가격 (예: 0.99) — 가장 가까운 pricePoint를 자동 매칭'),
+    locale: z.string().optional().describe('로컬라이제이션 로케일 (기본 en-US)'),
+    baseTerritory: z
+        .string()
+        .optional()
+        .describe('기준 지역 ISO 3166-1 alpha-3 (기본 USA)'),
+    reviewNote: z.string().optional().describe('Apple 리뷰어를 위한 노트'),
+    familySharable: z.boolean().optional().describe('패밀리 공유 가능 (기본 false)'),
+    autoSubmit: z
+        .boolean()
+        .optional()
+        .describe('생성 후 자동 심사 제출 시도 (기본 true). 실패해도 draft는 유지.'),
+}, async (args) => {
+    const result = await appstore.createInAppPurchase(args);
+    const lines = [
+        result.failedStep
+            ? `⚠ App Store IAP 일부 단계 실패 (failedStep=${result.failedStep})`
+            : `✓ App Store IAP 생성 완료`,
+        `iapId: ${result.iapId}`,
+        `productId: ${result.productId}`,
+        result.localizationId ? `✓ 로컬라이제이션 (${args.locale ?? 'en-US'})` : '⏸ 로컬라이제이션 미진행',
+        result.priceScheduleId
+            ? `✓ 가격 ($${args.priceUsd} ${args.baseTerritory ?? 'USA'})`
+            : '⏸ 가격 미설정',
+        result.priceMatchWarning ? `⚠ ${result.priceMatchWarning}` : '',
+        result.submissionId
+            ? `✓ 심사 제출됨 (state=${result.submissionState ?? 'WAITING_FOR_REVIEW'})`
+            : args.autoSubmit === false
+                ? '⏸ 자동 제출 skip (autoSubmit=false) — Console에서 수동 제출'
+                : result.failedStep === 'submission'
+                    ? `⚠ 자동 제출 실패 (draft·가격은 유지): ${result.error}`
+                    : '',
+        result.failedStep && result.failedStep !== 'submission'
+            ? `오류: ${result.error}`
+            : '',
+        '',
+        `Console: ${result.consoleUrl}`,
+    ].filter(Boolean);
+    return { content: [{ type: 'text', text: lines.join('\n') }] };
+});
+server.tool('appstore_create_subscription', [
+    'App Store에 자동 갱신 구독을 생성 — Subscription Group이 없으면 함께 생성.',
+    '내부 흐름: subscriptionGroup find/create → POST /subscriptions(draft) → /subscriptionLocalizations → /subscriptionPrices(매칭 pricePoint) → /subscriptionSubmissions(autoSubmit=true).',
+    'groupReferenceName이 같은 그룹 내 구독은 사용자가 한 번에 하나만 가질 수 있음 (upgrade/downgrade 가능).',
+    'autoSubmit 실패 시에도 draft + 가격까지는 유지 — 어디까지 됐는지 응답으로 알 수 있음.',
+].join(' '), {
+    appId: z.string().describe('App Store 앱 ID'),
+    groupReferenceName: z
+        .string()
+        .describe("구독 그룹 내부 이름 (예: 'premium'). 없으면 자동 생성, 있으면 기존 그룹 재사용."),
+    productId: z.string().describe('구독 productId (예: com.example.premium.monthly)'),
+    referenceName: z.string().describe('내부 식별 이름'),
+    subscriptionPeriod: z
+        .enum(['ONE_WEEK', 'ONE_MONTH', 'TWO_MONTHS', 'THREE_MONTHS', 'SIX_MONTHS', 'ONE_YEAR'])
+        .describe('구독 주기'),
+    displayName: z.string().describe('사용자 노출 이름'),
+    description: z.string().describe('사용자 노출 설명'),
+    priceUsd: z.number().describe('USD 가격'),
+    locale: z.string().optional().describe('기본 en-US'),
+    baseTerritory: z.string().optional().describe('기본 USA (alpha-3)'),
+    reviewNote: z.string().optional(),
+    familySharable: z.boolean().optional(),
+    groupLevel: z
+        .number()
+        .optional()
+        .describe('그룹 내 표시 순서. 미지정 시 Apple이 자동 부여 — 같은 그룹에 여러 구독 만들 때 명시적으로 충돌 안 하려면 비워둘 것.'),
+    autoSubmit: z.boolean().optional().describe('자동 심사 제출 (기본 true)'),
+}, async (args) => {
+    const result = await appstore.createAutoRenewableSubscription(args);
+    const lines = [
+        result.failedStep
+            ? `⚠ App Store 구독 일부 단계 실패 (failedStep=${result.failedStep})`
+            : `✓ App Store 자동 갱신 구독 생성 완료`,
+        `subscriptionId: ${result.subscriptionId}`,
+        `groupId: ${result.groupId} (${args.groupReferenceName})`,
+        `productId: ${result.productId}`,
+        result.localizationId ? `✓ 로컬라이제이션 (${args.locale ?? 'en-US'})` : '⏸ 로컬라이제이션 미진행',
+        result.pricesCreated
+            ? `✓ 가격 ($${args.priceUsd} ${args.baseTerritory ?? 'USA'})`
+            : '⏸ 가격 미설정',
+        result.priceMatchWarning ? `⚠ ${result.priceMatchWarning}` : '',
+        result.submissionId
+            ? `✓ 심사 제출됨 (state=${result.submissionState ?? 'WAITING_FOR_REVIEW'})`
+            : args.autoSubmit === false
+                ? '⏸ 자동 제출 skip — Console에서 수동 제출'
+                : result.failedStep === 'submission'
+                    ? `⚠ 자동 제출 실패 (draft·가격은 유지): ${result.error}`
+                    : '',
+        result.failedStep && result.failedStep !== 'submission'
+            ? `오류: ${result.error}`
+            : '',
+        '',
+        `Console: ${result.consoleUrl}`,
+    ].filter(Boolean);
+    return { content: [{ type: 'text', text: lines.join('\n') }] };
+});
 // --- App Store 심사 제출 (Submit for Review) ---
 server.tool('appstore_submit_for_review', [
     'App Store 버전을 심사에 제출 — 새 reviewSubmissions API 사용 (옛 /appStoreVersionSubmissions는 2024-01 deprecated).',
@@ -718,6 +936,39 @@ server.tool('playstore_submit_release', [
     const result = await playstore.submitRelease(auth, packageName, track, versionCode, status);
     return { content: [{ type: 'text', text: `✅ ${packageName} ${track} v${versionCode}: ${result.previousStatus} → ${result.newStatus}\n\n${JSON.stringify(result, null, 2)}` }] };
 });
+// --- Play Store 트랙 간 promote (internal → production 등) ---
+server.tool('playstore_promote_release', [
+    'Google Play 트랙 간 release promote — fromTrack(예: internal)의 versionCode를 toTrack(예: production)에 새 release로 추가.',
+    '단일 edit session에서 source 조회 → target 업데이트 → commit 까지 한 번에 처리.',
+    'source의 releaseNotes를 자동 복사 (copyReleaseNotes=false 또는 releaseNotes로 덮어쓰기 가능).',
+    'status="completed" + production 으로 전체 출시, status="inProgress" + userFraction 으로 단계 출시(예: 0.1 = 10%).',
+    'target에 같은 versionCode가 이미 있으면 해당 항목을 교체. status="completed"면 target 활성 release를 통째로 새 것으로 대체.',
+    '⚠️ status="completed"는 비가역에 가까움. playstore_check_submission_risks로 사전 점검 권장.',
+].join(' '), {
+    packageName: z.string().describe('패키지명 (예: gg.pryzm.coffee)'),
+    fromTrack: z.enum(['production', 'beta', 'alpha', 'internal']).describe('출처 트랙 (예: internal)'),
+    toTrack: z.enum(['production', 'beta', 'alpha', 'internal']).describe('대상 트랙 (예: production)'),
+    versionCode: z.string().describe('promote할 versionCode (문자열)'),
+    status: z.enum(['completed', 'draft', 'inProgress', 'halted']).optional().describe('대상 트랙에서의 status (기본 completed)'),
+    userFraction: z.number().min(0).max(1).optional().describe('status="inProgress"일 때 단계 출시 비율 (0~1, 예: 0.1)'),
+    releaseName: z.string().optional().describe('release 이름 (미지정 시 source 이름 그대로)'),
+    copyReleaseNotes: z.boolean().optional().describe('source releaseNotes 복사 여부 (기본 true)'),
+    releaseNotes: z.array(z.object({
+        language: z.string().describe('언어 코드 (예: ko-KR, en-US)'),
+        text: z.string().describe('릴리스 노트 본문 (500자 이내)'),
+    })).optional().describe('대상 트랙용 릴리스 노트 (미지정 + copyReleaseNotes=true면 source 그대로)'),
+}, async ({ packageName, fromTrack, toTrack, versionCode, status, userFraction, releaseName, copyReleaseNotes, releaseNotes }) => {
+    const auth = requireAuth();
+    const result = await playstore.promoteRelease(auth, packageName, fromTrack, toTrack, versionCode, {
+        status,
+        userFraction,
+        releaseName,
+        copyReleaseNotes,
+        releaseNotes,
+    });
+    const summary = `✅ ${packageName} ${fromTrack} → ${toTrack} v${versionCode} (status: ${result.newStatus}${result.userFraction != null ? `, userFraction: ${result.userFraction}` : ''})`;
+    return { content: [{ type: 'text', text: `${summary}\n\n${JSON.stringify(result, null, 2)}` }] };
+});
 // --- 인증 상태 ---
 server.tool('mimi_seed_auth_start', [
     'Google OAuth 로그인 링크를 발급하고 백그라운드 콜백 서버를 시작.',

package/dist/playstore/tools.d.ts

@@ -62,6 +62,28 @@ export declare function submitRelease(auth: OAuth2Client, packageName: string, t
     committed: boolean;
     result: import("googleapis").androidpublisher_v3.Schema$Track;
 }>;
+export interface PromoteReleaseOptions {
+    status?: 'completed' | 'draft' | 'inProgress' | 'halted';
+    userFraction?: number;
+    releaseName?: string;
+    releaseNotes?: Array<{
+        language: string;
+        text: string;
+    }>;
+    copyReleaseNotes?: boolean;
+}
+export declare function promoteRelease(auth: OAuth2Client, packageName: string, fromTrack: string, toTrack: string, versionCode: string, options?: PromoteReleaseOptions): Promise<{
+    packageName: string;
+    fromTrack: string;
+    toTrack: string;
+    versionCode: string;
+    newStatus: "completed" | "draft" | "inProgress" | "halted";
+    userFraction: number | undefined;
+    releaseName: string | null | undefined;
+    releaseNotesLanguages: (string | null | undefined)[];
+    committed: boolean;
+    result: import("googleapis").androidpublisher_v3.Schema$Track;
+}>;
 export declare function listReviews(auth: OAuth2Client, packageName: string): Promise<{
     reviewId: string | null | undefined;
     authorName: string | null | undefined;
@@ -83,6 +105,48 @@ export declare function listSubscriptions(auth: OAuth2Client, packageName: strin
     basePlans: import("googleapis").androidpublisher_v3.Schema$BasePlan[] | undefined;
     listings: import("googleapis").androidpublisher_v3.Schema$SubscriptionListing[] | undefined;
 }[]>;
+export interface CreateOneTimeProductInput {
+    packageName: string;
+    productId: string;
+    title: string;
+    description: string;
+    languageCode?: string;
+    priceUsd: number;
+    purchaseOptionId?: string;
+    legacyCompatible?: boolean;
+    regionsVersion?: string;
+    newRegionsPricing?: {
+        usdPrice: number;
+        eurPrice: number;
+    };
+}
+export declare function createOnetimeProduct(auth: OAuth2Client, input: CreateOneTimeProductInput): Promise<import("googleapis").androidpublisher_v3.Schema$OneTimeProduct>;
+export interface CreateSubscriptionInput {
+    packageName: string;
+    productId: string;
+    title: string;
+    description: string;
+    benefits?: string[];
+    languageCode?: string;
+    basePlanId?: string;
+    billingPeriod: 'P1W' | 'P1M' | 'P3M' | 'P6M' | 'P1Y';
+    priceUsd: number;
+    gracePeriod?: 'P0D' | 'P3D' | 'P7D' | 'P14D' | 'P30D';
+    resubscribeState?: 'RESUBSCRIBE_STATE_ACTIVE' | 'RESUBSCRIBE_STATE_INACTIVE';
+    autoActivate?: boolean;
+    regionsVersion?: string;
+    newRegionsPricing?: {
+        usdPrice: number;
+        eurPrice: number;
+    };
+}
+export declare function createSubscription(auth: OAuth2Client, input: CreateSubscriptionInput): Promise<{
+    productId: string;
+    basePlanId: string;
+    basePlanState?: string | null;
+    activated: boolean;
+    activateError?: string;
+}>;
 export type ServiceAccountVerifyResult = {
     ok: true;
     clientEmail: string;

package/dist/playstore/tools.js

@@ -262,6 +262,79 @@ export async function submitRelease(auth, packageName, track, versionCode, statu
         };
     }, true);
 }
+export async function promoteRelease(auth, packageName, fromTrack, toTrack, versionCode, options = {}) {
+    const { status = 'completed', userFraction, releaseName, releaseNotes, copyReleaseNotes = true, } = options;
+    if (fromTrack === toTrack) {
+        throw new Error('fromTrack과 toTrack이 같아. 다른 트랙으로 promote 해야 의미 있어.');
+    }
+    if (status === 'inProgress' && (userFraction == null || userFraction <= 0 || userFraction >= 1)) {
+        throw new Error('status="inProgress"일 때 userFraction은 0과 1 사이 필수 (예: 0.1 → 10%).');
+    }
+    return withEdit(auth, packageName, async (editId) => {
+        // 1. source 트랙에서 versionCode 매칭 release 찾기
+        const fromData = await publisher().edits.tracks.get({
+            auth, packageName, editId, track: fromTrack,
+        });
+        const fromReleases = fromData.data.releases ?? [];
+        const sourceRelease = fromReleases.find((r) => (r.versionCodes ?? []).some((v) => String(v) === String(versionCode)));
+        if (!sourceRelease) {
+            const available = fromReleases.map((r) => ({
+                name: r.name,
+                versionCodes: r.versionCodes,
+                status: r.status,
+            }));
+            throw new Error(`versionCode "${versionCode}"를 ${fromTrack} 트랙에서 찾을 수 없어. 가능한 릴리스: ${JSON.stringify(available)}`);
+        }
+        // 2. 새 release 객체 구성
+        const newRelease = {
+            name: releaseName ?? sourceRelease.name ?? versionCode,
+            versionCodes: [String(versionCode)],
+            status,
+            releaseNotes: releaseNotes ??
+                (copyReleaseNotes ? sourceRelease.releaseNotes ?? [] : []),
+        };
+        if (status === 'inProgress' && userFraction != null) {
+            newRelease.userFraction = userFraction;
+        }
+        // 3. target 트랙 현재 상태 조회 후 merge
+        //    - 같은 versionCode가 이미 target에 있으면 그 항목을 새 release로 교체
+        //    - status='completed'면 활성 release가 1개여야 하므로 [newRelease]로 통째 교체
+        //    - 그 외(draft/inProgress)는 기존 release에 append
+        const toData = await publisher().edits.tracks.get({
+            auth, packageName, editId, track: toTrack,
+        });
+        const toReleases = toData.data.releases ?? [];
+        const existingIdx = toReleases.findIndex((r) => (r.versionCodes ?? []).some((v) => String(v) === String(versionCode)));
+        let mergedReleases;
+        if (existingIdx >= 0) {
+            mergedReleases = [...toReleases];
+            mergedReleases[existingIdx] = newRelease;
+        }
+        else if (status === 'completed') {
+            mergedReleases = [newRelease];
+        }
+        else {
+            mergedReleases = [...toReleases, newRelease];
+        }
+        // 4. target 트랙 업데이트 (commit은 withEdit 마지막에)
+        const updated = await publisher().edits.tracks.update({
+            auth, packageName, editId, track: toTrack,
+            requestBody: { track: toTrack, releases: mergedReleases },
+        });
+        return {
+            packageName,
+            fromTrack,
+            toTrack,
+            versionCode: String(versionCode),
+            newStatus: status,
+            userFraction: status === 'inProgress' ? userFraction : undefined,
+            releaseName: newRelease.name,
+            releaseNotesLanguages: (newRelease.releaseNotes ?? []).map((n) => n.language),
+            committed: true,
+            result: updated.data,
+        };
+    }, true);
+}
 export async function listReviews(auth, packageName) {
     const res = await publisher().reviews.list({ auth, packageName });
     return (res.data.reviews ?? []).map((r) => ({
@@ -311,6 +384,166 @@ export async function listSubscriptions(auth, packageName) {
         listings: s.listings,
     }));
 }
+function moneyFromNumber(amount, currencyCode) {
+    const units = Math.trunc(amount).toString();
+    const nanos = Math.round((amount - Math.trunc(amount)) * 1_000_000_000);
+    return { currencyCode, units, nanos };
+}
+export async function createOnetimeProduct(auth, input) {
+    const languageCode = input.languageCode ?? 'en-US';
+    const purchaseOptionId = input.purchaseOptionId ?? 'default-buy';
+    const regionsVersion = input.regionsVersion ?? '2022/02';
+    const usdPrice = moneyFromNumber(input.priceUsd, 'USD');
+    const newRegionsConfig = input.newRegionsPricing
+        ? {
+            availability: 'AVAILABLE',
+            usdPrice: moneyFromNumber(input.newRegionsPricing.usdPrice, 'USD'),
+            eurPrice: moneyFromNumber(input.newRegionsPricing.eurPrice, 'EUR'),
+        }
+        : { availability: 'UNAVAILABLE' };
+    const res = await publisher().monetization.onetimeproducts.patch({
+        auth,
+        packageName: input.packageName,
+        productId: input.productId,
+        allowMissing: true,
+        updateMask: 'listings,purchaseOptions',
+        'regionsVersion.version': regionsVersion,
+        requestBody: {
+            packageName: input.packageName,
+            productId: input.productId,
+            listings: [
+                {
+                    languageCode,
+                    title: input.title,
+                    description: input.description,
+                },
+            ],
+            purchaseOptions: [
+                {
+                    purchaseOptionId,
+                    buyOption: {
+                        legacyCompatible: input.legacyCompatible ?? true,
+                    },
+                    regionalPricingAndAvailabilityConfigs: [
+                        {
+                            regionCode: 'US',
+                            availability: 'AVAILABLE',
+                            price: usdPrice,
+                        },
+                    ],
+                    newRegionsConfig,
+                },
+            ],
+        },
+    });
+    return res.data;
+}
+function defaultBasePlanIdFor(period) {
+    switch (period) {
+        case 'P1W': return 'weekly';
+        case 'P1M': return 'monthly';
+        case 'P3M': return 'quarterly';
+        case 'P6M': return 'semi-yearly';
+        case 'P1Y': return 'yearly';
+        default: return 'default';
+    }
+}
+export async function createSubscription(auth, input) {
+    const languageCode = input.languageCode ?? 'en-US';
+    const basePlanId = input.basePlanId ?? defaultBasePlanIdFor(input.billingPeriod);
+    const regionsVersion = input.regionsVersion ?? '2022/02';
+    const usdPrice = moneyFromNumber(input.priceUsd, 'USD');
+    const otherRegionsConfig = input.newRegionsPricing
+        ? {
+            newSubscriberAvailability: true,
+            usdPrice: moneyFromNumber(input.newRegionsPricing.usdPrice, 'USD'),
+            eurPrice: moneyFromNumber(input.newRegionsPricing.eurPrice, 'EUR'),
+        }
+        : { newSubscriberAvailability: false };
+    // 1) subscription 셸 upsert (allowMissing=true로 idempotent)
+    // updateMask는 mutable 필드만 — packageName/productId는 immutable이라 포함 시 reject 가능.
+    await publisher().monetization.subscriptions.patch({
+        auth,
+        packageName: input.packageName,
+        productId: input.productId,
+        allowMissing: true,
+        updateMask: 'listings',
+        'regionsVersion.version': regionsVersion,
+        requestBody: {
+            packageName: input.packageName,
+            productId: input.productId,
+            listings: [
+                {
+                    languageCode,
+                    title: input.title,
+                    description: input.description,
+                    benefits: input.benefits,
+                },
+            ],
+        },
+    });
+    // 2) basePlan 생성 (이미 있으면 conflict — 그땐 update 시도)
+    let basePlanState;
+    try {
+        const created = await publisher().monetization.subscriptions.basePlans.create({
+            auth,
+            packageName: input.packageName,
+            productId: input.productId,
+            basePlanId,
+            'regionsVersion.version': regionsVersion,
+            requestBody: {
+                basePlanId,
+                autoRenewingBasePlanType: {
+                    billingPeriodDuration: input.billingPeriod,
+                    gracePeriodDuration: input.gracePeriod ?? 'P7D',
+                    resubscribeState: input.resubscribeState ?? 'RESUBSCRIBE_STATE_ACTIVE',
+                },
+                regionalConfigs: [
+                    {
+                        regionCode: 'US',
+                        newSubscriberAvailability: true,
+                        price: usdPrice,
+                    },
+                ],
+                otherRegionsConfig,
+            },
+        });
+        basePlanState = created.data?.state;
+    }
+    catch (err) {
+        // 이미 존재하는 경우 409 — 그냥 진행
+        const e = err;
+        if (e.code !== 409 && e.status !== 409) {
+            throw err;
+        }
+    }
+    // 3) 자동 활성화 (옵션)
+    let activated = false;
+    let activateError;
+    if (input.autoActivate !== false) {
+        try {
+            const activated_ = await publisher().monetization.subscriptions.basePlans.activate({
+                auth,
+                packageName: input.packageName,
+                productId: input.productId,
+                basePlanId,
+                requestBody: {},
+            });
+            activated = true;
+            basePlanState = (activated_.data?.basePlans?.find?.((b) => b.basePlanId === basePlanId)?.state) ?? basePlanState;
+        }
+        catch (err) {
+            activateError = err.message;
+        }
+    }
+    return {
+        productId: input.productId,
+        basePlanId,
+        basePlanState,
+        activated,
+        activateError,
+    };
+}
 export async function verifyServiceAccountJson(serviceAccountJson, packageName) {
     let parsed;
     try {

package/package.json

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