@yoonion/mimi-seed-mcp 0.13.17 → 0.13.18

package/README.md

@@ -78,8 +78,8 @@ export ANTHROPIC_API_KEY=sk-ant-...
 
 | 영역 | 도구 수 | 주요 도구 |
 |------|---------|-----------|
-| App Store Connect | 58 | `appstore_submit_for_review` / `appstore_upload_screenshot` / `appstore_update_product_review_note` / `appstore_upload_product_review_screenshot` |
-| Google Play | 33 | `playstore_submit_release` / `playstore_promote_release` / `playstore_replace_images` / `playstore_reply_review` / `playstore_verify_service_account` |
+| App Store Connect | 61 | `appstore_submit_for_review` / `appstore_upload_screenshot` / `appstore_update_product_review_note` / `appstore_upload_product_review_screenshot` |
+| Google Play | 37 | `playstore_submit_release` / `playstore_promote_release` / `playstore_replace_images` / `playstore_reply_review` / `playstore_verify_service_account` |
 | Firebase | 20 | `firebase_create_project` / `firebase_create_android_app` / `firebase_get_android_config` / `firebase_create_ios_app` |
 | AdMob | 7 | `admob_list_apps` / `admob_create_ad_unit` / `admob_get_today_earnings` / `admob_get_report` |
 | CI/CD (GitHub Actions · GitLab) | 6 | `ci_trigger_build` / `ci_get_build_status` / `ci_list_workflows` / `ci_cancel_build` |

package/assets/agent-guide.md

@@ -58,6 +58,8 @@ you can paste. Pick the row for the job; batching two rows in one `select:` call
 | Pre-submission declarations (both stores) | `select:appstore_get_age_rating,appstore_update_age_rating,appstore_declare_encryption,appstore_get_availability,appstore_set_territory_availability,playstore_upload_data_safety` |
 | TestFlight external testing | `select:appstore_beta_status,appstore_update_beta_review_detail,appstore_update_beta_test_info,appstore_update_whats_to_test,appstore_submit_beta_review,appstore_set_beta_group_build,appstore_add_beta_testers,appstore_notify_beta_testers,appstore_list_beta_groups,appstore_list_builds` |
 | App Store review submission (the bundle) | `select:appstore_list_review_submissions,appstore_add_version_to_review_submission,appstore_remove_review_submission_item,appstore_update_version_string,appstore_cancel_review` |
+| App Store preview videos | `select:appstore_list_previews,appstore_upload_preview,appstore_delete_preview,appstore_get_metadata` |
+| Play post-release recovery | `select:playstore_list_recovery_actions,playstore_create_recovery_action,playstore_deploy_recovery_action,playstore_cancel_recovery_action,playstore_list_tracks` |
 | App Store screenshots | `select:appstore_list_app_info_localizations,appstore_get_metadata,appstore_list_screenshots,appstore_upload_screenshot,appstore_delete_screenshot,appstore_delete_screenshot_set,screenshot_validate` |
 | App Store app info + review notes | `select:appstore_get_app_info,appstore_update_app_info_localization,appstore_create_app_info_localization,appstore_update_localization,appstore_get_review_notes,appstore_update_review_notes` |
 | App Store reviews | `select:appstore_list_reviews,appstore_reply_review,generate_review_reply` |

package/dist/appstore/previews.d.ts

@@ -0,0 +1,41 @@
+export interface PreviewRow {
+    id: string;
+    fileName?: string;
+    fileSize?: number;
+    state?: string;
+    previewFrameTimeCode?: string;
+    videoUrl?: string;
+}
+export interface PreviewSetRow {
+    id: string;
+    previewType?: string;
+    previews: PreviewRow[];
+}
+/** 로케일의 미리보기 세트 + 각 동영상 상태. 업로드 후 인코딩 확인도 여기서 한다. */
+export declare function listPreviewSets(localizationId: string): Promise<PreviewSetRow[]>;
+/**
+ * 미리보기 동영상 업로드. `previewFrameTimeCode` 는 포스터 프레임 시각 (HH:MM:SS:FF).
+ *
+ * Apple 제약(업로드 후 인코딩 단계에서 거부될 수 있는 것들):
+ *   길이 15~30초 · previewType 별 해상도 고정 · 로케일·타입당 최대 3개.
+ */
+export declare function uploadPreview(args: {
+    localizationId: string;
+    previewType: string;
+    filePath: string;
+    previewFrameTimeCode?: string;
+}): Promise<{
+    id: string;
+    fileName: string;
+    fileSize: number;
+    previewType: string;
+    state?: string;
+}>;
+export declare function deletePreview(previewId: string): Promise<{
+    ok: true;
+    id: string;
+}>;
+export declare function deletePreviewSet(setId: string): Promise<{
+    ok: true;
+    id: string;
+}>;

package/dist/appstore/previews.js

@@ -0,0 +1,190 @@
+// App Store 제품 페이지 미리보기 **동영상** (appPreviewSets / appPreviews).
+//
+// 업로드 절차는 스크린샷과 같은 4단계다 (screenshots.ts 와 같은 기계):
+//   1. set 확보  POST /appPreviewSets              (previewType 별로 하나)
+//   2. 예약      POST /appPreviews                 → uploadOperations[]
+//   3. 업로드    PUT  각 operation URL (offset/length 로 조각내서)
+//   4. 커밋      PATCH /appPreviews/{id}           { uploaded, sourceFileChecksum }
+//
+// 스크린샷과 다른 점: 커밋 뒤 Apple 이 **인코딩**을 돌린다. 그래서 업로드 성공 ≠ 노출 가능이고,
+// assetDeliveryState 를 따로 확인해야 한다. previewFrameTimeCode 로 포스터 프레임도 고른다.
+import fs from 'node:fs';
+import path from 'node:path';
+import crypto from 'node:crypto';
+import { getAuthHeaders } from './auth.js';
+const BASE = 'https://api.appstoreconnect.apple.com/v1';
+async function req(pathOrUrl, init = {}) {
+    const headers = await getAuthHeaders();
+    if (!headers) {
+        throw new Error([
+            '❌ App Store Connect 인증이 필요해.',
+            '',
+            '터미널에서 실행:',
+            '  npx -p @yoonion/mimi-seed-mcp mimi-seed-appstore-auth',
+        ].join('\n'));
+    }
+    const url = pathOrUrl.startsWith('http') ? pathOrUrl : `${BASE}${pathOrUrl}`;
+    const res = await fetch(url, { ...init, headers: { ...headers, ...(init.headers ?? {}) } });
+    if (!res.ok) {
+        const body = await res.text();
+        throw new Error(`App Store API ${res.status} ${init.method ?? 'GET'} ${pathOrUrl}: ${body}`);
+    }
+    const text = await res.text();
+    return (text ? JSON.parse(text) : null);
+}
+/** 로케일의 미리보기 세트 + 각 동영상 상태. 업로드 후 인코딩 확인도 여기서 한다. */
+export async function listPreviewSets(localizationId) {
+    const data = await req(`/appStoreVersionLocalizations/${localizationId}/appPreviewSets` +
+        `?include=appPreviews` +
+        `&fields[appPreviewSets]=previewType,appPreviews` +
+        `&fields[appPreviews]=fileName,fileSize,assetDeliveryState,previewFrameTimeCode,videoUrl`);
+    const included = data?.included ?? [];
+    return (data?.data ?? []).map((s) => {
+        const ids = (s.relationships?.appPreviews?.data ?? []).map((p) => p.id);
+        return {
+            id: s.id,
+            previewType: s.attributes?.previewType,
+            previews: included
+                .filter((i) => i.type === 'appPreviews' && ids.includes(i.id))
+                .map((i) => ({
+                id: i.id,
+                fileName: i.attributes?.fileName,
+                fileSize: i.attributes?.fileSize,
+                state: i.attributes?.assetDeliveryState?.state,
+                previewFrameTimeCode: i.attributes?.previewFrameTimeCode,
+                videoUrl: i.attributes?.videoUrl,
+            })),
+        };
+    });
+}
+async function ensurePreviewSet(localizationId, previewType) {
+    const sets = await listPreviewSets(localizationId);
+    const hit = sets.find((s) => s.previewType === previewType);
+    if (hit)
+        return hit.id;
+    const created = await req('/appPreviewSets', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+            data: {
+                type: 'appPreviewSets',
+                attributes: { previewType },
+                relationships: {
+                    appStoreVersionLocalization: {
+                        data: { type: 'appStoreVersionLocalizations', id: localizationId },
+                    },
+                },
+            },
+        }),
+    });
+    return created.data.id;
+}
+async function uploadChunks(absPath, ops) {
+    const fd = fs.openSync(absPath, 'r');
+    try {
+        for (const op of ops) {
+            // 파일 전체를 메모리에 올리지 않는다 — 동영상은 수백 MB 가 될 수 있다.
+            const chunk = Buffer.alloc(op.length);
+            fs.readSync(fd, chunk, 0, op.length, op.offset);
+            const headers = {};
+            for (const h of op.requestHeaders ?? [])
+                headers[h.name] = h.value;
+            const res = await fetch(op.url, { method: op.method ?? 'PUT', headers, body: chunk });
+            if (!res.ok) {
+                throw new Error(`미리보기 업로드 실패 (offset ${op.offset}): ${res.status} ${await res.text()}`);
+            }
+        }
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}
+/** 확장자로 추정한 mimeType. Apple 은 없어도 받지만 있으면 처리 실패가 줄어든다. */
+function guessMimeType(fileName) {
+    const ext = path.extname(fileName).toLowerCase();
+    if (ext === '.mp4')
+        return 'video/mp4';
+    if (ext === '.mov')
+        return 'video/quicktime';
+    if (ext === '.m4v')
+        return 'video/x-m4v';
+    return undefined;
+}
+/**
+ * 미리보기 동영상 업로드. `previewFrameTimeCode` 는 포스터 프레임 시각 (HH:MM:SS:FF).
+ *
+ * Apple 제약(업로드 후 인코딩 단계에서 거부될 수 있는 것들):
+ *   길이 15~30초 · previewType 별 해상도 고정 · 로케일·타입당 최대 3개.
+ */
+export async function uploadPreview(args) {
+    const { localizationId, previewType, filePath, previewFrameTimeCode } = args;
+    if (!path.isAbsolute(filePath))
+        throw new Error(`filePath 는 절대경로여야 한다: ${filePath}`);
+    if (!fs.existsSync(filePath))
+        throw new Error(`파일이 존재하지 않는다: ${filePath}`);
+    const fileName = path.basename(filePath);
+    const fileSize = fs.statSync(filePath).size;
+    if (fileSize === 0)
+        throw new Error('빈 파일이다.');
+    const setId = await ensurePreviewSet(localizationId, previewType);
+    const mimeType = guessMimeType(fileName);
+    const reserved = await req('/appPreviews', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+            data: {
+                type: 'appPreviews',
+                attributes: {
+                    fileName,
+                    fileSize,
+                    ...(mimeType ? { mimeType } : {}),
+                    ...(previewFrameTimeCode ? { previewFrameTimeCode } : {}),
+                },
+                relationships: { appPreviewSet: { data: { type: 'appPreviewSets', id: setId } } },
+            },
+        }),
+    });
+    const previewId = reserved.data.id;
+    const ops = reserved.data.attributes?.uploadOperations ?? [];
+    if (ops.length === 0)
+        throw new Error('uploadOperations 가 비어 있다 — Apple 응답 형식 확인 필요.');
+    await uploadChunks(filePath, ops);
+    // 체크섬은 전체 파일 기준이라 스트리밍으로 계산한다 (메모리에 다 올리지 않는다).
+    const md5 = await new Promise((resolve, reject) => {
+        const hash = crypto.createHash('md5');
+        fs.createReadStream(filePath)
+            .on('data', (c) => hash.update(c))
+            .on('end', () => resolve(hash.digest('hex')))
+            .on('error', reject);
+    });
+    const committed = await req(`/appPreviews/${previewId}`, {
+        method: 'PATCH',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+            data: {
+                type: 'appPreviews',
+                id: previewId,
+                attributes: {
+                    uploaded: true,
+                    sourceFileChecksum: md5,
+                    ...(previewFrameTimeCode ? { previewFrameTimeCode } : {}),
+                },
+            },
+        }),
+    });
+    return {
+        id: previewId,
+        fileName,
+        fileSize,
+        previewType,
+        state: committed?.data?.attributes?.assetDeliveryState?.state,
+    };
+}
+export async function deletePreview(previewId) {
+    await req(`/appPreviews/${previewId}`, { method: 'DELETE' });
+    return { ok: true, id: previewId };
+}
+export async function deletePreviewSet(setId) {
+    await req(`/appPreviewSets/${setId}`, { method: 'DELETE' });
+    return { ok: true, id: setId };
+}

package/dist/playstore/tools.d.ts

@@ -168,6 +168,44 @@ export declare function updatePurchaseOptionState(auth: OAuth2Client | JWT, pack
         state: string | undefined;
     }[];
 }>;
+export interface RecoveryTargeting {
+    /** 전체 사용자 대상. versionCodes / 범위와 함께 쓸 수 없다. */
+    allUsers?: boolean;
+    /** 특정 버전 코드들 */
+    versionCodes?: string[];
+    /** 버전 코드 범위 (start~end) */
+    versionRange?: {
+        start: string;
+        end: string;
+    };
+    /** 지역 코드 (예: KR, US) */
+    regions?: string[];
+    /** Android SDK 레벨 */
+    sdkLevels?: string[];
+}
+export declare function buildTargeting(t: RecoveryTargeting): Record<string, unknown>;
+export declare function listRecoveryActions(auth: OAuth2Client | JWT, packageName: string, versionCode?: string): Promise<{
+    id: string | null | undefined;
+    status: string | null | undefined;
+    createTime: string | null | undefined;
+    deployTime: string | null | undefined;
+    cancelTime: string | null | undefined;
+    targeting: import("googleapis/build/src/apis/androidpublisher/v3.js").androidpublisher_v3.Schema$Targeting | undefined;
+}[]>;
+/** DRAFT 상태로만 만든다 — 실제 배포는 deployRecoveryAction 이 별도로 한다. */
+export declare function createRecoveryAction(auth: OAuth2Client | JWT, packageName: string, targeting: RecoveryTargeting): Promise<{
+    id: string | null | undefined;
+    status: string | null | undefined;
+    targeting: import("googleapis/build/src/apis/androidpublisher/v3.js").androidpublisher_v3.Schema$Targeting | undefined;
+}>;
+export declare function deployRecoveryAction(auth: OAuth2Client | JWT, packageName: string, appRecoveryId: string): Promise<{
+    appRecoveryId: string;
+    deployed: boolean;
+}>;
+export declare function cancelRecoveryAction(auth: OAuth2Client | JWT, packageName: string, appRecoveryId: string): Promise<{
+    appRecoveryId: string;
+    cancelled: boolean;
+}>;
 export declare function uploadDataSafety(auth: OAuth2Client | JWT, packageName: string, safetyLabelsCsv: string): Promise<{
     packageName: string;
     bytes: number;

package/dist/playstore/tools.js

@@ -650,9 +650,79 @@ export async function updatePurchaseOptionState(auth, packageName, productId, pu
     })));
     return { productId, purchaseOptionId, action, states };
 }
-// ─── 인앱 상품 / 구독 생성은 @onesub/providers로 위임 ───
-// IAP·구독 CRUD는 onesub의 도메인 (결제 영역). 이 파일에는 메타·이미지·릴리스·리뷰만 남김.
-// 옛 createOnetimeProduct / createSubscription 구현은 onesub 위임으로 대체됐어 (index.ts 참고).
+export function buildTargeting(t) {
+    const targeting = {};
+    if (t.allUsers)
+        targeting.allUsers = { isAllUsersRequested: true };
+    if (t.versionCodes?.length)
+        targeting.versionList = { versionCodes: t.versionCodes };
+    if (t.versionRange) {
+        targeting.versionRange = {
+            versionCodeStart: t.versionRange.start,
+            versionCodeEnd: t.versionRange.end,
+        };
+    }
+    if (t.regions?.length)
+        targeting.regions = { regionCode: t.regions };
+    if (t.sdkLevels?.length)
+        targeting.androidSdks = { sdkLevels: t.sdkLevels };
+    if (Object.keys(targeting).length === 0) {
+        throw new Error('대상(targeting)이 비어 있다 — allUsers / versionCodes / versionRange 중 하나는 필요하다.');
+    }
+    if (t.allUsers && (t.versionCodes?.length || t.versionRange)) {
+        throw new Error('allUsers 와 versionCodes/versionRange 는 함께 쓸 수 없다.');
+    }
+    return targeting;
+}
+export async function listRecoveryActions(auth, packageName, versionCode) {
+    const res = await publisher().apprecovery.list({
+        auth,
+        packageName,
+        ...(versionCode ? { versionCode } : {}),
+    });
+    return (res.data.recoveryActions ?? []).map((a) => ({
+        id: a.appRecoveryId,
+        status: a.status,
+        createTime: a.createTime,
+        deployTime: a.deployTime,
+        cancelTime: a.cancelTime,
+        targeting: a.targeting,
+    }));
+}
+/** DRAFT 상태로만 만든다 — 실제 배포는 deployRecoveryAction 이 별도로 한다. */
+export async function createRecoveryAction(auth, packageName, targeting) {
+    const res = await publisher().apprecovery.create({
+        auth,
+        packageName,
+        requestBody: {
+            remoteInAppUpdate: { isRemoteInAppUpdateRequested: true },
+            targeting: buildTargeting(targeting),
+        },
+    });
+    return {
+        id: res.data.appRecoveryId,
+        status: res.data.status,
+        targeting: res.data.targeting,
+    };
+}
+export async function deployRecoveryAction(auth, packageName, appRecoveryId) {
+    await publisher().apprecovery.deploy({
+        auth,
+        packageName,
+        appRecoveryId,
+        requestBody: {},
+    });
+    return { appRecoveryId, deployed: true };
+}
+export async function cancelRecoveryAction(auth, packageName, appRecoveryId) {
+    await publisher().apprecovery.cancel({
+        auth,
+        packageName,
+        appRecoveryId,
+        requestBody: {},
+    });
+    return { appRecoveryId, cancelled: true };
+}
 // ─── 데이터 안전(Safety Labels) 선언 ───
 //
 // 오랫동안 Console 전용이라고 알려졌지만 API 가 생겼다 (POST applications/{pkg}/dataSafety).

package/dist/registers/appstore.js

@@ -6,6 +6,7 @@ import * as appstoreProductLocalization from '../appstore/product-localization.j
 import * as appstoreRelease from '../appstore/release.js';
 import * as appstoreDeclarations from '../appstore/declarations.js';
 import * as testflight from '../appstore/testflight.js';
+import * as previews from '../appstore/previews.js';
 import { createAppleOneTimePurchase, createAppleSubscription, updateAppleProduct, deleteAppleProduct, listAppleProducts, } from '@onesub/providers';
 import { requireAppStoreCreds } from '../helpers.js';
 import { buildAppStoreReleasePlan } from '../checks/plan.js';
@@ -1437,4 +1438,91 @@ export function registerAppstoreTools(server) {
         const r = await testflight.notifyBetaTesters(buildId);
         return { content: [{ type: 'text', text: `✅ 알림 발송 (${r.notificationId})` }] };
     });
+    // ─── 제품 페이지 미리보기 동영상 ───
+    // 스크린샷과 같은 4단계 업로드지만, 커밋 후 Apple 인코딩이 남는다 — 업로드 성공 ≠ 노출 가능.
+    const PREVIEW_TYPES = [
+        'IPHONE_67', 'IPHONE_61', 'IPHONE_65', 'IPHONE_58', 'IPHONE_55', 'IPHONE_47', 'IPHONE_40', 'IPHONE_35',
+        'IPAD_PRO_3GEN_129', 'IPAD_PRO_3GEN_11', 'IPAD_PRO_129', 'IPAD_105', 'IPAD_97',
+        'DESKTOP', 'APPLE_TV', 'APPLE_VISION_PRO',
+    ];
+    server.tool('appstore_list_previews', [
+        '버전 로케일의 미리보기 동영상 세트를 조회한다 — 읽기 전용.',
+        '세트별 previewType 과 각 동영상의 처리 상태(assetDeliveryState)·포스터 프레임·videoUrl 을 보여준다.',
+        '업로드 직후 인코딩이 끝났는지 확인할 때도 이걸 쓴다.',
+    ].join(' '), {
+        localizationId: z
+            .string()
+            .describe('appStoreVersionLocalization ID (appstore_get_metadata 결과의 로케일별 id)'),
+    }, async ({ localizationId }) => {
+        const sets = await previews.listPreviewSets(localizationId);
+        if (sets.length === 0) {
+            return { content: [{ type: 'text', text: '미리보기 세트 없음.' }] };
+        }
+        const lines = [];
+        for (const s of sets) {
+            lines.push(`${s.previewType ?? '?'} (set ${s.id}) — ${s.previews.length}개`);
+            for (const p of s.previews) {
+                lines.push(`  ${p.id}: ${p.fileName ?? '?'} · ${p.state ?? '상태 미상'}` +
+                    (p.previewFrameTimeCode ? ` · 포스터 ${p.previewFrameTimeCode}` : '') +
+                    (p.videoUrl ? ' · 재생 가능' : ''));
+            }
+        }
+        return { content: [{ type: 'text', text: lines.join('\n') }] };
+    });
+    server.tool('appstore_upload_preview', [
+        '제품 페이지 미리보기 **동영상**을 업로드한다 — appPreviewSets/appPreviews 4단계 업로드.',
+        'previewType 세트가 없으면 만들고, 예약 → 조각 업로드 → 커밋까지 한 번에 처리한다.',
+        '⚠️ 커밋 후 Apple 인코딩이 남는다 — 성공 응답이 곧 노출 가능은 아니다. appstore_list_previews 로 확인할 것.',
+        'Apple 제약: 길이 15~30초, previewType 별 해상도 고정, 로케일·타입당 최대 3개. 어기면 인코딩 단계에서 거부된다.',
+        'previewFrameTimeCode(HH:MM:SS:FF)로 포스터 프레임을 지정할 수 있다.',
+        '파일은 절대경로로 넘긴다 (대용량이라 조각 업로드하며, 동영상 바이트는 대화에 싣지 않는다).',
+    ].join(' '), {
+        localizationId: z.string().describe('appStoreVersionLocalization ID'),
+        previewType: z.enum(PREVIEW_TYPES).describe('미리보기 타입 (기기군)'),
+        filePath: z.string().describe('동영상 파일 절대경로 (.mp4 / .mov / .m4v)'),
+        previewFrameTimeCode: z
+            .string()
+            .optional()
+            .describe('포스터 프레임 시각 HH:MM:SS:FF (예: 00:00:03:00)'),
+    }, async ({ localizationId, previewType, filePath, previewFrameTimeCode }) => {
+        const r = await previews.uploadPreview({ localizationId, previewType, filePath, previewFrameTimeCode });
+        return {
+            content: [{
+                    type: 'text',
+                    text: [
+                        '✅ 미리보기 업로드 완료 (인코딩 대기)',
+                        `  id: ${r.id}`,
+                        `  파일: ${r.fileName} (${(r.fileSize / 1024 / 1024).toFixed(1)} MB)`,
+                        `  타입: ${r.previewType}`,
+                        `  상태: ${r.state ?? '처리 중'}`,
+                        'Apple 인코딩이 끝나야 노출된다 — appstore_list_previews 로 상태를 확인할 것.',
+                    ].join('\n'),
+                }],
+        };
+    });
+    server.tool('appstore_delete_preview', [
+        '미리보기 동영상 또는 세트를 삭제한다 — DELETE /v1/appPreviews/{id} 또는 /appPreviewSets/{id}.',
+        '⚠️ 되돌릴 수 없다. 세트를 지우면 그 안의 동영상이 모두 사라진다. confirm 필요.',
+    ].join(' '), {
+        previewId: z.string().optional().describe('삭제할 미리보기 ID (set 과 둘 중 하나)'),
+        setId: z.string().optional().describe('삭제할 미리보기 세트 ID (안의 동영상 전부 삭제)'),
+        confirm: z.boolean().optional().describe('true 명시 시에만 삭제'),
+    }, async ({ previewId, setId, confirm }) => {
+        if (!previewId && !setId)
+            throw new Error('previewId 또는 setId 중 하나는 필요하다.');
+        if (!confirm) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: previewId
+                            ? `🛑 dry-run — 미리보기 ${previewId} 를 삭제할 참이다. confirm: true 로 다시 호출.`
+                            : `🛑 dry-run — 세트 ${setId} 와 그 안의 동영상 전부를 삭제할 참이다. confirm: true 로 다시 호출.`,
+                    }],
+            };
+        }
+        const r = previewId
+            ? await previews.deletePreview(previewId)
+            : await previews.deletePreviewSet(setId);
+        return { content: [{ type: 'text', text: `✅ 삭제 완료 — ${r.id}` }] };
+    });
 }

package/dist/registers/playstore.js

@@ -809,4 +809,127 @@ export function registerPlaystoreTools(server) {
                 }],
         };
     });
+    // ─── 앱 복구 (출시 후 긴급 대응) ───
+    server.tool('playstore_list_recovery_actions', [
+        '앱 복구 액션 목록을 조회한다 — 읽기 전용 (apprecovery.list).',
+        '이미 배포된 앱이 치명적으로 망가졌을 때 특정 버전 사용자에게 원격 인앱 업데이트를 밀어 넣는 장치다.',
+        '상태(DRAFT/ACTIVE/CANCELED)·생성·배포·취소 시각과 대상을 보여준다.',
+    ].join(' '), {
+        packageName: z.string().describe('패키지명'),
+        versionCode: z.string().optional().describe('특정 버전 코드로 필터'),
+    }, async ({ packageName, versionCode }) => {
+        const auth = await requirePlayStoreAuth(packageName);
+        const rows = await playstore.listRecoveryActions(auth, packageName, versionCode);
+        if (rows.length === 0)
+            return { content: [{ type: 'text', text: '복구 액션 없음.' }] };
+        return {
+            content: [{
+                    type: 'text',
+                    text: rows
+                        .map((r) => [
+                        `${r.id}: ${r.status}`,
+                        r.createTime ? `  생성 ${r.createTime}` : '',
+                        r.deployTime ? `  배포 ${r.deployTime}` : '',
+                        r.cancelTime ? `  취소 ${r.cancelTime}` : '',
+                        `  대상: ${JSON.stringify(r.targeting ?? {})}`,
+                    ].filter(Boolean).join('\n'))
+                        .join('\n'),
+                }],
+        };
+    });
+    server.tool('playstore_create_recovery_action', [
+        '앱 복구 액션을 DRAFT 상태로 만든다 — apprecovery.create.',
+        '만들기만 하고 배포하지 않는다 (배포는 playstore_deploy_recovery_action).',
+        '대상은 allUsers 또는 versionCodes / versionRange 중 하나로 정한다 — allUsers 와 버전 지정은 함께 못 쓴다.',
+        '⚠️ 배포 후에는 대상을 만들 때 고른 기준 안에서만 넓힐 수 있다. 범위를 신중히 잡을 것.',
+        '이건 롤백이 아니라 "고친 버전으로 강제 업데이트"다 — 먼저 정상 빌드를 올려 둬야 의미가 있다.',
+    ].join(' '), {
+        packageName: z.string().describe('패키지명'),
+        allUsers: z.boolean().optional().describe('전체 사용자 대상 (버전 지정과 함께 쓸 수 없음)'),
+        versionCodes: z.array(z.string()).optional().describe('대상 버전 코드 목록'),
+        versionRangeStart: z.string().optional().describe('대상 버전 범위 시작'),
+        versionRangeEnd: z.string().optional().describe('대상 버전 범위 끝'),
+        regions: z.array(z.string()).optional().describe('지역 코드 (예: KR, US)'),
+        sdkLevels: z.array(z.string()).optional().describe('Android SDK 레벨'),
+        confirm: z.boolean().optional().describe('true 명시 시에만 생성. 생략/false 면 계획만 반환.'),
+    }, async ({ packageName, allUsers, versionCodes, versionRangeStart, versionRangeEnd, regions, sdkLevels, confirm }) => {
+        const targeting = {
+            allUsers,
+            versionCodes,
+            versionRange: versionRangeStart && versionRangeEnd
+                ? { start: versionRangeStart, end: versionRangeEnd }
+                : undefined,
+            regions,
+            sdkLevels,
+        };
+        if (!confirm) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: [
+                            '🛑 dry-run — 아직 만들지 않았다.',
+                            `  패키지: ${packageName}`,
+                            `  대상: ${JSON.stringify(targeting)}`,
+                            '',
+                            'DRAFT 로 만들려면 confirm: true. 만든 뒤에도 배포는 별도 단계다.',
+                        ].join('\n'),
+                    }],
+            };
+        }
+        const auth = await requirePlayStoreAuth(packageName);
+        const r = await playstore.createRecoveryAction(auth, packageName, targeting);
+        return {
+            content: [{
+                    type: 'text',
+                    text: [
+                        '✅ 복구 액션 생성 (DRAFT — 아직 사용자에게 나가지 않았다)',
+                        `  id: ${r.id}`,
+                        `  상태: ${r.status}`,
+                        '배포하려면 playstore_deploy_recovery_action.',
+                    ].join('\n'),
+                }],
+        };
+    });
+    server.tool('playstore_deploy_recovery_action', [
+        'DRAFT 복구 액션을 실제로 배포한다 — apprecovery.deploy.',
+        '⚠️ 대상 사용자 기기에 원격 인앱 업데이트가 나간다. 되돌리려면 취소해야 하고, 이미 적용된 기기는 되돌아가지 않는다.',
+        '배포 전 playstore_list_recovery_actions 로 대상 범위를 반드시 재확인할 것. confirm 필요.',
+    ].join(' '), {
+        packageName: z.string().describe('패키지명'),
+        appRecoveryId: z.string().describe('복구 액션 ID'),
+        confirm: z.boolean().optional().describe('true 명시 시에만 배포'),
+    }, async ({ packageName, appRecoveryId, confirm }) => {
+        if (!confirm) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: `🛑 dry-run — 복구 액션 ${appRecoveryId} 를 배포할 참이다. 대상 사용자에게 원격 업데이트가 나간다. confirm: true 로 다시 호출.`,
+                    }],
+            };
+        }
+        const auth = await requirePlayStoreAuth(packageName);
+        const r = await playstore.deployRecoveryAction(auth, packageName, appRecoveryId);
+        return { content: [{ type: 'text', text: `✅ 복구 액션 배포 — ${r.appRecoveryId}` }] };
+    });
+    server.tool('playstore_cancel_recovery_action', [
+        '진행 중인 복구 액션을 취소한다 — apprecovery.cancel.',
+        '아직 받지 않은 기기에는 더 이상 나가지 않는다. 이미 적용된 기기는 되돌아가지 않는다.',
+        'confirm 필요.',
+    ].join(' '), {
+        packageName: z.string().describe('패키지명'),
+        appRecoveryId: z.string().describe('복구 액션 ID'),
+        confirm: z.boolean().optional().describe('true 명시 시에만 취소'),
+    }, async ({ packageName, appRecoveryId, confirm }) => {
+        if (!confirm) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: `🛑 dry-run — 복구 액션 ${appRecoveryId} 를 취소할 참이다. 이미 적용된 기기는 되돌아가지 않는다. confirm: true 로 다시 호출.`,
+                    }],
+            };
+        }
+        const auth = await requirePlayStoreAuth(packageName);
+        const r = await playstore.cancelRecoveryAction(auth, packageName, appRecoveryId);
+        return { content: [{ type: 'text', text: `✅ 복구 액션 취소 — ${r.appRecoveryId}` }] };
+    });
 }

package/package.json

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

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": 207,
+  "total": 214,
   "domains": {
     "admob": {
       "label": "AdMob",
@@ -97,7 +97,10 @@
         "appstore_submit_beta_review",
         "appstore_set_beta_group_build",
         "appstore_add_beta_testers",
-        "appstore_notify_beta_testers"
+        "appstore_notify_beta_testers",
+        "appstore_list_previews",
+        "appstore_upload_preview",
+        "appstore_delete_preview"
       ]
     },
     "auth": {
@@ -305,7 +308,11 @@
         "playstore_update_product",
         "playstore_delete_product",
         "setup_playstore_connection",
-        "playstore_upload_data_safety"
+        "playstore_upload_data_safety",
+        "playstore_list_recovery_actions",
+        "playstore_create_recovery_action",
+        "playstore_deploy_recovery_action",
+        "playstore_cancel_recovery_action"
       ]
     },
     "threads": {