@yoonion/mimi-seed-mcp 0.3.40 → 0.4.0

package/dist/admob/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/admob/cli.js

@@ -0,0 +1,53 @@
+#!/usr/bin/env node
+// mimi-seed-admob — AdMob sub-CLI (계정/앱/광고단위 조회 + v1beta 생성).
+// 사용자 진입점은 `mimi-seed admob <subcommand>`.
+// ⚠️ create-* 는 AdMob v1beta(Limited Access)라 계정 allowlist 미승인 시 403 → 콘솔 수동 폴백.
+import { requireAuth } from '../helpers.js';
+import * as admob from './tools.js';
+import { runDomainCli, requireFlag, flag, CliUsageError } from '../lib/cli-args.js';
+const HELP = `
+  💰 mimi-seed-admob — AdMob attach
+
+  사용법:
+    mimi-seed admob accounts
+        AdMob 계정 목록 (accountId 확인 — accounts/pub-XXXX)
+
+    mimi-seed admob apps --account <id>
+    mimi-seed admob ad-units --account <id>
+        등록된 앱 / 광고 단위 목록
+
+    mimi-seed admob create-app --account <id> --platform <ANDROID|IOS> --name <displayName>
+                               [--store-id com.x.y | 123456789]
+        앱 등록 (store-id 주면 스토어 링크). ⚠️ v1beta Limited Access — 403 가능
+
+    mimi-seed admob create-ad-unit --account <id> --app <appId> --name <name>
+                                   --format <BANNER|INTERSTITIAL|REWARDED|REWARDED_INTERSTITIAL|APP_OPEN|NATIVE>
+        광고 단위 생성. ⚠️ v1beta Limited Access — 403 가능
+
+  인증: npx -y @yoonion/mimi-seed-mcp mimi-seed-auth
+`;
+const AD_FORMATS = ['BANNER', 'INTERSTITIAL', 'REWARDED', 'REWARDED_INTERSTITIAL', 'APP_OPEN', 'NATIVE'];
+runDomainCli({
+    binName: 'mimi-seed-admob',
+    argv: process.argv.slice(2),
+    help: HELP,
+    handlers: {
+        accounts: async () => admob.listAccounts(await requireAuth()),
+        apps: async (p) => admob.listApps(await requireAuth(), requireFlag(p, 'account')),
+        'ad-units': async (p) => admob.listAdUnits(await requireAuth(), requireFlag(p, 'account')),
+        'create-app': async (p) => {
+            const platform = requireFlag(p, 'platform').toUpperCase();
+            if (platform !== 'ANDROID' && platform !== 'IOS') {
+                throw new CliUsageError('--platform 은 ANDROID | IOS 여야 합니다.');
+            }
+            return admob.createApp(await requireAuth(), requireFlag(p, 'account'), platform, requireFlag(p, 'name'), flag(p, 'store-id'));
+        },
+        'create-ad-unit': async (p) => {
+            const format = requireFlag(p, 'format').toUpperCase();
+            if (!AD_FORMATS.includes(format)) {
+                throw new CliUsageError(`--format 은 ${AD_FORMATS.join(' | ')} 중 하나여야 합니다.`);
+            }
+            return admob.createAdUnit(await requireAuth(), requireFlag(p, 'account'), requireFlag(p, 'app'), requireFlag(p, 'name'), format);
+        },
+    },
+});

package/dist/admob/tools.d.ts

@@ -35,5 +35,15 @@ export declare function getNetworkReport(auth: OAuth2Client, accountId: string,
     day: number;
 }): Promise<import("googleapis").admob_v1.Schema$GenerateNetworkReportResponse>;
 export declare function getTodayEarnings(auth: OAuth2Client, accountId: string): Promise<import("googleapis").admob_v1.Schema$GenerateNetworkReportResponse>;
-export declare function createApp(auth: OAuth2Client, accountId: string, platform: 'ANDROID' | 'IOS', displayName: string): Promise<any>;
-export declare function createAdUnit(auth: OAuth2Client, accountId: string, appId: string, displayName: string, adFormat: 'BANNER' | 'INTERSTITIAL' | 'REWARDED' | 'REWARDED_INTERSTITIAL' | 'APP_OPEN' | 'NATIVE'): Promise<any>;
+export type AdFormat = 'BANNER' | 'INTERSTITIAL' | 'REWARDED' | 'REWARDED_INTERSTITIAL' | 'APP_OPEN' | 'NATIVE';
+/**
+ * adFormat → adTypes 파생 (순수 함수 — 테스트 대상).
+ * AdMob v1beta adTypes 의 유효값은 'RICH_MEDIA'(텍스트·이미지 등 비동영상)와 'VIDEO' 둘뿐
+ * (Schema$AdUnit.adTypes 문서). 동영상 지원 포맷은 VIDEO 를 포함하고,
+ * REWARDED_INTERSTITIAL 은 문서상 video-only 다.
+ */
+export declare function adTypesForFormat(adFormat: AdFormat): string[];
+export declare function createApp(auth: OAuth2Client, accountId: string, platform: 'ANDROID' | 'IOS', displayName: string, 
+/** 스토어에 게시된 앱이면 store ID 로 링크 (Android=패키지명, iOS=App Store 숫자 ID). 없으면 manual(unlinked) 앱. */
+appStoreId?: string): Promise<any>;
+export declare function createAdUnit(auth: OAuth2Client, accountId: string, appId: string, displayName: string, adFormat: AdFormat): Promise<any>;

package/dist/admob/tools.js

@@ -91,17 +91,42 @@ export async function getTodayEarnings(auth, accountId) {
     const today = { year: now.getFullYear(), month: now.getMonth() + 1, day: now.getDate() };
     return getNetworkReport(auth, accountId, today, today);
 }
-// ─── v1beta: 앱 생성 (Limited Access) ───
-export async function createApp(auth, accountId, platform, displayName) {
+/**
+ * adFormat → adTypes 파생 (순수 함수 — 테스트 대상).
+ * AdMob v1beta adTypes 의 유효값은 'RICH_MEDIA'(텍스트·이미지 등 비동영상)와 'VIDEO' 둘뿐
+ * (Schema$AdUnit.adTypes 문서). 동영상 지원 포맷은 VIDEO 를 포함하고,
+ * REWARDED_INTERSTITIAL 은 문서상 video-only 다.
+ */
+export function adTypesForFormat(adFormat) {
+    switch (adFormat) {
+        case 'INTERSTITIAL':
+        case 'REWARDED':
+        case 'APP_OPEN':
+            return ['RICH_MEDIA', 'VIDEO'];
+        case 'REWARDED_INTERSTITIAL':
+            return ['VIDEO'];
+        case 'BANNER':
+        case 'NATIVE':
+        default:
+            return ['RICH_MEDIA'];
+    }
+}
+export async function createApp(auth, accountId, platform, displayName, 
+/** 스토어에 게시된 앱이면 store ID 로 링크 (Android=패키지명, iOS=App Store 숫자 ID). 없으면 manual(unlinked) 앱. */
+appStoreId) {
     // v1beta — 대부분 계정에서 403. Google Account Manager 승인 필요.
     const admobBeta = google.admob('v1beta');
+    const requestBody = { platform };
+    // manualAppInfo.displayName 은 writable(사용자 제공, AdMob UI 표시명) — linking 후에도 유지된다.
+    // linkedAppInfo.displayName 은 output-only(스토어 표시명)라 보내도 무시되므로, store 링크엔 appStoreId 만 넣는다.
+    requestBody.manualAppInfo = { displayName };
+    if (appStoreId) {
+        requestBody.linkedAppInfo = { appStoreId };
+    }
     const res = await admobBeta.accounts.apps.create({
         auth,
         parent: accountId,
-        requestBody: {
-            platform,
-            manualAppInfo: { displayName },
-        },
+        requestBody,
     });
     return res.data;
 }
@@ -115,7 +140,7 @@ export async function createAdUnit(auth, accountId, appId, displayName, adFormat
             appId,
             displayName,
             adFormat,
-            adTypes: ['DISPLAY'],
+            adTypes: adTypesForFormat(adFormat),
         },
     });
     return res.data;

package/dist/auth/errors.d.ts

@@ -1,4 +1,4 @@
-export type AuthErrorCode = 'UNAUTHENTICATED' | 'NO_REFRESH_TOKEN' | 'INVALID_GRANT' | 'RAPT_REQUIRED' | 'INVALID_CLIENT' | 'UNAUTHORIZED_CLIENT' | 'REFRESH_NETWORK_ERROR' | 'REFRESH_UNKNOWN' | 'CALLBACK_PORT_IN_USE' | 'CALLBACK_TIMEOUT' | 'BROWSER_OPEN_FAILED' | 'USER_DENIED' | 'CODE_EXCHANGE_FAILED' | 'TOKEN_RESPONSE_INVALID';
+export type AuthErrorCode = 'UNAUTHENTICATED' | 'NO_REFRESH_TOKEN' | 'INVALID_GRANT' | 'RAPT_REQUIRED' | 'INVALID_CLIENT' | 'UNAUTHORIZED_CLIENT' | 'REFRESH_NETWORK_ERROR' | 'REFRESH_UNKNOWN' | 'INSUFFICIENT_SCOPE' | 'CALLBACK_PORT_IN_USE' | 'CALLBACK_TIMEOUT' | 'BROWSER_OPEN_FAILED' | 'USER_DENIED' | 'CODE_EXCHANGE_FAILED' | 'TOKEN_RESPONSE_INVALID';
 export interface AuthErrorPayload {
     code: AuthErrorCode;
     message: string;

package/dist/auth/google-auth.d.ts

@@ -4,6 +4,8 @@ export interface StoredTokens {
     refresh_token: string;
     token_type: string;
     expiry_date: number;
+    /** 공백 구분 부여 스코프. 신규 도구(GA4 등) pre-flight 스코프 검사에 사용. 구 토큰은 undefined. */
+    scope?: string;
 }
 export declare function getStoredCredentials(): {
     clientId: string;

package/dist/auth/google-auth.js

@@ -14,6 +14,7 @@ const SCOPES = [
     'https://www.googleapis.com/auth/androidpublisher',
     'https://www.googleapis.com/auth/adwords', // Google Ads API (googleads_* tools)
     'https://www.googleapis.com/auth/webmasters', // Search Console API (gsc_* tools, 사이트맵 제출 포함)
+    'https://www.googleapis.com/auth/analytics.edit', // GA4 Analytics Admin API (ga4_* tools — property/data stream 생성·조회)
 ];
 // Primary config dir. Legacy `~/.preseed` is read as a fallback during the
 // rebrand so existing auth sessions don't force a re-login; new writes go to
@@ -112,6 +113,7 @@ export function getAuthenticatedClient() {
                 ...(newTokens.access_token && { access_token: newTokens.access_token }),
                 ...(newTokens.refresh_token && { refresh_token: newTokens.refresh_token }),
                 ...(newTokens.expiry_date && { expiry_date: newTokens.expiry_date }),
+                ...(newTokens.scope && { scope: newTokens.scope }),
             });
         }
     });
@@ -209,6 +211,7 @@ export function startAuth(clientId, clientSecret, options = {}) {
                     refresh_token: tokens.refresh_token,
                     token_type: tokens.token_type ?? 'Bearer',
                     expiry_date: tokens.expiry_date ?? Date.now() + 3600_000,
+                    ...(tokens.scope && { scope: tokens.scope }),
                 };
                 saveTokens(stored);
                 res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
@@ -327,6 +330,8 @@ export async function ensureFreshAccessToken(marginMs = 300_000) {
             refresh_token: credentials.refresh_token ?? tokens.refresh_token,
             token_type: credentials.token_type ?? tokens.token_type ?? 'Bearer',
             expiry_date: credentials.expiry_date ?? Date.now() + 3600_000,
+            // refresh 응답은 scope 를 생략할 수 있으므로 기존 값을 보존(blank 방지).
+            scope: credentials.scope ?? tokens.scope,
         };
         saveTokens(refreshed);
         return {

package/dist/firebase/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/firebase/cli.js

@@ -0,0 +1,82 @@
+#!/usr/bin/env node
+// mimi-seed-firebase — Firebase 프로비저닝 sub-CLI (프로젝트/앱 조회·생성, config 다운로드, GA4 링크).
+// 사용자 진입점은 `mimi-seed firebase <subcommand>`.
+import { requireAuth } from '../helpers.js';
+import * as firebase from './tools.js';
+import { runDomainCli, requireFlag, flag, CliUsageError } from '../lib/cli-args.js';
+const FB_PLATFORMS = ['android', 'ios', 'web'];
+const HELP = `
+  🔥 mimi-seed-firebase — Firebase attach (프로비저닝 + config 산출)
+
+  사용법:
+    mimi-seed firebase projects
+        내 Firebase 프로젝트 목록
+
+    mimi-seed firebase apps --project <id> [--platform android|ios|web]
+        프로젝트의 앱 목록 (기본: android+ios+web 전부)
+
+    mimi-seed firebase create-android --project <id> --package com.x.y --name <displayName>
+    mimi-seed firebase create-ios     --project <id> --bundle com.x.y  --name <displayName>
+        새 앱 등록
+
+    mimi-seed firebase config --project <id> --app <appId> --platform <android|ios|web>
+        ⭐ google-services.json / GoogleService-Info.plist / web config 출력 (attach 페이로드)
+
+    mimi-seed firebase enable-services --project <id>
+        Firebase 기본 서비스 일괄 활성화 (Analytics 포함)
+
+    mimi-seed firebase link-analytics --project <id> (--account <gaAccountId> | --property <gaPropertyId>)
+        GA4 링크 (앱 measurement 자동 활성화) — account(신규 property 생성) 또는 property(기존 연결) 중 하나 필수
+
+    mimi-seed firebase analytics-details --project <id>
+        GA4 링크 상세 (property + stream 매핑)
+
+  인증: npx -y @yoonion/mimi-seed-mcp mimi-seed-auth
+`;
+async function listApps(projectId, platform) {
+    const auth = await requireAuth();
+    // platform 이 지정됐는데 알 수 없는 값이면 조용히 'all' 로 떨어지지 않고 명시적으로 거부.
+    if (platform !== undefined && !FB_PLATFORMS.includes(platform)) {
+        throw new CliUsageError('--platform 은 android | ios | web 중 하나여야 합니다.');
+    }
+    if (platform === 'android')
+        return firebase.listAndroidApps(auth, projectId);
+    if (platform === 'ios')
+        return firebase.listIosApps(auth, projectId);
+    if (platform === 'web')
+        return firebase.listWebApps(auth, projectId);
+    const [android, ios, web] = await Promise.all([
+        firebase.listAndroidApps(auth, projectId),
+        firebase.listIosApps(auth, projectId),
+        firebase.listWebApps(auth, projectId),
+    ]);
+    return { android, ios, web };
+}
+async function getConfig(projectId, appId, platform) {
+    const auth = await requireAuth();
+    if (platform === 'android')
+        return firebase.getAndroidConfig(auth, projectId, appId);
+    if (platform === 'ios')
+        return firebase.getIosConfig(auth, projectId, appId);
+    if (platform === 'web')
+        return firebase.getWebConfig(auth, projectId, appId);
+    throw new CliUsageError('--platform 은 android | ios | web 중 하나여야 합니다.');
+}
+runDomainCli({
+    binName: 'mimi-seed-firebase',
+    argv: process.argv.slice(2),
+    help: HELP,
+    handlers: {
+        projects: async () => firebase.listProjects(await requireAuth()),
+        apps: async (p) => listApps(requireFlag(p, 'project'), flag(p, 'platform')?.toLowerCase()),
+        'create-android': async (p) => firebase.createAndroidApp(await requireAuth(), requireFlag(p, 'project'), requireFlag(p, 'package'), requireFlag(p, 'name')),
+        'create-ios': async (p) => firebase.createIosApp(await requireAuth(), requireFlag(p, 'project'), requireFlag(p, 'bundle'), requireFlag(p, 'name')),
+        config: async (p) => getConfig(requireFlag(p, 'project'), requireFlag(p, 'app'), requireFlag(p, 'platform').toLowerCase()),
+        'enable-services': async (p) => firebase.enableCommonServices(await requireAuth(), requireFlag(p, 'project')),
+        'link-analytics': async (p) => firebase.linkAnalytics(await requireAuth(), requireFlag(p, 'project'), {
+            analyticsAccountId: flag(p, 'account'),
+            analyticsPropertyId: flag(p, 'property'),
+        }),
+        'analytics-details': async (p) => firebase.getAnalyticsDetails(await requireAuth(), requireFlag(p, 'project')),
+    },
+});

package/dist/firebase/tools.d.ts

@@ -49,6 +49,20 @@ export declare function listEnabledServices(auth: OAuth2Client, projectId: strin
     name: string | null | undefined;
     title: string | null | undefined;
 }[]>;
+/**
+ * Firebase 프로젝트에 Google Analytics(GA4)를 링크한다.
+ * - analyticsAccountId: 그 GA 계정 하위에 GA4 property 를 새로 만들어 링크.
+ * - analyticsPropertyId: 기존 GA4 property 에 링크.
+ * 둘 중 정확히 하나는 필수다(addGoogleAnalytics API 계약 — 무인자 모드 없음).
+ * 앱별 data stream(android/ios measurement)은 링크 후 Firebase 가 자동 생성한다.
+ * (반환값은 long-running Operation — 완료까지 수 초 소요될 수 있음.)
+ */
+export declare function linkAnalytics(auth: OAuth2Client, projectId: string, opts?: {
+    analyticsAccountId?: string;
+    analyticsPropertyId?: string;
+}): Promise<import("googleapis").firebase_v1beta1.Schema$Operation>;
+/** 프로젝트의 GA4 링크 상세 — 연결된 analyticsProperty + 앱↔stream 매핑 조회. */
+export declare function getAnalyticsDetails(auth: OAuth2Client, projectId: string): Promise<import("googleapis").firebase_v1beta1.Schema$AnalyticsDetails>;
 export declare function enableCommonServices(auth: OAuth2Client, projectId: string): Promise<({
     service: string;
     status: string;

package/dist/firebase/tools.js

@@ -158,6 +158,39 @@ export async function listEnabledServices(auth, projectId) {
         title: s.config?.title,
     }));
 }
+// ─── Google Analytics(GA4) 링크 ───
+/**
+ * Firebase 프로젝트에 Google Analytics(GA4)를 링크한다.
+ * - analyticsAccountId: 그 GA 계정 하위에 GA4 property 를 새로 만들어 링크.
+ * - analyticsPropertyId: 기존 GA4 property 에 링크.
+ * 둘 중 정확히 하나는 필수다(addGoogleAnalytics API 계약 — 무인자 모드 없음).
+ * 앱별 data stream(android/ios measurement)은 링크 후 Firebase 가 자동 생성한다.
+ * (반환값은 long-running Operation — 완료까지 수 초 소요될 수 있음.)
+ */
+export async function linkAnalytics(auth, projectId, opts = {}) {
+    const requestBody = {};
+    if (opts.analyticsAccountId)
+        requestBody.analyticsAccountId = opts.analyticsAccountId;
+    if (opts.analyticsPropertyId)
+        requestBody.analyticsPropertyId = opts.analyticsPropertyId;
+    if (!requestBody.analyticsAccountId && !requestBody.analyticsPropertyId) {
+        throw new Error('GA4 링크엔 analyticsAccountId(신규 property 생성) 또는 analyticsPropertyId(기존 property 연결) 중 하나가 필요합니다.');
+    }
+    const res = await google.firebase('v1beta1').projects.addGoogleAnalytics({
+        auth,
+        parent: `projects/${projectId}`,
+        requestBody,
+    });
+    return res.data;
+}
+/** 프로젝트의 GA4 링크 상세 — 연결된 analyticsProperty + 앱↔stream 매핑 조회. */
+export async function getAnalyticsDetails(auth, projectId) {
+    const res = await google.firebase('v1beta1').projects.getAnalyticsDetails({
+        auth,
+        name: `projects/${projectId}/analyticsDetails`,
+    });
+    return res.data;
+}
 // ─── 편의 함수 ───
 const COMMON_SERVICES = [
     'firebase.googleapis.com',
@@ -167,6 +200,7 @@ const COMMON_SERVICES = [
     'fcm.googleapis.com',
     'identitytoolkit.googleapis.com',
     'cloudresourcemanager.googleapis.com',
+    'firebaseanalytics.googleapis.com', // GA4(Firebase Analytics) — linkAnalytics 전에 활성화
 ];
 export async function enableCommonServices(auth, projectId) {
     const results = [];

package/dist/ga4/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/ga4/cli.js

@@ -0,0 +1,63 @@
+#!/usr/bin/env node
+// mimi-seed-ga4 — GA4 Analytics Admin/Data API sub-CLI.
+// 사용자 진입점은 `mimi-seed ga4 <subcommand>` (cli 패키지가 npx 로 이 bin 을 호출).
+import { requireAuth } from '../helpers.js';
+import * as ga4 from './tools.js';
+import { runDomainCli, requireFlag, flag, flagList } from '../lib/cli-args.js';
+const HELP = `
+  📊 mimi-seed-ga4 — GA4(Google Analytics 4) attach
+
+  사용법:
+    mimi-seed ga4 accounts
+        접근 가능한 GA 계정 + property 요약 (accountId/propertyId 확인)
+
+    mimi-seed ga4 properties --account <id>
+        계정 하위 GA4 property 목록
+
+    mimi-seed ga4 create-property --account <id> --name <displayName>
+                                  [--timezone Asia/Seoul] [--currency KRW]
+        새 GA4 property 생성
+
+    mimi-seed ga4 create-stream --property <id> --platform <web|android|ios> --name <name>
+                                [--uri https://...] [--package com.x.y] [--bundle com.x.y]
+        data stream 생성 (web→measurementId, app→firebaseAppId)
+
+    mimi-seed ga4 streams --property <id>
+        data stream 목록
+
+    mimi-seed ga4 report --property <id> --start 28daysAgo --end today
+                         [--dimensions date,country] [--metrics activeUsers,eventCount]
+        GA4 Data API 리포트
+
+  ⚠️ analytics.edit 스코프 필요 — 처음이면 재로그인:
+     npx -y @yoonion/mimi-seed-mcp mimi-seed-auth
+`;
+runDomainCli({
+    binName: 'mimi-seed-ga4',
+    argv: process.argv.slice(2),
+    help: HELP,
+    handlers: {
+        accounts: async () => ga4.listAccountSummaries(await requireAuth(ga4.GA4_SCOPE)),
+        properties: async (p) => ga4.listProperties(await requireAuth(ga4.GA4_SCOPE), requireFlag(p, 'account')),
+        'create-property': async (p) => ga4.createProperty(await requireAuth(ga4.GA4_SCOPE), {
+            accountId: requireFlag(p, 'account'),
+            displayName: requireFlag(p, 'name'),
+            timeZone: flag(p, 'timezone'),
+            currencyCode: flag(p, 'currency'),
+        }),
+        'create-stream': async (p) => ga4.createDataStream(await requireAuth(ga4.GA4_SCOPE), requireFlag(p, 'property'), {
+            platform: requireFlag(p, 'platform'),
+            displayName: requireFlag(p, 'name'),
+            defaultUri: flag(p, 'uri'),
+            packageName: flag(p, 'package'),
+            bundleId: flag(p, 'bundle'),
+        }),
+        streams: async (p) => ga4.listDataStreams(await requireAuth(ga4.GA4_SCOPE), requireFlag(p, 'property')),
+        report: async (p) => ga4.runReport(await requireAuth(ga4.GA4_SCOPE), requireFlag(p, 'property'), {
+            startDate: requireFlag(p, 'start'),
+            endDate: requireFlag(p, 'end'),
+            dimensions: flagList(p, 'dimensions'),
+            metrics: flagList(p, 'metrics'),
+        }),
+    },
+});

package/dist/ga4/tools.d.ts

@@ -0,0 +1,107 @@
+import type { OAuth2Client } from 'google-auth-library';
+/** GA4 도구가 요구하는 OAuth 스코프 — requireAuth() pre-flight 검사에 사용. */
+export declare const GA4_SCOPE = "https://www.googleapis.com/auth/analytics.edit";
+export type Ga4Auth = OAuth2Client;
+export type DataStreamPlatform = 'web' | 'android' | 'ios';
+/** '123' | 'accounts/123' → 'accounts/123' */
+export declare function normalizeAccountName(accountId: string): string;
+/** '123' | 'properties/123' → 'properties/123' */
+export declare function normalizePropertyName(propertyId: string): string;
+/**
+ * dataStreams.create 응답에서 클라이언트가 실제로 필요로 하는 식별자를 평탄화한다.
+ * - web stream → measurementId (G-XXXX, gtag/web 연동용)
+ * - app stream → firebaseAppId (Firebase 앱과 자동 링크된 경우)
+ */
+export declare function flattenDataStream(d: {
+    name?: string | null;
+    type?: string | null;
+    displayName?: string | null;
+    webStreamData?: {
+        measurementId?: string | null;
+        defaultUri?: string | null;
+    } | null;
+    androidAppStreamData?: {
+        firebaseAppId?: string | null;
+        packageName?: string | null;
+    } | null;
+    iosAppStreamData?: {
+        firebaseAppId?: string | null;
+        bundleId?: string | null;
+    } | null;
+}): {
+    name: string | null;
+    type: string | null;
+    displayName: string | null;
+    measurementId: string | null;
+    firebaseAppId: string | null;
+};
+/** data stream 생성 요청 본문 조립 (순수 함수 — 테스트 대상). */
+export declare function buildDataStreamBody(opts: {
+    platform: DataStreamPlatform;
+    displayName: string;
+    defaultUri?: string;
+    packageName?: string;
+    bundleId?: string;
+}): {
+    type: string;
+    displayName: string;
+    webStreamData: {
+        defaultUri: string | undefined;
+    };
+    androidAppStreamData?: undefined;
+    iosAppStreamData?: undefined;
+} | {
+    type: string;
+    displayName: string;
+    androidAppStreamData: {
+        packageName: string | undefined;
+    };
+    webStreamData?: undefined;
+    iosAppStreamData?: undefined;
+} | {
+    type: string;
+    displayName: string;
+    iosAppStreamData: {
+        bundleId: string | undefined;
+    };
+    webStreamData?: undefined;
+    androidAppStreamData?: undefined;
+};
+/** 접근 가능한 GA 계정 + 각 계정의 property 요약. accountId/propertyId 를 찾는 시작점. */
+export declare function listAccountSummaries(auth: Ga4Auth): Promise<import("googleapis").analyticsadmin_v1beta.Schema$GoogleAnalyticsAdminV1betaAccountSummary[]>;
+/** 계정 하위 GA4 property 목록. accountId: '123' 또는 'accounts/123'. */
+export declare function listProperties(auth: Ga4Auth, accountId: string): Promise<import("googleapis").analyticsadmin_v1beta.Schema$GoogleAnalyticsAdminV1betaProperty[]>;
+export declare function createProperty(auth: Ga4Auth, opts: {
+    accountId: string;
+    displayName: string;
+    timeZone?: string;
+    currencyCode?: string;
+}): Promise<import("googleapis").analyticsadmin_v1beta.Schema$GoogleAnalyticsAdminV1betaProperty>;
+export declare function createDataStream(auth: Ga4Auth, propertyId: string, opts: {
+    platform: DataStreamPlatform;
+    displayName: string;
+    defaultUri?: string;
+    packageName?: string;
+    bundleId?: string;
+}): Promise<{
+    raw: import("googleapis").analyticsadmin_v1beta.Schema$GoogleAnalyticsAdminV1betaDataStream;
+    name: string | null;
+    type: string | null;
+    displayName: string | null;
+    measurementId: string | null;
+    firebaseAppId: string | null;
+}>;
+export declare function listDataStreams(auth: Ga4Auth, propertyId: string): Promise<{
+    name: string | null;
+    type: string | null;
+    displayName: string | null;
+    measurementId: string | null;
+    firebaseAppId: string | null;
+}[]>;
+export interface RunReportParams {
+    startDate: string;
+    endDate: string;
+    dimensions?: string[];
+    metrics?: string[];
+}
+export declare function runReport(auth: Ga4Auth, propertyId: string, params: RunReportParams): Promise<import("googleapis").analyticsdata_v1beta.Schema$RunReportResponse>;

package/dist/ga4/tools.js

@@ -0,0 +1,119 @@
+import { google } from 'googleapis';
+/**
+ * Google Analytics 4 — Admin API(v1beta) + Data API(v1beta) 래퍼.
+ *
+ * Admin API 로 GA4 property/data stream 을 직접 생성·조회한다. Firebase Analytics 를
+ * enable 하면 GA4 property 가 자동 생성되지만, 그 경로는 property 이름/타임존/통화나
+ * web data stream(measurement ID, G-XXXX) 을 제어할 수 없다. 풀 컨트롤이 필요하면 이 모듈을 쓴다.
+ *
+ * 인증은 mimi-seed OAuth 클라이언트(`requireAuth()`)를 그대로 사용 — `analytics.edit` 스코프 필요.
+ * (스코프 추가 후 기존 사용자는 1회 재로그인: `npx -y @yoonion/mimi-seed-mcp mimi-seed-auth`)
+ */
+const admin = () => google.analyticsadmin('v1beta');
+const data = () => google.analyticsdata('v1beta');
+/** GA4 도구가 요구하는 OAuth 스코프 — requireAuth() pre-flight 검사에 사용. */
+export const GA4_SCOPE = 'https://www.googleapis.com/auth/analytics.edit';
+// ─── 경로 정규화 (순수 함수 — 테스트 대상) ───
+/** '123' | 'accounts/123' → 'accounts/123' */
+export function normalizeAccountName(accountId) {
+    const id = accountId.trim();
+    return id.startsWith('accounts/') ? id : `accounts/${id}`;
+}
+/** '123' | 'properties/123' → 'properties/123' */
+export function normalizePropertyName(propertyId) {
+    const id = propertyId.trim();
+    return id.startsWith('properties/') ? id : `properties/${id}`;
+}
+/**
+ * dataStreams.create 응답에서 클라이언트가 실제로 필요로 하는 식별자를 평탄화한다.
+ * - web stream → measurementId (G-XXXX, gtag/web 연동용)
+ * - app stream → firebaseAppId (Firebase 앱과 자동 링크된 경우)
+ */
+export function flattenDataStream(d) {
+    return {
+        name: d.name ?? null,
+        type: d.type ?? null,
+        displayName: d.displayName ?? null,
+        measurementId: d.webStreamData?.measurementId ?? null,
+        firebaseAppId: d.androidAppStreamData?.firebaseAppId ?? d.iosAppStreamData?.firebaseAppId ?? null,
+    };
+}
+/** data stream 생성 요청 본문 조립 (순수 함수 — 테스트 대상). */
+export function buildDataStreamBody(opts) {
+    switch (opts.platform) {
+        case 'web':
+            return {
+                type: 'WEB_DATA_STREAM',
+                displayName: opts.displayName,
+                webStreamData: { defaultUri: opts.defaultUri },
+            };
+        case 'android':
+            return {
+                type: 'ANDROID_APP_DATA_STREAM',
+                displayName: opts.displayName,
+                androidAppStreamData: { packageName: opts.packageName },
+            };
+        case 'ios':
+            return {
+                type: 'IOS_APP_DATA_STREAM',
+                displayName: opts.displayName,
+                iosAppStreamData: { bundleId: opts.bundleId },
+            };
+    }
+}
+// ─── 계정/속성 디스커버리 ───
+/** 접근 가능한 GA 계정 + 각 계정의 property 요약. accountId/propertyId 를 찾는 시작점. */
+export async function listAccountSummaries(auth) {
+    const res = await admin().accountSummaries.list({ auth, pageSize: 200 });
+    return res.data.accountSummaries ?? [];
+}
+/** 계정 하위 GA4 property 목록. accountId: '123' 또는 'accounts/123'. */
+export async function listProperties(auth, accountId) {
+    const res = await admin().properties.list({
+        auth,
+        filter: `parent:${normalizeAccountName(accountId)}`,
+        pageSize: 200,
+    });
+    return res.data.properties ?? [];
+}
+// ─── property / data stream 생성 (attach 핵심) ───
+export async function createProperty(auth, opts) {
+    const res = await admin().properties.create({
+        auth,
+        requestBody: {
+            parent: normalizeAccountName(opts.accountId),
+            displayName: opts.displayName,
+            timeZone: opts.timeZone ?? 'America/Los_Angeles',
+            currencyCode: opts.currencyCode ?? 'USD',
+        },
+    });
+    return res.data; // { name: 'properties/XXXX', displayName, ... }
+}
+export async function createDataStream(auth, propertyId, opts) {
+    const res = await admin().properties.dataStreams.create({
+        auth,
+        parent: normalizePropertyName(propertyId),
+        requestBody: buildDataStreamBody(opts),
+    });
+    return { ...flattenDataStream(res.data), raw: res.data };
+}
+export async function listDataStreams(auth, propertyId) {
+    const res = await admin().properties.dataStreams.list({
+        auth,
+        parent: normalizePropertyName(propertyId),
+        pageSize: 200,
+    });
+    return (res.data.dataStreams ?? []).map((d) => flattenDataStream(d));
+}
+export async function runReport(auth, propertyId, params) {
+    const res = await data().properties.runReport({
+        auth,
+        property: normalizePropertyName(propertyId),
+        requestBody: {
+            dateRanges: [{ startDate: params.startDate, endDate: params.endDate }],
+            dimensions: (params.dimensions ?? []).map((name) => ({ name })),
+            metrics: (params.metrics ?? ['activeUsers', 'eventCount']).map((name) => ({ name })),
+        },
+    });
+    return res.data;
+}

package/dist/helpers.d.ts

@@ -8,7 +8,7 @@ export { ensureFreshAccessToken };
  * 기존엔 만료 시 각 OAuth 도구(firebase/admob/iam/googleads/checks)가
  * googleapis GaxiosError 를 그대로 노출 → 사용자는 "재로그인하라"는 안내를 못 받았다.
  */
-export declare function requireAuth(): Promise<import("google-auth-library").OAuth2Client>;
+export declare function requireAuth(requiredScope?: string): Promise<import("google-auth-library").OAuth2Client>;
 export declare const PLAY_AUTH_HINT: string;
 export declare const APPSTORE_AUTH_HINT: string;
 /**

package/dist/helpers.js

@@ -1,4 +1,4 @@
-import { getAuthenticatedClient, ensureFreshAccessToken } from './auth/google-auth.js';
+import { getAuthenticatedClient, ensureFreshAccessToken, getStoredTokens } from './auth/google-auth.js';
 import { getServiceAccountClient, getServiceAccountJson } from './auth/playstore-auth.js';
 import { getAppStoreCredentials } from './appstore/auth.js';
 export { ensureFreshAccessToken };
@@ -22,7 +22,7 @@ function formatAuthError(p) {
  * 기존엔 만료 시 각 OAuth 도구(firebase/admob/iam/googleads/checks)가
  * googleapis GaxiosError 를 그대로 노출 → 사용자는 "재로그인하라"는 안내를 못 받았다.
  */
-export async function requireAuth() {
+export async function requireAuth(requiredScope) {
     const result = await ensureFreshAccessToken();
     if (result.status === 'unauthenticated' || result.status === 'expired_refresh_failed') {
         throw new Error(formatAuthError(result.error));
@@ -37,6 +37,22 @@ export async function requireAuth() {
             needsReauth: true,
         }));
     }
+    // 신규 스코프(GA4 analytics.edit 등)는 변경 전 발급된 토큰엔 없다. expiry 만 보는
+    // ensureFreshAccessToken 은 이를 못 걸러내므로(런타임 ACCESS_TOKEN_SCOPE_INSUFFICIENT),
+    // 저장된 scope 로 pre-flight 검사해 결정적인 재로그인 안내를 던진다.
+    // (scope 가 undefined 인 구 토큰은 미보유로 간주 → 재로그인 유도.)
+    if (requiredScope) {
+        const granted = (getStoredTokens()?.scope ?? '').split(' ').filter(Boolean);
+        if (!granted.includes(requiredScope)) {
+            throw new Error(formatAuthError({
+                code: 'INSUFFICIENT_SCOPE',
+                message: `이 도구는 추가 권한이 필요해 (${requiredScope}). 기존 로그인에 없어서 1회 재로그인이 필요해.`,
+                hint: 'mimi-seed-auth 로 재로그인하면 새 권한이 부여돼.',
+                retriable: false,
+                needsReauth: true,
+            }));
+        }
+    }
     return client;
 }
 export const PLAY_AUTH_HINT = [

package/dist/index.js

@@ -16,6 +16,7 @@ import { registerInstagramTools } from './registers/instagram.js';
 import { registerFacebookTools } from './registers/facebook.js';
 import { registerGoogleAdsTools } from './registers/googleads.js';
 import { registerGscTools } from './registers/gsc.js';
+import { registerGa4Tools } from './registers/ga4.js';
 import { registerJenkinsTools } from './registers/jenkins.js';
 import { registerAndroidTools } from './registers/android.js';
 import { registerPrompts } from './prompts.js';
@@ -41,6 +42,7 @@ registerInstagramTools(server);
 registerFacebookTools(server);
 registerGoogleAdsTools(server);
 registerGscTools(server);
+registerGa4Tools(server);
 registerJenkinsTools(server);
 registerAndroidTools(server);
 registerPrompts(server);
@@ -54,6 +56,9 @@ const SUBCOMMANDS = {
     'mimi-seed-playstore-auth': () => import('./auth/playstore-setup-cli.js'),
     'mimi-seed-appstore-auth': () => import('./appstore/setup-cli.js'),
     'mimi-seed-bigquery-auth': () => import('./auth/bigquery-setup-cli.js'),
+    'mimi-seed-firebase': () => import('./firebase/cli.js'),
+    'mimi-seed-admob': () => import('./admob/cli.js'),
+    'mimi-seed-ga4': () => import('./ga4/cli.js'),
 };
 async function main() {
     const sub = process.argv[2];

package/dist/lib/cli-args.d.ts

@@ -0,0 +1,31 @@
+export interface ParsedArgs {
+    /** 첫 위치 인자 — 서브커맨드 (예: 'create-property') */
+    command: string | undefined;
+    /** --name value 형태의 값 플래그 */
+    flags: Record<string, string>;
+    /** --force 형태의 불리언 플래그 */
+    bools: Set<string>;
+}
+/** process.argv.slice(2) 같은 토큰 배열을 파싱. */
+export declare function parseArgs(argv: string[]): ParsedArgs;
+/** 값 플래그 조회 — 없으면 fallback. */
+export declare function flag(p: ParsedArgs, name: string, fallback?: string): string | undefined;
+/** 필수 값 플래그 — 없으면 친절 에러 throw. */
+export declare function requireFlag(p: ParsedArgs, name: string): string;
+/** 쉼표 구분 값 → 배열 ('a, b ,c' → ['a','b','c']). 없으면 undefined. */
+export declare function flagList(p: ParsedArgs, name: string): string[] | undefined;
+/** 사용법 위반 — main()에서 잡아 도움말과 함께 exit 1. */
+export declare class CliUsageError extends Error {
+}
+/** 결과 JSON 을 stdout 으로 출력 (stderr 는 진행/안내용). */
+export declare function printJson(data: unknown): void;
+/**
+ * 도메인 sub-CLI 공통 러너. requireAuth → 핸들러 매핑 실행 → JSON 출력 → exit code.
+ * 핸들러는 ParsedArgs 를 받아 출력할 데이터를 반환한다.
+ */
+export declare function runDomainCli(opts: {
+    binName: string;
+    argv: string[];
+    help: string;
+    handlers: Record<string, (p: ParsedArgs) => Promise<unknown>>;
+}): Promise<void>;

package/dist/lib/cli-args.js

@@ -0,0 +1,96 @@
+// 도메인별 sub-CLI(mimi-seed-firebase / -admob / -ga4)가 공유하는 최소 argv 파서.
+// `mimi-seed <domain> <subcommand> [--flag value] [--bool]` 형태를 파싱한다.
+// 실제 사용자 진입점은 cli 패키지의 `mimi-seed <domain> ...` 이고, 그게 npx 로
+// 이 bin 들을 stdio 그대로 호출한다(auth.ts:runMcpBin 패턴과 동일).
+/** process.argv.slice(2) 같은 토큰 배열을 파싱. */
+export function parseArgs(argv) {
+    const flags = {};
+    const bools = new Set();
+    let command;
+    for (let i = 0; i < argv.length; i++) {
+        const tok = argv[i];
+        if (tok.startsWith('--')) {
+            const eq = tok.indexOf('=');
+            if (eq !== -1) {
+                // --key=value — 값이 '--'로 시작해도 안전하게 전달.
+                flags[tok.slice(2, eq)] = tok.slice(eq + 1);
+                continue;
+            }
+            const key = tok.slice(2);
+            const next = argv[i + 1];
+            // 다음 토큰이 또 다른 플래그(--)면 값으로 소비하지 않는다 → 값 누락을 bool 로 기록.
+            if (next !== undefined && !next.startsWith('--')) {
+                flags[key] = next;
+                i++;
+            }
+            else {
+                bools.add(key);
+            }
+        }
+        else if (command === undefined) {
+            command = tok;
+        }
+    }
+    return { command, flags, bools };
+}
+/** 값 플래그 조회 — 없으면 fallback. */
+export function flag(p, name, fallback) {
+    return p.flags[name] ?? fallback;
+}
+/** 필수 값 플래그 — 없으면 친절 에러 throw. */
+export function requireFlag(p, name) {
+    const v = p.flags[name];
+    if (v === undefined || v === '') {
+        if (p.bools.has(name)) {
+            throw new CliUsageError(`--${name} 에 값이 필요합니다 (값 없이 단독으로 쓰였습니다). 값이 '--'로 시작하면 --${name}=값 형태로 쓰세요.`);
+        }
+        throw new CliUsageError(`--${name} 가 필요합니다.`);
+    }
+    return v;
+}
+/** 쉼표 구분 값 → 배열 ('a, b ,c' → ['a','b','c']). 없으면 undefined. */
+export function flagList(p, name) {
+    const v = p.flags[name];
+    if (!v)
+        return undefined;
+    return v.split(',').map((s) => s.trim()).filter(Boolean);
+}
+/** 사용법 위반 — main()에서 잡아 도움말과 함께 exit 1. */
+export class CliUsageError extends Error {
+}
+/** 결과 JSON 을 stdout 으로 출력 (stderr 는 진행/안내용). */
+export function printJson(data) {
+    process.stdout.write(JSON.stringify(data, null, 2) + '\n');
+}
+/**
+ * 도메인 sub-CLI 공통 러너. requireAuth → 핸들러 매핑 실행 → JSON 출력 → exit code.
+ * 핸들러는 ParsedArgs 를 받아 출력할 데이터를 반환한다.
+ */
+export async function runDomainCli(opts) {
+    const p = parseArgs(opts.argv);
+    if (!p.command || p.command === 'help' || p.bools.has('help') || p.bools.has('h')) {
+        process.stderr.write(opts.help + '\n');
+        process.exit(p.command ? 0 : 1);
+    }
+    const handler = opts.handlers[p.command];
+    if (!handler) {
+        process.stderr.write(`❌ 알 수 없는 서브커맨드: ${p.command}\n\n` + opts.help + '\n');
+        process.exit(1);
+    }
+    try {
+        const result = await handler(p);
+        printJson(result);
+        process.exit(0);
+    }
+    catch (e) {
+        if (e instanceof CliUsageError) {
+            process.stderr.write(`❌ ${e.message}\n\n` + opts.help + '\n');
+        }
+        else {
+            process.stderr.write(`❌ ${e instanceof Error ? e.message : String(e)}\n`);
+            if (process.env.DEBUG && e instanceof Error)
+                process.stderr.write((e.stack ?? '') + '\n');
+        }
+        process.exit(1);
+    }
+}

package/dist/lib/google-errors.d.ts

@@ -1,5 +1,13 @@
 export declare function extractHttpStatus(e: unknown): number | undefined;
 export declare function rawMessage(e: unknown): string;
+/**
+ * Google API 에러에서 구조화된 실제 사유를 추출한다. GaxiosError는
+ * `response.data.error.{message,errors[].reason}` 에 진짜 원인을 담는데,
+ * 친절화 레이어가 이를 버리고 일반 메시지("권한 없음")로 덮으면, 권한이 멀쩡한데도
+ * 권한 문제로 오진하게 된다 (예: 같은 SA로 이미지 업로드는 되는데 listings.update만 403).
+ * 추출 실패 시 undefined.
+ */
+export declare function googleErrorDetail(e: unknown): string | undefined;
 /** invalid_grant / 만료 refresh_token / 부족 scope → 재로그인 안내 메시지. 아니면 null. */
 export declare function authReauthMessage(text: string): string | null;
 export declare function withCause(err: Error, cause: unknown): Error;

package/dist/lib/google-errors.js

@@ -26,6 +26,32 @@ export function rawMessage(e) {
         return String(e);
     }
 }
+/**
+ * Google API 에러에서 구조화된 실제 사유를 추출한다. GaxiosError는
+ * `response.data.error.{message,errors[].reason}` 에 진짜 원인을 담는데,
+ * 친절화 레이어가 이를 버리고 일반 메시지("권한 없음")로 덮으면, 권한이 멀쩡한데도
+ * 권한 문제로 오진하게 된다 (예: 같은 SA로 이미지 업로드는 되는데 listings.update만 403).
+ * 추출 실패 시 undefined.
+ */
+export function googleErrorDetail(e) {
+    if (!e || typeof e !== 'object')
+        return undefined;
+    const any = e;
+    const apiErr = any.response?.data?.error;
+    const parts = [];
+    if (apiErr?.message)
+        parts.push(String(apiErr.message));
+    const reasons = apiErr?.errors ?? any.errors;
+    if (Array.isArray(reasons)) {
+        for (const r of reasons) {
+            const bit = [r?.reason, r?.message].filter(Boolean).join(': ');
+            if (bit && !parts.some((p) => p.includes(bit)))
+                parts.push(bit);
+        }
+    }
+    const joined = parts.join(' | ').trim();
+    return joined.length ? joined : undefined;
+}
 /** invalid_grant / 만료 refresh_token / 부족 scope → 재로그인 안내 메시지. 아니면 null. */
 export function authReauthMessage(text) {
     if (/invalid_grant|invalid_rapt|rapt_required|unauthorized_client|ACCESS_TOKEN_SCOPE_INSUFFICIENT|insufficient.*scope/i.test(text)) {

package/dist/playstore/errors.js

@@ -2,17 +2,23 @@
 // App Store 의 friendlyAppStoreError 와 대칭 — Play 쪽엔 없던 친절화 레이어.
 // 신규 사용자가 가장 자주 막히는 두 케이스(서비스 계정 권한 403, edit 세션 충돌)에
 // 구체적 복구 단계를 붙인다. 인식 못 한 에러(도메인 에러 포함)는 원본 보존.
-import { extractHttpStatus, authReauthMessage, withCause } from '../lib/google-errors.js';
-// playstore_verify_service_account 의 403 안내와 동일한 체크리스트.
-const PERMISSION_403 = [
-    '❌ Google Play 권한 부족 (403).',
-    '원인: 인증은 됐지만 Play Console에서 이 계정/서비스 계정에 권한이 없어요.',
-    '',
-    '1. Play Console → 사용자 및 권한(Users and permissions)',
-    '2. 이 Google 계정(또는 서비스 계정 이메일)을 초대 / 권한 부여',
-    '3. 앱 권한에 "앱 정보 관리" (재무 데이터 필요 시 "재무 데이터 보기") 부여',
-    '4. 권한 적용까지 ~5분 대기 후 재시도 (너무 빨리 시도하면 계속 403)',
-].join('\n');
+import { extractHttpStatus, authReauthMessage, withCause, googleErrorDetail } from '../lib/google-errors.js';
+// 403 안내. raw Google 사유를 먼저 보여주고, 권한이 멀쩡한데 특정 작업만 거부되는
+// 케이스(같은 SA로 이미지 업로드는 되는데 listings.update만 403 등)를 위해
+// "다른 쓰기가 되면 권한 문제가 아니다"라는 단서를 붙인다. detail 은 googleErrorDetail() 결과.
+function permission403Message(detail) {
+    return [
+        '❌ Google Play 403 — 요청이 거부됐어요.',
+        detail ? `Google 사유: ${detail}` : '',
+        '⚠️ 같은 계정/서비스 계정으로 다른 쓰기(예: 이미지 업로드)가 된다면 권한 문제가 아닐 수 있어요 — 위 Google 사유 또는 앱 상태·정책·작업별 제한을 먼저 확인하세요.',
+        '',
+        '정말 권한 문제라면:',
+        '1. Play Console → 사용자 및 권한(Users and permissions)',
+        '2. 이 Google 계정(또는 서비스 계정 이메일)을 초대 / 권한 부여',
+        '3. 앱 권한에 "앱 정보 관리"(Manage store presence) 부여',
+        '4. 권한 적용까지 ~5분 대기 후 재시도',
+    ].filter((l) => l !== '').join('\n');
+}
 export function friendlyPlayError(e, packageName) {
     const text = e instanceof Error ? e.message : String(e);
     const status = extractHttpStatus(e);
@@ -20,7 +26,7 @@ export function friendlyPlayError(e, packageName) {
     if (reauth)
         return withCause(new Error(reauth), e);
     if (status === 403 || /PERMISSION_DENIED|insufficient permission|forbidden/i.test(text)) {
-        return withCause(new Error(PERMISSION_403), e);
+        return withCause(new Error(permission403Message(googleErrorDetail(e))), e);
     }
     if (status === 404 || /NOT_FOUND|not found/i.test(text)) {
         return withCause(new Error(`❌ 패키지${packageName ? ` (${packageName})` : ''}를 이 개발자 계정에서 찾을 수 없어요.\n→ packageName 철자와 계정 권한을 확인하세요.`), e);

package/dist/registers/admob.js

@@ -35,14 +35,15 @@ export function registerAdmobTools(server) {
         const report = await admob.getNetworkReport(auth, accountId, { year: startYear, month: startMonth, day: startDay }, { year: endYear, month: endMonth, day: endDay });
         return { content: [{ type: 'text', text: JSON.stringify(report, null, 2) }] };
     });
-    server.tool('admob_create_app', 'AdMob에 새 앱 등록 (v1beta — Limited Access)', {
+    server.tool('admob_create_app', 'AdMob에 새 앱 등록 (v1beta — Limited Access). appStoreId 를 주면 스토어 게시 앱과 링크(Android=패키지명, iOS=App Store 숫자 ID), 없으면 manual(unlinked) 앱.', {
         accountId: z.string().describe('AdMob 계정 ID'),
         platform: z.enum(['ANDROID', 'IOS']).describe('플랫폼'),
         displayName: z.string().describe('앱 이름'),
-    }, async ({ accountId, platform, displayName }) => {
+        appStoreId: z.string().optional().describe('스토어 링크용 ID — Android는 패키지명(com.x.y), iOS는 App Store 숫자 ID'),
+    }, async ({ accountId, platform, displayName, appStoreId }) => {
         const auth = await requireAuth();
         try {
-            const result = await admob.createApp(auth, accountId, platform, displayName);
+            const result = await admob.createApp(auth, accountId, platform, displayName, appStoreId);
             return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
         }
         catch (err) {

package/dist/registers/firebase.js

@@ -144,4 +144,18 @@ export function registerFirebaseTools(server) {
         const services = await firebase.listEnabledServices(auth, projectId);
         return { content: [{ type: 'text', text: JSON.stringify(services, null, 2) }] };
     });
+    server.tool('firebase_link_analytics', 'Firebase 프로젝트에 Google Analytics(GA4) 링크 → 앱별 measurement 자동 활성화. analyticsAccountId(그 계정에 GA4 property 신규 생성) 또는 analyticsPropertyId(기존 property 링크) 중 하나 필수. 먼저 firebase_enable_common_services 로 firebaseanalytics 활성화 권장. property 이름/web stream 까지 직접 제어하려면 ga4_create_property/ga4_create_data_stream 사용.', {
+        projectId: z.string().describe('Firebase 프로젝트 ID'),
+        analyticsAccountId: z.string().optional().describe('GA 계정 ID (신규 property 생성 위치) — 예: 123456'),
+        analyticsPropertyId: z.string().optional().describe('기존 GA4 property ID 에 링크할 경우'),
+    }, async ({ projectId, analyticsAccountId, analyticsPropertyId }) => {
+        const auth = await requireAuth();
+        const result = await firebase.linkAnalytics(auth, projectId, { analyticsAccountId, analyticsPropertyId });
+        return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+    });
+    server.tool('firebase_get_analytics_details', '프로젝트의 GA4 링크 상세 — 연결된 analyticsProperty + 앱↔data stream 매핑 조회.', { projectId: z.string().describe('Firebase 프로젝트 ID') }, async ({ projectId }) => {
+        const auth = await requireAuth();
+        const details = await firebase.getAnalyticsDetails(auth, projectId);
+        return { content: [{ type: 'text', text: JSON.stringify(details, null, 2) }] };
+    });
 }

package/dist/registers/ga4.d.ts

@@ -0,0 +1,2 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerGa4Tools(server: McpServer): void;

package/dist/registers/ga4.js

@@ -0,0 +1,90 @@
+import { z } from 'zod';
+import * as ga4Raw from '../ga4/tools.js';
+import { requireAuth } from '../helpers.js';
+import { friendlyGoogleError } from '../lib/google-errors.js';
+// firebase register 와 동일한 프록시 — raw GaxiosError(SERVICE_DISABLED / 403 /
+// ACCESS_TOKEN_SCOPE_INSUFFICIENT)를 "다음에 뭘 할지" 메시지로 변환. 특히 GA4 는
+// analytics.edit 스코프를 새로 추가했으므로 기존 사용자는 재로그인 안내가 필수.
+const ga4 = new Proxy(ga4Raw, {
+    get(target, prop, receiver) {
+        const orig = Reflect.get(target, prop, receiver);
+        if (typeof orig !== 'function')
+            return orig;
+        return (...args) => {
+            try {
+                const out = orig(...args);
+                if (out && typeof out.then === 'function') {
+                    return out.catch((err) => {
+                        throw friendlyGoogleError(err);
+                    });
+                }
+                return out;
+            }
+            catch (err) {
+                throw friendlyGoogleError(err);
+            }
+        };
+    },
+});
+const PROPERTY_DESC = "GA4 property ID — '123456789' 또는 'properties/123456789'";
+export function registerGa4Tools(server) {
+    server.tool('ga4_list_account_summaries', '접근 가능한 Google Analytics 계정 + 각 계정의 GA4 property 요약. accountId / propertyId 를 확인할 때 먼저 호출. analytics.edit 스코프 필요(없으면 재로그인 안내).', {}, async () => {
+        const auth = await requireAuth(ga4Raw.GA4_SCOPE);
+        const summaries = await ga4.listAccountSummaries(auth);
+        return { content: [{ type: 'text', text: JSON.stringify(summaries, null, 2) }] };
+    });
+    server.tool('ga4_list_properties', '특정 GA 계정 하위 GA4 property 목록.', { accountId: z.string().describe("GA 계정 ID — '123' 또는 'accounts/123'") }, async ({ accountId }) => {
+        const auth = await requireAuth(ga4Raw.GA4_SCOPE);
+        const properties = await ga4.listProperties(auth, accountId);
+        return { content: [{ type: 'text', text: JSON.stringify(properties, null, 2) }] };
+    });
+    server.tool('ga4_create_property', '새 GA4 property 생성. 생성 후 ga4_create_data_stream 으로 플랫폼별 stream(웹=measurement ID, 앱=firebaseAppId)을 붙인다.', {
+        accountId: z.string().describe("GA 계정 ID — '123' 또는 'accounts/123'"),
+        displayName: z.string().describe('property 표시 이름 (예: SpeakReward)'),
+        timeZone: z.string().optional().describe("IANA 타임존 (기본 'America/Los_Angeles', 예: 'Asia/Seoul')"),
+        currencyCode: z.string().optional().describe("ISO 4217 통화코드 (기본 'USD', 예: 'KRW')"),
+    }, async ({ accountId, displayName, timeZone, currencyCode }) => {
+        const auth = await requireAuth(ga4Raw.GA4_SCOPE);
+        const property = await ga4.createProperty(auth, { accountId, displayName, timeZone, currencyCode });
+        return { content: [{ type: 'text', text: JSON.stringify(property, null, 2) }] };
+    });
+    server.tool('ga4_create_data_stream', 'GA4 property 에 data stream 생성. web → measurementId(G-XXXX) 반환, android/ios → firebaseAppId 반환(Firebase 링크 시). RN 앱은 android/ios 스트림 사용.', {
+        propertyId: z.string().describe(PROPERTY_DESC),
+        platform: z.enum(['web', 'android', 'ios']).describe('스트림 플랫폼'),
+        displayName: z.string().describe('스트림 표시 이름'),
+        defaultUri: z.string().optional().describe('web 전용 — 사이트 URL (예: https://example.com)'),
+        packageName: z.string().optional().describe('android 전용 — 패키지명 (예: com.example.app)'),
+        bundleId: z.string().optional().describe('ios 전용 — Bundle ID (예: com.example.app)'),
+    }, async ({ propertyId, platform, displayName, defaultUri, packageName, bundleId }) => {
+        const auth = await requireAuth(ga4Raw.GA4_SCOPE);
+        const stream = await ga4.createDataStream(auth, propertyId, {
+            platform,
+            displayName,
+            defaultUri,
+            packageName,
+            bundleId,
+        });
+        return { content: [{ type: 'text', text: JSON.stringify(stream, null, 2) }] };
+    });
+    server.tool('ga4_list_data_streams', 'GA4 property 의 data stream 목록 (measurementId / firebaseAppId 평탄화).', { propertyId: z.string().describe(PROPERTY_DESC) }, async ({ propertyId }) => {
+        const auth = await requireAuth(ga4Raw.GA4_SCOPE);
+        const streams = await ga4.listDataStreams(auth, propertyId);
+        return { content: [{ type: 'text', text: JSON.stringify(streams, null, 2) }] };
+    });
+    server.tool('ga4_run_report', 'GA4 Data API 리포트 (활성 사용자·이벤트 등). dimensions/metrics 는 쉼표 구분 GA4 API 이름.', {
+        propertyId: z.string().describe(PROPERTY_DESC),
+        startDate: z.string().describe("시작일 (YYYY-MM-DD 또는 'NdaysAgo', 'today')"),
+        endDate: z.string().describe("종료일 (YYYY-MM-DD 또는 'today')"),
+        dimensions: z.string().optional().describe('쉼표 구분 dimension (예: date,country). 생략 시 전체 합계'),
+        metrics: z.string().optional().describe('쉼표 구분 metric (기본 activeUsers,eventCount)'),
+    }, async ({ propertyId, startDate, endDate, dimensions, metrics }) => {
+        const auth = await requireAuth(ga4Raw.GA4_SCOPE);
+        const report = await ga4.runReport(auth, propertyId, {
+            startDate,
+            endDate,
+            dimensions: dimensions ? dimensions.split(',').map((d) => d.trim()).filter(Boolean) : undefined,
+            metrics: metrics ? metrics.split(',').map((m) => m.trim()).filter(Boolean) : undefined,
+        });
+        return { content: [{ type: 'text', text: JSON.stringify(report, null, 2) }] };
+    });
+}

package/dist/registers/playstore.js

@@ -46,7 +46,7 @@ export function registerPlaystoreTools(server) {
         const listing = await playstore.getListing(auth, packageName, language);
         return { content: [{ type: 'text', text: JSON.stringify(listing, null, 2) }] };
     });
-    server.tool('playstore_update_listing', 'Google Play 스토어 리스팅 수정 (제목, 설명문 변경)', {
+    server.tool('playstore_update_listing', 'Google Play 스토어 리스팅 수정 (제목, 설명문 변경). ⚠️ Play API 편집과 Console 동시 편집은 충돌 — Console에서 같은 리스팅을 편집·미게시 중이면 그 변경이 덮어써질 수 있음.', {
         packageName: z.string().describe('패키지명'),
         language: z.string().describe('언어 코드 (예: ko-KR, en-US)'),
         title: z.string().optional().describe('앱 제목 (30자 이내)'),
@@ -115,7 +115,7 @@ export function registerPlaystoreTools(server) {
         const images = await playstore.listImages(auth, packageName, language, imageType);
         return { content: [{ type: 'text', text: JSON.stringify(images, null, 2) }] };
     });
-    server.tool('playstore_upload_image', 'Google Play 리스팅 이미지 단일 업로드 (기존 이미지 유지). featureGraphic 1024x500 / icon 512x512 / phoneScreenshots 320~3840px', {
+    server.tool('playstore_upload_image', 'Google Play 리스팅 이미지 단일 업로드 (기존 이미지 유지). featureGraphic 1024x500 / icon 512x512 / phoneScreenshots 320~3840px. ⚠️ 이 작업은 edit을 commit하므로 Play Console의 미게시(저장 전) 리스팅 변경을 덮어쓸 수 있음 — Console에서 같은 앱을 편집 중이면 먼저 저장·게시하거나 텍스트도 update_listing으로 처리하세요.', {
         packageName: z.string().describe('패키지명'),
         language: z.string().describe('언어 코드'),
         imageType: z.enum(['featureGraphic', 'icon', 'phoneScreenshots', 'promoGraphic', 'sevenInchScreenshots', 'tenInchScreenshots', 'tvBanner', 'tvScreenshots', 'wearScreenshots']),
@@ -125,7 +125,7 @@ export function registerPlaystoreTools(server) {
         const result = await playstore.uploadImage(auth, packageName, language, imageType, filePath);
         return { content: [{ type: 'text', text: `✅ 업로드 완료\n${JSON.stringify(result, null, 2)}` }] };
     });
-    server.tool('playstore_delete_all_images', 'Google Play 리스팅 특정 imageType의 이미지 전체 삭제 (교체 전 정리)', {
+    server.tool('playstore_delete_all_images', 'Google Play 리스팅 특정 imageType의 이미지 전체 삭제 (교체 전 정리). ⚠️ commit이 Play Console의 미게시 리스팅 변경을 덮어쓸 수 있음.', {
         packageName: z.string().describe('패키지명'),
         language: z.string().describe('언어 코드'),
         imageType: z.enum(['featureGraphic', 'icon', 'phoneScreenshots', 'promoGraphic', 'sevenInchScreenshots', 'tenInchScreenshots', 'tvBanner', 'tvScreenshots', 'wearScreenshots']),
@@ -134,7 +134,7 @@ export function registerPlaystoreTools(server) {
         const result = await playstore.deleteAllImages(auth, packageName, language, imageType);
         return { content: [{ type: 'text', text: `✅ 전체 삭제\n${JSON.stringify(result, null, 2)}` }] };
     });
-    server.tool('playstore_replace_images', 'Google Play 리스팅 이미지 일괄 교체 (한 edit 세션: deleteall → 순서대로 upload → commit). 스크린샷 5~8장 한 번에 교체 시 효율적. 업로드 순서가 스토어 노출 순서', {
+    server.tool('playstore_replace_images', 'Google Play 리스팅 이미지 일괄 교체 (한 edit 세션: deleteall → 순서대로 upload → commit). 스크린샷 5~8장 한 번에 교체 시 효율적. 업로드 순서가 스토어 노출 순서. ⚠️ commit이 Play Console의 미게시 리스팅 변경을 덮어쓸 수 있음.', {
         packageName: z.string().describe('패키지명'),
         language: z.string().describe('언어 코드'),
         imageType: z.enum(['featureGraphic', 'icon', 'phoneScreenshots', 'promoGraphic', 'sevenInchScreenshots', 'tenInchScreenshots', 'tvBanner', 'tvScreenshots', 'wearScreenshots']),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yoonion/mimi-seed-mcp",
-  "version": "0.3.40",
+  "version": "0.4.0",
   "description": "Mimi Seed MCP server — Firebase + AdMob + Google Play + App Store management for Claude Code / Codex / Cursor / any MCP client.",
   "type": "module",
   "bin": {
@@ -8,7 +8,10 @@
     "mimi-seed-auth": "dist/auth/cli.js",
     "mimi-seed-appstore-auth": "dist/appstore/setup-cli.js",
     "mimi-seed-playstore-auth": "dist/auth/playstore-setup-cli.js",
-    "mimi-seed-bigquery-auth": "dist/auth/bigquery-setup-cli.js"
+    "mimi-seed-bigquery-auth": "dist/auth/bigquery-setup-cli.js",
+    "mimi-seed-firebase": "dist/firebase/cli.js",
+    "mimi-seed-admob": "dist/admob/cli.js",
+    "mimi-seed-ga4": "dist/ga4/cli.js"
   },
   "files": [
     "dist",