@yoonion/mimi-seed-mcp 0.1.0 → 0.3.0

package/dist/auth/google-auth.js

@@ -92,10 +92,23 @@ export function getAuthenticatedClient() {
     });
     return client;
 }
+// 동시 실행 방지용 — 활성 콜백 서버 참조
+let activeAuthServer = null;
 /**
- * Interactive login — opens browser, waits for callback
+ * OAuth 플로우 시작.
+ * URL과 대기 Promise를 즉시 반환. localhost:9876 콜백 서버는 백그라운드로 실행.
+ * 호출자가 URL을 사용자에게 전달하거나 `open()`을 직접 호출.
+ * `wait` Promise: 토큰 저장 시 resolve, 타임아웃/에러 시 reject.
+ * 재호출 시 기존 세션 자동 정리.
  */
-export async function login(clientId, clientSecret) {
+export function startAuth(clientId, clientSecret, options = {}) {
+    if (activeAuthServer) {
+        try {
+            activeAuthServer.close();
+        }
+        catch { /* noop */ }
+        activeAuthServer = null;
+    }
     saveCredentials(clientId, clientSecret);
     const oauth2Client = createOAuth2Client(clientId, clientSecret);
     const authUrl = oauth2Client.generateAuthUrl({
@@ -103,7 +116,7 @@ export async function login(clientId, clientSecret) {
         scope: SCOPES,
         prompt: 'consent',
     });
-    return new Promise((resolve, reject) => {
+    const wait = new Promise((resolve, reject) => {
         const server = http.createServer(async (req, res) => {
             try {
                 const url = new URL(req.url, `http://localhost:9876`);
@@ -139,21 +152,47 @@ export async function login(clientId, clientSecret) {
           </body></html>
         `);
                 server.close();
+                activeAuthServer = null;
                 resolve(stored);
             }
             catch (err) {
                 res.writeHead(500);
                 res.end('Auth error');
-                server.close();
+                try {
+                    server.close();
+                }
+                catch { /* noop */ }
+                activeAuthServer = null;
                 reject(err);
             }
         });
         server.on('error', (err) => {
-            reject(new Error(`포트 9876이 이미 사용 중입니다. 다른 mimi-seed auth 프로세스를 종료하세요.`));
+            reject(new Error(`포트 9876이 이미 사용 중이거나 에러: ${err.message}`));
         });
         server.listen(9876, () => {
-            console.log('🔐 브라우저에서 Google 로그인 중...');
-            open(authUrl);
+            activeAuthServer = server;
         });
+        const timeoutMs = options.timeoutMs ?? 10 * 60 * 1000;
+        setTimeout(() => {
+            if (server.listening) {
+                try {
+                    server.close();
+                }
+                catch { /* noop */ }
+                activeAuthServer = null;
+                reject(new Error(`Auth timeout (${Math.round(timeoutMs / 1000)}s).`));
+            }
+        }, timeoutMs);
     });
+    return { url: authUrl, wait };
+}
+/**
+ * Interactive login — opens browser, waits for callback.
+ * startAuth() 래퍼 — CLI에서 사용.
+ */
+export async function login(clientId, clientSecret) {
+    const { url, wait } = startAuth(clientId, clientSecret);
+    console.log('🔐 브라우저에서 Google 로그인 중...');
+    open(url);
+    return wait;
 }

package/dist/checks/risks.d.ts

@@ -0,0 +1,12 @@
+import type { OAuth2Client } from 'google-auth-library';
+export type RiskLevel = 'blocker' | 'warning' | 'info';
+export interface SubmissionRisk {
+    level: RiskLevel;
+    code: string;
+    title: string;
+    detail: string;
+    fixUrl?: string;
+}
+export declare function checkPlayStoreRisks(auth: OAuth2Client, packageName: string, language?: string): Promise<SubmissionRisk[]>;
+export declare function checkAppStoreRisks(appId: string): Promise<SubmissionRisk[]>;
+export declare function formatRisks(risks: SubmissionRisk[], platform: string): string;

package/dist/checks/risks.js

@@ -0,0 +1,123 @@
+import { publisher, withEdit } from '../playstore/tools.js';
+import { apiGet } from '../appstore/tools.js';
+const APPSTORE_EDITABLE_STATES = 'PREPARE_FOR_SUBMISSION,WAITING_FOR_REVIEW';
+export async function checkPlayStoreRisks(auth, packageName, language = 'ko-KR') {
+    const risks = [];
+    await withEdit(auth, packageName, async (editId) => {
+        const [listing, phoneScreenshots, icons, details, tracks] = await Promise.all([
+            publisher().edits.listings.get({ auth, packageName, editId, language }).catch(() => null),
+            publisher().edits.images.list({ auth, packageName, editId, language, imageType: 'phoneScreenshots' }).catch(() => null),
+            publisher().edits.images.list({ auth, packageName, editId, language, imageType: 'icon' }).catch(() => null),
+            publisher().edits.details.get({ auth, packageName, editId }).catch(() => null),
+            publisher().edits.tracks.list({ auth, packageName, editId }).catch(() => null),
+        ]);
+        if (!listing?.data) {
+            risks.push({ level: 'blocker', code: 'NO_LISTING', title: `${language} 리스팅 없음`, detail: 'Play Console에서 스토어 정보를 입력하세요.', fixUrl: 'https://play.google.com/console/developers' });
+        }
+        else {
+            const { title, shortDescription, fullDescription } = listing.data;
+            if (!title || title.length < 2) {
+                risks.push({ level: 'blocker', code: 'NO_TITLE', title: '앱 이름 없음', detail: '제목은 필수 항목입니다.' });
+            }
+            else if (title.length > 50) {
+                risks.push({ level: 'warning', code: 'TITLE_TOO_LONG', title: '앱 이름 50자 초과', detail: `현재 ${title.length}자. Google 가이드라인: 50자 이내.` });
+            }
+            if (!shortDescription || shortDescription.length < 10) {
+                risks.push({ level: 'warning', code: 'NO_SHORT_DESC', title: '짧은 설명 없음', detail: '짧은 설명은 검색 노출에 영향을 줍니다.' });
+            }
+            if (!fullDescription || fullDescription.length < 50) {
+                risks.push({ level: 'blocker', code: 'NO_FULL_DESC', title: '전체 설명 없음', detail: '전체 설명은 필수 항목입니다.' });
+            }
+            else if (fullDescription.length > 4000) {
+                risks.push({ level: 'warning', code: 'DESC_TOO_LONG', title: '설명 4000자 초과', detail: `현재 ${fullDescription.length}자. 4000자 이내로 줄이세요.` });
+            }
+        }
+        const screenCount = phoneScreenshots?.data?.images?.length ?? 0;
+        if (screenCount === 0) {
+            risks.push({ level: 'blocker', code: 'NO_SCREENSHOTS', title: '전화 스크린샷 없음', detail: '최소 2장 이상의 스크린샷이 필요합니다.' });
+        }
+        else if (screenCount < 2) {
+            risks.push({ level: 'warning', code: 'FEW_SCREENSHOTS', title: `스크린샷 ${screenCount}장 (권장: 4~8장)`, detail: '더 많은 스크린샷이 전환율을 높입니다.' });
+        }
+        if (!icons?.data?.images?.length) {
+            risks.push({ level: 'blocker', code: 'NO_ICON', title: '앱 아이콘 없음', detail: '512×512px PNG 아이콘이 필요합니다.' });
+        }
+        if (!details?.data?.contactEmail) {
+            risks.push({ level: 'warning', code: 'NO_CONTACT_EMAIL', title: '개발자 이메일 없음', detail: 'Play Console에서 개발자 연락처를 설정하세요.' });
+        }
+        const hasBuild = (tracks?.data?.tracks ?? []).some((t) => (t.releases ?? []).some((r) => r.versionCodes && r.versionCodes.length > 0));
+        if (!hasBuild) {
+            risks.push({ level: 'blocker', code: 'NO_BUILD', title: '업로드된 빌드 없음', detail: '내부 테스트 트랙에 APK/AAB를 먼저 업로드하세요.' });
+        }
+        return null;
+    });
+    return risks;
+}
+export async function checkAppStoreRisks(appId) {
+    const risks = [];
+    const versions = await apiGet(`/apps/${appId}/appStoreVersions`, {
+        'filter[appStoreState]': APPSTORE_EDITABLE_STATES,
+        'limit': '5',
+    }).catch(() => null);
+    if (!versions?.data?.length) {
+        risks.push({ level: 'warning', code: 'NO_EDITABLE_VERSION', title: '편집 가능한 버전 없음', detail: 'App Store Connect에서 새 버전을 만드세요.', fixUrl: 'https://appstoreconnect.apple.com' });
+        return risks;
+    }
+    const versionId = versions.data[0].id;
+    const [locs, builds, appInfo] = await Promise.all([
+        apiGet(`/appStoreVersions/${versionId}/appStoreVersionLocalizations`).catch(() => null),
+        apiGet(`/apps/${appId}/builds`, { 'limit': '5', 'sort': '-uploadedDate' }).catch(() => null),
+        apiGet(`/apps/${appId}`, { 'fields[apps]': 'privacyPolicyUrl' }).catch(() => null),
+    ]);
+    if (!locs?.data?.length) {
+        risks.push({ level: 'blocker', code: 'NO_LOCALIZATIONS', title: '로컬라이제이션 없음', detail: '메타데이터를 입력하세요.' });
+    }
+    else {
+        for (const loc of locs.data) {
+            const { locale, description, whatsNew, keywords } = loc.attributes ?? {};
+            if (!description)
+                risks.push({ level: 'blocker', code: `NO_DESC_${locale}`, title: `${locale} 설명 없음`, detail: '앱 설명은 필수 항목입니다.' });
+            if (!whatsNew)
+                risks.push({ level: 'warning', code: `NO_WHATS_NEW_${locale}`, title: `${locale} 새로운 기능 없음`, detail: '릴리즈 노트를 입력하면 다운로드 전환율이 높아집니다.' });
+            if (!keywords)
+                risks.push({ level: 'warning', code: `NO_KEYWORDS_${locale}`, title: `${locale} 키워드 없음`, detail: '키워드는 검색 노출에 직접 영향을 줍니다.' });
+        }
+        // screenshots depend on locs being present
+        const locId = locs.data[0].id;
+        const screenshots = await apiGet(`/appStoreVersionLocalizations/${locId}/appScreenshotSets`).catch(() => null);
+        if (!screenshots?.data?.length) {
+            risks.push({ level: 'blocker', code: 'NO_SCREENSHOTS', title: '스크린샷 없음', detail: 'iPhone 6.5" 또는 6.9" 스크린샷이 필요합니다.' });
+        }
+    }
+    if (!builds?.data?.length) {
+        risks.push({ level: 'blocker', code: 'NO_BUILD', title: 'TestFlight 빌드 없음', detail: 'Xcode 또는 Fastlane으로 빌드를 업로드하세요.' });
+    }
+    if (!appInfo?.data?.attributes?.privacyPolicyUrl) {
+        risks.push({ level: 'blocker', code: 'NO_PRIVACY', title: '개인정보처리방침 URL 없음', detail: 'App Store 가이드라인 5.1.1 — 필수 항목입니다.' });
+    }
+    return risks;
+}
+export function formatRisks(risks, platform) {
+    if (risks.length === 0)
+        return `✅ ${platform} — 제출 위험 요소 없음`;
+    const blockers = risks.filter((r) => r.level === 'blocker');
+    const warnings = risks.filter((r) => r.level === 'warning');
+    const lines = [`📊 ${platform} 제출 위험 분석 (${risks.length}건)\n`];
+    if (blockers.length) {
+        lines.push(`🚫 블로커 ${blockers.length}건 — 반드시 수정해야 제출 가능:`);
+        for (const r of blockers) {
+            lines.push(`  • [${r.code}] ${r.title}\n    ${r.detail}${r.fixUrl ? `\n    → ${r.fixUrl}` : ''}`);
+        }
+        lines.push('');
+    }
+    if (warnings.length) {
+        lines.push(`⚠ 경고 ${warnings.length}건 — 강력 권장:`);
+        for (const r of warnings) {
+            lines.push(`  • [${r.code}] ${r.title}\n    ${r.detail}`);
+        }
+        lines.push('');
+    }
+    if (blockers.length === 0)
+        lines.push('✅ 블로커 없음 — 경고 항목 검토 후 제출 가능');
+    return lines.join('\n');
+}

package/dist/checks/screenshots.d.ts

@@ -0,0 +1,68 @@
+export interface ScreenshotSpec {
+    label: string;
+    width: number;
+    height: number;
+    minWidth?: number;
+    maxWidth?: number;
+    minHeight?: number;
+    maxHeight?: number;
+    maxBytes: number;
+}
+export interface ValidationResult {
+    filePath: string;
+    fileName: string;
+    valid: boolean;
+    issues: string[];
+    info: {
+        sizeBytes: number;
+        detectedWidth?: number;
+        detectedHeight?: number;
+    };
+    matchedSpec?: string;
+}
+export declare const APPSTORE_SPECS: Record<string, ScreenshotSpec>;
+export declare const PLAYSTORE_SPECS: {
+    phoneScreenshots: {
+        label: string;
+        minWidth: number;
+        maxWidth: number;
+        minHeight: number;
+        maxHeight: number;
+        minAspect: number;
+        maxAspect: number;
+        maxBytes: number;
+    };
+    sevenInchScreenshots: {
+        label: string;
+        minWidth: number;
+        maxWidth: number;
+        minHeight: number;
+        maxHeight: number;
+        minAspect: number;
+        maxAspect: number;
+        maxBytes: number;
+    };
+    tenInchScreenshots: {
+        label: string;
+        minWidth: number;
+        maxWidth: number;
+        minHeight: number;
+        maxHeight: number;
+        minAspect: number;
+        maxAspect: number;
+        maxBytes: number;
+    };
+    featureGraphic: {
+        label: string;
+        minWidth: number;
+        maxWidth: number;
+        minHeight: number;
+        maxHeight: number;
+        minAspect: number;
+        maxAspect: number;
+        maxBytes: number;
+    };
+};
+export declare function validateAppStoreScreenshots(filePaths: string[], expectedDisplayType?: string): ValidationResult[];
+export declare function validatePlayStoreScreenshots(filePaths: string[], imageType?: string): ValidationResult[];
+export declare function formatValidationResults(results: ValidationResult[], platform: string): string;

package/dist/checks/screenshots.js

@@ -0,0 +1,168 @@
+import fs from 'node:fs';
+import path from 'node:path';
+export const APPSTORE_SPECS = {
+    'APP_IPHONE_69': { label: 'iPhone 6.9"', width: 1320, height: 2868, maxBytes: 50 * 1024 * 1024 },
+    'APP_IPHONE_67': { label: 'iPhone 6.7"', width: 1290, height: 2796, maxBytes: 50 * 1024 * 1024 },
+    'APP_IPHONE_65': { label: 'iPhone 6.5"', width: 1242, height: 2688, maxBytes: 50 * 1024 * 1024 },
+    'APP_IPHONE_61': { label: 'iPhone 6.1"', width: 1170, height: 2532, maxBytes: 50 * 1024 * 1024 },
+    'APP_IPHONE_58': { label: 'iPhone 5.8"', width: 1125, height: 2436, maxBytes: 50 * 1024 * 1024 },
+    'APP_IPHONE_55': { label: 'iPhone 5.5"', width: 1242, height: 2208, maxBytes: 50 * 1024 * 1024 },
+    'APP_IPAD_PRO_3GEN_129': { label: 'iPad Pro 12.9" (3세대+)', width: 2064, height: 2752, maxBytes: 50 * 1024 * 1024 },
+    'APP_IPAD_PRO_3GEN_11': { label: 'iPad Pro 11"', width: 1668, height: 2388, maxBytes: 50 * 1024 * 1024 },
+    'APP_IPAD_PRO_129': { label: 'iPad Pro 12.9" (2세대)', width: 2048, height: 2732, maxBytes: 50 * 1024 * 1024 },
+    'APP_DESKTOP': { label: 'Mac', minWidth: 1280, maxWidth: 2560, minHeight: 800, maxHeight: 1600, width: 1440, height: 900, maxBytes: 50 * 1024 * 1024 },
+};
+export const PLAYSTORE_SPECS = {
+    phoneScreenshots: { label: '전화 스크린샷', minWidth: 320, maxWidth: 3840, minHeight: 320, maxHeight: 3840, minAspect: 0.5, maxAspect: 2.0, maxBytes: 8 * 1024 * 1024 },
+    sevenInchScreenshots: { label: '7인치 태블릿 스크린샷', minWidth: 320, maxWidth: 3840, minHeight: 320, maxHeight: 3840, minAspect: 0.5, maxAspect: 2.0, maxBytes: 8 * 1024 * 1024 },
+    tenInchScreenshots: { label: '10인치 태블릿 스크린샷', minWidth: 1080, maxWidth: 7680, minHeight: 1080, maxHeight: 7680, minAspect: 0.5, maxAspect: 2.0, maxBytes: 8 * 1024 * 1024 },
+    featureGraphic: { label: '특성 그래픽', minWidth: 1024, maxWidth: 1024, minHeight: 500, maxHeight: 500, minAspect: 2.048, maxAspect: 2.048, maxBytes: 1024 * 1024 },
+};
+const PNG_SIGNATURE = [0x89, 0x50, 0x4e, 0x47];
+function readPngDimensions(filePath) {
+    try {
+        const fd = fs.openSync(filePath, 'r');
+        const buf = Buffer.alloc(24);
+        fs.readSync(fd, buf, 0, 24, 0);
+        fs.closeSync(fd);
+        if (PNG_SIGNATURE.some((b, i) => buf[i] !== b))
+            return null;
+        return { width: buf.readUInt32BE(16), height: buf.readUInt32BE(20) };
+    }
+    catch {
+        return null;
+    }
+}
+function readJpegDimensions(filePath) {
+    try {
+        // JPEG SOF markers typically appear within the first 64KB
+        const fd = fs.openSync(filePath, 'r');
+        const chunk = Buffer.alloc(65536);
+        const bytesRead = fs.readSync(fd, chunk, 0, chunk.length, 0);
+        fs.closeSync(fd);
+        const data = chunk.subarray(0, bytesRead);
+        if (data[0] !== 0xFF || data[1] !== 0xD8)
+            return null;
+        let i = 2;
+        while (i < data.length - 8) {
+            if (data[i] !== 0xFF)
+                break;
+            const marker = data[i + 1];
+            const length = data.readUInt16BE(i + 2);
+            if (marker === 0xC0 || marker === 0xC2) {
+                return { height: data.readUInt16BE(i + 5), width: data.readUInt16BE(i + 7) };
+            }
+            i += 2 + length;
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+function getImageDimensions(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    if (ext === '.png')
+        return readPngDimensions(filePath);
+    if (ext === '.jpg' || ext === '.jpeg')
+        return readJpegDimensions(filePath);
+    return null;
+}
+export function validateAppStoreScreenshots(filePaths, expectedDisplayType) {
+    return filePaths.map((filePath) => {
+        const fileName = path.basename(filePath);
+        const issues = [];
+        if (!fs.existsSync(filePath)) {
+            return { filePath, fileName, valid: false, issues: ['파일 없음'], info: { sizeBytes: 0 } };
+        }
+        const sizeBytes = fs.statSync(filePath).size;
+        const dims = getImageDimensions(filePath);
+        const info = { sizeBytes, detectedWidth: dims?.width, detectedHeight: dims?.height };
+        if (!dims) {
+            return { filePath, fileName, valid: false, issues: ['PNG/JPEG가 아니거나 읽기 실패'], info };
+        }
+        let matchedSpec;
+        if (expectedDisplayType && APPSTORE_SPECS[expectedDisplayType]) {
+            const spec = APPSTORE_SPECS[expectedDisplayType];
+            if (sizeBytes > spec.maxBytes)
+                issues.push(`파일 크기 초과 (최대 ${spec.maxBytes / 1024 / 1024 | 0}MB)`);
+            const wOk = spec.minWidth ? dims.width >= spec.minWidth && dims.width <= (spec.maxWidth ?? Infinity) : dims.width === spec.width;
+            const hOk = spec.minHeight ? dims.height >= spec.minHeight && dims.height <= (spec.maxHeight ?? Infinity) : dims.height === spec.height;
+            if (!wOk || !hOk) {
+                const expected = spec.minWidth ? `${spec.minWidth}~${spec.maxWidth}×${spec.minHeight}~${spec.maxHeight}` : `${spec.width}×${spec.height}`;
+                issues.push(`해상도 불일치 (${spec.label}): 필요 ${expected}, 현재 ${dims.width}×${dims.height}`);
+            }
+            else {
+                matchedSpec = spec.label;
+            }
+        }
+        else {
+            for (const [key, spec] of Object.entries(APPSTORE_SPECS)) {
+                // check both portrait and landscape orientations
+                const fw = dims.width, fh = dims.height;
+                const matches = (w, h) => spec.minWidth ? (w >= spec.minWidth && w <= (spec.maxWidth ?? Infinity) && h >= (spec.minHeight ?? 0) && h <= (spec.maxHeight ?? Infinity))
+                    : (w === spec.width && h === spec.height) || (w === spec.height && h === spec.width);
+                if (matches(fw, fh)) {
+                    matchedSpec = `${key} (${spec.label})`;
+                    break;
+                }
+            }
+            if (!matchedSpec) {
+                issues.push(`알 수 없는 해상도 ${dims.width}×${dims.height} — Apple 스펙과 일치하지 않음`);
+            }
+            if (sizeBytes > 50 * 1024 * 1024)
+                issues.push('파일 크기 50MB 초과');
+        }
+        return { filePath, fileName, valid: issues.length === 0, issues, info, matchedSpec };
+    });
+}
+export function validatePlayStoreScreenshots(filePaths, imageType = 'phoneScreenshots') {
+    if (!(imageType in PLAYSTORE_SPECS)) {
+        return filePaths.map((fp) => ({
+            filePath: fp, fileName: path.basename(fp), valid: false,
+            issues: [`알 수 없는 imageType: ${imageType}. 유효값: ${Object.keys(PLAYSTORE_SPECS).join(', ')}`],
+            info: { sizeBytes: 0 },
+        }));
+    }
+    const spec = PLAYSTORE_SPECS[imageType];
+    return filePaths.map((filePath) => {
+        const fileName = path.basename(filePath);
+        const issues = [];
+        if (!fs.existsSync(filePath)) {
+            return { filePath, fileName, valid: false, issues: ['파일 없음'], info: { sizeBytes: 0 } };
+        }
+        const sizeBytes = fs.statSync(filePath).size;
+        if (sizeBytes > spec.maxBytes) {
+            issues.push(`파일 크기 초과: ${(sizeBytes / 1024 / 1024).toFixed(1)}MB (최대 ${(spec.maxBytes / 1024 / 1024).toFixed(0)}MB)`);
+        }
+        const dims = getImageDimensions(filePath);
+        const info = { sizeBytes, detectedWidth: dims?.width, detectedHeight: dims?.height };
+        if (!dims)
+            return { filePath, fileName, valid: false, issues: ['PNG/JPEG가 아니거나 읽기 실패', ...issues], info };
+        if (dims.width < spec.minWidth || dims.width > spec.maxWidth) {
+            issues.push(`너비 범위 초과: ${dims.width}px (${spec.minWidth}~${spec.maxWidth}px 필요)`);
+        }
+        if (dims.height < spec.minHeight || dims.height > spec.maxHeight) {
+            issues.push(`높이 범위 초과: ${dims.height}px (${spec.minHeight}~${spec.maxHeight}px 필요)`);
+        }
+        const ar = dims.width / dims.height;
+        if (ar < spec.minAspect || ar > spec.maxAspect) {
+            issues.push(`종횡비 범위 초과: ${ar.toFixed(2)} (${spec.minAspect}~${spec.maxAspect} 필요)`);
+        }
+        return { filePath, fileName, valid: issues.length === 0, issues, info };
+    });
+}
+export function formatValidationResults(results, platform) {
+    const passed = results.filter((r) => r.valid).length;
+    const lines = [`📐 ${platform} 스크린샷 검증: ${passed}/${results.length} 통과\n`];
+    for (const r of results) {
+        const dims = r.info.detectedWidth ? ` (${r.info.detectedWidth}×${r.info.detectedHeight})` : '';
+        const size = ` ${(r.info.sizeBytes / 1024).toFixed(0)}KB`;
+        lines.push(`${r.valid ? '✅' : '❌'} ${r.fileName}${dims}${size}`);
+        if (r.matchedSpec)
+            lines.push(`   → ${r.matchedSpec}`);
+        for (const issue of r.issues)
+            lines.push(`   ⚠ ${issue}`);
+    }
+    return lines.join('\n');
+}

package/dist/iam/tools.d.ts

@@ -0,0 +1,45 @@
+import type { OAuth2Client } from 'google-auth-library';
+export declare function listServiceAccounts(auth: OAuth2Client, projectId: string): Promise<{
+    email: string | null | undefined;
+    displayName: string | null | undefined;
+    uniqueId: string | null | undefined;
+    disabled: boolean;
+}[]>;
+export declare function createServiceAccount(auth: OAuth2Client, projectId: string, accountId: string, displayName: string): Promise<{
+    email: string | null | undefined;
+    uniqueId: string | null | undefined;
+    displayName: string | null | undefined;
+    projectId: string | null | undefined;
+}>;
+export declare function createServiceAccountKey(auth: OAuth2Client, serviceAccountEmail: string): Promise<{
+    keyId: string | null;
+    clientEmail: string | undefined;
+    projectId: string | undefined;
+    json: string;
+}>;
+export declare function listServiceAccountKeys(auth: OAuth2Client, serviceAccountEmail: string): Promise<{
+    id: string | null;
+    keyType: string | null | undefined;
+    validBeforeTime: string | null | undefined;
+    validAfterTime: string | null | undefined;
+}[]>;
+/**
+ * 프로젝트의 IAM 정책을 read-modify-write 해서 member에게 role 부여.
+ * 이미 같은 (role, member) 바인딩이 있으면 no-op.
+ *
+ * member 예:
+ *   'serviceAccount:my-sa@my-project.iam.gserviceaccount.com'
+ *   'user:alice@example.com'
+ *   'group:admins@example.com'
+ *
+ * 자주 쓰는 role 예:
+ *   'roles/iam.serviceAccountUser'         — 서비스 계정으로 위임 가능
+ *   'roles/iam.serviceAccountTokenCreator' — 서비스 계정의 단기 토큰 발급
+ *   'roles/editor' / 'roles/owner'         — 광범위 (조심)
+ */
+export declare function addProjectIamPolicyBinding(auth: OAuth2Client, projectId: string, member: string, role: string): Promise<{
+    added: boolean;
+    role: string;
+    member: string;
+    etag: string | null | undefined;
+}>;

package/dist/iam/tools.js

@@ -0,0 +1,126 @@
+import { google } from 'googleapis';
+/**
+ * Google Cloud IAM + Cloud Resource Manager 래퍼.
+ *
+ * 사용자가 mimi-seed-mcp로 "서비스 계정 만들기 → JSON 키 발급 → Cloud IAM
+ * 역할 부여"를 자동화할 때 쓰는 도구들. (Play Console의 'View financial
+ * data' 권한은 여기서 부여하는 Cloud IAM 역할과는 별개 — 그건 Play Console
+ * Users and permissions에서 androidpublisher.users API 또는 수동으로.)
+ */
+const iam = () => google.iam('v1');
+const crm = () => google.cloudresourcemanager('v1');
+// ─── 서비스 계정 조회 ───
+export async function listServiceAccounts(auth, projectId) {
+    const res = await iam().projects.serviceAccounts.list({
+        auth,
+        name: `projects/${projectId}`,
+        pageSize: 100,
+    });
+    return (res.data.accounts ?? []).map((a) => ({
+        email: a.email,
+        displayName: a.displayName,
+        uniqueId: a.uniqueId,
+        disabled: a.disabled ?? false,
+    }));
+}
+// ─── 서비스 계정 생성 ───
+export async function createServiceAccount(auth, projectId, accountId, displayName) {
+    const res = await iam().projects.serviceAccounts.create({
+        auth,
+        name: `projects/${projectId}`,
+        requestBody: {
+            accountId,
+            serviceAccount: { displayName },
+        },
+    });
+    return {
+        email: res.data.email,
+        uniqueId: res.data.uniqueId,
+        displayName: res.data.displayName,
+        projectId: res.data.projectId,
+    };
+}
+// ─── 키 발급 (JSON 다운로드) ───
+export async function createServiceAccountKey(auth, serviceAccountEmail) {
+    const res = await iam().projects.serviceAccounts.keys.create({
+        auth,
+        name: `projects/-/serviceAccounts/${serviceAccountEmail}`,
+        requestBody: {
+            keyAlgorithm: 'KEY_ALG_RSA_2048',
+            privateKeyType: 'TYPE_GOOGLE_CREDENTIALS_FILE',
+        },
+    });
+    // privateKeyData는 base64로 인코딩된 JSON 전체 — 디코딩해서 반환.
+    // 주의: 이 JSON은 영구 자격증명이므로 절대 로그에 남기거나 원격으로 보내면 안 됨.
+    const privateKeyData = res.data.privateKeyData;
+    if (!privateKeyData)
+        throw new Error('No privateKeyData in response');
+    const jsonString = Buffer.from(privateKeyData, 'base64').toString('utf-8');
+    // 파싱해서 필드 일부만 미리보기로 노출 + 전체 JSON도 함께 반환
+    const parsed = JSON.parse(jsonString);
+    return {
+        keyId: res.data.name?.split('/').pop() ?? null,
+        clientEmail: parsed.client_email,
+        projectId: parsed.project_id,
+        json: jsonString,
+    };
+}
+// ─── 키 목록 ───
+export async function listServiceAccountKeys(auth, serviceAccountEmail) {
+    const res = await iam().projects.serviceAccounts.keys.list({
+        auth,
+        name: `projects/-/serviceAccounts/${serviceAccountEmail}`,
+    });
+    return (res.data.keys ?? []).map((k) => ({
+        id: k.name?.split('/').pop() ?? null,
+        keyType: k.keyType, // 'USER_MANAGED' | 'SYSTEM_MANAGED'
+        validBeforeTime: k.validBeforeTime,
+        validAfterTime: k.validAfterTime,
+    }));
+}
+// ─── 프로젝트 IAM 정책에 역할 바인딩 추가 ───
+/**
+ * 프로젝트의 IAM 정책을 read-modify-write 해서 member에게 role 부여.
+ * 이미 같은 (role, member) 바인딩이 있으면 no-op.
+ *
+ * member 예:
+ *   'serviceAccount:my-sa@my-project.iam.gserviceaccount.com'
+ *   'user:alice@example.com'
+ *   'group:admins@example.com'
+ *
+ * 자주 쓰는 role 예:
+ *   'roles/iam.serviceAccountUser'         — 서비스 계정으로 위임 가능
+ *   'roles/iam.serviceAccountTokenCreator' — 서비스 계정의 단기 토큰 발급
+ *   'roles/editor' / 'roles/owner'         — 광범위 (조심)
+ */
+export async function addProjectIamPolicyBinding(auth, projectId, member, role) {
+    const current = await crm().projects.getIamPolicy({
+        auth,
+        resource: projectId,
+        requestBody: {},
+    });
+    const policy = current.data;
+    const bindings = policy.bindings ?? [];
+    const existing = bindings.find((b) => b.role === role);
+    let added = false;
+    if (existing) {
+        const members = existing.members ?? [];
+        if (!members.includes(member)) {
+            existing.members = [...members, member];
+            added = true;
+        }
+    }
+    else {
+        bindings.push({ role, members: [member] });
+        added = true;
+    }
+    if (!added) {
+        return { added: false, role, member, etag: policy.etag };
+    }
+    const updated = await crm().projects.setIamPolicy({
+        auth,
+        resource: projectId,
+        requestBody: { policy: { bindings, etag: policy.etag } },
+    });
+    return { added: true, role, member, etag: updated.data.etag };
+}