@yoonion/mimi-seed-mcp 0.3.10 → 0.3.12

package/dist/appstore/tools.d.ts

@@ -2,6 +2,30 @@ export declare function apiGet(path: string, params?: Record<string, string>): P
 export declare function listApps(): Promise<any>;
 export declare function getApp(appId: string): Promise<any>;
 export declare function listVersions(appId: string): Promise<any>;
+export type ApplePlatform = 'IOS' | 'MAC_OS' | 'TV_OS' | 'VISION_OS';
+export type AppleReleaseType = 'MANUAL' | 'AFTER_APPROVAL' | 'SCHEDULED';
+export interface CreateVersionInput {
+    appId: string;
+    versionString: string;
+    platform: ApplePlatform;
+    copyright?: string;
+    releaseType?: AppleReleaseType;
+    earliestReleaseDate?: string;
+    buildId?: string;
+}
+export declare function createVersion(input: CreateVersionInput): Promise<{
+    id: any;
+    version: any;
+    platform: any;
+    state: any;
+    releaseType: any;
+    createdDate: any;
+}>;
+export declare function attachBuildToVersion(versionId: string, buildId: string): Promise<{
+    versionId: string;
+    buildId: string;
+    ok: boolean;
+}>;
 export declare function getVersionLocalizations(versionId: string): Promise<any>;
 export interface LocalizationUpdateFields {
     whatsNew?: string;

package/dist/appstore/tools.js

@@ -107,6 +107,46 @@ export async function listVersions(appId) {
         createdDate: v.attributes?.createdDate,
     }));
 }
+export async function createVersion(input) {
+    const attributes = {
+        platform: input.platform,
+        versionString: input.versionString,
+    };
+    if (input.copyright !== undefined)
+        attributes.copyright = input.copyright;
+    if (input.releaseType !== undefined)
+        attributes.releaseType = input.releaseType;
+    if (input.earliestReleaseDate !== undefined)
+        attributes.earliestReleaseDate = input.earliestReleaseDate;
+    const relationships = {
+        app: { data: { type: 'apps', id: input.appId } },
+    };
+    if (input.buildId) {
+        relationships.build = { data: { type: 'builds', id: input.buildId } };
+    }
+    const created = await apiPost('/appStoreVersions', {
+        data: {
+            type: 'appStoreVersions',
+            attributes,
+            relationships,
+        },
+    });
+    return {
+        id: created?.data?.id,
+        version: created?.data?.attributes?.versionString,
+        platform: created?.data?.attributes?.platform,
+        state: created?.data?.attributes?.appStoreState ?? created?.data?.attributes?.state,
+        releaseType: created?.data?.attributes?.releaseType,
+        createdDate: created?.data?.attributes?.createdDate,
+    };
+}
+export async function attachBuildToVersion(versionId, buildId) {
+    // /relationships/build 엔드포인트는 204 No Content 반환
+    await apiPatch(`/appStoreVersions/${versionId}/relationships/build`, {
+        data: { type: 'builds', id: buildId },
+    });
+    return { versionId, buildId, ok: true };
+}
 // ─── 로컬라이제이션 (메타데이터) ───
 export async function getVersionLocalizations(versionId) {
     const data = await apiGet(`/appStoreVersions/${versionId}/appStoreVersionLocalizations`, {

package/dist/checks/plan.d.ts

@@ -0,0 +1,20 @@
+import type { OAuth2Client } from 'google-auth-library';
+export type StepState = 'done' | 'pending' | 'blocked';
+export interface PlanStep {
+    state: StepState;
+    title: string;
+    detail?: string;
+    tool?: string;
+    irreversible?: boolean;
+}
+export declare function buildPlayStoreReleasePlan(opts: {
+    auth: OAuth2Client;
+    packageName: string;
+    versionCode?: string;
+    track: 'production' | 'beta' | 'alpha' | 'internal';
+    language: string;
+}): Promise<string>;
+export declare function buildAppStoreReleasePlan(opts: {
+    appId: string;
+    versionString?: string;
+}): Promise<string>;

package/dist/checks/plan.js

@@ -0,0 +1,258 @@
+// Release Plan — Play Store / App Store 배포 사전 점검 + AI에게 TodoWrite 지시
+//
+// 이 모듈은 read-only.
+// 실행 도구(playstore_submit_release, appstore_submit_for_review 등)는 호출하지 않고,
+// 현재 상태를 조사해서 markdown 체크리스트로 변환한다.
+// AI 에이전트가 응답을 받아 TodoWrite로 사용자에게 제시한 뒤,
+// 단계별로 기존 *_update_*, *_submit_*, *_check_* 도구를 호출하도록 유도한다.
+import { publisher, withEdit } from '../playstore/tools.js';
+import { apiGet } from '../appstore/tools.js';
+import { checkPlayStoreRisks, checkAppStoreRisks } from './risks.js';
+const TODO_DIRECTIVE = [
+    '📋 [AI 지시 — 호출자 에이전트 전용]',
+    '',
+    '이 응답은 배포 플랜입니다. 다음 절차를 반드시 따르세요:',
+    '',
+    '1. 아래 체크리스트의 미완료(◻︎) 항목을 TodoWrite 도구로 사용자에게 먼저 보여주세요.',
+    '2. 사용자가 진행에 명시적으로 동의하기 전엔 ⚠️ 비가역 도구를 호출하지 마세요',
+    '   (playstore_submit_release status=completed, playstore_promote_release status=completed,',
+    '    appstore_submit_for_review).',
+    '3. 한 단계 끝날 때마다 TodoWrite로 해당 항목을 completed로 표시하세요.',
+    '4. 항목 옆에 "도구:" 가 표기된 경우, 그 도구를 직접 호출해서 단계를 실행하세요.',
+    '',
+].join('\n');
+function fmtState(s) {
+    return s === 'done' ? '☑︎' : s === 'blocked' ? '⛔' : '◻︎';
+}
+function risksToSteps(risks, toolHint) {
+    return risks.map((r) => ({
+        state: 'blocked',
+        title: `[${r.code}] ${r.title}`,
+        detail: r.detail + (r.fixUrl ? `  → ${r.fixUrl}` : ''),
+        tool: r.level === 'blocker' ? toolHint : undefined,
+    }));
+}
+function renderPlan(ctx, steps) {
+    const blocked = steps.filter((s) => s.state === 'blocked').length;
+    const pending = steps.filter((s) => s.state === 'pending').length;
+    const done = steps.filter((s) => s.state === 'done').length;
+    const lines = [];
+    lines.push(TODO_DIRECTIVE);
+    lines.push(`🎯 ${ctx.platform} 배포 플랜`);
+    lines.push('');
+    lines.push(`  대상: ${ctx.identity}`);
+    lines.push(`  버전: ${ctx.version}`);
+    if (ctx.track)
+        lines.push(`  트랙: ${ctx.track}`);
+    lines.push('');
+    lines.push(`  진행률: ☑︎ ${done}  ◻︎ ${pending}  ⛔ ${blocked}`);
+    if (blocked > 0) {
+        lines.push(`  ⚠️  블로커 ${blocked}건 — 먼저 해결해야 제출 가능`);
+    }
+    lines.push('');
+    lines.push('체크리스트 (TodoWrite로 사용자에게 제시):');
+    lines.push('');
+    for (const s of steps) {
+        const irr = s.irreversible ? ' ⚠️ 비가역' : '';
+        lines.push(`${fmtState(s.state)} ${s.title}${irr}`);
+        if (s.detail)
+            lines.push(`     ${s.detail}`);
+        if (s.tool)
+            lines.push(`     도구: ${s.tool}`);
+    }
+    lines.push('');
+    lines.push('—');
+    lines.push('TodoWrite로 위 미완료 항목을 등록한 후, 사용자 확인을 받고 도구를 단계별로 호출하세요.');
+    return lines.join('\n');
+}
+// ─── Play Store ──────────────────────────────────────────────────────
+export async function buildPlayStoreReleasePlan(opts) {
+    const { auth, packageName, versionCode, track, language } = opts;
+    const steps = [];
+    // 1) 인증 + 트랙 / 빌드 상태 조회 (단일 edit session)
+    let trackInfo = {
+        hasTargetVersion: false,
+    };
+    let listingPresent = false;
+    try {
+        await withEdit(auth, packageName, async (editId) => {
+            const [tracks, listing] = await Promise.all([
+                publisher().edits.tracks.list({ auth, packageName, editId }).catch(() => null),
+                publisher().edits.listings.get({ auth, packageName, editId, language }).catch(() => null),
+            ]);
+            const targetTrack = tracks?.data?.tracks?.find((t) => t.track === track);
+            const release = targetTrack?.releases?.[0];
+            const codes = release?.versionCodes ?? [];
+            trackInfo = {
+                hasTargetVersion: versionCode ? codes.includes(versionCode) : codes.length > 0,
+                latestVersionCode: codes[codes.length - 1],
+                releaseStatus: release?.status ?? undefined,
+            };
+            listingPresent = !!listing?.data?.title;
+            return null;
+        });
+        steps.push({ state: 'done', title: 'Google Play 인증 + 트랙 조회 성공' });
+    }
+    catch (e) {
+        steps.push({
+            state: 'blocked',
+            title: 'Google Play 인증 또는 트랙 조회 실패',
+            detail: e instanceof Error ? e.message : String(e),
+            tool: 'mimi_seed_auth_status',
+        });
+        return renderPlan({ platform: 'Play Store', identity: packageName, version: versionCode ?? 'latest', track }, steps);
+    }
+    // 2) 빌드 도착 확인
+    if (trackInfo.hasTargetVersion) {
+        steps.push({
+            state: 'done',
+            title: `${track} 트랙에 versionCode ${versionCode ?? trackInfo.latestVersionCode} 도착 확인`,
+            detail: `현재 release status: ${trackInfo.releaseStatus ?? 'unknown'}`,
+        });
+    }
+    else {
+        steps.push({
+            state: 'blocked',
+            title: versionCode
+                ? `${track} 트랙에 versionCode ${versionCode} 없음`
+                : `${track} 트랙에 release 없음`,
+            detail: 'Gradle / Fastlane / Play Console 업로드를 먼저 완료하세요.',
+            tool: 'playstore_list_tracks',
+        });
+    }
+    // 3) 메타데이터 / 스크린샷 / 정책 위험 점검
+    const risks = await checkPlayStoreRisks(auth, packageName, language);
+    if (risks.length === 0) {
+        steps.push({
+            state: 'done',
+            title: '제출 위험 점검 통과 (블로커 0)',
+        });
+    }
+    else {
+        const blockers = risks.filter((r) => r.level === 'blocker');
+        const warnings = risks.filter((r) => r.level === 'warning');
+        steps.push({
+            state: blockers.length > 0 ? 'blocked' : 'pending',
+            title: `제출 위험 ${risks.length}건 (블로커 ${blockers.length} / 경고 ${warnings.length})`,
+            detail: '아래 항목을 개별 수정 후 다시 plan 호출 권장',
+            tool: 'playstore_check_submission_risks',
+        });
+        steps.push(...risksToSteps(blockers, 'playstore_update_listing'));
+        steps.push(...risksToSteps(warnings, 'playstore_update_listing'));
+    }
+    // 4) 릴리즈 노트
+    steps.push({
+        state: 'pending',
+        title: `릴리즈 노트 등록/갱신 (${language})`,
+        detail: 'AI 노트 초안 + 사용자 확인 후 적용',
+        tool: 'playstore_update_release_notes (또는 playstore_update_latest_release_notes)',
+    });
+    // 5) 제출
+    const canSubmit = !risks.some((r) => r.level === 'blocker') && trackInfo.hasTargetVersion;
+    steps.push({
+        state: canSubmit ? 'pending' : 'blocked',
+        title: `${track} 트랙 release status 변경 (draft → completed)`,
+        detail: canSubmit
+            ? '⚠️ 비가역에 가까움. 사용자 명시 동의 필수.'
+            : '블로커 해결 후 가능',
+        tool: 'playstore_submit_release',
+        irreversible: true,
+    });
+    return renderPlan({ platform: 'Play Store', identity: packageName, version: versionCode ?? 'latest', track }, steps);
+}
+// ─── App Store ────────────────────────────────────────────────────────
+export async function buildAppStoreReleasePlan(opts) {
+    const { appId, versionString } = opts;
+    const steps = [];
+    // 1) 편집 가능한 버전 조회
+    let versionId;
+    let versionState;
+    let buildAttached = false;
+    try {
+        const versions = await apiGet(`/apps/${appId}/appStoreVersions`, {
+            'filter[appStoreState]': 'PREPARE_FOR_SUBMISSION,WAITING_FOR_REVIEW,DEVELOPER_REJECTED',
+            ...(versionString ? { 'filter[versionString]': versionString } : {}),
+            limit: '5',
+        }).catch(() => null);
+        if (versions?.data?.length) {
+            versionId = versions.data[0].id;
+            versionState = versions.data[0].attributes?.appStoreState;
+            steps.push({
+                state: 'done',
+                title: `편집 가능한 버전 발견 (${versions.data[0].attributes?.versionString}, state=${versionState})`,
+            });
+            // build attached?
+            const build = await apiGet(`/appStoreVersions/${versionId}/build`).catch(() => null);
+            buildAttached = !!build?.data?.id;
+            if (buildAttached) {
+                steps.push({ state: 'done', title: '버전에 빌드 연결됨' });
+            }
+            else {
+                steps.push({
+                    state: 'blocked',
+                    title: '버전에 빌드 미연결',
+                    detail: 'TestFlight 빌드 처리 완료 후 App Store Connect에서 연결하거나 API로 attach.',
+                    tool: 'appstore_list_builds',
+                });
+            }
+        }
+        else {
+            steps.push({
+                state: 'blocked',
+                title: versionString
+                    ? `편집 가능한 ${versionString} 버전 없음`
+                    : '편집 가능한 버전 없음',
+                detail: 'App Store Connect에서 새 버전을 생성하세요.',
+            });
+        }
+    }
+    catch (e) {
+        steps.push({
+            state: 'blocked',
+            title: 'App Store 인증 또는 버전 조회 실패',
+            detail: e instanceof Error ? e.message : String(e),
+            tool: 'mimi_seed_auth_status',
+        });
+        return renderPlan({ platform: 'App Store', identity: appId, version: versionString ?? 'latest' }, steps);
+    }
+    // 2) 메타데이터 / 스크린샷 / 정책 위험 점검
+    const risks = await checkAppStoreRisks(appId);
+    if (risks.length === 0) {
+        steps.push({ state: 'done', title: '제출 위험 점검 통과 (블로커 0)' });
+    }
+    else {
+        const blockers = risks.filter((r) => r.level === 'blocker');
+        const warnings = risks.filter((r) => r.level === 'warning');
+        steps.push({
+            state: blockers.length > 0 ? 'blocked' : 'pending',
+            title: `제출 위험 ${risks.length}건 (블로커 ${blockers.length} / 경고 ${warnings.length})`,
+            tool: 'appstore_check_submission_risks',
+        });
+        steps.push(...risksToSteps(blockers, 'appstore_update_localization'));
+        steps.push(...risksToSteps(warnings, 'appstore_update_localization'));
+    }
+    // 3) What's New / promotional text / reviewer notes
+    steps.push({
+        state: 'pending',
+        title: "What's New (릴리즈 노트) 등록/갱신",
+        detail: '버전별 로컬라이제이션마다 입력',
+        tool: 'appstore_update_whats_new',
+    });
+    steps.push({
+        state: 'pending',
+        title: 'Promotional Text / Description / Keywords 검토',
+        tool: 'appstore_update_localization',
+    });
+    // 4) 제출
+    const canSubmit = versionId && buildAttached && !risks.some((r) => r.level === 'blocker');
+    steps.push({
+        state: canSubmit ? 'pending' : 'blocked',
+        title: '심사 제출 (reviewSubmissions v2)',
+        detail: canSubmit
+            ? '⚠️ 비가역. 제출 후 메타/빌드 변경 불가 (REJECTED 시 재편집).'
+            : '블로커 해결 후 가능',
+        tool: versionId ? `appstore_submit_for_review (versionId=${versionId})` : 'appstore_submit_for_review',
+        irreversible: true,
+    });
+    return renderPlan({ platform: 'App Store', identity: appId, version: versionString ?? 'latest' }, steps);
+}

package/dist/index.js

@@ -14,6 +14,7 @@ import * as appstore from './appstore/tools.js';
 import * as appstoreScreenshots from './appstore/screenshots.js';
 import * as iam from './iam/tools.js';
 import { checkPlayStoreRisks, checkAppStoreRisks, formatRisks } from './checks/risks.js';
+import { buildPlayStoreReleasePlan, buildAppStoreReleasePlan } from './checks/plan.js';
 import { validateAppStoreScreenshots, validatePlayStoreScreenshots, formatValidationResults } from './checks/screenshots.js';
 import { generateReleaseNotesFromCommits, formatGeneratedNotes } from './ai/notes.js';
 import { generateReviewReply, formatReviewReply } from './ai/review.js';
@@ -704,6 +705,69 @@ server.tool('appstore_list_versions', 'App Store 버전 목록 (심사 상태
     const versions = await appstore.listVersions(appId);
     return { content: [{ type: 'text', text: JSON.stringify(versions, null, 2) }] };
 });
+server.tool('appstore_create_version', [
+    'App Store 새 버전 레코드 생성 — POST /v1/appStoreVersions.',
+    '새 versionString(예: "1.2.3")으로 PREPARE_FOR_SUBMISSION 상태의 버전을 만듦.',
+    'buildId를 함께 주면 생성과 동시에 빌드 연결. 나중에 붙이려면 appstore_attach_build 사용.',
+    'releaseType: MANUAL(개발자가 출시) / AFTER_APPROVAL(승인 후 자동) / SCHEDULED(earliestReleaseDate 필요).',
+].join(' '), {
+    appId: z.string().describe('App Store 앱 ID (appstore_list_apps 결과의 id, 숫자형)'),
+    versionString: z.string().describe('버전 문자열 (예: "1.2.3")'),
+    platform: z
+        .enum(['IOS', 'MAC_OS', 'TV_OS', 'VISION_OS'])
+        .default('IOS')
+        .describe('플랫폼 (기본 IOS)'),
+    copyright: z.string().optional().describe('저작권 표기 (예: "© 2026 Foo Inc.")'),
+    releaseType: z
+        .enum(['MANUAL', 'AFTER_APPROVAL', 'SCHEDULED'])
+        .optional()
+        .describe('출시 방식 (생략 시 Apple 기본값)'),
+    earliestReleaseDate: z
+        .string()
+        .optional()
+        .describe('SCHEDULED일 때 가장 빠른 출시 시각 (ISO 8601, 예: "2026-05-01T00:00:00Z")'),
+    buildId: z
+        .string()
+        .optional()
+        .describe('연결할 빌드 ID (appstore_list_builds 결과). 생략 시 버전만 생성하고 나중에 attach.'),
+}, async ({ appId, versionString, platform, copyright, releaseType, earliestReleaseDate, buildId }) => {
+    const result = await appstore.createVersion({
+        appId,
+        versionString,
+        platform,
+        copyright,
+        releaseType,
+        earliestReleaseDate,
+        buildId,
+    });
+    return {
+        content: [
+            {
+                type: 'text',
+                text: `✅ 버전 ${versionString} (${platform}) 생성됨${buildId ? ` + 빌드 ${buildId} 연결됨` : ''}.\n\n${JSON.stringify(result, null, 2)}`,
+            },
+        ],
+    };
+});
+server.tool('appstore_attach_build', [
+    'App Store 버전에 업로드된 빌드를 연결 — PATCH /v1/appStoreVersions/{id}/relationships/build.',
+    'TestFlight에 업로드되어 processingState=VALID 상태인 빌드만 연결 가능.',
+    '편집 가능한 버전(PREPARE_FOR_SUBMISSION 등)에서만 변경됨.',
+    'buildId는 appstore_list_builds 결과 사용.',
+].join(' '), {
+    versionId: z.string().describe('App Store 버전 ID (appstore_list_versions 또는 appstore_create_version 결과)'),
+    buildId: z.string().describe('빌드 ID (appstore_list_builds 결과)'),
+}, async ({ versionId, buildId }) => {
+    const result = await appstore.attachBuildToVersion(versionId, buildId);
+    return {
+        content: [
+            {
+                type: 'text',
+                text: `✅ 빌드 ${buildId}가 버전 ${versionId}에 연결됐어.\n\n${JSON.stringify(result, null, 2)}`,
+            },
+        ],
+    };
+});
 server.tool('appstore_get_metadata', 'App Store 버전 메타데이터 (설명문, 키워드, What\'s New)', { versionId: z.string().describe('버전 ID') }, async ({ versionId }) => {
     const localizations = await appstore.getVersionLocalizations(versionId);
     return { content: [{ type: 'text', text: JSON.stringify(localizations, null, 2) }] };
@@ -1042,6 +1106,42 @@ server.tool('appstore_delete_product', '⚠️ 비가역. App Store IAP 상품
     }
     return { content: [{ type: 'text', text: `✓ ${productId} 삭제 완료` }] };
 });
+// --- 배포 플랜 (read-only, AI에게 TodoWrite 지시) ---
+server.tool('playstore_plan_release', [
+    'Google Play 배포 플랜 — 인증/빌드/메타데이터/스크린샷/정책 위험을 한 번에 점검하고',
+    '체크리스트로 반환합니다 (read-only, 아무것도 변경하지 않음).',
+    '⚠️ AI 호출자 지시: 응답을 받으면 미완료 항목을 반드시 TodoWrite로 사용자에게 먼저 보여주고,',
+    '사용자 동의 후 단계별로 기존 도구(playstore_update_listing, playstore_update_release_notes,',
+    'playstore_submit_release 등)를 호출하세요. submit_release(status=completed)는 비가역이므로 반드시 명시 동의 필요.',
+].join(' '), {
+    packageName: z.string().describe('Android 패키지명 (예: gg.pryzm.coffee)'),
+    versionCode: z.string().optional().describe('확인할 versionCode. 미지정 시 트랙 최신 release 검사'),
+    track: z.enum(['production', 'beta', 'alpha', 'internal']).optional().describe('대상 트랙 (기본: production)'),
+    language: z.string().optional().describe('점검할 리스팅 언어 (기본: ko-KR)'),
+}, async ({ packageName, versionCode, track, language }) => {
+    const auth = requirePlayStoreAuth();
+    const text = await buildPlayStoreReleasePlan({
+        auth,
+        packageName,
+        versionCode,
+        track: track ?? 'production',
+        language: language ?? 'ko-KR',
+    });
+    return { content: [{ type: 'text', text }] };
+});
+server.tool('appstore_plan_release', [
+    'App Store 배포 플랜 — 편집 가능한 버전/빌드 attach/메타/스크린샷/정책 위험을 한 번에 점검하고',
+    '체크리스트로 반환합니다 (read-only).',
+    '⚠️ AI 호출자 지시: 응답의 미완료 항목을 반드시 TodoWrite로 사용자에게 먼저 보여주고,',
+    '사용자 동의 후 단계별로 기존 도구(appstore_update_localization, appstore_update_whats_new,',
+    'appstore_submit_for_review 등)를 호출하세요. submit_for_review는 비가역이므로 반드시 명시 동의 필요.',
+].join(' '), {
+    appId: z.string().describe('App Store 앱 ID (appstore_list_apps 결과의 id)'),
+    versionString: z.string().optional().describe('대상 버전 (예: 1.3.0). 미지정 시 가장 최근 편집 가능 버전'),
+}, async ({ appId, versionString }) => {
+    const text = await buildAppStoreReleasePlan({ appId, versionString });
+    return { content: [{ type: 'text', text }] };
+});
 // --- App Store 심사 제출 (Submit for Review) ---
 server.tool('appstore_submit_for_review', [
     'App Store 버전을 심사에 제출 — 새 reviewSubmissions API 사용 (옛 /appStoreVersionSubmissions는 2024-01 deprecated).',

package/package.json

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