@yoonion/mimi-seed-mcp 0.3.14 → 0.3.16

package/dist/appstore/tools.js

@@ -395,20 +395,16 @@ async function getVersionAppAndPlatform(versionId) {
     return { appId, platform };
 }
 async function findOpenReviewSubmission(appId, platform) {
+    // ASC API는 filter[state]=CREATED를 더 이상 허용하지 않음 (READY_FOR_REVIEW, WAITING_FOR_REVIEW 등만 허용).
+    // CREATED 상태 submission은 별도로 조회 불가 → 이미 진행 중인 submission만 재사용.
+    // 없으면 submitVersionForReview가 새로 생성.
     const data = await apiGet('/reviewSubmissions', {
         'filter[app]': appId,
         'filter[platform]': platform,
-        'filter[state]': 'READY_FOR_REVIEW,COMPLETING,UNRESOLVED_ISSUES',
+        'filter[state]': 'READY_FOR_REVIEW,WAITING_FOR_REVIEW,COMPLETING,UNRESOLVED_ISSUES',
         'limit': '1',
     });
-    // CREATED 상태(아직 제출 안 된)도 별도 조회해서 우선 재사용
-    const created = await apiGet('/reviewSubmissions', {
-        'filter[app]': appId,
-        'filter[platform]': platform,
-        'filter[state]': 'CREATED',
-        'limit': '1',
-    });
-    return created?.data?.[0]?.id ?? data?.data?.[0]?.id ?? null;
+    return data?.data?.[0]?.id ?? null;
 }
 async function isVersionAttached(submissionId, versionId) {
     const data = await apiGet(`/reviewSubmissions/${submissionId}/items`, {

package/dist/bigquery/tools.d.ts

@@ -0,0 +1,29 @@
+import type { OAuth2Client } from 'google-auth-library';
+export declare function runQuery(auth: OAuth2Client, projectId: string, query: string, maxResults?: number): Promise<{
+    jobComplete: boolean | null | undefined;
+    totalRows: string | null | undefined;
+    schema: {
+        name: string | null | undefined;
+        type: string | null | undefined;
+    }[];
+    rows: {
+        [k: string]: any;
+    }[];
+}>;
+export declare function listDatasets(auth: OAuth2Client, projectId: string): Promise<{
+    datasetId: string | null | undefined;
+    location: string | undefined;
+}[]>;
+export declare function listTables(auth: OAuth2Client, projectId: string, datasetId: string): Promise<{
+    tableId: string | null | undefined;
+    type: string | undefined;
+}[]>;
+export declare function getTableSchema(auth: OAuth2Client, projectId: string, datasetId: string, tableId: string): Promise<{
+    tableId: string;
+    schema: {
+        name: string | null | undefined;
+        type: string | null | undefined;
+        mode: string | null | undefined;
+        description: string | null | undefined;
+    }[] | undefined;
+}>;

package/dist/bigquery/tools.js

@@ -0,0 +1,53 @@
+import { google } from 'googleapis';
+const bq = () => google.bigquery('v2');
+// ─── 쿼리 실행 ───
+export async function runQuery(auth, projectId, query, maxResults = 1000) {
+    const res = await bq().jobs.query({
+        auth,
+        projectId,
+        requestBody: {
+            query,
+            useLegacySql: false,
+            maxResults,
+            timeoutMs: 30000,
+        },
+    });
+    const data = res.data;
+    const schema = data.schema?.fields ?? [];
+    const rows = (data.rows ?? []).map((row) => Object.fromEntries((row.f ?? []).map((cell, i) => [schema[i]?.name ?? `col${i}`, cell.v])));
+    return {
+        jobComplete: data.jobComplete,
+        totalRows: data.totalRows,
+        schema: schema.map((f) => ({ name: f.name, type: f.type })),
+        rows,
+    };
+}
+// ─── 데이터셋 목록 ───
+export async function listDatasets(auth, projectId) {
+    const res = await bq().datasets.list({ auth, projectId });
+    return (res.data.datasets ?? []).map((d) => ({
+        datasetId: d.datasetReference?.datasetId,
+        location: d.location,
+    }));
+}
+// ─── 테이블 목록 ───
+export async function listTables(auth, projectId, datasetId) {
+    const res = await bq().tables.list({ auth, projectId, datasetId });
+    return (res.data.tables ?? []).map((t) => ({
+        tableId: t.tableReference?.tableId,
+        type: t.type,
+    }));
+}
+// ─── 테이블 스키마 ───
+export async function getTableSchema(auth, projectId, datasetId, tableId) {
+    const res = await bq().tables.get({ auth, projectId, datasetId, tableId });
+    return {
+        tableId,
+        schema: res.data.schema?.fields?.map((f) => ({
+            name: f.name,
+            type: f.type,
+            mode: f.mode,
+            description: f.description,
+        })),
+    };
+}

package/dist/checks/risks.js

@@ -53,21 +53,42 @@ export async function checkPlayStoreRisks(auth, packageName, language = 'ko-KR')
     });
     return risks;
 }
+// Apple의 ASC API 호출은 권한·필드명·deprecated endpoint 등으로 실패할 수 있다.
+// 실패를 silent하게 null로 만들면 후속 check가 false-positive blocker를 토해낸다 —
+// 이 헬퍼는 실패 사실을 risks 배열에 warning으로 기록해 사용자에게 노출시키되,
+// 호출부는 null을 받아 blocker 분기를 건너뛸 수 있게 해준다.
+async function safeGet(call, risks, code, title) {
+    try {
+        return await call();
+    }
+    catch (e) {
+        risks.push({
+            level: 'warning',
+            code: `API_ERROR_${code}`,
+            title: `App Store Connect 조회 실패 — ${title}`,
+            detail: `이 항목은 위험 분석에서 제외됨. 원인: ${e instanceof Error ? e.message : String(e)}`,
+        });
+        return null;
+    }
+}
+const APP_INFO_LIVE_STATE = 'READY_FOR_DISTRIBUTION';
 export async function checkAppStoreRisks(appId) {
     const risks = [];
-    const versions = await apiGet(`/apps/${appId}/appStoreVersions`, {
+    const versions = await safeGet(() => apiGet(`/apps/${appId}/appStoreVersions`, {
         'filter[appStoreState]': APPSTORE_EDITABLE_STATES,
         'limit': '5',
-    }).catch(() => null);
+    }), risks, 'VERSIONS', '편집 가능한 버전 목록');
     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),
+    // 1) 메타데이터·스크린샷·버전 첨부 빌드는 versionId 기반으로 조회.
+    // 2) 개인정보 URL은 appInfoLocalization 단위(앱 단위)로 조회.
+    const [locs, attachedBuildRel, appInfos] = await Promise.all([
+        safeGet(() => apiGet(`/appStoreVersions/${versionId}/appStoreVersionLocalizations`), risks, 'LOCALIZATIONS', '버전 로컬라이제이션'),
+        safeGet(() => apiGet(`/appStoreVersions/${versionId}/relationships/build`), risks, 'BUILD', '버전 첨부 빌드'),
+        safeGet(() => apiGet(`/apps/${appId}/appInfos`, { 'fields[appInfos]': 'state', 'limit': '10' }), risks, 'APP_INFO', '앱 정보'),
     ]);
     if (!locs?.data?.length) {
         risks.push({ level: 'blocker', code: 'NO_LOCALIZATIONS', title: '로컬라이제이션 없음', detail: '메타데이터를 입력하세요.' });
@@ -84,16 +105,49 @@ export async function checkAppStoreRisks(appId) {
         }
         // 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) {
+        const screenshots = await safeGet(() => apiGet(`/appStoreVersionLocalizations/${locId}/appScreenshotSets`), risks, 'SCREENSHOTS', '스크린샷 셋');
+        if (screenshots && !screenshots?.data?.length) {
             risks.push({ level: 'blocker', code: 'NO_SCREENSHOTS', title: '스크린샷 없음', detail: 'iPhone 6.5" 또는 6.9" 스크린샷이 필요합니다.' });
         }
     }
-    if (!builds?.data?.length) {
+    // 빌드 — 1차: 버전에 첨부된 빌드. 2차 폴백: 앱 전체 빌드 (예전 동작).
+    // attachedBuildRel?.data가 null이면 "관계 조회 성공 + 첨부 안 됨" 의미.
+    // attachedBuildRel 자체가 null이면 safeGet 실패 — fall back.
+    let buildVerdict;
+    if (attachedBuildRel) {
+        buildVerdict = attachedBuildRel.data ? 'present' : 'missing';
+    }
+    else {
+        const fallbackBuilds = await safeGet(() => apiGet(`/builds`, {
+            'filter[app]': appId,
+            'fields[builds]': 'version,uploadedDate,processingState',
+            'sort': '-uploadedDate',
+            'limit': '5',
+        }), risks, 'BUILDS_FALLBACK', '앱 빌드 목록(폴백)');
+        buildVerdict = fallbackBuilds?.data?.length ? 'present' : fallbackBuilds ? 'missing' : 'unknown';
+    }
+    if (buildVerdict === 'missing') {
         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 — 필수 항목입니다.' });
+    // 개인정보처리방침 — appInfoLocalization 어디 한 곳이라도 URL 또는 in-app 텍스트가 있으면 OK.
+    // appInfos 조회 자체가 실패하면 unknown으로 두고 blocker 안 띄움 (warning만 기록됨).
+    if (appInfos) {
+        const infos = (appInfos.data ?? []);
+        const stateOf = (i) => i.attributes?.state ?? i.attributes?.appStoreState ?? '';
+        const editable = infos.find((i) => stateOf(i) !== APP_INFO_LIVE_STATE) ?? infos[0];
+        if (editable) {
+            const localizations = await safeGet(() => apiGet(`/appInfos/${editable.id}/appInfoLocalizations`, {
+                'fields[appInfoLocalizations]': 'locale,privacyPolicyUrl,privacyPolicyText',
+                'limit': '200',
+            }), risks, 'PRIVACY', '개인정보 로컬라이제이션');
+            if (localizations) {
+                const locs = (localizations.data ?? []);
+                const hasPrivacy = locs.some((l) => l.attributes?.privacyPolicyUrl || l.attributes?.privacyPolicyText);
+                if (!hasPrivacy) {
+                    risks.push({ level: 'blocker', code: 'NO_PRIVACY', title: '개인정보처리방침 URL 없음', detail: 'App Store 가이드라인 5.1.1 — 필수 항목입니다. 모든 로컬라이제이션에서 privacyPolicyUrl 또는 privacyPolicyText 중 하나를 입력하세요.' });
+                }
+            }
+        }
     }
     return risks;
 }

package/dist/index.js

@@ -13,6 +13,7 @@ import * as playstore from './playstore/tools.js';
 import * as appstore from './appstore/tools.js';
 import * as appstoreScreenshots from './appstore/screenshots.js';
 import * as iam from './iam/tools.js';
+import * as bigquery from './bigquery/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';
@@ -1407,9 +1408,73 @@ server.tool('generate_review_reply', [
     return { content: [{ type: 'text', text }] };
 });
 // ══════════════════════════════════════════════════
+// BigQuery
+// ══════════════════════════════════════════════════
+server.tool('bigquery_run_query', 'BigQuery SQL 쿼리 실행 (SELECT). GA4 analytics_* 테이블 분석에 사용.', {
+    projectId: z.string().describe('GCP 프로젝트 ID (예: ads-coffee)'),
+    query: z.string().describe('실행할 StandardSQL 쿼리'),
+    maxResults: z.number().optional().describe('최대 행 수 (기본 1000)'),
+}, async ({ projectId, query, maxResults }) => {
+    const auth = requireAuth();
+    const result = await bigquery.runQuery(auth, projectId, query, maxResults ?? 1000);
+    return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+});
+server.tool('bigquery_list_datasets', 'BigQuery 프로젝트의 데이터셋 목록 조회', {
+    projectId: z.string().describe('GCP 프로젝트 ID'),
+}, async ({ projectId }) => {
+    const auth = requireAuth();
+    const datasets = await bigquery.listDatasets(auth, projectId);
+    return { content: [{ type: 'text', text: JSON.stringify(datasets, null, 2) }] };
+});
+server.tool('bigquery_list_tables', 'BigQuery 데이터셋의 테이블 목록 조회', {
+    projectId: z.string().describe('GCP 프로젝트 ID'),
+    datasetId: z.string().describe('데이터셋 ID (예: analytics_530080532)'),
+}, async ({ projectId, datasetId }) => {
+    const auth = requireAuth();
+    const tables = await bigquery.listTables(auth, projectId, datasetId);
+    return { content: [{ type: 'text', text: JSON.stringify(tables, null, 2) }] };
+});
+server.tool('bigquery_get_table_schema', 'BigQuery 테이블 스키마(컬럼 정보) 조회', {
+    projectId: z.string().describe('GCP 프로젝트 ID'),
+    datasetId: z.string().describe('데이터셋 ID'),
+    tableId: z.string().describe('테이블 ID'),
+}, async ({ projectId, datasetId, tableId }) => {
+    const auth = requireAuth();
+    const schema = await bigquery.getTableSchema(auth, projectId, datasetId, tableId);
+    return { content: [{ type: 'text', text: JSON.stringify(schema, null, 2) }] };
+});
+// ══════════════════════════════════════════════════
 // Start
 // ══════════════════════════════════════════════════
+// `npx -y @yoonion/mimi-seed-mcp <subcommand>` 처리.
+// npx는 스코프 패키지의 basename(`mimi-seed-mcp`)을 매치해 이 bin을 실행하므로,
+// 추가 인자(`mimi-seed-auth` 등)는 여기 argv로 흘러들어온다. 이전엔 MCP 서버가
+// stdin을 기다리며 영구 hang 됐다 — 이제 sub-CLI로 위임한다.
+const SUBCOMMANDS = {
+    'mimi-seed-auth': () => import('./auth/cli.js'),
+    'mimi-seed-playstore-auth': () => import('./auth/playstore-setup-cli.js'),
+    'mimi-seed-appstore-auth': () => import('./appstore/setup-cli.js'),
+};
 async function main() {
+    const sub = process.argv[2];
+    if (sub && SUBCOMMANDS[sub]) {
+        // argv에서 subcommand 토큰 제거 후 sub-CLI 모듈 import — 모듈 top-level이 main() 실행
+        process.argv.splice(2, 1);
+        await SUBCOMMANDS[sub]();
+        return;
+    }
+    if (sub && !sub.startsWith('-')) {
+        console.error([
+            `❌ Unknown subcommand: ${sub}`,
+            '',
+            'Available:',
+            ...Object.keys(SUBCOMMANDS).map((k) => `  npx -y @yoonion/mimi-seed-mcp ${k}`),
+            '',
+            'Or run the MCP server (no args):',
+            '  npx -y @yoonion/mimi-seed-mcp',
+        ].join('\n'));
+        process.exit(2);
+    }
     const transport = new StdioServerTransport();
     await server.connect(transport);
 }

package/package.json

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