@yoonion/mimi-seed-mcp 0.19.18 → 0.20.0

package/dist/android/messages.js

@@ -0,0 +1,145 @@
+// Android 서명/Jenkins 셋업 도구의 사람용 응답 문구 — register 는 판단만 하고, 긴 단계별
+// 안내는 여기서 조립한다. 반환값은 줄 배열이다 (textResult 가 '\n' 으로 합친다).
+import path from 'node:path';
+import { isGenericCredentialPrefix } from '../jenkins/messages.js';
+import { KEYSTORE_FILE, SIGNING_SECRETS_FILE } from './keystore-store.js';
+/** 기본 id 접두사가 흔한 이름이면 계획 맨 앞에 붙이는 경고 (없으면 빈 배열). */
+function genericPrefixWarning(packageName, prefix) {
+    if (!isGenericCredentialPrefix(prefix))
+        return [];
+    return [
+        `⚠️ 아래 기본 credential id 접두사 "${prefix}" 는 ${packageName} 의 마지막 세그먼트만으로 만든 흔한 이름이라 ` +
+            '같은 Jenkins 의 다른 앱 credential 과 겹칠 수 있다. 기존 id 라는 dry-run 이 나오면 설명을 확인하고, 필요하면 고유한 id 를 쓰세요.',
+        '',
+    ];
+}
+/** keystore·비밀번호 **파일 경로**로 Jenkins 에 등록하는 네 단계 (start 번부터). */
+function pathRegistrationSteps(prefix, keystorePath, secretsPath, start) {
+    return [
+        `  ${start}. jenkins_upload_keystore(id="${prefix}-android-keystore", keystore_path="${keystorePath}", file_name="upload.jks")`,
+        `  ${start + 1}. jenkins_create_credential(id="${prefix}-android-store-password", secret_file="${secretsPath}", secret_field="storePassword")`,
+        `  ${start + 2}. jenkins_create_credential(id="${prefix}-android-key-alias", secret_file="${secretsPath}", secret_field="keyAlias")`,
+        `  ${start + 3}. jenkins_create_credential(id="${prefix}-android-key-password", secret_file="${secretsPath}", secret_field="keyPassword")`,
+    ];
+}
+/**
+ * android_signing_setup — Play Console 에 이미 있는 앱. 기존 keystore 를 받아 등록하는 순서.
+ *
+ * 비밀값(keystore 바이트·비밀번호)을 대화에 싣지 않는다 — 사용자가 keystore 를 `keystoreDir` 로 복사하고
+ * 비밀번호를 그 폴더의 signing.json 에 적게 한 뒤, Jenkins 도구에는 경로만 넘긴다
+ * (jenkins_upload_keystore.keystore_path, jenkins_create_credential.secret_file + secret_field).
+ */
+export function existingAppSigningPlanLines(packageName, prefix, jenkinsStatus, keystoreDir) {
+    const keystorePath = path.join(keystoreDir, KEYSTORE_FILE);
+    const secretsPath = path.join(keystoreDir, SIGNING_SECRETS_FILE);
+    return [
+        `📦 ${packageName} — **기존 앱** (Play Console에 이미 존재)`,
+        '',
+        '기존 upload keystore와 비밀번호가 있어야 합니다.',
+        '분실한 경우 새 앱으로 다시 등록하거나 Play App Signing으로 마이그레이션해야 합니다.',
+        '',
+        `Jenkins: ${jenkinsStatus}`,
+        '',
+        ...genericPrefixWarning(packageName, prefix),
+        '── 준비 (사용자가 직접 — 비밀번호·keystore 를 대화에 붙여넣지 않는다) ──',
+        `  1. 폴더를 만든다: ${keystoreDir}`,
+        `  2. 기존 upload keystore 를 복사한다 → ${keystorePath}  (.jks / .keystore / .p12)`,
+        `  3. 같은 폴더에 비밀번호 파일을 만든다 → ${secretsPath}`,
+        '     내용: {"storePassword": "…", "keyAlias": "…", "keyPassword": "…"}',
+        '  4. 두 파일을 본인만 읽게 한다 (macOS/Linux: chmod 600)',
+        '  5. Play Store SA JSON 이 없으면 setup_playstore_connection 으로 만든다',
+        '',
+        '── 등록 순서 (값이 아니라 경로를 넘긴다) ────────────',
+        ...pathRegistrationSteps(prefix, keystorePath, secretsPath, 1),
+        `  5. jenkins_upload_playstore_sa(package_name="${packageName}", credential_id="${prefix}-playstore-sa")`,
+        `     └ SA JSON이 없으면 먼저: setup_playstore_connection(packageName="${packageName}", projectId="...")`,
+        '',
+        '사용자가 비밀번호를 채팅에 적었다면 secret 파라미터로 옮기지 말고, 위 signing.json 에 저장하도록 안내하세요.',
+    ];
+}
+/** android_signing_setup — 신규 앱(또는 Play Console 확인 불가). keystore 생성부터의 순서. */
+export function newAppSigningPlanLines(opts) {
+    const { packageName, prefix, appStatus, playNote, jenkinsStatus, jenkinsConfigured, keytoolOk, projectId, keystoreDir } = opts;
+    const keystorePath = path.join(keystoreDir, KEYSTORE_FILE);
+    const secretsPath = path.join(keystoreDir, SIGNING_SECRETS_FILE);
+    const appLabel = appStatus === 'new' ? '**신규 앱**' : '**신규 앱으로 처리** (Play Console 확인 불가)';
+    return [
+        `📦 ${packageName} — ${appLabel}`,
+        playNote ? `   ${playNote}` : '',
+        '',
+        ...genericPrefixWarning(packageName, prefix),
+        `Jenkins: ${jenkinsStatus}`,
+        `keytool(Java JDK): ${keytoolOk ? '✅ 설치됨 — 자동 생성 가능' : '❌ 미설치 — android_generate_keystore 호출 불가, 수동 생성 필요'}`,
+        '',
+        '── 신규 앱 설정 순서 ─────────────────────────────',
+        jenkinsConfigured ? '' : '  0. jenkins_status → jenkins_save_config (Jenkins 먼저 설정)',
+        keytoolOk
+            ? `  1. android_generate_keystore(app_name="${prefix}") → keystore + 비밀번호를 ~/.mimi-seed/keystores/ 에 파일로 생성`
+            : `  1. ⚠️  사용자가 직접 keytool -genkeypair 로 만든 keystore 를 ${keystorePath} 에, 비밀번호를 ${secretsPath} ({"storePassword","keyAlias","keyPassword"}) 에 저장 — 대화에 붙여넣지 않는다`,
+        ...(keytoolOk
+            ? [`  2~5. android_generate_keystore 응답의 경로로 jenkins_upload_keystore(keystore_path=…) + jenkins_create_credential(secret_file=…, secret_field=storePassword|keyAlias|keyPassword) — id 는 "${prefix}-android-keystore" / "-store-password" / "-key-alias" / "-key-password"`]
+            : pathRegistrationSteps(prefix, keystorePath, secretsPath, 2)),
+        projectId
+            ? `  6. setup_playstore_connection(packageName="${packageName}", projectId="${projectId}")`
+            : `  6. setup_playstore_connection(packageName="${packageName}", projectId="<GCP 프로젝트 ID>")`,
+        '     └ GCP 프로젝트 ID를 모르면 사용자에게 확인하세요.',
+        `  7. jenkins_upload_playstore_sa(package_name="${packageName}", credential_id="${prefix}-playstore-sa")`,
+        '  8. Play Console에서 서비스 계정 초대 (수동, 1회)',
+        '     → Play Console → 사용자 및 권한 → SA 이메일 → 릴리즈 관리자 권한 부여',
+        '  9. 첫 AAB 빌드 후 Play Console에 내부 테스트용으로 수동 업로드 (신규 앱 첫 번째만)',
+    ];
+}
+/** android_generate_keystore — keytool 이 없을 때 설치 안내. */
+export function keytoolMissingLines() {
+    return [
+        '❌ keytool이 설치되지 않았습니다.',
+        '',
+        'Java JDK를 설치하면 keytool이 포함됩니다:',
+        '  macOS: brew install openjdk',
+        '  Ubuntu: sudo apt install default-jdk',
+        '  Windows: https://adoptium.net/',
+        '',
+        '설치 후 다시 android_generate_keystore를 호출하세요.',
+    ];
+}
+/** android_generate_keystore — 생성 완료. 비밀값은 싣지 않고 경로만 넘긴다. */
+export function keystoreGeneratedLines(prefix, saved) {
+    return [
+        '✅ Android upload keystore 생성 완료 — 비밀번호와 keystore 는 파일로만 저장했습니다 (응답에 싣지 않음).',
+        '',
+        `keystore:     ${saved.keystorePath} (0600)`,
+        `비밀번호 파일: ${saved.secretsPath} (0600 — keyAlias / storePassword / keyPassword)`,
+        `keyAlias:     ${saved.keyAlias}`,
+        '',
+        '🔒 분실하면 앱 서명을 영구히 잃습니다. 위 폴더를 비밀번호 관리자 등 안전한 곳에 백업하세요.',
+        '',
+        '── 다음 단계 — 값을 복사하지 말고 경로를 넘기세요 ──',
+        `  jenkins_upload_keystore(id="${prefix}-android-keystore", keystore_path="${saved.keystorePath}", file_name="upload.jks")`,
+        `  jenkins_create_credential(id="${prefix}-android-store-password", secret_file="${saved.secretsPath}", secret_field="storePassword")`,
+        `  jenkins_create_credential(id="${prefix}-android-key-alias",      secret_file="${saved.secretsPath}", secret_field="keyAlias")`,
+        `  jenkins_create_credential(id="${prefix}-android-key-password",   secret_file="${saved.secretsPath}", secret_field="keyPassword")`,
+    ];
+}
+/** jenkins_upload_playstore_sa — 패키지별 SA 파일이 아직 없을 때. */
+export function playServiceAccountMissingLines(packageName, saPath) {
+    return [
+        `❌ ${packageName} 서비스 계정 JSON이 없습니다.`,
+        `   경로: ${saPath}`,
+        '',
+        '먼저 setup_playstore_connection을 호출해 서비스 계정을 생성하세요.',
+    ];
+}
+/** jenkins_upload_playstore_sa — 업로드 완료 + Play Console 권한 부여(수동 1회) 안내. */
+export function playServiceAccountUploadedLines(opts) {
+    const { result, credentialId, clientEmail, rawLength } = opts;
+    return [
+        `✅ Play Store SA JSON → Jenkins ${result}: \`${credentialId}\``,
+        `   서비스 계정: ${clientEmail}`,
+        `   파일 크기:  ${rawLength}자`,
+        '',
+        '다음 단계:',
+        '  Play Console → 설정 → 사용자 및 권한 → 서비스 계정에서',
+        `  ${clientEmail} 를 찾아 "릴리즈 관리자" 권한을 부여하세요.`,
+        '  (수동 1회 작업)',
+    ];
+}

package/dist/android/playstore-sa.d.ts

@@ -0,0 +1,18 @@
+/**
+ * jenkins_upload_playstore_sa 가 올릴 Play 서비스 계정 JSON 을 고른다.
+ *
+ * - explicitPath 가 있으면 iam_create_key 가 저장한 키 파일(~/.mimi-seed/keys/ 안만 허용)을 읽는다.
+ * - 없으면 패키지별 등록 SA(~/.mimi-seed/play-service-accounts/<pkg>.json)를 읽는다. 그 파일이
+ *   없으면 `found: false` 로 경로만 돌려준다 — register 가 "먼저 setup_playstore_connection" 을 안내한다.
+ *
+ * clientEmail 은 안내문용이다. JSON 이 깨져 있어도 업로드 자체는 막지 않는다 (예전 동작 그대로).
+ */
+export type PlayServiceAccountSource = {
+    found: false;
+    path: string;
+} | {
+    found: true;
+    raw: string;
+    clientEmail: string;
+};
+export declare function loadPlayServiceAccountForUpload(packageName: string, explicitPath?: string): PlayServiceAccountSource;

package/dist/android/playstore-sa.js

@@ -0,0 +1,15 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { serviceAccountPathForPackage } from '../auth/playstore-auth.js';
+import { readServiceAccountKeyFile } from '../iam/key-files.js';
+export function loadPlayServiceAccountForUpload(packageName, explicitPath) {
+    const saPath = explicitPath ?? serviceAccountPathForPackage(packageName);
+    if (!explicitPath && !existsSync(saPath))
+        return { found: false, path: saPath };
+    const raw = explicitPath ? readServiceAccountKeyFile(explicitPath) : readFileSync(saPath, 'utf-8');
+    let clientEmail = '(파싱 실패)';
+    try {
+        clientEmail = JSON.parse(raw).client_email ?? clientEmail;
+    }
+    catch { /* ignore */ }
+    return { found: true, raw, clientEmail };
+}

package/dist/appstore/analytics.js

@@ -4,6 +4,7 @@ import { getReportsAuthHeaders } from './auth.js';
 import { V1_BASE, apiRequest, authHeadersOrThrow } from './http.js';
 import { fetchWithTimeout, HTTP_TRANSFER_TIMEOUT_MS } from '../lib/http.js';
 import { parseTsv } from './sales.js';
+import { encodePathSegment } from '../lib/url-path.js';
 export function selectWeeklyAnalyticsReports(reports) {
     const standard = reports.filter((row) => !/Detailed/i.test(row.attributes?.name ?? ''));
     const detailed = reports.filter((row) => /Detailed/i.test(row.attributes?.name ?? ''));
@@ -97,14 +98,14 @@ export function selectLatestInstanceRows(batches) {
         .flatMap(([, value]) => value.rows);
 }
 async function rowsForReport(reportId) {
-    const instances = await reportGet(`/analyticsReports/${reportId}/instances`, { 'filter[granularity]': 'WEEKLY', limit: '200' });
+    const instances = await reportGet(`/analyticsReports/${encodePathSegment(reportId)}/instances`, { 'filter[granularity]': 'WEEKLY', limit: '200' });
     const latest = (instances.data ?? [])
         .filter((row) => row.attributes?.processingDate)
         .sort((a, b) => (b.attributes?.processingDate ?? '').localeCompare(a.attributes?.processingDate ?? ''))
         .slice(0, MAX_WEEKLY_INSTANCES);
     const batches = [];
     for (const instance of latest) {
-        const segments = await reportGet(`/analyticsReportInstances/${instance.id}/segments`, { limit: '200' });
+        const segments = await reportGet(`/analyticsReportInstances/${encodePathSegment(instance.id)}/segments`, { limit: '200' });
         const rows = [];
         for (const segment of segments.data ?? [])
             rows.push(...await downloadSegment(segment));
@@ -260,7 +261,7 @@ export function buildWeeklyInsight(input) {
     };
 }
 export async function getWeeklyInsight(input) {
-    const requests = await reportGet(`/apps/${input.appId}/analyticsReportRequests`, { 'filter[accessType]': 'ONGOING', limit: '10' });
+    const requests = await reportGet(`/apps/${encodePathSegment(input.appId)}/analyticsReportRequests`, { 'filter[accessType]': 'ONGOING', limit: '10' });
     const active = (requests.data ?? []).find((row) => !row.attributes?.stoppedDueToInactivity);
     if (!active) {
         if (!input.createIfMissing) {
@@ -283,7 +284,7 @@ export async function getWeeklyInsight(input) {
             message: 'ONGOING Analytics report request를 만들었습니다. 최초 데이터는 보통 24~48시간 뒤 생성됩니다.',
         };
     }
-    const reports = await reportGet(`/analyticsReportRequests/${active.id}/reports`, { limit: '200' });
+    const reports = await reportGet(`/analyticsReportRequests/${encodePathSegment(active.id)}/reports`, { limit: '200' });
     const { engagement, downloads, purchases } = selectWeeklyAnalyticsReports(reports.data ?? []);
     if (!engagement && !downloads && !purchases) {
         return {

package/dist/appstore/apps.d.ts

@@ -0,0 +1,81 @@
+import type { AscResource, AscToOne } from './types.js';
+interface AppAttributes {
+    name?: string;
+    bundleId?: string;
+    sku?: string;
+    primaryLocale?: string;
+}
+export declare function listApps(): Promise<{
+    id: string;
+    name: string | undefined;
+    bundleId: string | undefined;
+    sku: string | undefined;
+    primaryLocale: string | undefined;
+}[]>;
+export declare function getApp(appId: string): Promise<AscResource<AppAttributes, {
+    [x: string]: AscToOne | import("./types.js").AscToMany | undefined;
+}> | undefined>;
+export declare function listBetaGroups(appId: string): Promise<{
+    id: string;
+    name: string | undefined;
+    isInternal: boolean | undefined;
+    publicLink: string | undefined;
+    publicLinkEnabled: boolean | undefined;
+}[]>;
+export declare function getAppInfo(appId: string): Promise<{
+    id: string;
+    state: string | undefined;
+    ageRating: string | undefined;
+}[]>;
+export interface AppInfoLocalizationFields {
+    name?: string;
+    subtitle?: string;
+    privacyPolicyUrl?: string;
+    privacyPolicyText?: string;
+}
+export declare function listAppInfoLocalizations(appId: string, locale?: string): Promise<{
+    appInfoId: string;
+    appInfoState: string;
+    localizations: {
+        id: string;
+        locale: string | undefined;
+        name: string | undefined;
+        subtitle: string | undefined;
+        privacyPolicyUrl: string | undefined;
+        privacyPolicyText: string | undefined;
+    }[];
+}>;
+export declare function updateAppInfoLocalization(localizationId: string, fields: AppInfoLocalizationFields): Promise<any>;
+export declare function createAppInfoLocalization(appId: string, locale: string, fields: AppInfoLocalizationFields): Promise<{
+    appInfoId: string;
+    appInfoState: string;
+    localization: {
+        id: any;
+        locale: any;
+        name: any;
+        subtitle: any;
+        privacyPolicyUrl: any;
+        privacyPolicyText: any;
+    };
+}>;
+export interface ListCustomerReviewsOptions {
+    limit?: number;
+    territory?: string;
+    rating?: 1 | 2 | 3 | 4 | 5;
+}
+export declare function listCustomerReviews(appId: string, opts?: ListCustomerReviewsOptions): Promise<{
+    id: string;
+    rating: number | undefined;
+    title: string | undefined;
+    body: string | undefined;
+    nickname: string | undefined;
+    createdDate: string | undefined;
+    territory: string | undefined;
+    response: {
+        body: string | undefined;
+        lastModifiedDate: string | undefined;
+        state: string | undefined;
+    } | null;
+}[]>;
+export declare function createReviewResponse(reviewId: string, responseBody: string): Promise<any>;
+export {};

package/dist/appstore/apps.js

@@ -0,0 +1,174 @@
+// App Store Connect — 앱·앱 정보(로컬라이제이션)·TestFlight 베타 그룹·고객 리뷰.
+// appstore/tools.ts 가 이 모듈을 그대로 re-export 한다 — 호출부는 tools.js 경로를 계속 쓴다.
+import { apiGet, apiPatch, apiPost } from './client.js';
+import { encodePathSegment } from '../lib/url-path.js';
+export async function listApps() {
+    const data = (await apiGet('/apps', {
+        'fields[apps]': 'name,bundleId,sku,primaryLocale,contentRightsDeclaration',
+        'limit': '200',
+    }));
+    return (data.data ?? []).map((a) => ({
+        id: a.id,
+        name: a.attributes?.name,
+        bundleId: a.attributes?.bundleId,
+        sku: a.attributes?.sku,
+        primaryLocale: a.attributes?.primaryLocale,
+    }));
+}
+export async function getApp(appId) {
+    const data = (await apiGet(`/apps/${encodePathSegment(appId)}`, {
+        'fields[apps]': 'name,bundleId,sku,primaryLocale,contentRightsDeclaration',
+        'include': 'appStoreVersions',
+    }));
+    return data.data;
+}
+// ─── TestFlight 베타 그룹 ───
+export async function listBetaGroups(appId) {
+    const data = (await apiGet(`/apps/${encodePathSegment(appId)}/betaGroups`, {
+        'fields[betaGroups]': 'name,isInternalGroup,publicLink,publicLinkEnabled',
+    }));
+    return (data.data ?? []).map((g) => ({
+        id: g.id,
+        name: g.attributes?.name,
+        isInternal: g.attributes?.isInternalGroup,
+        publicLink: g.attributes?.publicLink,
+        publicLinkEnabled: g.attributes?.publicLinkEnabled,
+    }));
+}
+// ─── 앱 정보 (카테고리 등) ───
+// AppInfoState — READY_FOR_DISTRIBUTION이 라이브 버전, 그 외(PREPARE_FOR_SUBMISSION /
+// DEVELOPER_REJECTED 등)가 편집 가능한 appInfo.
+const APP_INFO_LIVE_STATE = 'READY_FOR_DISTRIBUTION';
+export async function getAppInfo(appId) {
+    const data = (await apiGet(`/apps/${encodePathSegment(appId)}/appInfos`, {
+        'fields[appInfos]': 'state,appStoreAgeRating,brazilAgeRating',
+    }));
+    return (data.data ?? []).map((i) => ({
+        id: i.id,
+        // 새 필드명 state, 옛 필드명 appStoreState 모두 케어
+        state: i.attributes?.state ?? i.attributes?.appStoreState,
+        ageRating: i.attributes?.appStoreAgeRating,
+    }));
+}
+async function findEditableAppInfoId(appId) {
+    const data = await apiGet(`/apps/${encodePathSegment(appId)}/appInfos`, {
+        'fields[appInfos]': 'state',
+        'limit': '10',
+    });
+    const infos = (data?.data ?? []);
+    if (infos.length === 0) {
+        throw new Error(`앱 ${appId}에 appInfos가 없어. 앱 ID 확인 필요.`);
+    }
+    const stateOf = (i) => i.attributes?.state ?? i.attributes?.appStoreState ?? '';
+    const editable = infos.find((i) => stateOf(i) !== APP_INFO_LIVE_STATE);
+    const target = editable ?? infos[0];
+    return { appInfoId: target.id, state: stateOf(target) };
+}
+export async function listAppInfoLocalizations(appId, locale) {
+    const { appInfoId, state } = await findEditableAppInfoId(appId);
+    const data = await apiGet(`/appInfos/${encodePathSegment(appInfoId)}/appInfoLocalizations`, {
+        'fields[appInfoLocalizations]': 'locale,name,subtitle,privacyPolicyUrl,privacyPolicyText',
+        'limit': '200',
+    });
+    const all = (data?.data ?? []).map((l) => ({
+        id: l.id,
+        locale: l.attributes?.locale,
+        name: l.attributes?.name,
+        subtitle: l.attributes?.subtitle,
+        privacyPolicyUrl: l.attributes?.privacyPolicyUrl,
+        privacyPolicyText: l.attributes?.privacyPolicyText,
+    }));
+    const filtered = locale ? all.filter((l) => l.locale === locale) : all;
+    return { appInfoId, appInfoState: state, localizations: filtered };
+}
+export async function updateAppInfoLocalization(localizationId, fields) {
+    const attributes = Object.fromEntries(Object.entries(fields).filter(([, v]) => v !== undefined));
+    if (Object.keys(attributes).length === 0) {
+        throw new Error('수정할 필드가 없어 (name / subtitle / privacyPolicyUrl / privacyPolicyText 중 하나 이상).');
+    }
+    return apiPatch(`/appInfoLocalizations/${encodePathSegment(localizationId)}`, {
+        data: {
+            type: 'appInfoLocalizations',
+            id: localizationId,
+            attributes,
+        },
+    });
+}
+export async function createAppInfoLocalization(appId, locale, fields) {
+    const attributes = Object.fromEntries(Object.entries(fields).filter(([, v]) => v !== undefined));
+    const { appInfoId, state } = await findEditableAppInfoId(appId);
+    const data = await apiPost('/appInfoLocalizations', {
+        data: {
+            type: 'appInfoLocalizations',
+            attributes: { locale, ...attributes },
+            relationships: {
+                appInfo: { data: { type: 'appInfos', id: appInfoId } },
+            },
+        },
+    });
+    const created = data?.data;
+    return {
+        appInfoId,
+        appInfoState: state,
+        localization: {
+            id: created?.id,
+            locale: created?.attributes?.locale,
+            name: created?.attributes?.name,
+            subtitle: created?.attributes?.subtitle,
+            privacyPolicyUrl: created?.attributes?.privacyPolicyUrl,
+            privacyPolicyText: created?.attributes?.privacyPolicyText,
+        },
+    };
+}
+export async function listCustomerReviews(appId, opts = {}) {
+    const params = {
+        'sort': '-createdDate',
+        'limit': String(opts.limit ?? 50),
+        'fields[customerReviews]': 'rating,title,body,reviewerNickname,createdDate,territory',
+        'include': 'response',
+        'fields[customerReviewResponses]': 'responseBody,lastModifiedDate,state',
+    };
+    if (opts.territory)
+        params['filter[territory]'] = opts.territory;
+    if (opts.rating != null)
+        params['filter[rating]'] = String(opts.rating);
+    const data = (await apiGet(`/apps/${encodePathSegment(appId)}/customerReviews`, params));
+    // include로 가져온 답변 매핑
+    const responses = new Map();
+    for (const inc of data.included ?? []) {
+        if (inc.type === 'customerReviewResponses') {
+            responses.set(inc.id, inc.attributes);
+        }
+    }
+    return (data.data ?? []).map((r) => {
+        const respId = r.relationships?.response?.data?.id;
+        const resp = respId ? responses.get(respId) : null;
+        return {
+            id: r.id,
+            rating: r.attributes?.rating,
+            title: r.attributes?.title,
+            body: r.attributes?.body,
+            nickname: r.attributes?.reviewerNickname,
+            createdDate: r.attributes?.createdDate,
+            territory: r.attributes?.territory,
+            response: resp
+                ? {
+                    body: resp.responseBody,
+                    lastModifiedDate: resp.lastModifiedDate,
+                    state: resp.state,
+                }
+                : null,
+        };
+    });
+}
+export async function createReviewResponse(reviewId, responseBody) {
+    return apiPost('/customerReviewResponses', {
+        data: {
+            type: 'customerReviewResponses',
+            attributes: { responseBody },
+            relationships: {
+                review: { data: { type: 'customerReviews', id: reviewId } },
+            },
+        },
+    });
+}

package/dist/appstore/client.d.ts

@@ -0,0 +1,21 @@
+export declare function apiGet(path: string, params?: Record<string, string>): Promise<any>;
+export interface AppStoreVerifyResult {
+    ok: boolean;
+    stage: 'creds' | 'sign' | 'auth' | 'api' | 'done';
+    message: string;
+    httpStatus?: number;
+    appCount?: number;
+    firstApp?: {
+        id: string;
+        name?: string;
+    };
+}
+/**
+ * appstore.json 자격증명 유효성 단계별 검증 (creds → sign → auth → api).
+ * playstore_verify_service_account 의 App Store 대응. 읽기 전용 — GET /apps?limit=1.
+ * 파일 존재만 보는 requireAppStoreCreds 와 달리, 잘못된 .p8/keyId/issuerId 를
+ * "첫 호출 401" 로 늦게 터지기 전에 setup 단계에서 잡아준다.
+ */
+export declare function verifyAppStoreCredentials(creds?: import("./auth.js").AppStoreCredentials | null): Promise<AppStoreVerifyResult>;
+export declare function apiPatch(path: string, body: unknown): Promise<any>;
+export declare function apiPost(path: string, body: unknown): Promise<any>;

package/dist/appstore/client.js

@@ -0,0 +1,130 @@
+import { getAuthHeaders, getAppStoreCredentials, generateToken } from './auth.js';
+import { friendlyAppStoreError } from './errors.js';
+import { fetchWithTimeout } from '../lib/http.js';
+/**
+ * App Store Connect API v1 래퍼
+ * https://developer.apple.com/documentation/appstoreconnectapi
+ */
+const BASE = 'https://api.appstoreconnect.apple.com/v1';
+export async function apiGet(path, params) {
+    const headers = await getAuthHeaders();
+    if (!headers)
+        throw new Error([
+            '❌ App Store Connect 인증이 필요해.',
+            '',
+            '터미널에서 실행:',
+            '  npx -p @yoonion/mimi-seed-mcp mimi-seed-appstore-auth',
+            '',
+            'API Key가 필요해:',
+            '  App Store Connect > Users and Access > Integrations > Keys',
+        ].join('\n'));
+    const url = new URL(`${BASE}${path}`);
+    if (params) {
+        for (const [k, v] of Object.entries(params))
+            url.searchParams.set(k, v);
+    }
+    const res = await fetchWithTimeout(url.toString(), { headers });
+    if (!res.ok) {
+        const body = await res.text();
+        throw friendlyAppStoreError(res.status, body);
+    }
+    return res.json();
+}
+/**
+ * appstore.json 자격증명 유효성 단계별 검증 (creds → sign → auth → api).
+ * playstore_verify_service_account 의 App Store 대응. 읽기 전용 — GET /apps?limit=1.
+ * 파일 존재만 보는 requireAppStoreCreds 와 달리, 잘못된 .p8/keyId/issuerId 를
+ * "첫 호출 401" 로 늦게 터지기 전에 setup 단계에서 잡아준다.
+ */
+export async function verifyAppStoreCredentials(creds = getAppStoreCredentials()) {
+    if (!creds) {
+        return {
+            ok: false,
+            stage: 'creds',
+            message: '~/.mimi-seed/appstore.json 이 없습니다. `mimi-seed auth appstore` 로 등록하세요.',
+        };
+    }
+    let token;
+    try {
+        token = await generateToken(creds);
+    }
+    catch (e) {
+        return {
+            ok: false,
+            stage: 'sign',
+            message: `JWT 서명 실패 — .p8 privateKey / keyId 확인 필요.\n${e.message}`,
+        };
+    }
+    let res;
+    try {
+        res = await fetchWithTimeout(`${BASE}/apps?limit=1`, { headers: { Authorization: `Bearer ${token}` } });
+    }
+    catch (e) {
+        return { ok: false, stage: 'api', message: `App Store API 연결 실패: ${e.message}` };
+    }
+    if (res.status === 401 || res.status === 403) {
+        return {
+            ok: false,
+            stage: 'auth',
+            httpStatus: res.status,
+            message: 'Apple이 인증을 거부했어요 — issuerId / keyId / .p8 조합이 틀렸거나 키 권한이 부족합니다.\n`mimi-seed auth appstore` 로 재등록하세요.',
+        };
+    }
+    if (!res.ok) {
+        const body = await res.text();
+        return { ok: false, stage: 'api', httpStatus: res.status, message: `App Store API ${res.status}: ${body.slice(0, 200)}` };
+    }
+    const data = (await res.json());
+    const first = data.data?.[0];
+    return {
+        ok: true,
+        stage: 'done',
+        message: '인증 유효',
+        appCount: data.meta?.paging?.total,
+        firstApp: first ? { id: first.id, name: first.attributes?.name } : undefined,
+    };
+}
+export async function apiPatch(path, body) {
+    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 res = await fetchWithTimeout(`${BASE}${path}`, {
+        method: 'PATCH',
+        headers: { ...headers, 'Content-Type': 'application/json' },
+        body: JSON.stringify(body),
+    });
+    if (!res.ok) {
+        const text = await res.text();
+        throw friendlyAppStoreError(res.status, text);
+    }
+    // 204 No Content 가능
+    const text = await res.text();
+    return text ? JSON.parse(text) : { ok: true };
+}
+export async function apiPost(path, body) {
+    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 res = await fetchWithTimeout(`${BASE}${path}`, {
+        method: 'POST',
+        headers: { ...headers, 'Content-Type': 'application/json' },
+        body: JSON.stringify(body),
+    });
+    if (!res.ok) {
+        const text = await res.text();
+        throw friendlyAppStoreError(res.status, text);
+    }
+    // 201 Created — 본문에 created entity. 일부 엔드포인트는 204
+    const text = await res.text();
+    return text ? JSON.parse(text) : { ok: true };
+}