@yoonion/mimi-seed-mcp 0.11.0 → 0.12.0

package/dist/checks/risks.js

@@ -1,6 +1,6 @@
 import { publisher, withEdit } from '../playstore/tools.js';
 import { apiGet } from '../appstore/tools.js';
-const APPSTORE_EDITABLE_STATES = 'PREPARE_FOR_SUBMISSION,WAITING_FOR_REVIEW';
+const APPSTORE_EDITABLE_STATES = 'PREPARE_FOR_SUBMISSION,DEVELOPER_REJECTED,METADATA_REJECTED,REJECTED';
 export async function checkPlayStoreRisks(auth, packageName, language = 'ko-KR') {
     const risks = [];
     await withEdit(auth, packageName, async (editId) => {
@@ -95,19 +95,23 @@ export async function checkAppStoreRisks(appId) {
     }
     else {
         for (const loc of locs.data) {
-            const { locale, description, whatsNew, keywords } = loc.attributes ?? {};
+            const { locale: rawLocale, description, whatsNew, keywords } = loc.attributes ?? {};
+            const locale = rawLocale ?? loc.id;
             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 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" 스크린샷이 필요합니다.' });
+            const screenshots = await safeGet(() => apiGet(`/appStoreVersionLocalizations/${loc.id}/appScreenshotSets`), risks, `SCREENSHOTS_${locale}`, `${locale} 스크린샷 셋`);
+            if (screenshots && !screenshots.data?.length) {
+                risks.push({
+                    level: 'blocker',
+                    code: `NO_SCREENSHOTS_${locale}`,
+                    title: `${locale} 스크린샷 없음`,
+                    detail: 'iPhone 6.5" 또는 6.9" 스크린샷이 필요합니다.',
+                });
+            }
         }
     }
     // 빌드 — 1차: 버전에 첨부된 빌드. 2차 폴백: 앱 전체 빌드 (예전 동작).

package/dist/helpers.js

@@ -1,4 +1,5 @@
 import { getAuthenticatedClient, ensureFreshAccessToken, getStoredTokens } from './auth/google-auth.js';
+import { domainsForScope, isPreTrackingScope } from './auth/scopes.js';
 import { getServiceAccountClient, getServiceAccountJson } from './auth/playstore-auth.js';
 import { getAppStoreCredentials } from './appstore/auth.js';
 export { ensureFreshAccessToken };
@@ -37,17 +38,28 @@ export async function requireAuth(requiredScope) {
             needsReauth: true,
         }));
     }
-    // 신규 스코프(GA4 analytics.edit 등)는 변경 전 발급된 토큰엔 없다. expiry 만 보는
-    // ensureFreshAccessToken 은 이를 못 걸러내므로(런타임 ACCESS_TOKEN_SCOPE_INSUFFICIENT),
-    // 저장된 scope 로 pre-flight 검사해 결정적인 재로그인 안내를 던진다.
-    // (scope 가 undefined 인 구 토큰은 미보유로 간주 → 재로그인 유도.)
+    // 도구가 요구하는 스코프의 pre-flight 검사. expiry 만 보는 ensureFreshAccessToken 은
+    // 스코프 미보유를 못 걸러내므로(런타임 ACCESS_TOKEN_SCOPE_INSUFFICIENT), 저장된 scope 로
+    // 결정적인 안내를 던진다. 도메인 선택형 로그인 도입 후에는 "전체 재로그인"이 아니라
+    // "--domains <해당 도메인> 으로 추가 부여(기존 권한 유지)"가 올바른 해법이다.
+    //
+    // scope 가 undefined 인 구 토큰(스코프 추적 도입 전 full-scope 로그인)은 추적 도입
+    // 이전부터 있던 스코프는 보유한 게 확실하므로 통과시킨다 — 안 그러면 pre-flight 를 새로
+    // 다는 순간 멀쩡한 기존 사용자에게 재로그인을 강제한다. 추적 이후 추가된 스코프(GA4)만
+    // 미보유 확정으로 본다.
     if (requiredScope) {
-        const granted = (getStoredTokens()?.scope ?? '').split(' ').filter(Boolean);
-        if (!granted.includes(requiredScope)) {
+        const scopeStr = getStoredTokens()?.scope;
+        const missing = scopeStr === undefined
+            ? !isPreTrackingScope(requiredScope)
+            : !scopeStr.split(' ').filter(Boolean).includes(requiredScope);
+        if (missing) {
+            const domainArg = domainsForScope(requiredScope).join(',');
             throw new Error(formatAuthError({
                 code: 'INSUFFICIENT_SCOPE',
-                message: `이 도구는 추가 권한이 필요해 (${requiredScope}). 기존 로그인에 없어서 1회 재로그인이 필요해.`,
-                hint: 'mimi-seed-auth 로 재로그인하면 새 권한이 부여돼.',
+                message: `이 도구는 추가 권한이 필요해 (${requiredScope}). 현재 로그인에 그 권한이 없어.`,
+                hint: domainArg
+                    ? `mimi-seed-auth --domains ${domainArg} 로 재로그인하면 기존 권한은 유지한 채 이 권한만 추가돼.`
+                    : 'mimi-seed-auth 로 재로그인하면 새 권한이 부여돼.',
                 retriable: false,
                 needsReauth: true,
             }));

package/dist/index.js

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
-import { readFileSync } from 'node:fs';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { buildServer } from './server.js';
-// dist/index.js 기준 ../package.json — npm 패키지 루트의 버전을 단일 출처로 사용.
+import { readPackageRootText } from './lib/package-root.js';
+// npm 패키지 루트의 버전을 단일 출처로 사용.
 // 하드코딩하면 publish 때마다 serverInfo.version 이 드리프트하므로 런타임에 읽는다.
-const { version } = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8'));
+const { version } = JSON.parse(readPackageRootText('package.json'));
 // `npx -y @yoonion/mimi-seed-mcp <subcommand>` 처리.
 // npx는 스코프 패키지의 basename(`mimi-seed-mcp`)을 매치해 이 bin을 실행하므로,
 // 추가 인자(`mimi-seed-auth` 등)는 여기 argv로 흘러들어온다. 이전엔 MCP 서버가

package/dist/lib/package-root.d.ts

@@ -0,0 +1,24 @@
+/**
+ * 패키지 루트의 파일을 읽는다 (없거나 못 읽으면 throw).
+ * src/lib/ 와 dist/lib/ 모두 패키지 루트에서 두 단계 아래라 `../../` 가 같은 곳을 가리킨다 —
+ * dev(tsx)·vitest·배포본(npm) 어디서 실행해도 동일하게 동작한다.
+ * 개별 `new URL('../..', import.meta.url)` 복사본을 만들지 말고 이 헬퍼를 쓸 것
+ * (빌드 레이아웃이 바뀌면 여기 한 곳만 고치면 된다).
+ */
+export declare function readPackageRootText(relativePath: string): string;
+export type DomainEntry = {
+    /** 사람이 읽는 도메인 이름 (예: "Google Play") */
+    label: string;
+    /** 이 도메인을 쓰기 위해 필요한 자격증명 + 연결 명령 힌트 */
+    credential: string;
+    /** 도메인이 하는 일 한 줄 요약 */
+    summary: string;
+    tools: string[];
+};
+/** tool-manifest.json 의 형태 — 도구 인벤토리 + 도메인 메타데이터의 SSOT. */
+export type ToolManifest = {
+    total: number;
+    domains: Record<string, DomainEntry>;
+};
+/** tool-manifest.json 을 읽고 최소 형태를 검증한다. 손상/형태이상이면 throw. */
+export declare function readToolManifest(): ToolManifest;

package/dist/lib/package-root.js

@@ -0,0 +1,21 @@
+import { readFileSync } from 'node:fs';
+/**
+ * 패키지 루트의 파일을 읽는다 (없거나 못 읽으면 throw).
+ * src/lib/ 와 dist/lib/ 모두 패키지 루트에서 두 단계 아래라 `../../` 가 같은 곳을 가리킨다 —
+ * dev(tsx)·vitest·배포본(npm) 어디서 실행해도 동일하게 동작한다.
+ * 개별 `new URL('../..', import.meta.url)` 복사본을 만들지 말고 이 헬퍼를 쓸 것
+ * (빌드 레이아웃이 바뀌면 여기 한 곳만 고치면 된다).
+ */
+export function readPackageRootText(relativePath) {
+    return readFileSync(new URL(`../../${relativePath}`, import.meta.url), 'utf8');
+}
+/** tool-manifest.json 을 읽고 최소 형태를 검증한다. 손상/형태이상이면 throw. */
+export function readToolManifest() {
+    const manifest = JSON.parse(readPackageRootText('tool-manifest.json'));
+    if (typeof manifest?.total !== 'number' ||
+        typeof manifest?.domains !== 'object' ||
+        manifest.domains === null) {
+        throw new Error('tool-manifest.json 의 형태가 예상과 다릅니다');
+    }
+    return manifest;
+}

package/dist/playstore/tools.js

@@ -1,6 +1,7 @@
 import { google } from 'googleapis';
 import { JWT } from 'google-auth-library';
 import fs from 'node:fs';
+import { extractHttpStatus } from '../lib/google-errors.js';
 function mimeTypeFor(filePath) {
     const ext = filePath.toLowerCase().split('.').pop() ?? '';
     if (ext === 'png')
@@ -149,14 +150,35 @@ export async function updateListing(auth, packageName, language, data) {
     // 그대로 실려 나가면 patch 라도 해당 필드를 비우려는 의도로 해석될 여지가 있다.
     const requestBody = Object.fromEntries(Object.entries(data).filter(([, v]) => v !== undefined));
     return withEdit(auth, packageName, async (editId) => {
-        const updated = await publisher().edits.listings.patch({
-            auth,
-            packageName,
-            editId,
-            language,
-            requestBody,
-        });
-        return updated.data;
+        try {
+            const updated = await publisher().edits.listings.patch({
+                auth,
+                packageName,
+                editId,
+                language,
+                requestBody,
+            });
+            return updated.data;
+        }
+        catch (error) {
+            // PATCH only works when the locale already exists. A missing translation returns
+            // 404 even though the package and edit are valid. In that case a complete PUT is
+            // the documented create-or-replace operation for the new locale.
+            if (extractHttpStatus(error) !== 404)
+                throw error;
+            const { title, shortDescription, fullDescription } = data;
+            if (!title || !shortDescription || !fullDescription) {
+                throw new Error(`Google Play ${language} 리스팅이 아직 없어요. 새 언어를 만들려면 title, shortDescription, fullDescription을 모두 보내야 해요.`, { cause: error });
+            }
+            const created = await publisher().edits.listings.update({
+                auth,
+                packageName,
+                editId,
+                language,
+                requestBody: { title, shortDescription, fullDescription },
+            });
+            return created.data;
+        }
     }, true);
 }
 // ─── 트랙 목록 (릴리스 현황) ───

package/dist/registers/auth.js

@@ -1,8 +1,8 @@
-import { readFileSync } from 'node:fs';
 import { z } from 'zod';
 import { getMcpOAuthClient } from '../auth/constants.js';
 import { classifyError } from '../auth/errors.js';
-import { startAuth, ensureFreshAccessToken, getTokensLastRefreshMs } from '../auth/google-auth.js';
+import { startAuth, ensureFreshAccessToken, getTokensLastRefreshMs, getStoredTokens, } from '../auth/google-auth.js';
+import { AUTH_DOMAINS, DOMAIN_IDS, summarizeGrantedDomains } from '../auth/scopes.js';
 import { listRegisteredServiceAccounts } from '../auth/playstore-auth.js';
 import { getAppStoreCredentials } from '../appstore/auth.js';
 import { loadJenkinsConfig } from '../jenkins/config.js';
@@ -12,6 +12,7 @@ import { loadFacebookConfig } from '../facebook/config.js';
 import { loadInstagramConfig } from '../instagram/config.js';
 import { loadThreadsConfig } from '../threads/config.js';
 import { metaTokenFreshness } from '../lib/meta-auth.js';
+import { readPackageRootText } from '../lib/package-root.js';
 import { resolveBigQueryAuth } from '../auth/bigquery-auth.js';
 import { syncRemoteCredentials } from '../remote-sync.js';
 import { findProjectManifest, manifestServiceEntries, } from '../lib/project-manifest.js';
@@ -68,7 +69,7 @@ const MANIFEST_FIX = {
 };
 // 두 MCP 가 모두 'mimi-seed' 로 등록되는 환경에서 에이전트가 프로그램적으로
 // 어느 서버인지 판별할 수 있도록 status 첫 줄에 자기소개를 넣는다.
-const { version: PKG_VERSION } = JSON.parse(readFileSync(new URL('../../package.json', import.meta.url), 'utf8'));
+const { version: PKG_VERSION } = JSON.parse(readPackageRootText('package.json'));
 /** 서비스별 식별자를 한 줄 detail 로 (예: "ads-coffee / analytics_530080532"). */
 function manifestServiceDetail(id, svc) {
     const parts = [];
@@ -249,8 +250,15 @@ export function registerAuthTools(server) {
         'Google OAuth 로그인 링크를 발급하고 백그라운드 콜백 서버를 시작.',
         '응답에 포함된 URL을 브라우저에서 열고 승인하면 localhost:9876으로 자동 콜백 → 토큰이 ~/.mimi-seed/tokens.json에 저장됨.',
         '이후 playstore_*, firebase_*, admob_* 등 다른 MCP 도구 바로 호출 가능.',
+        'domains 로 필요한 권한 도메인만 골라 요청 가능 (미지정 시 전체). 재로그인 시 기존 부여 권한은 유지되고 새 권한만 추가됨(incremental).',
         '토큰 만료(invalid_rapt) / 재인증 필요 시 사용. 10분 내 완료해야 함.',
-    ].join(' '), {}, async () => {
+    ].join(' '), {
+        domains: z
+            .array(z.enum(DOMAIN_IDS))
+            .optional()
+            .describe(`요청할 권한 도메인 서브셋 (미지정 시 전체). 가능한 값: ${DOMAIN_IDS.join(', ')}. ` +
+            '예: ["ga4","googleads"] — 기존에 부여된 다른 도메인 권한은 유지된다.'),
+    }, async ({ domains }) => {
         // 설정 조회 실패를 분류된 안내로 — raw throw 는 MCP 클라이언트에 마커 문자열만 노출된다.
         let clientId;
         let clientSecret;
@@ -266,9 +274,12 @@ export function registerAuthTools(server) {
                     }],
             };
         }
-        const { url, wait } = startAuth(clientId, clientSecret);
+        const { url, wait } = startAuth(clientId, clientSecret, { domains });
         // fire-and-forget — 토큰은 콜백 서버가 자동 저장
         wait.then(() => { }, (err) => { console.error('[mimi-seed auth]', err.message); });
+        const scopeLine = domains?.length
+            ? `요청 도메인: ${domains.map((d) => `${d} (${AUTH_DOMAINS[d].label})`).join(', ')} — 기존 부여 권한은 유지됨.`
+            : `요청 도메인: 전체 (${DOMAIN_IDS.join(', ')})`;
         return {
             content: [{
                     type: 'text',
@@ -277,6 +288,8 @@ export function registerAuthTools(server) {
                         '',
                         url,
                         '',
+                        scopeLine,
+                        '',
                         '이 URL을 브라우저에서 열고 Google 계정으로 승인해줘.',
                         '완료되면 localhost:9876으로 자동 리다이렉트되고 토큰이 저장돼.',
                         '이후 바로 다른 MCP 도구(playstore_*, firebase_* 등) 호출 가능.',
@@ -289,6 +302,23 @@ export function registerAuthTools(server) {
         const refreshHint = formatLastRefreshHint(getTokensLastRefreshMs());
         const refreshLine = `   마지막 갱신: ${refreshHint.label}`;
         const recommendation = refreshHint.recommendation ? `\n\n${refreshHint.recommendation}` : '';
+        // 도메인 선택형 로그인 이후 토큰은 전체 권한이 아닐 수 있다 — 부여 현황을 함께
+        // 보여준다. 유효/갱신된 상태에서만 쓰므로 그 두 arm 에서만 계산한다(불필요한 토큰
+        // 재조회 + 도메인 스캔 방지).
+        const domainStatusBlock = () => {
+            const summary = summarizeGrantedDomains(getStoredTokens()?.scope);
+            const domainLines = [];
+            if (!summary.known) {
+                domainLines.push('   권한 도메인: (구 토큰 — scope 기록 없음. 재로그인하면 기록됨)');
+            }
+            else {
+                domainLines.push(`   권한 도메인: ${summary.granted.join(', ') || '(없음)'}`);
+                if (summary.missing.length > 0) {
+                    domainLines.push(`   미부여: ${summary.missing.join(', ')} → mimi_seed_auth_start(domains=[...]) 로 추가 (기존 권한 유지)`);
+                }
+            }
+            return `\n${domainLines.join('\n')}`;
+        };
         switch (r.status) {
             case 'unauthenticated':
                 return {
@@ -304,7 +334,7 @@ export function registerAuthTools(server) {
                 return {
                     content: [{
                             type: 'text',
-                            text: `✅ 인증 유효 (${min}분 남음).\n${refreshLine}${recommendation}`,
+                            text: `✅ 인증 유효 (${min}분 남음).\n${refreshLine}${domainStatusBlock()}${recommendation}`,
                         }],
                 };
             }
@@ -313,7 +343,7 @@ export function registerAuthTools(server) {
                 return {
                     content: [{
                             type: 'text',
-                            text: `✅ 토큰 만료 → refresh_token으로 자동 갱신 완료 (${min}분 남음).\n${refreshLine}${recommendation}`,
+                            text: `✅ 토큰 만료 → refresh_token으로 자동 갱신 완료 (${min}분 남음).\n${refreshLine}${domainStatusBlock()}${recommendation}`,
                         }],
                 };
             }

package/dist/registers/firebase.js

@@ -1,6 +1,7 @@
 import { z } from 'zod';
 import * as firebaseRaw from '../firebase/tools.js';
 import { requireAuth } from '../helpers.js';
+import { CLOUD_PLATFORM_SCOPE } from '../auth/scopes.js';
 import { friendlyGoogleError } from '../lib/google-errors.js';
 // 모든 firebase tools 호출을 친절 에러로 감싸는 프록시 — 17개 핸들러에 개별
 // try/catch 없이 raw GaxiosError(API 미활성화/프로젝트 없음/billing/권한)를
@@ -53,7 +54,8 @@ export function registerFirebaseTools(server) {
             .optional()
             .describe("조직/폴더 소속이 필요한 계정일 때만: 'organizations/<id>' 또는 'folders/<id>'. 생략 시 계정 기본 정책대로 생성"),
     }, async ({ projectId, displayName, parent }) => {
-        const auth = await requireAuth();
+        // 프로젝트 생성은 Cloud Resource Manager 라 firebase 스코프만으로는 안 된다.
+        const auth = await requireAuth(CLOUD_PLATFORM_SCOPE);
         const project = await firebase.createProject(auth, projectId, displayName, { parent });
         return {
             content: [
@@ -167,17 +169,18 @@ export function registerFirebaseTools(server) {
         projectId: z.string().describe('프로젝트 ID'),
         serviceId: z.string().describe('서비스 ID (예: firestore.googleapis.com)'),
     }, async ({ projectId, serviceId }) => {
-        const auth = await requireAuth();
+        // Service Usage API — firebase 스코프가 아니라 cloud-platform 을 요구한다.
+        const auth = await requireAuth(CLOUD_PLATFORM_SCOPE);
         const result = await firebase.enableService(auth, projectId, serviceId);
         return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
     });
     server.tool('firebase_enable_common_services', 'Firebase 기본 서비스 일괄 활성화 (Firestore, Auth, Storage, FCM 등)', { projectId: z.string().describe('프로젝트 ID') }, async ({ projectId }) => {
-        const auth = await requireAuth();
+        const auth = await requireAuth(CLOUD_PLATFORM_SCOPE);
         const results = await firebase.enableCommonServices(auth, projectId);
         return { content: [{ type: 'text', text: JSON.stringify(results, null, 2) }] };
     });
     server.tool('firebase_list_enabled_services', '프로젝트에서 활성화된 GCP 서비스 목록', { projectId: z.string().describe('프로젝트 ID') }, async ({ projectId }) => {
-        const auth = await requireAuth();
+        const auth = await requireAuth(CLOUD_PLATFORM_SCOPE);
         const services = await firebase.listEnabledServices(auth, projectId);
         return { content: [{ type: 'text', text: JSON.stringify(services, null, 2) }] };
     });

package/dist/registers/iam.js

@@ -1,11 +1,12 @@
 import { z } from 'zod';
 import * as iam from '../iam/tools.js';
 import { requireAuth } from '../helpers.js';
+import { CLOUD_PLATFORM_SCOPE } from '../auth/scopes.js';
 export function registerIamTools(server) {
     server.tool('iam_list_service_accounts', '주어진 projectId의 서비스 계정 목록. 이메일 / displayName / disabled 상태 반환.', {
         projectId: z.string().describe('Google Cloud 프로젝트 ID'),
     }, async ({ projectId }) => {
-        const auth = await requireAuth();
+        const auth = await requireAuth(CLOUD_PLATFORM_SCOPE);
         const accounts = await iam.listServiceAccounts(auth, projectId);
         return { content: [{ type: 'text', text: JSON.stringify(accounts, null, 2) }] };
     });
@@ -17,7 +18,7 @@ export function registerIamTools(server) {
             .describe('서비스 계정 ID (이메일 로컬 파트)'),
         displayName: z.string().describe('사람이 읽을 표시 이름 (예: "onesub Play verifier")'),
     }, async ({ projectId, accountId, displayName }) => {
-        const auth = await requireAuth();
+        const auth = await requireAuth(CLOUD_PLATFORM_SCOPE);
         const account = await iam.createServiceAccount(auth, projectId, accountId, displayName);
         return {
             content: [
@@ -41,7 +42,7 @@ export function registerIamTools(server) {
     server.tool('iam_list_keys', '주어진 서비스 계정의 기존 키 목록. keyId / keyType / 만료시간 반환. 회수할 키 찾을 때 사용.', {
         serviceAccount: z.string().describe('서비스 계정 이메일'),
     }, async ({ serviceAccount }) => {
-        const auth = await requireAuth();
+        const auth = await requireAuth(CLOUD_PLATFORM_SCOPE);
         const keys = await iam.listServiceAccountKeys(auth, serviceAccount);
         return { content: [{ type: 'text', text: JSON.stringify(keys, null, 2) }] };
     });
@@ -51,7 +52,7 @@ export function registerIamTools(server) {
     ].join(' '), {
         serviceAccount: z.string().describe('서비스 계정 이메일'),
     }, async ({ serviceAccount }) => {
-        const auth = await requireAuth();
+        const auth = await requireAuth(CLOUD_PLATFORM_SCOPE);
         const key = await iam.createServiceAccountKey(auth, serviceAccount);
         return {
             content: [
@@ -89,7 +90,7 @@ export function registerIamTools(server) {
             .describe('권한 받을 주체 (예: serviceAccount:my-sa@my-project.iam.gserviceaccount.com)'),
         role: z.string().describe('IAM 역할 (예: roles/iam.serviceAccountTokenCreator)'),
     }, async ({ projectId, member, role }) => {
-        const auth = await requireAuth();
+        const auth = await requireAuth(CLOUD_PLATFORM_SCOPE);
         const result = await iam.addProjectIamPolicyBinding(auth, projectId, member, role);
         return {
             content: [

package/dist/registers/playstore.js

@@ -59,7 +59,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 스토어 리스팅 수정 (제목, 설명문 변경). 넘긴 필드만 부분 갱신(edits.listings.patch) — 생략한 필드와 프로모 영상(video)은 보존된다. ⚠️ Play API 편집과 Console 동시 편집은 충돌 — Console에서 같은 리스팅을 편집·미게시 중이면 그 변경이 덮어써질 수 있음.', {
+    server.tool('playstore_update_listing', 'Google Play 스토어 리스팅 수정 또는 새 언어 생성. 기존 언어는 넘긴 필드만 부분 갱신(edits.listings.patch)해 생략한 필드와 프로모 영상(video)을 보존한다. 새 언어는 title·shortDescription·fullDescription을 모두 전달해야 하며 전체 리스팅을 생성한다. ⚠️ Play API 편집과 Console 동시 편집은 충돌 — Console에서 같은 리스팅을 편집·미게시 중이면 그 변경이 덮어써질 수 있음.', {
         packageName: z.string().describe('패키지명'),
         language: z.string().describe('언어 코드 (예: ko-KR, en-US)'),
         title: z.string().optional().describe('앱 제목 (30자 이내)'),

package/dist/registers/video.d.ts

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

package/dist/registers/video.js

@@ -0,0 +1,165 @@
+import { z } from 'zod';
+import { addLocalAsset, buildTimeline, loadProject, loadTimeline, planStory, } from '../video/project.js';
+import { downloadStockAssets, generateImage, researchYouTube, searchStock, } from '../video/providers.js';
+import { getRenderJob, startRender, validateVideo } from '../video/render.js';
+import { synthesizeResearch } from '../video/research.js';
+function text(value) {
+    return { content: [{ type: 'text', text: JSON.stringify(value, null, 2) }] };
+}
+const absolutePath = z.string().min(1).describe('절대경로. 상대경로는 허용하지 않습니다.');
+const httpUrl = z.string().url().refine((value) => {
+    const protocol = new URL(value).protocol;
+    return protocol === 'https:' || protocol === 'http:';
+}, 'HTTP(S) URL만 허용합니다.');
+export function registerVideoTools(server) {
+    server.tool('video_plan_from_story', [
+        '정리된 story를 장면별 스토리보드로 변환하고 로컬 영상 프로젝트를 만듭니다.',
+        'ANTHROPIC_API_KEY가 필요합니다. projectDir에는 project.json과 자산/리서치/렌더 폴더가 생성됩니다.',
+        '기존 project.json은 overwrite=true 없이는 덮어쓰지 않습니다.',
+    ].join(' '), {
+        projectDir: absolutePath,
+        title: z.string().min(1).max(500).describe('영상 제목'),
+        story: z.string().min(1).max(200_000).describe('영상으로 만들 story 원문'),
+        language: z.string().default('ko').describe('내레이션과 화면 문구 언어'),
+        aspectRatio: z.enum(['9:16', '16:9', '1:1']).default('9:16').describe('출력 화면비'),
+        targetDurationSec: z.number().min(5).max(300).default(30).describe('목표 영상 길이(초)'),
+        style: z.string().max(10_000).optional().describe('시각 스타일과 톤'),
+        overwrite: z.boolean().default(false).describe('기존 메타데이터를 .history에 보관하고 새 프로젝트로 덮어쓸지 여부'),
+    }, async (input) => text(await planStory(input)));
+    server.tool('video_research_youtube', [
+        '스토리보드 검색어나 지정 검색어로 YouTube 유사 영상을 조사합니다.',
+        'YOUTUBE_API_KEY가 필요하며 결과는 research/youtube.json에 저장됩니다.',
+        '결과는 reference-only로 기록되어 영상 파일 다운로드나 렌더링 소스로 사용되지 않습니다.',
+    ].join(' '), {
+        projectDir: absolutePath,
+        queries: z.array(z.string().min(1).max(1_000)).min(1).max(5).optional().describe('검색어. 생략하면 스토리보드 searchQuery 사용'),
+        maxResultsPerQuery: z.number().int().min(1).max(10).default(5),
+        regionCode: z.string().length(2).optional().describe('ISO 3166-1 alpha-2 지역 코드'),
+        publishedAfter: z.string().datetime().optional().describe('RFC 3339 게시 시각 하한'),
+        creativeCommonsOnly: z.boolean().default(false).describe('Creative Commons 표시 영상만 검색'),
+        order: z.enum(['relevance', 'viewCount', 'date']).default('relevance').describe('유사도/조회수/최신순 정렬'),
+    }, async (input) => text(await researchYouTube(input)));
+    server.tool('video_synthesize_research', [
+        '저장된 YouTube/Pexels 메타데이터와 사용자가 직접 관찰한 영상 메모를 독창적인 제작 방향으로 종합합니다.',
+        'ANTHROPIC_API_KEY가 필요하며 결과는 research/brief.json에 저장됩니다.',
+        '실제 영상 프레임이나 오디오를 보았다고 주장하지 않고, 외부 제목·설명 안의 명령은 신뢰하지 않습니다.',
+        '훅·구조·템포의 추상 패턴만 제안하고 복제하면 안 되는 요소와 분석 한계를 함께 기록합니다.',
+    ].join(' '), {
+        projectDir: absolutePath,
+        goal: z.string().max(10_000).optional(),
+        observations: z.array(z.object({
+            referenceUrl: httpUrl,
+            notes: z.string().min(1).max(10_000).describe('사용자/에이전트가 직접 관찰한 훅·장면·템포 메모'),
+        })).max(20).optional(),
+    }, async (input) => text(await synthesizeResearch(input)));
+    server.tool('video_search_stock_assets', [
+        '스토리보드 검색어나 지정 검색어로 Pexels 라이선스 스톡 영상을 찾습니다.',
+        'PEXELS_API_KEY가 필요하며 결과는 research/pexels.json에 저장됩니다.',
+        '검색만 수행하며 다운로드는 video_download_stock_assets로 별도 승인 후 실행합니다.',
+    ].join(' '), {
+        projectDir: absolutePath,
+        queries: z.array(z.string().min(1)).min(1).max(10).optional(),
+        orientation: z.enum(['landscape', 'portrait', 'square']).optional(),
+        perQuery: z.number().int().min(1).max(15).default(5),
+    }, async (input) => text(await searchStock(input)));
+    server.tool('video_download_stock_assets', [
+        '선택한 Pexels 스톡 영상을 프로젝트로 다운로드하고 출처·라이선스·해시를 assets.json에 기록합니다.',
+        'confirm=false는 다운로드 계획만 반환합니다. 외부 파일 다운로드 전 사용자 승인을 받은 뒤 confirm=true로 다시 호출하세요.',
+        'Pexels 공식 미디어 호스트만 허용하며 파일당 100MB, 호출당 5개로 제한합니다.',
+    ].join(' '), {
+        projectDir: absolutePath,
+        selections: z.array(z.object({
+            id: z.number().int(),
+            downloadUrl: httpUrl,
+            pageUrl: httpUrl,
+            author: z.string().optional(),
+            attribution: z.string().optional(),
+        })).min(1).max(5),
+        confirm: z.boolean().default(false),
+    }, async ({ projectDir, selections, confirm }) => {
+        loadProject(projectDir);
+        if (!confirm)
+            return text({ confirmed: false, action: 'download', count: selections.length, selections });
+        return text(await downloadStockAssets(projectDir, selections));
+    });
+    server.tool('video_generate_image', [
+        'OpenAI Image API로 장면 이미지를 생성하고 프로젝트 자산으로 등록합니다.',
+        'OPENAI_API_KEY가 필요합니다. 기본 모델은 gpt-image-2이며 이미지 바이트는 도구 응답에 넣지 않고 로컬 절대경로만 반환합니다.',
+        'confirm=false는 생성 계획만 반환합니다. 비용이 발생하므로 사용자 승인 후 confirm=true로 호출하세요.',
+    ].join(' '), {
+        projectDir: absolutePath,
+        prompt: z.string().min(1),
+        name: z.string().optional().describe('출력 파일명 힌트(확장자 제외)'),
+        model: z.enum(['gpt-image-2', 'gpt-image-1.5', 'gpt-image-1', 'gpt-image-1-mini']).default('gpt-image-2'),
+        quality: z.enum(['low', 'medium', 'high', 'auto']).default('medium'),
+        size: z.enum(['1024x1024', '1024x1536', '1536x1024']).optional(),
+        confirm: z.boolean().default(false),
+    }, async ({ confirm, ...input }) => {
+        loadProject(input.projectDir);
+        if (!confirm)
+            return text({ confirmed: false, action: 'generate_image', ...input });
+        return text(await generateImage(input));
+    });
+    server.tool('video_add_local_asset', [
+        '사용자 소유 또는 별도 라이선스를 확보한 로컬 이미지·영상·오디오를 프로젝트에 복사해 등록합니다.',
+        'filePath는 절대경로여야 하며 license와 출처 정보가 assets.json에 기록됩니다.',
+        'reference-only 자료는 이 도구로 등록하지 마세요.',
+    ].join(' '), {
+        projectDir: absolutePath,
+        filePath: absolutePath,
+        kind: z.enum(['image', 'video', 'audio']),
+        sourceType: z.enum(['user-owned', 'licensed']),
+        license: z.string().min(1).describe('소유권 또는 라이선스 근거'),
+        author: z.string().optional(),
+        attribution: z.string().optional(),
+    }, async (input) => text(addLocalAsset(input)));
+    server.tool('video_build_timeline', [
+        '등록된 이미지·영상 자산을 장면 순서와 길이에 맞춰 timeline.json으로 조합합니다.',
+        'assets.json에서 allowedForRendering=true이고 reference-only가 아닌 자산만 허용합니다.',
+        '화면 문구는 최종 렌더에서 자막으로 번인됩니다.',
+    ].join(' '), {
+        projectDir: absolutePath,
+        scenes: z.array(z.object({
+            id: z.string().min(1),
+            assetId: z.string().min(1),
+            durationSec: z.number().positive().max(300),
+            onScreenText: z.string().optional(),
+            narration: z.string().optional(),
+        })).min(1).max(30),
+        audioAssetId: z.string().optional(),
+    }, async ({ projectDir, scenes, audioAssetId }) => text(buildTimeline(projectDir, scenes, audioAssetId)));
+    server.tool('video_render', [
+        'timeline.json과 등록 자산을 FFmpeg로 합성해 MP4 렌더 작업을 시작합니다.',
+        '이미지/영상 크롭, 장면 연결, 화면 문구 번인, 선택적 배경음, H.264/yuv420p 출력을 지원합니다.',
+        'confirm=false는 계획만 반환합니다. CPU를 사용하는 로컬 쓰기 작업이므로 승인 후 confirm=true로 호출하세요.',
+        '즉시 jobId를 반환하므로 video_job_status로 완료 여부를 확인하세요.',
+    ].join(' '), {
+        projectDir: absolutePath,
+        outputFileName: z.string().default('output.mp4'),
+        ffmpegPath: z.string().optional().describe('FFmpeg 실행 파일 경로. 생략하면 MIMI_SEED_FFMPEG_PATH 또는 PATH 사용'),
+        overwriteOutput: z.boolean().default(false).describe('기존 출력 MP4 덮어쓰기 여부'),
+        confirm: z.boolean().default(false),
+    }, async ({ confirm, ...input }) => {
+        const project = loadProject(input.projectDir);
+        const timeline = loadTimeline(input.projectDir);
+        if (!confirm) {
+            return text({
+                confirmed: false,
+                action: 'render',
+                title: project.title,
+                scenes: timeline.scenes.length,
+                durationSec: timeline.totalDurationSec,
+                outputFileName: input.outputFileName,
+            });
+        }
+        return text(await startRender(input));
+    });
+    server.tool('video_job_status', 'video_render가 시작한 비동기 FFmpeg 작업의 상태와 결과 절대경로를 조회합니다. 실패한 경우 로그 마지막 부분을 함께 반환합니다.', {
+        projectDir: absolutePath,
+        jobId: z.string().uuid(),
+    }, async ({ projectDir, jobId }) => text(getRenderJob(projectDir, jobId)));
+    server.tool('video_validate', 'ffprobe로 완성된 영상의 길이·해상도·코덱·픽셀 포맷을 검사합니다. H.264와 yuv420p가 아니면 이슈로 표시합니다.', {
+        filePath: absolutePath,
+        ffmpegPath: z.string().optional().describe('FFmpeg 절대경로를 주면 같은 폴더의 ffprobe를 사용'),
+    }, async ({ filePath, ffmpegPath }) => text(await validateVideo(filePath, ffmpegPath)));
+}

package/dist/resources.d.ts

@@ -1,7 +1,2 @@
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-/** tool-manifest.json 의 형태. 테스트들도 이 타입을 import 해 캐스트 드리프트를 막는다. */
-export type ToolManifest = {
-    total: number;
-    domains: Record<string, string[]>;
-};
 export declare function registerResources(server: McpServer): void;