@yoonion/mimi-seed-mcp 0.13.14 → 0.13.16

package/README.md

@@ -78,8 +78,8 @@ export ANTHROPIC_API_KEY=sk-ant-...
 
 | 영역 | 도구 수 | 주요 도구 |
 |------|---------|-----------|
-| App Store Connect | 34 | `appstore_submit_for_review` / `appstore_upload_screenshot` / `appstore_update_product_review_note` / `appstore_upload_product_review_screenshot` |
-| Google Play | 29 | `playstore_submit_release` / `playstore_promote_release` / `playstore_replace_images` / `playstore_reply_review` / `playstore_verify_service_account` |
+| App Store Connect | 50 | `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` |
 | 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

@@ -16,7 +16,7 @@ and which actions are irreversible.
 
 ## 0. The one thing that trips every agent: deferred tools
 
-Mimi Seed exposes **150+ MCP tools** across 19 domains (full inventory:
+Mimi Seed exposes **150+ MCP tools** across every store, cloud, CI, social, and video domain (full inventory:
 [`docs/domain/tool-catalog.md`](domain/tool-catalog.md)). Harnesses that lazy-load large tool catalogs —
 **Claude Code most notably** — register these tools as **deferred**: the tool *names*
 are visible (in a system reminder), but the **input schemas are not loaded**. If you
@@ -42,20 +42,38 @@ tools directly — but the *call order* and *safety rules* below still apply.
 
 ### Ready-made `select:` batches
 
+Every registered tool appears in at least one batch below (test-enforced), so a task you can name is a batch
+you can paste. Pick the row for the job; batching two rows in one `select:` call is fine.
+
 | Goal | `ToolSearch` query |
 |------|--------------------|
 | First contact / "what's connected?" | `select:mimi_seed_status,mimi_seed_auth_status,mimi_seed_auth_start,mimi_seed_remote_sync_credentials` |
-| Play Store release | `select:playstore_get_app,playstore_list_tracks,playstore_update_latest_release_notes,playstore_promote_release,playstore_submit_release,playstore_check_submission_risks,playstore_plan_release` |
-| Play Store listing + images | `select:playstore_get_listing,playstore_update_listing,playstore_upload_image,playstore_list_images,playstore_replace_images,playstore_delete_all_images` |
-| App Store / TestFlight | `select:appstore_list_apps,appstore_list_versions,appstore_create_version,appstore_get_metadata,appstore_update_whats_new,appstore_list_builds,appstore_attach_latest_build,appstore_submit_for_review,appstore_check_submission_risks,appstore_plan_release` |
-| App Store screenshots | `select:appstore_list_app_info_localizations,appstore_get_metadata,appstore_list_screenshots,appstore_upload_screenshot,appstore_delete_screenshot_set,screenshot_validate` |
-| App Store IAP review metadata | `select:appstore_list_apps,appstore_list_products,appstore_update_product_review_note,appstore_upload_product_review_screenshot` |
+| Release readiness (either store) | `select:release_status,playstore_check_submission_risks,appstore_check_submission_risks,screenshot_validate` |
+| Play Store release | `select:playstore_get_app,playstore_list_tracks,playstore_update_release_notes,playstore_update_latest_release_notes,playstore_promote_release,playstore_submit_release,playstore_check_submission_risks,playstore_plan_release` |
+| Play Store listing + images | `select:playstore_get_listing,playstore_update_listing,playstore_update_details,playstore_upload_image,playstore_list_images,playstore_replace_images,playstore_delete_all_images` |
+| Play Store reviews + stats | `select:playstore_list_reviews,playstore_reply_review,playstore_get_statistics,generate_review_reply` |
+| Play Store IAP / subscriptions | `select:playstore_list_products,playstore_list_inapp_products,playstore_list_subscriptions,playstore_create_onetime_product,playstore_create_subscription,playstore_update_product,playstore_update_product_listing,playstore_update_subscription_listing,playstore_update_product_state,playstore_delete_product` |
+| App Store / TestFlight | `select:appstore_list_apps,appstore_verify_credentials,appstore_get_app,appstore_list_versions,appstore_create_version,appstore_get_metadata,appstore_update_whats_new,appstore_list_builds,appstore_attach_build,appstore_attach_latest_build,appstore_list_beta_groups,appstore_submit_for_review,appstore_check_submission_risks,appstore_plan_release` |
+| App Store release control (after approval) | `select:appstore_release_status,appstore_release_version,appstore_update_release_type,appstore_phased_release,appstore_list_versions` |
+| 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` |
+| 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 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` |
+| App Store IAP (products + review metadata) | `select:appstore_list_products,appstore_create_inapp_purchase,appstore_create_subscription,appstore_update_product,appstore_list_product_localizations,appstore_update_product_localization,appstore_update_product_review_note,appstore_upload_product_review_screenshot,appstore_add_product_to_review,appstore_delete_product` |
 | Release notes from commits | `select:generate_release_notes_from_commits,playstore_update_release_notes,appstore_update_whats_new` |
-| Firebase setup | `select:firebase_list_projects,firebase_get_project,firebase_create_project,firebase_create_android_app,firebase_create_ios_app,firebase_get_android_config,firebase_enable_common_services` |
-| AdMob | `select:admob_list_accounts,admob_list_apps,admob_create_ad_unit,admob_list_ad_units,admob_get_today_earnings,admob_get_report` |
-| Jenkins credentials + jobs | `select:jenkins_status,jenkins_save_config,jenkins_list_credentials,jenkins_create_credential,jenkins_upload_keystore,jenkins_upload_playstore_sa,jenkins_list_jobs,jenkins_get_job_config,jenkins_create_job,jenkins_update_job` |
-| CI (GitHub/GitLab) | `select:ci_save_config,ci_list_workflows,ci_trigger_build,ci_get_build_status,ci_list_recent_builds` |
-| Service account end-to-end | `select:iam_create_service_account,iam_create_key,iam_add_iam_policy_binding,playstore_register_service_account,playstore_verify_service_account` |
+| Firebase setup | `select:firebase_list_projects,firebase_get_project,firebase_create_project,firebase_create_android_app,firebase_create_ios_app,firebase_get_android_config,firebase_get_ios_config,firebase_enable_common_services` |
+| Firebase apps + services (incl. web) | `select:firebase_list_android_apps,firebase_list_ios_apps,firebase_list_web_apps,firebase_create_web_app,firebase_get_web_config,firebase_enable_service,firebase_list_enabled_services,firebase_delete_android_app,firebase_delete_ios_app,firebase_delete_web_app` |
+| Analytics wiring (Firebase ↔ GA4 ↔ BigQuery) | `select:firebase_link_analytics,firebase_get_analytics_details,ga4_list_account_summaries,ga4_list_properties,ga4_create_property,ga4_list_data_streams,ga4_create_data_stream,ga4_plan_bigquery_link,ga4_create_bigquery_link,ga4_run_report` |
+| BigQuery | `select:bigquery_auth_status,bigquery_list_datasets,bigquery_list_tables,bigquery_get_table_schema,bigquery_run_query` |
+| AdMob | `select:admob_list_accounts,admob_list_apps,admob_create_app,admob_create_ad_unit,admob_list_ad_units,admob_get_today_earnings,admob_get_report` |
+| Google Ads (UAC) | `select:googleads_config_status,googleads_save_config,googleads_list_accessible_customers,googleads_list_campaigns,googleads_get_campaign_report,googleads_get_uac_report` |
+| Search Console | `select:gsc_list_sites,gsc_list_sitemaps,gsc_get_sitemap,gsc_submit_sitemap,gsc_inspect_url,gsc_search_analytics` |
+| Social posting (Facebook / Instagram / Threads) | `select:facebook_current_config,facebook_save_config,facebook_list_pages,facebook_get_page,facebook_post_photo,facebook_post_multi_photo,instagram_save_config,instagram_get_account,instagram_post_image,instagram_post_carousel,threads_current_config,threads_save_config,threads_refresh_token,threads_get_account,threads_post,threads_post_carousel` |
+| Jenkins credentials + jobs | `select:jenkins_status,jenkins_save_config,jenkins_list_credentials,jenkins_create_credential,jenkins_delete_credential,jenkins_upload_keystore,jenkins_upload_playstore_sa,jenkins_list_jobs,jenkins_get_job_config,jenkins_create_job,jenkins_update_job` |
+| CI (GitHub/GitLab) | `select:ci_save_config,ci_list_workflows,ci_trigger_build,ci_get_build_status,ci_list_recent_builds,ci_cancel_build` |
+| Android signing / keystore | `select:android_signing_setup,android_generate_keystore,jenkins_upload_keystore,jenkins_upload_playstore_sa` |
+| Service account end-to-end | `select:iam_list_service_accounts,iam_create_service_account,iam_list_keys,iam_create_key,iam_add_iam_policy_binding,setup_playstore_connection,playstore_register_service_account,playstore_verify_service_account,playstore_list_service_accounts,playstore_delete_service_account` |
 | Story → researched video | `select:video_plan_from_story,video_research_youtube,video_search_stock_assets,video_synthesize_research,video_download_stock_assets,video_generate_image,video_add_local_asset,video_build_timeline,video_render,video_job_status,video_validate` |
 | YouTube upload / publish | `select:youtube_upload_video,youtube_get_video_status,youtube_update_video_privacy,mimi_seed_auth_start` |
 
@@ -156,7 +174,10 @@ per-domain inventory is [`docs/domain/tool-catalog.md`](domain/tool-catalog.md).
 | **Jenkins** (credentials + jobs) | `jenkins_status` · `jenkins_save_config` · `jenkins_create_credential` · `jenkins_upload_keystore` · `jenkins_upload_playstore_sa` · `jenkins_create_job` · `jenkins_update_job` |
 | **Google Cloud IAM** | `iam_create_service_account` · `iam_create_key` · `iam_add_iam_policy_binding` |
 | **BigQuery** | `bigquery_run_query` · `bigquery_list_datasets` · `bigquery_get_table_schema` |
+| **GA4** | `ga4_list_properties` · `ga4_create_property` · `ga4_create_data_stream` · `ga4_run_report` · `ga4_plan_bigquery_link` · `ga4_create_bigquery_link` |
+| **Google Ads (UAC)** | `googleads_list_campaigns` · `googleads_get_uac_report` · `googleads_get_campaign_report` · `googleads_config_status` |
 | **Search Console** | `gsc_inspect_url` · `gsc_search_analytics` · `gsc_submit_sitemap` |
+| **Android signing** | `android_signing_setup` · `android_generate_keystore` · `jenkins_upload_playstore_sa` |
 | **Facebook / Instagram / Threads** | `facebook_post_photo` · `instagram_post_carousel` · `threads_post` · `threads_refresh_token` |
 | **Checks** | `playstore_check_submission_risks` · `appstore_check_submission_risks` · `screenshot_validate` · `release_status` |
 | **AI / Auth** | `generate_release_notes_from_commits` · `generate_review_reply` · `mimi_seed_status` · `mimi_seed_auth_start` · `mimi_seed_auth_status` · `mimi_seed_remote_sync_credentials` |
@@ -183,6 +204,10 @@ per-domain inventory is [`docs/domain/tool-catalog.md`](domain/tool-catalog.md).
 `playstore_update_release_notes` / `appstore_update_whats_new`.
 
 ### Story → researched video
+For visual production, use the bundled `video-create-publish` skill. It requires an explicit typography system,
+aspect-ratio-specific human-safe crops, video-native motion, an original-resolution frame review, and a saved
+contact sheet; codec validation alone is not a quality pass.
+
 1. `video_plan_from_story` — create the project and scene plan.
 2. `video_research_youtube` — collect reference-only metadata; never treat a result as a render asset.
 3. `video_search_stock_assets` — find licensed Pexels candidates.
@@ -226,9 +251,9 @@ General rules:
 - **Draft-app track constraint (Play).** Until an app has its first non-internal
   publish, only the **`internal`** track can be `completed`. `alpha`/`beta`/`production`
   reject anything but `draft` → error: *"Only releases with status draft may be created
-  on draft app."* Closed/open testing also needs the **App Content** declarations
-  (content rating, data safety, target audience) which are **Console-only** — the API
-  cannot set them.
+  on draft app."* Closed/open testing also needs the **App Content** declarations. **Data safety** is
+  uploadable as a CSV (`playstore_upload_data_safety`); **content rating and target
+  audience remain Console-only** — no API sets them.
 - **A `403` on one write but not another is usually NOT a permissions gap.** Every
   `playstore_*` write resolves the same credential (`requirePlayStoreAuth`), so if
   `playstore_upload_image` succeeds but `playstore_update_listing` returns `403`, the

package/dist/appstore/declarations.d.ts

@@ -0,0 +1,73 @@
+/** Apple 이 쓰는 빈도 척도. 필드마다 같은 enum 을 쓴다. */
+export type Frequency = 'NONE' | 'INFREQUENT_OR_MILD' | 'FREQUENT_OR_INTENSE' | 'INFREQUENT' | 'FREQUENT';
+export interface AgeRatingDeclaration {
+    [key: string]: string | boolean | undefined;
+}
+export declare function getAgeRating(appId: string): Promise<{
+    appInfoId: string;
+    declarationId?: string;
+    declaration: AgeRatingDeclaration;
+}>;
+/**
+ * 연령 등급 설문 갱신 (PATCH /v1/ageRatingDeclarations/{id}).
+ * 넘긴 필드만 바뀐다 — Apple 이 부분 갱신을 허용하므로 전체를 다시 보낼 필요가 없다.
+ */
+export declare function updateAgeRating(args: {
+    appId: string;
+    declaration: AgeRatingDeclaration;
+}): Promise<{
+    declarationId: string;
+    declaration: AgeRatingDeclaration;
+}>;
+/**
+ * 수출 규정 선언 생성 (POST /v1/appEncryptionDeclarations).
+ * buildIds 를 주면 그 빌드들에 바로 연결한다 (POST …/relationships/builds).
+ *
+ * Info.plist 의 ITSAppUsesNonExemptEncryption 으로 해결되는 경우가 더 많다 —
+ * 이 도구는 그게 없어서 ASC 가 선언을 요구할 때의 경로다.
+ */
+export declare function declareEncryption(args: {
+    appId: string;
+    appDescription: string;
+    containsProprietaryCryptography: boolean;
+    containsThirdPartyCryptography: boolean;
+    availableOnFrenchStore: boolean;
+    buildIds?: string[];
+}): Promise<{
+    declarationId: string;
+    state?: string;
+    attachedBuilds: number;
+}>;
+export interface TerritoryRow {
+    /** territoryAvailability 리소스 id — PATCH 할 때 그대로 쓴다. */
+    id: string;
+    available?: boolean;
+    releaseDate?: string;
+    preOrderEnabled?: boolean;
+}
+/**
+ * 현재 판매 지역 상태 (GET /v1/apps/{id}/appAvailabilityV2 → territoryAvailabilities).
+ * 지역이 175개라 기본은 판매 중인 곳만 세고, `includeTerritories` 로 목록을 받는다.
+ */
+export declare function getAvailability(args: {
+    appId: string;
+    includeTerritories?: boolean;
+    limit?: number;
+}): Promise<{
+    availabilityId?: string;
+    availableInNewTerritories?: boolean;
+    availableCount: number;
+    unavailableCount: number;
+    territories?: TerritoryRow[];
+}>;
+/**
+ * 지역별 판매 여부·출시일 변경 (PATCH /v1/territoryAvailabilities/{id}).
+ * id 는 appstore_get_availability 결과에서 온다 — 추측해서 만들지 말 것.
+ */
+export declare function setTerritoryAvailability(args: {
+    territories: TerritoryRow[];
+}): Promise<Array<{
+    id: string;
+    ok: boolean;
+    error?: string;
+}>>;

package/dist/appstore/declarations.js

@@ -0,0 +1,154 @@
+// 심사 제출 **전에** 채워야 하는 선언들 — 비어 있으면 제출 자체가 막히거나 심사에서 반려된다.
+//
+//   연령 등급 (ageRatingDeclarations)        : appInfo 에 딸린 단일 리소스. PATCH 로만 바꾼다
+//   수출 규정 (appEncryptionDeclarations)    : 앱 단위로 만들고 빌드에 붙인다
+//   판매 지역 (appAvailabilityV2 / territoryAvailabilities): 지역별 available·출시일
+//
+// Play 쪽 대응물(데이터 안전 CSV)은 playstore/tools.ts 에 있다 — 자격증명 계통이 달라서 파일을 나눴다.
+import { V1_BASE, V2_BASE, apiRequest, authHeadersOrThrow } from './http.js';
+async function get(base, path, params) {
+    const headers = await authHeadersOrThrow();
+    const query = params ? `?${new URLSearchParams(params).toString()}` : '';
+    return apiRequest(base, `${path}${query}`, headers, { method: 'GET' });
+}
+async function send(base, method, path, body) {
+    const headers = await authHeadersOrThrow();
+    return apiRequest(base, path, headers, {
+        method,
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(body),
+    });
+}
+/** 연령 등급은 appInfo 에 딸려 있다. 편집 가능한 appInfo 를 우선 고른다. */
+async function resolveAppInfoId(appId) {
+    const data = await get(V1_BASE, `/apps/${appId}/appInfos`, { 'fields[appInfos]': 'state' });
+    const infos = data.data ?? [];
+    if (infos.length === 0)
+        throw new Error(`앱 ${appId} 의 appInfo 를 찾지 못했다.`);
+    const editable = infos.find((i) => {
+        const s = i.attributes?.state ?? i.attributes?.appStoreState;
+        return s && s !== 'READY_FOR_DISTRIBUTION' && s !== 'REPLACED_WITH_NEW_INFO';
+    });
+    return (editable ?? infos[0]).id;
+}
+export async function getAgeRating(appId) {
+    const appInfoId = await resolveAppInfoId(appId);
+    const data = await get(V1_BASE, `/appInfos/${appInfoId}/ageRatingDeclaration`);
+    return {
+        appInfoId,
+        declarationId: data.data?.id,
+        declaration: data.data?.attributes ?? {},
+    };
+}
+/**
+ * 연령 등급 설문 갱신 (PATCH /v1/ageRatingDeclarations/{id}).
+ * 넘긴 필드만 바뀐다 — Apple 이 부분 갱신을 허용하므로 전체를 다시 보낼 필요가 없다.
+ */
+export async function updateAgeRating(args) {
+    const { appId, declaration } = args;
+    const attributes = Object.fromEntries(Object.entries(declaration).filter(([, v]) => v !== undefined));
+    if (Object.keys(attributes).length === 0) {
+        throw new Error('바꿀 항목이 하나도 없다 — declaration 에 최소 한 필드는 넣어야 한다.');
+    }
+    const current = await getAgeRating(appId);
+    if (!current.declarationId) {
+        throw new Error([
+            '❌ 이 앱에는 연령 등급 선언 리소스가 없다.',
+            'App Store Connect 에서 앱을 한 번 연 뒤 다시 시도하거나, appInfo 상태를 확인할 것.',
+        ].join('\n'));
+    }
+    await send(V1_BASE, 'PATCH', `/ageRatingDeclarations/${current.declarationId}`, {
+        data: { type: 'ageRatingDeclarations', id: current.declarationId, attributes },
+    });
+    const after = await getAgeRating(appId);
+    return { declarationId: current.declarationId, declaration: after.declaration };
+}
+/**
+ * 수출 규정 선언 생성 (POST /v1/appEncryptionDeclarations).
+ * buildIds 를 주면 그 빌드들에 바로 연결한다 (POST …/relationships/builds).
+ *
+ * Info.plist 의 ITSAppUsesNonExemptEncryption 으로 해결되는 경우가 더 많다 —
+ * 이 도구는 그게 없어서 ASC 가 선언을 요구할 때의 경로다.
+ */
+export async function declareEncryption(args) {
+    const { appId, buildIds = [], ...attributes } = args;
+    const created = await send(V1_BASE, 'POST', '/appEncryptionDeclarations', {
+        data: {
+            type: 'appEncryptionDeclarations',
+            attributes,
+            relationships: { app: { data: { type: 'apps', id: appId } } },
+        },
+    });
+    const declarationId = created.data?.id;
+    if (!declarationId)
+        throw new Error(`수출 규정 선언 생성 응답에 id 가 없다: ${JSON.stringify(created)}`);
+    if (buildIds.length > 0) {
+        await send(V1_BASE, 'POST', `/appEncryptionDeclarations/${declarationId}/relationships/builds`, {
+            data: buildIds.map((id) => ({ type: 'builds', id })),
+        });
+    }
+    return {
+        declarationId,
+        state: created.data?.attributes?.state,
+        attachedBuilds: buildIds.length,
+    };
+}
+/**
+ * 현재 판매 지역 상태 (GET /v1/apps/{id}/appAvailabilityV2 → territoryAvailabilities).
+ * 지역이 175개라 기본은 판매 중인 곳만 세고, `includeTerritories` 로 목록을 받는다.
+ */
+export async function getAvailability(args) {
+    const { appId, includeTerritories = false, limit = 200 } = args;
+    const av = await get(V1_BASE, `/apps/${appId}/appAvailabilityV2`);
+    const availabilityId = av.data?.id;
+    if (!availabilityId) {
+        return { availableCount: 0, unavailableCount: 0, availableInNewTerritories: undefined };
+    }
+    const rows = await get(V2_BASE, `/appAvailabilities/${availabilityId}/territoryAvailabilities`, {
+        limit: String(Math.min(limit, 200)),
+    });
+    const list = (rows.data ?? []).map((t) => ({
+        id: t.id,
+        available: t.attributes?.available,
+        releaseDate: t.attributes?.releaseDate,
+        preOrderEnabled: t.attributes?.preOrderEnabled,
+    }));
+    return {
+        availabilityId,
+        availableInNewTerritories: av.data?.attributes?.availableInNewTerritories,
+        availableCount: list.filter((t) => t.available).length,
+        unavailableCount: list.filter((t) => t.available === false).length,
+        ...(includeTerritories ? { territories: list } : {}),
+    };
+}
+/**
+ * 지역별 판매 여부·출시일 변경 (PATCH /v1/territoryAvailabilities/{id}).
+ * id 는 appstore_get_availability 결과에서 온다 — 추측해서 만들지 말 것.
+ */
+export async function setTerritoryAvailability(args) {
+    const results = [];
+    for (const t of args.territories) {
+        const attributes = {};
+        if (t.available !== undefined)
+            attributes.available = t.available;
+        if (t.releaseDate !== undefined)
+            attributes.releaseDate = t.releaseDate;
+        if (t.preOrderEnabled !== undefined)
+            attributes.preOrderEnabled = t.preOrderEnabled;
+        if (Object.keys(attributes).length === 0) {
+            results.push({ id: t.id, ok: false, error: '바꿀 필드가 없음' });
+            continue;
+        }
+        try {
+            await send(V1_BASE, 'PATCH', `/territoryAvailabilities/${t.id}`, {
+                data: { type: 'territoryAvailabilities', id: t.id, attributes },
+            });
+            results.push({ id: t.id, ok: true });
+        }
+        catch (err) {
+            // 한 지역 실패가 나머지를 막지 않게 한다 — 어디까지 됐는지 그대로 보고한다.
+            results.push({ id: t.id, ok: false, error: err.message });
+        }
+    }
+    return results;
+}

package/dist/appstore/release.d.ts

@@ -0,0 +1,58 @@
+export type AppleReleaseType = 'MANUAL' | 'AFTER_APPROVAL' | 'SCHEDULED';
+export type PhasedReleaseState = 'INACTIVE' | 'ACTIVE' | 'PAUSED' | 'COMPLETE';
+export type PhasedReleaseAction = 'status' | 'enable' | 'pause' | 'resume' | 'complete' | 'disable';
+export interface VersionReleaseSummary {
+    versionId: string;
+    versionString?: string;
+    state?: string;
+    releaseType?: string;
+    earliestReleaseDate?: string;
+}
+export interface PhasedReleaseSummary {
+    id: string;
+    state?: PhasedReleaseState;
+    /** 1~7. Apple 의 7일 램프에서 현재 며칠째인지. */
+    currentDayNumber?: number;
+    startDate?: string;
+    totalPauseDuration?: number;
+}
+export declare function getVersionSummary(versionId: string): Promise<VersionReleaseSummary>;
+export declare function stateNote(state?: string): string;
+/** 버전 상태 + 단계적 출시 상태를 한 번에. 쓰기 전 미리보기용. */
+export declare function getReleaseStatus(versionId: string): Promise<{
+    version: VersionReleaseSummary;
+    phased: PhasedReleaseSummary | null;
+    note: string;
+}>;
+/**
+ * 개발자 출시 대기 중인 버전을 지금 출시한다 (POST /v1/appStoreVersionReleaseRequests).
+ * 콘솔의 "이 버전 출시" 버튼과 같은 동작 — 되돌릴 수 없다.
+ */
+export declare function requestRelease(versionId: string): Promise<VersionReleaseSummary>;
+/**
+ * 이미 만들어진 버전의 출시 방식을 바꾼다 (PATCH /v1/appStoreVersions/{id}).
+ * MANUAL 로 만들어 두고 "역시 승인되면 바로 내보내자"로 바꾸는 경우가 대부분.
+ * SCHEDULED 는 earliestReleaseDate(ISO 8601, 미래)가 함께 필요하다.
+ */
+export declare function updateReleaseType(args: {
+    versionId: string;
+    releaseType: AppleReleaseType;
+    earliestReleaseDate?: string;
+}): Promise<VersionReleaseSummary>;
+/**
+ * 단계적 출시(7일 램프) 제어.
+ *
+ * - enable   : 없으면 만들고(ACTIVE), PAUSED 면 재개한다
+ * - pause    : 일시중지 (되돌릴 수 있음)
+ * - resume   : 재개
+ * - complete : 남은 사용자에게 즉시 전체 공개 — 되돌릴 수 없다
+ * - disable  : 단계적 출시 자체를 제거. 출시 전이면 일반(전체) 출시로, 출시 후면 즉시 전체 공개가 된다
+ */
+export declare function setPhasedRelease(args: {
+    versionId: string;
+    action: Exclude<PhasedReleaseAction, 'status'>;
+}): Promise<{
+    action: string;
+    phased: PhasedReleaseSummary | null;
+    version: VersionReleaseSummary;
+}>;

package/dist/appstore/release.js

@@ -0,0 +1,173 @@
+// App Store 출시 제어 — 심사 통과 **이후**의 단계.
+//
+// 버전 생성 때 releaseType 을 정하는 것(appstore_create_version)까지는 이미 되지만,
+// 그 뒤 세 가지가 API 로 안 됐다:
+//   1. 이미 PENDING_DEVELOPER_RELEASE 로 대기 중인 버전을 "지금 출시" (releaseRequests)
+//   2. 만들어 둔 버전의 releaseType 을 나중에 바꾸기 (PATCH appStoreVersions)
+//   3. 단계적 출시 시작·일시중지·재개·즉시완료 (phasedRelease)
+// Play 는 userFraction/halted 로 3번이 되는데 iOS 만 비어 있었다.
+import { V1_BASE, apiRequest, authHeadersOrThrow } from './http.js';
+/** 각 상태가 "지금 출시" 요청을 받을 수 있는지 + 사람이 읽을 설명. */
+const STATE_NOTE = {
+    PENDING_DEVELOPER_RELEASE: '심사 통과 후 개발자 출시 대기 — 지금 출시할 수 있다.',
+    PENDING_APPLE_RELEASE: '예약 출시 대기 — Apple 이 earliestReleaseDate 에 출시한다.',
+    READY_FOR_SALE: '이미 출시됨.',
+    WAITING_FOR_REVIEW: '심사 대기열에 있음.',
+    IN_REVIEW: '심사 진행 중.',
+    PREPARE_FOR_SUBMISSION: '아직 제출 전 — appstore_submit_for_review 먼저.',
+    DEVELOPER_REJECTED: '개발자가 회수함 — 다시 제출해야 한다.',
+    REJECTED: 'Apple 이 거절함 — 수정 후 재제출.',
+    METADATA_REJECTED: '메타데이터 거절 — 수정 후 재제출.',
+};
+async function get(path, params) {
+    const headers = await authHeadersOrThrow();
+    const query = params ? `?${new URLSearchParams(params).toString()}` : '';
+    return apiRequest(V1_BASE, `${path}${query}`, headers, { method: 'GET' });
+}
+async function send(method, path, body) {
+    const headers = await authHeadersOrThrow();
+    return apiRequest(V1_BASE, path, headers, {
+        method,
+        ...(body === undefined
+            ? {}
+            : { headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(body) }),
+    });
+}
+export async function getVersionSummary(versionId) {
+    const data = await get(`/appStoreVersions/${versionId}`, { 'fields[appStoreVersions]': 'versionString,appStoreState,releaseType,earliestReleaseDate' });
+    const a = data.data?.attributes ?? {};
+    return {
+        versionId,
+        versionString: a.versionString,
+        state: a.appStoreState,
+        releaseType: a.releaseType,
+        earliestReleaseDate: a.earliestReleaseDate,
+    };
+}
+/** to-one 관계는 없을 때 200 + data:null 로 오기도 하고 404 로 오기도 한다. 둘 다 "없음"으로 본다. */
+async function getPhasedRelease(versionId) {
+    try {
+        const data = await get(`/appStoreVersions/${versionId}/appStoreVersionPhasedRelease`);
+        if (!data.data)
+            return null;
+        const a = (data.data.attributes ?? {});
+        return {
+            id: data.data.id,
+            state: a.phasedReleaseState,
+            currentDayNumber: a.currentDayNumber,
+            startDate: a.startDate,
+            totalPauseDuration: a.totalPauseDuration,
+        };
+    }
+    catch (err) {
+        if (/404|not found|NOT_FOUND/i.test(err.message))
+            return null;
+        throw err;
+    }
+}
+export function stateNote(state) {
+    return (state && STATE_NOTE[state]) || '';
+}
+/** 버전 상태 + 단계적 출시 상태를 한 번에. 쓰기 전 미리보기용. */
+export async function getReleaseStatus(versionId) {
+    const version = await getVersionSummary(versionId);
+    const phased = await getPhasedRelease(versionId);
+    return { version, phased, note: stateNote(version.state) };
+}
+/**
+ * 개발자 출시 대기 중인 버전을 지금 출시한다 (POST /v1/appStoreVersionReleaseRequests).
+ * 콘솔의 "이 버전 출시" 버튼과 같은 동작 — 되돌릴 수 없다.
+ */
+export async function requestRelease(versionId) {
+    const version = await getVersionSummary(versionId);
+    if (version.state !== 'PENDING_DEVELOPER_RELEASE') {
+        throw new Error([
+            `❌ 지금 출시할 수 없는 상태다: ${version.state ?? '(알 수 없음)'}`,
+            stateNote(version.state),
+            '',
+            '출시 요청은 심사를 통과해 PENDING_DEVELOPER_RELEASE 로 대기 중인 버전에만 보낼 수 있다.',
+        ]
+            .filter(Boolean)
+            .join('\n'));
+    }
+    await send('POST', '/appStoreVersionReleaseRequests', {
+        data: {
+            type: 'appStoreVersionReleaseRequests',
+            relationships: { appStoreVersion: { data: { type: 'appStoreVersions', id: versionId } } },
+        },
+    });
+    return getVersionSummary(versionId);
+}
+/**
+ * 이미 만들어진 버전의 출시 방식을 바꾼다 (PATCH /v1/appStoreVersions/{id}).
+ * MANUAL 로 만들어 두고 "역시 승인되면 바로 내보내자"로 바꾸는 경우가 대부분.
+ * SCHEDULED 는 earliestReleaseDate(ISO 8601, 미래)가 함께 필요하다.
+ */
+export async function updateReleaseType(args) {
+    const { versionId, releaseType, earliestReleaseDate } = args;
+    if (releaseType === 'SCHEDULED' && !earliestReleaseDate) {
+        throw new Error('releaseType=SCHEDULED 에는 earliestReleaseDate(ISO 8601, 미래 시각)가 필요하다.');
+    }
+    const attributes = { releaseType };
+    // SCHEDULED 가 아닌데 날짜가 남아 있으면 Apple 이 400 을 낸다 — 명시적으로 비운다.
+    if (releaseType === 'SCHEDULED')
+        attributes.earliestReleaseDate = earliestReleaseDate;
+    else if (earliestReleaseDate === undefined)
+        attributes.earliestReleaseDate = null;
+    await send('PATCH', `/appStoreVersions/${versionId}`, {
+        data: { type: 'appStoreVersions', id: versionId, attributes },
+    });
+    return getVersionSummary(versionId);
+}
+/**
+ * 단계적 출시(7일 램프) 제어.
+ *
+ * - enable   : 없으면 만들고(ACTIVE), PAUSED 면 재개한다
+ * - pause    : 일시중지 (되돌릴 수 있음)
+ * - resume   : 재개
+ * - complete : 남은 사용자에게 즉시 전체 공개 — 되돌릴 수 없다
+ * - disable  : 단계적 출시 자체를 제거. 출시 전이면 일반(전체) 출시로, 출시 후면 즉시 전체 공개가 된다
+ */
+export async function setPhasedRelease(args) {
+    const { versionId, action } = args;
+    const version = await getVersionSummary(versionId);
+    const current = await getPhasedRelease(versionId);
+    if (action === 'enable') {
+        if (!current) {
+            const created = await send('POST', '/appStoreVersionPhasedReleases', {
+                data: {
+                    type: 'appStoreVersionPhasedReleases',
+                    attributes: { phasedReleaseState: 'ACTIVE' },
+                    relationships: { appStoreVersion: { data: { type: 'appStoreVersions', id: versionId } } },
+                },
+            });
+            void created;
+        }
+        else if (current.state === 'PAUSED') {
+            await patchState(current.id, 'ACTIVE');
+        }
+        return { action, phased: await getPhasedRelease(versionId), version };
+    }
+    if (!current) {
+        throw new Error([
+            `❌ 이 버전에는 단계적 출시가 설정돼 있지 않다 (버전 상태: ${version.state ?? '알 수 없음'}).`,
+            '먼저 action="enable" 로 켜야 한다.',
+        ].join('\n'));
+    }
+    if (action === 'disable') {
+        await send('DELETE', `/appStoreVersionPhasedReleases/${current.id}`);
+        return { action, phased: null, version };
+    }
+    const next = action === 'pause' ? 'PAUSED' : action === 'resume' ? 'ACTIVE' : 'COMPLETE';
+    await patchState(current.id, next);
+    return { action, phased: await getPhasedRelease(versionId), version };
+}
+async function patchState(phasedReleaseId, state) {
+    await send('PATCH', `/appStoreVersionPhasedReleases/${phasedReleaseId}`, {
+        data: {
+            type: 'appStoreVersionPhasedReleases',
+            id: phasedReleaseId,
+            attributes: { phasedReleaseState: state },
+        },
+    });
+}

package/dist/playstore/tools.d.ts

@@ -168,6 +168,11 @@ export declare function updatePurchaseOptionState(auth: OAuth2Client | JWT, pack
         state: string | undefined;
     }[];
 }>;
+export declare function uploadDataSafety(auth: OAuth2Client | JWT, packageName: string, safetyLabelsCsv: string): Promise<{
+    packageName: string;
+    bytes: number;
+    lines: number;
+}>;
 export type ServiceAccountVerifyResult = {
     ok: true;
     clientEmail: string;

package/dist/playstore/tools.js

@@ -650,6 +650,29 @@ export async function updatePurchaseOptionState(auth, packageName, productId, pu
     })));
     return { productId, purchaseOptionId, action, states };
 }
+// ─── 인앱 상품 / 구독 생성은 @onesub/providers로 위임 ───
+// IAP·구독 CRUD는 onesub의 도메인 (결제 영역). 이 파일에는 메타·이미지·릴리스·리뷰만 남김.
+// 옛 createOnetimeProduct / createSubscription 구현은 onesub 위임으로 대체됐어 (index.ts 참고).
+// ─── 데이터 안전(Safety Labels) 선언 ───
+//
+// 오랫동안 Console 전용이라고 알려졌지만 API 가 생겼다 (POST applications/{pkg}/dataSafety).
+// 입력은 **Play Console 이 내려주는 CSV 원문**이고, 기존 제출을 통째로 덮어쓴다 —
+// 부분 갱신이 아니므로 항상 최신 전체 CSV 를 보내야 한다.
+// 콘텐츠 등급·타깃 연령 설문은 여전히 API 가 없다 (Console 전용).
+export async function uploadDataSafety(auth, packageName, safetyLabelsCsv) {
+    const csv = safetyLabelsCsv.trim();
+    if (!csv)
+        throw new Error('safetyLabels CSV 가 비어 있다.');
+    if (!csv.includes(',')) {
+        throw new Error('CSV 로 보이지 않는다 — Play Console 에서 받은 데이터 안전 CSV 원문을 그대로 넣을 것.');
+    }
+    await publisher().applications.dataSafety({
+        auth,
+        packageName,
+        requestBody: { safetyLabels: csv },
+    });
+    return { packageName, bytes: Buffer.byteLength(csv, 'utf8'), lines: csv.split('\n').length };
+}
 export async function verifyServiceAccountJson(serviceAccountJson, packageName) {
     let parsed;
     try {

package/dist/registers/appstore.js

@@ -3,6 +3,8 @@ 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 * as appstoreRelease from '../appstore/release.js';
+import * as appstoreDeclarations from '../appstore/declarations.js';
 import { createAppleOneTimePurchase, createAppleSubscription, updateAppleProduct, deleteAppleProduct, listAppleProducts, } from '@onesub/providers';
 import { requireAppStoreCreds } from '../helpers.js';
 import { buildAppStoreReleasePlan } from '../checks/plan.js';
@@ -869,4 +871,334 @@ export function registerAppstoreTools(server) {
                 }],
         };
     });
+    // ─── 심사 통과 이후: 출시 제어 ───
+    // 버전 생성 시 releaseType 을 정하는 것까지는 appstore_create_version 이 한다.
+    // 그 뒤 "지금 출시 / 출시 방식 변경 / 단계적 출시" 세 가지가 API 로 안 돼서 콘솔을 열어야 했다.
+    server.tool('appstore_release_status', [
+        '버전의 출시 상태를 한 번에 읽는다 — 읽기 전용.',
+        'appStoreState(PENDING_DEVELOPER_RELEASE / READY_FOR_SALE …), releaseType(MANUAL / AFTER_APPROVAL / SCHEDULED),',
+        'earliestReleaseDate, 그리고 단계적 출시가 켜져 있으면 그 상태(ACTIVE/PAUSED/COMPLETE)와 현재 며칠째인지.',
+        '출시 관련 쓰기 도구를 부르기 전에 이걸로 먼저 확인할 것.',
+    ].join(' '), {
+        versionId: z.string().describe('App Store 버전 ID (appstore_list_versions 결과)'),
+    }, async ({ versionId }) => {
+        const { version, phased, note } = await appstoreRelease.getReleaseStatus(versionId);
+        const lines = [
+            `버전 ${version.versionString ?? version.versionId}`,
+            `  상태: ${version.state ?? '알 수 없음'}${note ? ` — ${note}` : ''}`,
+            `  출시 방식: ${version.releaseType ?? '(미지정 — Apple 기본값)'}`,
+        ];
+        if (version.earliestReleaseDate)
+            lines.push(`  예약 시각: ${version.earliestReleaseDate}`);
+        if (phased) {
+            lines.push(`  단계적 출시: ${phased.state ?? '?'}` +
+                (phased.currentDayNumber ? ` (${phased.currentDayNumber}일째/7일)` : '') +
+                (phased.startDate ? ` · 시작 ${phased.startDate}` : ''));
+        }
+        else {
+            lines.push('  단계적 출시: 꺼짐');
+        }
+        return { content: [{ type: 'text', text: lines.join('\n') }] };
+    });
+    server.tool('appstore_release_version', [
+        '심사를 통과해 개발자 출시 대기(PENDING_DEVELOPER_RELEASE) 중인 버전을 지금 출시한다 — POST /v1/appStoreVersionReleaseRequests.',
+        '콘솔의 "이 버전 출시" 버튼과 같은 동작.',
+        '⚠️ 비가역: 실행 즉시 App Store 에 공개된다. 되돌리려면 새 버전을 내거나 판매 중단해야 한다.',
+        '안전 가드: confirm 생략/false 면 현재 상태만 보여주는 dry-run.',
+        'releaseType=AFTER_APPROVAL 로 만든 버전은 승인 시 자동 출시되므로 이 도구가 필요 없다 — MANUAL 로 대기 중인 버전용이다.',
+    ].join(' '), {
+        versionId: z.string().describe('App Store 버전 ID (appstore_list_versions 결과)'),
+        confirm: z.boolean().optional().describe('true 명시 시에만 실제 출시. 생략/false 면 dry-run.'),
+    }, async ({ versionId, confirm }) => {
+        if (!confirm) {
+            const { version, phased, note } = await appstoreRelease.getReleaseStatus(versionId);
+            const ready = version.state === 'PENDING_DEVELOPER_RELEASE';
+            return {
+                content: [{
+                        type: 'text',
+                        text: [
+                            '🛑 출시 dry-run — 아직 출시하지 않았다.',
+                            `  버전: ${version.versionString ?? versionId}`,
+                            `  상태: ${version.state ?? '알 수 없음'}${note ? ` — ${note}` : ''}`,
+                            phased ? `  단계적 출시: ${phased.state ?? '?'}` : '  단계적 출시: 꺼짐',
+                            '',
+                            ready
+                                ? '실제 출시하려면 confirm: true 로 다시 호출. 실행 즉시 공개된다.'
+                                : '지금은 출시할 수 없는 상태다. PENDING_DEVELOPER_RELEASE 여야 한다.',
+                        ].join('\n'),
+                    }],
+            };
+        }
+        const after = await appstoreRelease.requestRelease(versionId);
+        return {
+            content: [{
+                    type: 'text',
+                    text: [
+                        '✅ 출시 요청 전송',
+                        `  버전: ${after.versionString ?? versionId}`,
+                        `  상태: ${after.state ?? '조회 실패'}`,
+                        'App Store 반영에는 보통 수십 분~수 시간이 걸린다. appstore_release_status 로 확인.',
+                    ].join('\n'),
+                }],
+        };
+    });
+    server.tool('appstore_update_release_type', [
+        '이미 만들어진 버전의 출시 방식을 바꾼다 — PATCH /v1/appStoreVersions/{id}.',
+        'MANUAL(개발자가 직접 출시) / AFTER_APPROVAL(승인되면 자동 출시) / SCHEDULED(지정 시각 출시).',
+        'SCHEDULED 는 earliestReleaseDate(ISO 8601, 미래 시각)가 함께 필요하다.',
+        '편집 가능한 상태에서만 통한다 — 이미 READY_FOR_SALE 이면 바꿀 수 없다.',
+        'MANUAL 로 만들어 둔 버전을 "승인되면 알아서 나가게" 바꾸는 용도가 대부분이다.',
+    ].join(' '), {
+        versionId: z.string().describe('App Store 버전 ID'),
+        releaseType: z
+            .enum(['MANUAL', 'AFTER_APPROVAL', 'SCHEDULED'])
+            .describe('출시 방식'),
+        earliestReleaseDate: z
+            .string()
+            .optional()
+            .describe('SCHEDULED 일 때 필수. ISO 8601 UTC (예: 2026-08-01T09:00:00Z)'),
+    }, async ({ versionId, releaseType, earliestReleaseDate }) => {
+        const after = await appstoreRelease.updateReleaseType({ versionId, releaseType, earliestReleaseDate });
+        return {
+            content: [{
+                    type: 'text',
+                    text: [
+                        '✅ 출시 방식 변경',
+                        `  버전: ${after.versionString ?? versionId}`,
+                        `  출시 방식: ${after.releaseType ?? releaseType}`,
+                        after.earliestReleaseDate ? `  예약 시각: ${after.earliestReleaseDate}` : '',
+                        `  상태: ${after.state ?? '알 수 없음'}`,
+                    ].filter(Boolean).join('\n'),
+                }],
+        };
+    });
+    server.tool('appstore_phased_release', [
+        'iOS 단계적 출시(7일 램프)를 제어한다 — appStoreVersionPhasedReleases.',
+        'action: status(조회) / enable(켜기·PAUSED면 재개) / pause(일시중지) / resume(재개) / complete(즉시 전체 공개) / disable(단계적 출시 제거).',
+        'Play 의 userFraction·halted 에 해당하는 iOS 쪽 장치다.',
+        '⚠️ complete 와 disable 은 남은 사용자 전체에게 즉시 공개되며 되돌릴 수 없다 — confirm: true 필요.',
+        'pause/resume/enable 은 되돌릴 수 있어 confirm 없이 실행된다.',
+    ].join(' '), {
+        versionId: z.string().describe('App Store 버전 ID'),
+        action: z
+            .enum(['status', 'enable', 'pause', 'resume', 'complete', 'disable'])
+            .describe('수행할 동작'),
+        confirm: z
+            .boolean()
+            .optional()
+            .describe('complete / disable 에만 필요. 생략/false 면 현재 상태만 반환하는 dry-run.'),
+    }, async ({ versionId, action, confirm }) => {
+        if (action === 'status' || ((action === 'complete' || action === 'disable') && !confirm)) {
+            const { version, phased, note } = await appstoreRelease.getReleaseStatus(versionId);
+            const header = action === 'status'
+                ? '단계적 출시 상태'
+                : `🛑 ${action} dry-run — 아직 실행하지 않았다.`;
+            return {
+                content: [{
+                        type: 'text',
+                        text: [
+                            header,
+                            `  버전: ${version.versionString ?? versionId} (${version.state ?? '?'}${note ? ` — ${note}` : ''})`,
+                            phased
+                                ? `  단계적 출시: ${phased.state ?? '?'}` +
+                                    (phased.currentDayNumber ? ` (${phased.currentDayNumber}일째/7일)` : '')
+                                : '  단계적 출시: 꺼짐',
+                            action === 'status'
+                                ? ''
+                                : '실행하려면 confirm: true 로 다시 호출. 남은 사용자 전체에게 즉시 공개된다.',
+                        ].filter(Boolean).join('\n'),
+                    }],
+            };
+        }
+        const { phased } = await appstoreRelease.setPhasedRelease({ versionId, action });
+        return {
+            content: [{
+                    type: 'text',
+                    text: [
+                        `✅ 단계적 출시: ${action}`,
+                        phased ? `  현재 상태: ${phased.state ?? '?'}` : '  단계적 출시 제거됨 (전체 공개)',
+                    ].join('\n'),
+                }],
+        };
+    });
+    // ─── 심사 제출 전 선언 ───
+    // 비어 있으면 제출이 막히거나 심사에서 반려되는 항목들. Console 에서만 되는 줄 알았던 것들이다.
+    server.tool('appstore_get_age_rating', [
+        '앱의 연령 등급 설문(ageRatingDeclaration) 현재 값을 읽는다 — 읽기 전용.',
+        'appInfo 에 딸린 단일 리소스이며, 편집 가능한 appInfo 를 자동으로 고른다.',
+        '수정 전에 이걸로 현재 답변을 먼저 확인할 것.',
+    ].join(' '), { appId: z.string().describe('App Store 앱 ID (appstore_list_apps 결과)') }, async ({ appId }) => {
+        const { appInfoId, declarationId, declaration } = await appstoreDeclarations.getAgeRating(appId);
+        const filled = Object.entries(declaration).filter(([, v]) => v !== undefined && v !== null);
+        return {
+            content: [{
+                    type: 'text',
+                    text: [
+                        `연령 등급 선언 (appInfo ${appInfoId}${declarationId ? ` · declaration ${declarationId}` : ' · 선언 없음'})`,
+                        ...filled.map(([k, v]) => `  ${k}: ${v}`),
+                        filled.length === 0 ? '  (아직 답변된 항목 없음)' : '',
+                    ].filter(Boolean).join('\n'),
+                }],
+        };
+    });
+    const FREQ = z.enum(['NONE', 'INFREQUENT_OR_MILD', 'FREQUENT_OR_INTENSE', 'INFREQUENT', 'FREQUENT']);
+    const freq = (what) => FREQ.optional().describe(`${what} — NONE / INFREQUENT_OR_MILD / FREQUENT_OR_INTENSE`);
+    server.tool('appstore_update_age_rating', [
+        '연령 등급 설문을 갱신한다 — PATCH /v1/ageRatingDeclarations/{id}.',
+        '넘긴 필드만 바뀐다 (부분 갱신). 전체를 다시 보낼 필요 없다.',
+        '미완성이면 심사 제출이 막히므로 첫 출시 전 반드시 채워야 한다.',
+        'Play 의 콘텐츠 등급 설문과 달리 Apple 은 이렇게 API 로 답변할 수 있다.',
+    ].join(' '), {
+        appId: z.string().describe('App Store 앱 ID'),
+        violenceCartoonOrFantasy: freq('만화/판타지 폭력'),
+        violenceRealistic: freq('사실적 폭력'),
+        violenceRealisticProlongedGraphicOrSadistic: freq('지속적·잔혹한 사실적 폭력'),
+        profanityOrCrudeHumor: freq('욕설/저속한 유머'),
+        matureOrSuggestiveThemes: freq('성인/암시적 주제'),
+        horrorOrFearThemes: freq('공포/공포 유발 주제'),
+        sexualContentOrNudity: freq('성적 콘텐츠 또는 노출'),
+        sexualContentGraphicAndNudity: freq('노골적 성적 콘텐츠·노출'),
+        alcoholTobaccoOrDrugUseOrReferences: freq('음주/흡연/약물'),
+        medicalOrTreatmentInformation: freq('의료/치료 정보'),
+        gamblingSimulated: freq('모의 도박'),
+        contests: freq('경품/콘테스트'),
+        gunsOrOtherWeapons: freq('총기·무기'),
+        gambling: z.boolean().optional().describe('실제 도박 포함 여부'),
+        lootBox: z.boolean().optional().describe('확률형 아이템(루트박스) 포함 여부'),
+        unrestrictedWebAccess: z.boolean().optional().describe('제한 없는 웹 접근'),
+        userGeneratedContent: z.boolean().optional().describe('사용자 생성 콘텐츠'),
+        messagingAndChat: z.boolean().optional().describe('메시지/채팅 기능'),
+        advertising: z.boolean().optional().describe('광고 포함'),
+        healthOrWellnessTopics: z.boolean().optional().describe('건강/웰니스 주제'),
+        parentalControls: z.boolean().optional().describe('자녀 보호 기능 제공'),
+        ageAssurance: z.boolean().optional().describe('연령 확인 장치 제공'),
+        kidsAgeBand: z
+            .enum(['FIVE_AND_UNDER', 'SIX_TO_EIGHT', 'NINE_TO_ELEVEN'])
+            .optional()
+            .describe('키즈 카테고리 대상 연령대 (키즈 앱만)'),
+        ageRatingOverrideV2: z
+            .enum(['NONE', 'NINE_PLUS', 'THIRTEEN_PLUS', 'SIXTEEN_PLUS', 'EIGHTEEN_PLUS', 'UNRATED'])
+            .optional()
+            .describe('산출 등급을 더 높게 덮어쓸 때만'),
+        koreaAgeRatingOverride: z
+            .enum(['NONE', 'FIFTEEN_PLUS', 'NINETEEN_PLUS'])
+            .optional()
+            .describe('한국 등급 별도 지정 (게임물관리위원회 등급을 반영해야 할 때)'),
+        developerAgeRatingInfoUrl: z.string().optional().describe('등급 근거 안내 URL'),
+    }, async ({ appId, ...declaration }) => {
+        const { declarationId, declaration: after } = await appstoreDeclarations.updateAgeRating({
+            appId,
+            declaration: declaration,
+        });
+        const changed = Object.keys(declaration).filter((k) => declaration[k] !== undefined);
+        return {
+            content: [{
+                    type: 'text',
+                    text: [
+                        `✅ 연령 등급 갱신 (${changed.length}개 항목) — declaration ${declarationId}`,
+                        ...changed.map((k) => `  ${k}: ${String(after[k])}`),
+                    ].join('\n'),
+                }],
+        };
+    });
+    server.tool('appstore_declare_encryption', [
+        '수출 규정(암호화) 선언을 만들고 선택한 빌드에 연결한다 — POST /v1/appEncryptionDeclarations.',
+        'Info.plist 의 ITSAppUsesNonExemptEncryption 이 있으면 보통 이 선언이 필요 없다 —',
+        '그게 없어서 ASC 가 "수출 규정 정보 누락"으로 제출을 막을 때 쓰는 경로다.',
+        '⚠️ 법적 신고 성격의 선언이다. 값은 반드시 사용자에게 확인받고 넣을 것.',
+    ].join(' '), {
+        appId: z.string().describe('App Store 앱 ID'),
+        appDescription: z.string().describe('앱이 사용하는 암호화에 대한 설명 (심사용)'),
+        containsProprietaryCryptography: z.boolean().describe('자체 개발한 암호화를 포함하는가'),
+        containsThirdPartyCryptography: z.boolean().describe('서드파티 암호화를 포함하는가'),
+        availableOnFrenchStore: z.boolean().describe('프랑스 스토어에 배포하는가 (프랑스는 별도 신고 규정)'),
+        buildIds: z
+            .array(z.string())
+            .optional()
+            .describe('이 선언을 연결할 빌드 ID들 (appstore_list_builds 결과). 생략 시 선언만 생성'),
+    }, async ({ appId, buildIds, ...attrs }) => {
+        const r = await appstoreDeclarations.declareEncryption({ appId, buildIds, ...attrs });
+        return {
+            content: [{
+                    type: 'text',
+                    text: [
+                        '✅ 수출 규정 선언 생성',
+                        `  declarationId: ${r.declarationId}`,
+                        `  상태: ${r.state ?? '(응답에 없음)'}`,
+                        `  연결된 빌드: ${r.attachedBuilds}개`,
+                        r.state === 'IN_REVIEW' ? '  Apple 검토 중 — 승인되면 빌드에 반영된다.' : '',
+                    ].filter(Boolean).join('\n'),
+                }],
+        };
+    });
+    server.tool('appstore_get_availability', [
+        '앱의 판매 지역 상태를 읽는다 — GET /v1/apps/{id}/appAvailabilityV2.',
+        '판매 중/중지 지역 수와 신규 지역 자동 포함 여부를 보여준다.',
+        'includeTerritories=true 면 지역별 행(id·available·releaseDate)까지 — 이 id 가 변경 도구의 입력이다.',
+    ].join(' '), {
+        appId: z.string().describe('App Store 앱 ID'),
+        includeTerritories: z.boolean().optional().describe('지역 목록까지 반환 (기본 false)'),
+    }, async ({ appId, includeTerritories }) => {
+        const r = await appstoreDeclarations.getAvailability({ appId, includeTerritories });
+        const lines = [
+            `판매 지역 (availability ${r.availabilityId ?? '없음'})`,
+            `  판매 중: ${r.availableCount}개 · 중지: ${r.unavailableCount}개`,
+            `  신규 지역 자동 포함: ${r.availableInNewTerritories === undefined ? '알 수 없음' : r.availableInNewTerritories}`,
+        ];
+        if (r.territories) {
+            for (const t of r.territories) {
+                lines.push(`  ${t.id}: ${t.available ? '판매' : '중지'}` +
+                    (t.releaseDate ? ` · 출시일 ${t.releaseDate}` : '') +
+                    (t.preOrderEnabled ? ' · 사전주문' : ''));
+            }
+        }
+        return { content: [{ type: 'text', text: lines.join('\n') }] };
+    });
+    server.tool('appstore_set_territory_availability', [
+        '지역별 판매 여부·출시일을 바꾼다 — PATCH /v1/territoryAvailabilities/{id}.',
+        'id 는 appstore_get_availability(includeTerritories=true) 결과에서 가져올 것 — 지역 코드를 추측해 넣지 말 것.',
+        '한 지역이 실패해도 나머지는 계속 진행하고, 지역별 성공/실패를 그대로 보고한다.',
+        '⚠️ available=false 는 그 지역에서 앱을 내리는 동작이다.',
+    ].join(' '), {
+        territories: z
+            .array(z.object({
+            id: z.string().describe('territoryAvailability 리소스 id'),
+            available: z.boolean().optional().describe('판매 여부'),
+            releaseDate: z.string().optional().describe('출시일 (YYYY-MM-DD)'),
+            preOrderEnabled: z.boolean().optional().describe('사전주문 활성화'),
+        }))
+            .min(1)
+            .describe('변경할 지역 목록'),
+        confirm: z.boolean().optional().describe('true 명시 시에만 실제 변경. 생략/false 면 변경 예정 목록만 반환.'),
+    }, async ({ territories, confirm }) => {
+        if (!confirm) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: [
+                            `🛑 dry-run — ${territories.length}개 지역, 아직 바꾸지 않았다.`,
+                            ...territories.map((t) => `  ${t.id}: ` +
+                                [
+                                    t.available === undefined ? '' : `판매=${t.available}`,
+                                    t.releaseDate ? `출시일=${t.releaseDate}` : '',
+                                    t.preOrderEnabled === undefined ? '' : `사전주문=${t.preOrderEnabled}`,
+                                ].filter(Boolean).join(' · ')),
+                            '',
+                            '실행하려면 confirm: true 로 다시 호출.',
+                        ].join('\n'),
+                    }],
+            };
+        }
+        const results = await appstoreDeclarations.setTerritoryAvailability({ territories });
+        const ok = results.filter((r) => r.ok).length;
+        return {
+            content: [{
+                    type: 'text',
+                    text: [
+                        `지역 변경: 성공 ${ok} / 실패 ${results.length - ok}`,
+                        ...results.filter((r) => !r.ok).map((r) => `  ✗ ${r.id}: ${r.error}`),
+                    ].join('\n'),
+                }],
+        };
+    });
 }

package/dist/registers/playstore.js

@@ -1,3 +1,5 @@
+import fs from 'node:fs';
+import path from 'node:path';
 import { z } from 'zod';
 import * as playstoreRaw from '../playstore/tools.js';
 import { friendlyPlayError } from '../playstore/errors.js';
@@ -755,4 +757,56 @@ export function registerPlaystoreTools(server) {
                 }],
         };
     });
+    server.tool('playstore_upload_data_safety', [
+        'Play 데이터 안전(Safety Labels) 선언을 업로드한다 — POST applications/{packageName}/dataSafety.',
+        '오래 Console 전용으로 알려졌던 항목이지만 API 가 있다.',
+        '입력은 Play Console 이 내려주는 **CSV 원문**이다 (Console > 앱 콘텐츠 > 데이터 안전 > 내보내기).',
+        '⚠️ 기존 제출을 통째로 덮어쓴다 — 부분 갱신이 아니므로 항상 최신 전체 CSV 를 보낼 것.',
+        '콘텐츠 등급·타깃 연령 설문은 여전히 API 가 없다 (Console 전용).',
+    ].join(' '), {
+        packageName: z.string().describe('패키지명 (예: com.example.app)'),
+        csvPath: z
+            .string()
+            .optional()
+            .describe('데이터 안전 CSV 파일의 절대경로. csv 와 둘 중 하나는 필수'),
+        csv: z.string().optional().describe('CSV 원문 문자열. csvPath 와 둘 중 하나는 필수'),
+        confirm: z.boolean().optional().describe('true 명시 시에만 업로드. 생략/false 면 요약만 반환.'),
+    }, async ({ packageName, csvPath, csv, confirm }) => {
+        if (!csv && !csvPath)
+            throw new Error('csvPath 또는 csv 중 하나는 필요하다.');
+        if (!csv && csvPath && !path.isAbsolute(csvPath)) {
+            throw new Error(`csvPath 는 절대경로여야 한다: ${csvPath}`);
+        }
+        const content = csv ?? fs.readFileSync(csvPath, 'utf8');
+        const lines = content.trim().split('\n');
+        if (!confirm) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: [
+                            '🛑 데이터 안전 업로드 dry-run — 아직 보내지 않았다.',
+                            `  패키지: ${packageName}`,
+                            `  CSV: ${lines.length}줄 / ${Buffer.byteLength(content, 'utf8')} bytes`,
+                            `  첫 줄: ${lines[0]?.slice(0, 120) ?? '(비어 있음)'}`,
+                            '',
+                            '⚠️ 업로드하면 기존 데이터 안전 제출을 통째로 덮어쓴다.',
+                            '실행하려면 confirm: true 로 다시 호출.',
+                        ].join('\n'),
+                    }],
+            };
+        }
+        const auth = await requirePlayStoreAuth(packageName);
+        const r = await playstore.uploadDataSafety(auth, packageName, content);
+        return {
+            content: [{
+                    type: 'text',
+                    text: [
+                        '✅ 데이터 안전 선언 업로드 완료',
+                        `  패키지: ${r.packageName}`,
+                        `  전송: ${r.lines}줄 / ${r.bytes} bytes`,
+                        'Play Console > 앱 콘텐츠 > 데이터 안전에서 반영을 확인할 것.',
+                    ].join('\n'),
+                }],
+        };
+    });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yoonion/mimi-seed-mcp",
-  "version": "0.13.14",
+  "version": "0.13.16",
   "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": 189,
+  "total": 199,
   "domains": {
     "admob": {
       "label": "AdMob",
@@ -80,7 +80,16 @@
         "appstore_remove_review_submission_item",
         "appstore_add_version_to_review_submission",
         "appstore_update_version_string",
-        "appstore_cancel_review"
+        "appstore_cancel_review",
+        "appstore_release_status",
+        "appstore_release_version",
+        "appstore_update_release_type",
+        "appstore_phased_release",
+        "appstore_get_age_rating",
+        "appstore_update_age_rating",
+        "appstore_declare_encryption",
+        "appstore_get_availability",
+        "appstore_set_territory_availability"
       ]
     },
     "auth": {
@@ -287,7 +296,8 @@
         "playstore_update_product_state",
         "playstore_update_product",
         "playstore_delete_product",
-        "setup_playstore_connection"
+        "setup_playstore_connection",
+        "playstore_upload_data_safety"
       ]
     },
     "threads": {