@yoonion/mimi-seed-mcp 0.12.1 → 0.13.0

package/README.md

@@ -96,7 +96,7 @@ export ANTHROPIC_API_KEY=sk-ant-...
 | Android 서명 | 3 | `android_signing_setup` / `android_generate_keystore` / `jenkins_upload_playstore_sa` |
 | 인증 | 4 | `mimi_seed_status` / `mimi_seed_auth_start` / `mimi_seed_auth_status` / `mimi_seed_remote_sync_credentials` |
 | AI (Claude) | 2 | `generate_release_notes_from_commits` / `generate_review_reply` |
-| 영상 제작 | 11 | `video_plan_from_story` / `video_research_youtube` / `video_synthesize_research` / `video_generate_image` / `video_render` |
+| 영상 제작·YouTube | 14 | `youtube_upload_video` / `youtube_get_video_status` / `youtube_update_video_privacy` / `video_plan_from_story` / `video_render` |
 
 > 인앱 결제(IAP·구독) 도구는 위 Play Store·App Store 카운트에 포함됩니다 — `appstore_create_inapp_purchase` · `appstore_update_product_review_note` · `appstore_upload_product_review_screenshot` 등.
 > 전체 카탈로그(항상 최신): [`docs/domain/tool-catalog.md`](../../docs/domain/tool-catalog.md)

package/assets/agent-guide.md

@@ -57,6 +57,7 @@ tools directly — but the *call order* and *safety rules* below still apply.
 | CI (GitHub/GitLab) | `select:ci_save_config,ci_list_workflows,ci_trigger_build,ci_get_build_status,ci_list_recent_builds` |
 | Service account end-to-end | `select:iam_create_service_account,iam_create_key,iam_add_iam_policy_binding,playstore_register_service_account,playstore_verify_service_account` |
 | Story → researched video | `select:video_plan_from_story,video_research_youtube,video_search_stock_assets,video_synthesize_research,video_download_stock_assets,video_generate_image,video_add_local_asset,video_build_timeline,video_render,video_job_status,video_validate` |
+| YouTube upload / publish | `select:youtube_upload_video,youtube_get_video_status,youtube_update_video_privacy,mimi_seed_auth_start` |
 
 ---
 
@@ -80,7 +81,7 @@ every credential, which also tells them where to obtain each token
 
 | Service | Fix |
 |---------|-----|
-| Google (Firebase/AdMob/Play/Ads/GSC/GA4/IAM/BigQuery) | tool `mimi_seed_auth_start` → give the user the OAuth URL, **or** `mimi-seed auth login`. Both accept a **domain subset** (`domains=["ga4","googleads"]` / `--domains ga4,googleads`) — request only what the task needs; re-auth keeps prior grants (incremental). Omit for all domains |
+| Google (Firebase/AdMob/Play/Ads/GSC/GA4/IAM/BigQuery/YouTube) | tool `mimi_seed_auth_start` → give the user the OAuth URL, **or** `mimi-seed auth login`. Both accept a **domain subset** (`domains=["youtube"]` / `--domains youtube`) — request only what the task needs; re-auth keeps prior grants (incremental). Omit for all domains |
 | App Store Connect | `mimi-seed auth appstore` → verify with `appstore_verify_credentials` |
 | Play service account | `mimi-seed auth playstore`, or register per-package with `playstore_register_service_account`. **Optional** — the OAuth token carries `androidpublisher`, so this is only needed for headless/CI |
 | BigQuery | `mimi-seed auth bigquery` (optional — OAuth works too) |
@@ -153,7 +154,7 @@ per-domain inventory is [`docs/domain/tool-catalog.md`](domain/tool-catalog.md).
 | **Facebook / Instagram / Threads** | `facebook_post_photo` · `instagram_post_carousel` · `threads_post` · `threads_refresh_token` |
 | **Checks** | `playstore_check_submission_risks` · `appstore_check_submission_risks` · `screenshot_validate` · `release_status` |
 | **AI / Auth** | `generate_release_notes_from_commits` · `generate_review_reply` · `mimi_seed_status` · `mimi_seed_auth_start` · `mimi_seed_auth_status` · `mimi_seed_remote_sync_credentials` |
-| **Video production** | `video_plan_from_story` · `video_research_youtube` · `video_search_stock_assets` · `video_synthesize_research` · `video_generate_image` · `video_build_timeline` · `video_render` · `video_job_status` · `video_validate` |
+| **Video production** | `youtube_upload_video` · `youtube_get_video_status` · `youtube_update_video_privacy` · `video_plan_from_story` · `video_research_youtube` · `video_search_stock_assets` · `video_synthesize_research` · `video_generate_image` · `video_build_timeline` · `video_render` · `video_job_status` · `video_validate` |
 
 ---
 

package/dist/auth/scopes.d.ts

@@ -59,6 +59,11 @@ export declare const AUTH_DOMAINS: {
         readonly scopes: readonly ["https://www.googleapis.com/auth/analytics.edit", "https://www.googleapis.com/auth/analytics.readonly"];
         readonly summary: "ga4_* — property/data stream 생성·조회 + 리포트";
     };
+    readonly youtube: {
+        readonly label: "YouTube";
+        readonly scopes: readonly ["https://www.googleapis.com/auth/youtube.force-ssl"];
+        readonly summary: "youtube_* — 영상 업로드·처리 상태 조회·공개 상태 변경";
+    };
 };
 export type AuthDomainId = keyof typeof AUTH_DOMAINS;
 /** z.enum 등 튜플이 필요한 자리에 쓰는 도메인 id 목록 (선언 순서 유지). */

package/dist/auth/scopes.js

@@ -61,6 +61,11 @@ export const AUTH_DOMAINS = {
         ],
         summary: 'ga4_* — property/data stream 생성·조회 + 리포트',
     },
+    youtube: {
+        label: 'YouTube',
+        scopes: ['https://www.googleapis.com/auth/youtube.force-ssl'],
+        summary: 'youtube_* — 영상 업로드·처리 상태 조회·공개 상태 변경',
+    },
 };
 /** z.enum 등 튜플이 필요한 자리에 쓰는 도메인 id 목록 (선언 순서 유지). */
 export const DOMAIN_IDS = Object.keys(AUTH_DOMAINS);

package/dist/registers/auth.js

@@ -132,6 +132,13 @@ export function registerAuthTools(server) {
         else {
             lines.push('❌ Google OAuth      — 미연결 → mimi_seed_auth_start');
         }
+        const youtubeGranted = summarizeGrantedDomains(getStoredTokens()?.scope).granted.includes('youtube');
+        if (youtubeGranted && (oauthResult.status === 'fresh' || oauthResult.status === 'refreshed')) {
+            lines.push('✅ YouTube           — 업로드·상태 관리 권한 연결됨');
+        }
+        else {
+            lines.push('❌ YouTube           — 미연결 → mimi_seed_auth_start(domains=["youtube"])  (선택)');
+        }
         // 2. Play Store SA
         const saInfo = listRegisteredServiceAccounts();
         const saCount = saInfo.perPackage.length + (saInfo.default ? 1 : 0);

package/dist/registers/video.js

@@ -3,6 +3,8 @@ import { addLocalAsset, buildTimeline, loadProject, loadTimeline, planStory, } f
 import { downloadStockAssets, generateImage, researchYouTube, searchStock, } from '../video/providers.js';
 import { getRenderJob, startRender, validateVideo } from '../video/render.js';
 import { synthesizeResearch } from '../video/research.js';
+import { requireAuth } from '../helpers.js';
+import { YOUTUBE_SCOPE, getYouTubeVideoStatus, updateYouTubeVideoPrivacy, uploadYouTubeVideo, } from '../video/youtube-publish.js';
 function text(value) {
     return { content: [{ type: 'text', text: JSON.stringify(value, null, 2) }] };
 }
@@ -12,6 +14,45 @@ const httpUrl = z.string().url().refine((value) => {
     return protocol === 'https:' || protocol === 'http:';
 }, 'HTTP(S) URL만 허용합니다.');
 export function registerVideoTools(server) {
+    server.tool('youtube_upload_video', [
+        '로컬 영상 파일을 현재 Google OAuth 계정의 YouTube 채널에 업로드합니다.',
+        '기본 공개 상태는 private이며 public/unlisted는 같은 턴의 명시 승인 후 confirmVisible=true가 필요합니다.',
+        '업로드 후 youtube_get_video_status로 처리 완료 여부와 실제 공개 상태를 확인하세요.',
+        '요청이 타임아웃되면 업로드가 뒤늦게 완료될 수 있으므로 YouTube Studio를 먼저 확인하고 중복 재시도하지 마세요.',
+        'YouTube OAuth 권한이 없으면 mimi_seed_auth_start(domains=["youtube"])로 증분 연결하세요.',
+    ].join(' '), {
+        filePath: absolutePath.describe('업로드할 .mp4/.mov/.webm 영상 절대경로'),
+        title: z.string().min(1).max(100).describe('YouTube 영상 제목'),
+        description: z.string().max(5_000).optional().describe('영상 설명과 음원 출처/라이선스 표기'),
+        tags: z.array(z.string().min(1).max(500)).max(100).optional(),
+        categoryId: z.string().regex(/^\d+$/).default('24').describe('YouTube 카테고리 ID'),
+        privacyStatus: z.enum(['private', 'unlisted', 'public']).default('private'),
+        madeForKids: z.boolean().default(false),
+        containsSyntheticMedia: z.boolean().optional().describe('현실적으로 보이는 AI 생성·변형 콘텐츠 여부를 YouTube에 고지'),
+        notifySubscribers: z.boolean().default(false),
+        shortsOnly: z.boolean().default(false).describe('true면 세로/정사각형·180초 이하 쇼츠 규격을 강제'),
+        confirmVisible: z.boolean().default(false).describe('public/unlisted 게시에 대한 명시 확인'),
+    }, async (input) => {
+        const auth = await requireAuth(YOUTUBE_SCOPE);
+        return text(await uploadYouTubeVideo(auth, input));
+    });
+    server.tool('youtube_get_video_status', '내 YouTube 영상의 업로드 처리 상태와 현재 공개 상태를 조회합니다.', {
+        videoId: z.string().min(1).max(64).describe('YouTube video ID'),
+    }, async ({ videoId }) => {
+        const auth = await requireAuth(YOUTUBE_SCOPE);
+        return text(await getYouTubeVideoStatus(auth, videoId));
+    });
+    server.tool('youtube_update_video_privacy', [
+        '내 YouTube 영상의 공개 상태를 변경하고 실제 반영 상태를 다시 조회합니다.',
+        'public/unlisted 변경은 같은 턴의 명시 승인 후 confirmVisible=true가 필요합니다.',
+    ].join(' '), {
+        videoId: z.string().min(1).max(64).describe('YouTube video ID'),
+        privacyStatus: z.enum(['private', 'unlisted', 'public']),
+        confirmVisible: z.boolean().default(false).describe('public/unlisted 변경에 대한 명시 확인'),
+    }, async (input) => {
+        const auth = await requireAuth(YOUTUBE_SCOPE);
+        return text(await updateYouTubeVideoPrivacy(auth, input));
+    });
     server.tool('video_plan_from_story', [
         '정리된 story를 장면별 스토리보드로 변환하고 로컬 영상 프로젝트를 만듭니다.',
         'ANTHROPIC_API_KEY가 필요합니다. projectDir에는 project.json과 자산/리서치/렌더 폴더가 생성됩니다.',

package/dist/video/youtube-publish.d.ts

@@ -0,0 +1,88 @@
+import { type youtube_v3 } from 'googleapis';
+import type { OAuth2Client } from 'google-auth-library';
+import { validateVideo } from './render.js';
+export declare const YOUTUBE_SCOPE = "https://www.googleapis.com/auth/youtube.force-ssl";
+export type YouTubePrivacyStatus = 'private' | 'unlisted' | 'public';
+export interface UploadYouTubeVideoInput {
+    filePath: string;
+    title: string;
+    description?: string;
+    tags?: string[];
+    categoryId?: string;
+    privacyStatus?: YouTubePrivacyStatus;
+    madeForKids?: boolean;
+    containsSyntheticMedia?: boolean;
+    notifySubscribers?: boolean;
+    shortsOnly?: boolean;
+    confirmVisible?: boolean;
+}
+export interface UpdateYouTubePrivacyInput {
+    videoId: string;
+    privacyStatus: YouTubePrivacyStatus;
+    confirmVisible?: boolean;
+}
+declare function assertVisibilityConfirmed(privacyStatus: YouTubePrivacyStatus, confirmVisible?: boolean): void;
+declare function assertUploadFile(filePath: string): {
+    size: number;
+    mimeType: string;
+};
+declare function assertTags(tags?: string[]): void;
+declare function videoFacts(validation: Awaited<ReturnType<typeof validateVideo>>): {
+    width?: number;
+    height?: number;
+    durationSec?: number;
+};
+declare function assertShortsCompatible(facts: ReturnType<typeof videoFacts>): void;
+export declare function getYouTubeVideoStatus(auth: OAuth2Client, videoId: string): Promise<{
+    videoId: string | null;
+    title: string | null;
+    privacyStatus: string | null;
+    uploadStatus: string | null;
+    processingStatus: string | null;
+    processingProgress: youtube_v3.Schema$VideoProcessingDetailsProcessingProgress | null;
+    madeForKids: boolean | null;
+    containsSyntheticMedia: boolean | null;
+    watchUrl: string | null;
+    studioUrl: string | null;
+}>;
+export declare function uploadYouTubeVideo(auth: OAuth2Client, input: UploadYouTubeVideoInput): Promise<{
+    requestedPrivacyStatus: YouTubePrivacyStatus;
+    file: {
+        width?: number;
+        height?: number;
+        durationSec?: number;
+        path: string;
+        size: number;
+    };
+    validationWarnings: string[];
+    videoId: string | null;
+    title: string | null;
+    privacyStatus: string | null;
+    uploadStatus: string | null;
+    processingStatus: string | null;
+    processingProgress: youtube_v3.Schema$VideoProcessingDetailsProcessingProgress | null;
+    madeForKids: boolean | null;
+    containsSyntheticMedia: boolean | null;
+    watchUrl: string | null;
+    studioUrl: string | null;
+}>;
+export declare function updateYouTubeVideoPrivacy(auth: OAuth2Client, input: UpdateYouTubePrivacyInput): Promise<{
+    videoId: string | null;
+    title: string | null;
+    privacyStatus: string | null;
+    uploadStatus: string | null;
+    processingStatus: string | null;
+    processingProgress: youtube_v3.Schema$VideoProcessingDetailsProcessingProgress | null;
+    madeForKids: boolean | null;
+    containsSyntheticMedia: boolean | null;
+    watchUrl: string | null;
+    studioUrl: string | null;
+}>;
+export declare const __testing: {
+    assertVisibilityConfirmed: typeof assertVisibilityConfirmed;
+    assertUploadFile: typeof assertUploadFile;
+    assertTags: typeof assertTags;
+    assertShortsCompatible: typeof assertShortsCompatible;
+    videoFacts: typeof videoFacts;
+};
+export {};

package/dist/video/youtube-publish.js

@@ -0,0 +1,179 @@
+import { createReadStream, existsSync, statSync } from 'node:fs';
+import path from 'node:path';
+import { google } from 'googleapis';
+import { friendlyGoogleError } from '../lib/google-errors.js';
+import { validateVideo } from './render.js';
+export const YOUTUBE_SCOPE = 'https://www.googleapis.com/auth/youtube.force-ssl';
+function assertVisibilityConfirmed(privacyStatus, confirmVisible) {
+    if (privacyStatus !== 'private' && confirmVisible !== true) {
+        throw new Error(`${privacyStatus} 게시에는 confirmVisible=true가 필요합니다.`);
+    }
+}
+function assertUploadFile(filePath) {
+    if (!path.isAbsolute(filePath) || !existsSync(filePath)) {
+        throw new Error('filePath는 존재하는 절대경로여야 합니다.');
+    }
+    const stat = statSync(filePath);
+    if (!stat.isFile() || stat.size <= 0)
+        throw new Error('업로드할 영상 파일이 비어 있거나 파일이 아닙니다.');
+    const ext = path.extname(filePath).toLowerCase();
+    const mimeType = ext === '.mp4'
+        ? 'video/mp4'
+        : ext === '.mov'
+            ? 'video/quicktime'
+            : ext === '.webm'
+                ? 'video/webm'
+                : null;
+    if (!mimeType)
+        throw new Error('지원 영상 형식은 .mp4, .mov, .webm입니다.');
+    return { size: stat.size, mimeType };
+}
+function assertTags(tags = []) {
+    if (tags.join(',').length > 500)
+        throw new Error('tags의 전체 길이는 쉼표를 포함해 500자 이하여야 합니다.');
+}
+function videoFacts(validation) {
+    const stream = validation.streams.find((item) => typeof item === 'object' && item !== null && item.codec_type === 'video');
+    const format = validation.format;
+    const width = Number(stream?.width);
+    const height = Number(stream?.height);
+    const durationSec = Number(format.duration);
+    return {
+        width: Number.isFinite(width) ? width : undefined,
+        height: Number.isFinite(height) ? height : undefined,
+        durationSec: Number.isFinite(durationSec) ? durationSec : undefined,
+    };
+}
+function assertShortsCompatible(facts) {
+    if (!facts.width || !facts.height || !facts.durationSec) {
+        throw new Error('쇼츠 규격을 확인할 영상 정보를 읽지 못했습니다.');
+    }
+    if (facts.width > facts.height)
+        throw new Error('shortsOnly=true일 때 영상은 정사각형 또는 세로형이어야 합니다.');
+    if (facts.durationSec > 180)
+        throw new Error('YouTube Shorts 영상은 180초 이하여야 합니다.');
+}
+function safeStatus(video) {
+    return {
+        videoId: video.id ?? null,
+        title: video.snippet?.title ?? null,
+        privacyStatus: video.status?.privacyStatus ?? null,
+        uploadStatus: video.status?.uploadStatus ?? null,
+        processingStatus: video.processingDetails?.processingStatus ?? null,
+        processingProgress: video.processingDetails?.processingProgress ?? null,
+        madeForKids: video.status?.madeForKids ?? null,
+        containsSyntheticMedia: video.status?.containsSyntheticMedia ?? null,
+        watchUrl: video.id ? `https://youtu.be/${video.id}` : null,
+        studioUrl: video.id ? `https://studio.youtube.com/video/${video.id}/edit` : null,
+    };
+}
+export async function getYouTubeVideoStatus(auth, videoId) {
+    const youtube = google.youtube({ version: 'v3', auth });
+    try {
+        const response = await youtube.videos.list({
+            part: ['snippet', 'status', 'processingDetails'],
+            id: [videoId],
+        });
+        const video = response.data.items?.[0];
+        if (!video)
+            throw new Error(`YouTube 영상을 찾지 못했습니다: ${videoId}`);
+        return safeStatus(video);
+    }
+    catch (error) {
+        if (error instanceof Error && error.message.startsWith('YouTube 영상을 찾지 못했습니다'))
+            throw error;
+        throw friendlyGoogleError(error);
+    }
+}
+export async function uploadYouTubeVideo(auth, input) {
+    const privacyStatus = input.privacyStatus ?? 'private';
+    assertVisibilityConfirmed(privacyStatus, input.confirmVisible);
+    const file = assertUploadFile(input.filePath);
+    if (!input.title.trim() || input.title.length > 100)
+        throw new Error('title은 1~100자여야 합니다.');
+    if ((input.description?.length ?? 0) > 5_000)
+        throw new Error('description은 5,000자 이하여야 합니다.');
+    assertTags(input.tags);
+    const validation = await validateVideo(input.filePath);
+    const facts = videoFacts(validation);
+    if (!validation.streams.some((item) => typeof item === 'object' && item !== null && item.codec_type === 'video')) {
+        throw new Error('업로드 파일에 비디오 스트림이 없습니다.');
+    }
+    if (input.shortsOnly)
+        assertShortsCompatible(facts);
+    const youtube = google.youtube({ version: 'v3', auth });
+    try {
+        const response = await youtube.videos.insert({
+            part: ['snippet', 'status'],
+            notifySubscribers: input.notifySubscribers ?? false,
+            requestBody: {
+                snippet: {
+                    title: input.title.trim(),
+                    description: input.description ?? '',
+                    tags: input.tags ?? [],
+                    categoryId: input.categoryId ?? '24',
+                },
+                status: {
+                    privacyStatus,
+                    selfDeclaredMadeForKids: input.madeForKids ?? false,
+                    ...(typeof input.containsSyntheticMedia === 'boolean'
+                        ? { containsSyntheticMedia: input.containsSyntheticMedia }
+                        : {}),
+                },
+            },
+            media: {
+                mimeType: file.mimeType,
+                body: createReadStream(input.filePath),
+            },
+        });
+        const videoId = response.data.id;
+        if (!videoId)
+            throw new Error('YouTube 업로드 응답에 videoId가 없습니다.');
+        return {
+            ...safeStatus(response.data),
+            requestedPrivacyStatus: privacyStatus,
+            file: { path: input.filePath, size: file.size, ...facts },
+            validationWarnings: validation.issues,
+        };
+    }
+    catch (error) {
+        if (error instanceof Error && error.message.includes('videoId'))
+            throw error;
+        throw friendlyGoogleError(error);
+    }
+}
+export async function updateYouTubeVideoPrivacy(auth, input) {
+    assertVisibilityConfirmed(input.privacyStatus, input.confirmVisible);
+    const youtube = google.youtube({ version: 'v3', auth });
+    try {
+        const currentResponse = await youtube.videos.list({ part: ['status'], id: [input.videoId] });
+        const current = currentResponse.data.items?.[0];
+        if (!current)
+            throw new Error(`YouTube 영상을 찾지 못했습니다: ${input.videoId}`);
+        await youtube.videos.update({
+            part: ['status'],
+            requestBody: {
+                id: input.videoId,
+                status: {
+                    privacyStatus: input.privacyStatus,
+                    embeddable: current.status?.embeddable ?? true,
+                    license: current.status?.license ?? 'youtube',
+                    publicStatsViewable: current.status?.publicStatsViewable ?? true,
+                    selfDeclaredMadeForKids: current.status?.selfDeclaredMadeForKids ?? false,
+                    containsSyntheticMedia: current.status?.containsSyntheticMedia ?? false,
+                },
+            },
+        });
+        return await getYouTubeVideoStatus(auth, input.videoId);
+    }
+    catch (error) {
+        throw friendlyGoogleError(error);
+    }
+}
+export const __testing = {
+    assertVisibilityConfirmed,
+    assertUploadFile,
+    assertTags,
+    assertShortsCompatible,
+    videoFacts,
+};

package/package.json

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

package/tool-manifest.json

@@ -1,6 +1,6 @@
 {
   "$comment": "등록된 MCP 도구 + 도메인 메타데이터(label·credential·summary)의 SSOT. src/__tests__/tool-manifest.test.ts 가 실제 서버 등록 목록과 diff 하고 메타데이터 정합성을 검사한다. 도구 추가/삭제/개명 시 이 파일을 함께 갱신할 것 — 산문 문서에는 정확한 개수를 쓰지 말고 이 파일을 가리킬 것. mimi-seed://tools/catalog 리소스가 이 파일을 그대로 서빙한다.",
-  "total": 174,
+  "total": 177,
   "domains": {
     "admob": {
       "label": "AdMob",
@@ -293,9 +293,12 @@
     },
     "video": {
       "label": "영상 제작",
-      "credential": "ANTHROPIC_API_KEY / YOUTUBE_API_KEY / PEXELS_API_KEY / OPENAI_API_KEY + FFmpeg (기능별 선택)",
-      "summary": "story 스토리보드·유사 영상 리서치·라이선스 자산/이미지 생성·타임라인·MP4 렌더",
+      "credential": "기능별 API 키 + Google OAuth(YouTube 게시) + FFmpeg",
+      "summary": "story 스토리보드·영상 리서치/제작·YouTube 업로드와 공개 상태 관리",
       "tools": [
+        "youtube_upload_video",
+        "youtube_get_video_status",
+        "youtube_update_video_privacy",
         "video_plan_from_story",
         "video_research_youtube",
         "video_search_stock_assets",