@yoonion/mimi-seed-mcp 0.11.0 → 0.12.0

package/dist/resources.js

@@ -1,5 +1,5 @@
-import { readFileSync } from 'node:fs';
 import { ensureFreshAccessToken } from './auth/google-auth.js';
+import { readPackageRootText, readToolManifest } from './lib/package-root.js';
 // assets/agent-guide.md = docs/agent-guide.md 의 배포용 사본 (npm 배포본에는 docs/ 가 없다).
 // 갱신은 `npm run plugin:sync`, 드리프트는 prompts-resources.test.ts 가 잡는다.
 // 읽기 실패는 정상 설치에서 불가능하다(files 화이트리스트에 포함) — 그래서 폴백은 가이드
@@ -13,109 +13,6 @@ const AGENT_GUIDE_FALLBACK = [
     '가이드 전문: https://github.com/jeonghwanko/mimi-seed-sdk/blob/main/docs/agent-guide.md',
     '최소 안전수칙: 스토어 제출·승격·삭제·공개 게시는 사용자 명시 동의 없이 실행하지 않는다.',
 ].join('\n');
-function readPackageAsset(relativePath) {
-    try {
-        // src/ 와 dist/ 모두 패키지 루트 바로 아래라 ../ 가 같은 곳을 가리킨다 (index.ts 의 package.json 읽기와 동일 패턴).
-        return readFileSync(new URL(relativePath, import.meta.url), 'utf8');
-    }
-    catch {
-        return null;
-    }
-}
-/** 도메인 id → 라벨·필요 자격증명·한줄 요약. 키 집합은 tool-manifest.json 의 domains 와
- *  일치해야 한다 (prompts-resources.test.ts 가 강제) — 도메인을 추가하면 여기도 추가할 것. */
-const DOMAIN_SUMMARY = {
-    playstore: {
-        label: 'Google Play',
-        credential: 'Google OAuth (CI/헤드리스는 Play 서비스 계정)',
-        summary: '리스팅·트랙 릴리스·이미지·리뷰 답변·통계·서비스 계정 등록',
-    },
-    appstore: {
-        label: 'App Store Connect',
-        credential: 'ASC API 키 (mimi-seed auth appstore)',
-        summary: '버전·빌드 attach·What\'s New·스크린샷·IAP 심사 메타데이터·심사 제출',
-    },
-    firebase: {
-        label: 'Firebase',
-        credential: 'Google OAuth',
-        summary: '프로젝트/앱 생성·설정 파일 다운로드·서비스 활성화',
-    },
-    admob: {
-        label: 'AdMob',
-        credential: 'Google OAuth',
-        summary: '앱·광고 단위 생성, 오늘 수익·기간 리포트',
-    },
-    iam: {
-        label: 'Google Cloud IAM',
-        credential: 'Google OAuth',
-        summary: '서비스 계정 생성·키 발급·IAM 정책 바인딩',
-    },
-    bigquery: {
-        label: 'BigQuery',
-        credential: 'Google OAuth (또는 BigQuery 서비스 계정)',
-        summary: '쿼리 실행·데이터셋/테이블/스키마 조회',
-    },
-    ga4: {
-        label: 'Google Analytics 4',
-        credential: 'Google OAuth',
-        summary: '계정/속성·데이터 스트림 관리, 리포트 실행',
-    },
-    gsc: {
-        label: 'Search Console',
-        credential: 'Google OAuth',
-        summary: 'URL 검사·검색 성과 분석·사이트맵 제출',
-    },
-    googleads: {
-        label: 'Google Ads',
-        credential: 'Google Ads 설정 (mimi-seed auth googleads, adwords 스코프)',
-        summary: '캠페인 목록·캠페인/UAC 리포트',
-    },
-    ci: {
-        label: 'CI (GitHub Actions / GitLab)',
-        credential: 'GitHub/GitLab 토큰 (mimi-seed auth ci)',
-        summary: '워크플로 조회·빌드 트리거/상태/취소 — Jenkins 빌드는 대상 아님',
-    },
-    jenkins: {
-        label: 'Jenkins',
-        credential: 'Jenkins URL + API 토큰 (mimi-seed auth jenkins)',
-        summary: '크리덴셜·keystore 업로드·잡 생성/수정 — 빌드 트리거 도구는 없음',
-    },
-    android: {
-        label: 'Android 서명',
-        credential: '없음 (로컬 파일 작업)',
-        summary: 'keystore 생성·서명 설정·Jenkins 로 Play SA 업로드',
-    },
-    facebook: {
-        label: 'Facebook',
-        credential: 'Facebook 페이지 토큰 (mimi-seed auth facebook)',
-        summary: '페이지 텍스트/사진/링크 포스팅',
-    },
-    instagram: {
-        label: 'Instagram',
-        credential: 'Instagram 토큰 (mimi-seed auth instagram)',
-        summary: '사진·캐러셀·릴스 포스팅',
-    },
-    threads: {
-        label: 'Threads',
-        credential: 'Threads 토큰 (mimi-seed auth threads)',
-        summary: '텍스트/이미지 포스팅·토큰 갱신',
-    },
-    checks: {
-        label: '출시 점검',
-        credential: '점검 대상 스토어의 자격증명',
-        summary: '제출 전 위험 점검·스크린샷 규격 검증·릴리스 상태',
-    },
-    ai: {
-        label: 'AI 생성',
-        credential: 'ANTHROPIC_API_KEY 환경변수',
-        summary: '커밋 기반 릴리스 노트·리뷰 답변 초안 생성',
-    },
-    auth: {
-        label: '연결/진단',
-        credential: '없음 (이것이 셋업 도구)',
-        summary: '전체 연결 상태 스캔(mimi_seed_status)·OAuth 시작·원격 크리덴셜 동기화',
-    },
-};
 export function registerResources(server) {
     server.resource('auth-status', 'mimi-seed://auth/status', { description: 'Google OAuth 인증 상태 — fresh / refreshed / expired / unauthenticated', mimeType: 'application/json' }, async () => {
         const r = await ensureFreshAccessToken();
@@ -137,35 +34,42 @@ export function registerResources(server) {
     server.resource('agent-guide', 'mimi-seed://agent/guide', {
         description: 'Mimi Seed 에이전트 운영 규약 전문 (docs/agent-guide.md) — deferred 도구 로딩·ToolSearch select: 배치·호출 순서·비가역 액션 안전수칙',
         mimeType: 'text/markdown',
-    }, async () => ({
-        contents: [{
-                uri: 'mimi-seed://agent/guide',
-                mimeType: 'text/markdown',
-                text: readPackageAsset('../assets/agent-guide.md') ?? AGENT_GUIDE_FALLBACK,
-            }],
-    }));
+    }, async () => {
+        let text;
+        try {
+            text = readPackageRootText('assets/agent-guide.md');
+        }
+        catch {
+            text = AGENT_GUIDE_FALLBACK;
+        }
+        return {
+            contents: [{
+                    uri: 'mimi-seed://agent/guide',
+                    mimeType: 'text/markdown',
+                    text,
+                }],
+        };
+    });
     server.resource('tools-catalog', 'mimi-seed://tools/catalog', {
         description: '150+ 도구 전체 카탈로그 — 도메인별 도구 목록·필요 자격증명·한줄 요약. "mimi-seed 로 뭘 할 수 있어?" 에는 이 리소스를 읽고 답하세요.',
         mimeType: 'application/json',
     }, async () => {
         // LLM 이 읽는 페이로드라 compact 로 직렬화한다 (pretty 들여쓰기는 ~40% 바이트 낭비).
+        // 도메인 메타데이터(label·credential·summary)는 tool-manifest.json 이 SSOT —
+        // 여기서는 그대로 서빙만 한다.
         let payload;
         try {
-            const raw = readFileSync(new URL('../tool-manifest.json', import.meta.url), 'utf8');
-            const manifest = JSON.parse(raw);
-            if (typeof manifest?.total !== 'number' || typeof manifest?.domains !== 'object' || manifest.domains === null) {
-                throw new Error('tool-manifest.json 의 형태가 예상과 다릅니다');
-            }
+            const manifest = readToolManifest();
             payload = JSON.stringify({
                 total: manifest.total,
                 deferredHint: 'Claude Code 에서는 도구 schema 가 lazy 로드됩니다 — 호출 전 ToolSearch(query="select:<tool,...>") 로 선로드하세요. 상세: mimi-seed://agent/guide',
-                domains: Object.entries(manifest.domains).map(([id, tools]) => ({
+                domains: Object.entries(manifest.domains).map(([id, d]) => ({
                     id,
-                    label: DOMAIN_SUMMARY[id]?.label ?? id,
-                    credential: DOMAIN_SUMMARY[id]?.credential ?? '알 수 없음',
-                    summary: DOMAIN_SUMMARY[id]?.summary ?? '',
-                    toolCount: tools.length,
-                    tools,
+                    label: d.label,
+                    credential: d.credential,
+                    summary: d.summary,
+                    toolCount: d.tools.length,
+                    tools: d.tools,
                 })),
             });
         }

package/dist/server.js

@@ -17,6 +17,7 @@ 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 { registerVideoTools } from './registers/video.js';
 import { registerPrompts } from './prompts.js';
 import { registerResources } from './resources.js';
 /**
@@ -50,6 +51,7 @@ export function buildServer(version) {
     registerGa4Tools(server);
     registerJenkinsTools(server);
     registerAndroidTools(server);
+    registerVideoTools(server);
     registerPrompts(server);
     registerResources(server);
     return server;

package/dist/video/files.d.ts

@@ -0,0 +1,3 @@
+export declare function writeJsonAtomic(filePath: string, value: unknown): void;
+export declare function readJson(filePath: string, maxBytes?: number): unknown;
+export declare function requireAbsolutePath(value: string, label: string): string;

package/dist/video/files.js

@@ -0,0 +1,37 @@
+import { randomUUID } from 'node:crypto';
+import { mkdirSync, readFileSync, renameSync, statSync, unlinkSync, writeFileSync } from 'node:fs';
+import path from 'node:path';
+export function writeJsonAtomic(filePath, value) {
+    mkdirSync(path.dirname(filePath), { recursive: true });
+    const tempPath = `${filePath}.${process.pid}.${randomUUID()}.tmp`;
+    try {
+        writeFileSync(tempPath, `${JSON.stringify(value, null, 2)}\n`, 'utf8');
+        renameSync(tempPath, filePath);
+    }
+    catch (error) {
+        try {
+            unlinkSync(tempPath);
+        }
+        catch {
+            // The temp file may not have been created or may already have been renamed.
+        }
+        throw error;
+    }
+}
+export function readJson(filePath, maxBytes = 20 * 1024 * 1024) {
+    try {
+        const size = statSync(filePath).size;
+        if (size > maxBytes) {
+            throw new Error(`JSON 파일이 ${Math.round(maxBytes / 1024 / 1024)}MB 제한을 초과합니다 (${size} bytes).`);
+        }
+        return JSON.parse(readFileSync(filePath, 'utf8'));
+    }
+    catch (error) {
+        throw new Error(`JSON 파일을 읽거나 파싱할 수 없습니다: ${filePath}`, { cause: error });
+    }
+}
+export function requireAbsolutePath(value, label) {
+    if (!path.isAbsolute(value))
+        throw new Error(`${label}은 절대경로여야 합니다.`);
+    return path.resolve(value);
+}

package/dist/video/project.d.ts

@@ -0,0 +1,38 @@
+import type { VideoAspectRatio, VideoAsset, VideoAssetKind, VideoAssetManifest, VideoAssetSource, VideoProject, VideoScenePlan, VideoTimeline, VideoTimelineScene } from './types.js';
+declare function dimensions(aspectRatio: VideoAspectRatio): {
+    width: number;
+    height: number;
+};
+declare function normalizeScenes(raw: Partial<VideoScenePlan>[], targetDurationSec: number): VideoScenePlan[];
+export interface PlanStoryInput {
+    projectDir: string;
+    title: string;
+    story: string;
+    language: string;
+    aspectRatio: VideoAspectRatio;
+    targetDurationSec: number;
+    style?: string;
+    overwrite?: boolean;
+}
+export declare function planStory(input: PlanStoryInput): Promise<VideoProject>;
+export declare function loadProject(projectDir: string): VideoProject;
+export declare function loadAssets(projectDir: string): VideoAssetManifest;
+export declare function sha256File(filePath: string): string;
+export declare function registerAsset(projectDir: string, asset: Omit<VideoAsset, 'createdAt' | 'sha256'>): VideoAsset;
+export interface AddLocalAssetInput {
+    projectDir: string;
+    filePath: string;
+    kind: VideoAssetKind;
+    sourceType: Extract<VideoAssetSource, 'user-owned' | 'licensed'>;
+    license: string;
+    author?: string;
+    attribution?: string;
+}
+export declare function addLocalAsset(input: AddLocalAssetInput): VideoAsset;
+export declare function buildTimeline(projectDir: string, scenes: VideoTimelineScene[], audioAssetId?: string): VideoTimeline;
+export declare function loadTimeline(projectDir: string): VideoTimeline;
+export declare const __testing: {
+    dimensions: typeof dimensions;
+    normalizeScenes: typeof normalizeScenes;
+};
+export {};

package/dist/video/project.js

@@ -0,0 +1,255 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { closeSync, copyFileSync, existsSync, mkdirSync, openSync, readSync, statSync, unlinkSync, } from 'node:fs';
+import path from 'node:path';
+import { parseJsonResponse, requireApiKey } from '../ai/client.js';
+import { readJson, requireAbsolutePath, writeJsonAtomic } from './files.js';
+import { assetManifestSchema, assetSchema, parseFile, projectSchema, timelineSchema } from './schemas.js';
+const PROJECT_FILE = 'project.json';
+const ASSET_FILE = 'assets.json';
+const TIMELINE_FILE = 'timeline.json';
+function dimensions(aspectRatio) {
+    if (aspectRatio === '16:9')
+        return { width: 1920, height: 1080 };
+    if (aspectRatio === '1:1')
+        return { width: 1080, height: 1080 };
+    return { width: 1080, height: 1920 };
+}
+function normalizeScenes(raw, targetDurationSec) {
+    if (!Array.isArray(raw) || raw.length === 0) {
+        throw new Error('AI가 유효한 장면 목록을 만들지 못했습니다. 다시 시도하세요.');
+    }
+    const maxScenes = Math.min(12, Math.max(1, Math.floor(targetDurationSec)));
+    const scenes = raw.slice(0, maxScenes).map((scene, index) => ({
+        id: scene.id?.trim() || `scene-${index + 1}`,
+        durationSec: Number.isFinite(scene.durationSec) && Number(scene.durationSec) > 0 ? Number(scene.durationSec) : 1,
+        narration: scene.narration?.trim() || '',
+        onScreenText: scene.onScreenText?.trim() || '',
+        visualPrompt: scene.visualPrompt?.trim() || '',
+        searchQuery: scene.searchQuery?.trim() || scene.visualPrompt?.trim() || '',
+    }));
+    const weightTotal = scenes.reduce((sum, scene) => sum + scene.durationSec, 0);
+    const distributable = targetDurationSec - scenes.length;
+    const normalized = scenes.map((scene) => ({
+        ...scene,
+        durationSec: Math.round((1 + distributable * (scene.durationSec / weightTotal)) * 10) / 10,
+    }));
+    const roundedTotal = normalized.reduce((sum, scene) => sum + scene.durationSec, 0);
+    const adjustmentIndex = normalized.reduce((best, scene, index) => scene.durationSec > normalized[best].durationSec ? index : best, 0);
+    normalized[adjustmentIndex].durationSec = Math.round((normalized[adjustmentIndex].durationSec + targetDurationSec - roundedTotal) * 10) / 10;
+    return normalized;
+}
+export async function planStory(input) {
+    const projectDir = requireAbsolutePath(input.projectDir, 'projectDir');
+    const projectPath = path.join(projectDir, PROJECT_FILE);
+    if (existsSync(projectPath) && !input.overwrite) {
+        throw new Error(`이미 영상 프로젝트가 있습니다: ${projectPath}\noverwrite=true로 명시해야 덮어씁니다.`);
+    }
+    const client = requireApiKey();
+    const response = await client.messages.create({
+        model: 'claude-haiku-4-5-20251001',
+        max_tokens: 3000,
+        system: [
+            '당신은 숏폼 영상 스토리보드 디렉터입니다.',
+            '사용자의 이야기에서 핵심 메시지를 보존하고 장면별 시각 계획을 만드세요.',
+            '반드시 설명이나 마크다운 없이 유효한 JSON만 반환하세요.',
+        ].join(' '),
+        messages: [{
+                role: 'user',
+                content: [
+                    `제목: ${input.title}`,
+                    `언어: ${input.language}`,
+                    `목표 길이: ${input.targetDurationSec}초`,
+                    `화면비: ${input.aspectRatio}`,
+                    input.style ? `스타일: ${input.style}` : '',
+                    '',
+                    '이야기:',
+                    input.story,
+                    '',
+                    '다음 JSON 형식으로 3~12개 장면을 만드세요:',
+                    '{"scenes":[{"id":"scene-1","durationSec":5,"narration":"...","onScreenText":"...","visualPrompt":"...","searchQuery":"..."}]}',
+                    'onScreenText는 짧게, visualPrompt는 이미지 생성용, searchQuery는 스톡 영상 검색용 영문 검색어로 작성하세요.',
+                ].filter(Boolean).join('\n'),
+            }],
+    });
+    const text = response.content[0]?.type === 'text' ? response.content[0].text : '';
+    const parsed = parseJsonResponse(text);
+    const dims = dimensions(input.aspectRatio);
+    const project = parseFile(projectSchema, {
+        version: 1,
+        projectId: randomUUID(),
+        title: input.title,
+        story: input.story,
+        language: input.language,
+        createdAt: new Date().toISOString(),
+        settings: {
+            aspectRatio: input.aspectRatio,
+            ...dims,
+            fps: 30,
+            targetDurationSec: input.targetDurationSec,
+            style: input.style,
+        },
+        scenes: normalizeScenes(parsed.scenes ?? [], input.targetDurationSec),
+    }, 'AI가 생성한 영상 프로젝트');
+    mkdirSync(projectDir, { recursive: true });
+    mkdirSync(path.join(projectDir, 'assets', 'stock'), { recursive: true });
+    mkdirSync(path.join(projectDir, 'assets', 'generated'), { recursive: true });
+    mkdirSync(path.join(projectDir, 'assets', 'local'), { recursive: true });
+    mkdirSync(path.join(projectDir, 'research'), { recursive: true });
+    mkdirSync(path.join(projectDir, 'render'), { recursive: true });
+    mkdirSync(path.join(projectDir, '.jobs'), { recursive: true });
+    if (existsSync(projectPath) && input.overwrite) {
+        const archiveDir = path.join(projectDir, '.history', `${Date.now()}-${project.projectId}`);
+        mkdirSync(archiveDir, { recursive: true });
+        for (const name of [PROJECT_FILE, ASSET_FILE, TIMELINE_FILE]) {
+            const source = path.join(projectDir, name);
+            if (existsSync(source))
+                copyFileSync(source, path.join(archiveDir, name));
+        }
+        const oldTimeline = path.join(projectDir, TIMELINE_FILE);
+        if (existsSync(oldTimeline))
+            unlinkSync(oldTimeline);
+    }
+    writeJsonAtomic(projectPath, project);
+    writeJsonAtomic(path.join(projectDir, ASSET_FILE), {
+        version: 1,
+        projectId: project.projectId,
+        assets: [],
+    });
+    return project;
+}
+export function loadProject(projectDir) {
+    const dir = requireAbsolutePath(projectDir, 'projectDir');
+    const filePath = path.join(dir, PROJECT_FILE);
+    if (!existsSync(filePath))
+        throw new Error(`영상 프로젝트를 찾을 수 없습니다: ${filePath}`);
+    return parseFile(projectSchema, readJson(filePath), filePath);
+}
+export function loadAssets(projectDir) {
+    const dir = requireAbsolutePath(projectDir, 'projectDir');
+    const project = loadProject(dir);
+    const filePath = path.join(dir, ASSET_FILE);
+    if (!existsSync(filePath))
+        return { version: 1, projectId: project.projectId, assets: [] };
+    const manifest = parseFile(assetManifestSchema, readJson(filePath), filePath);
+    if (manifest.projectId !== project.projectId) {
+        throw new Error('assets.json이 현재 project.json과 다른 프로젝트에 속합니다. 프로젝트를 다시 계획하거나 자산 매니페스트를 복구하세요.');
+    }
+    return manifest;
+}
+export function sha256File(filePath) {
+    const hash = createHash('sha256');
+    const fd = openSync(filePath, 'r');
+    const buffer = Buffer.allocUnsafe(1024 * 1024);
+    try {
+        let bytesRead = 0;
+        do {
+            bytesRead = readSync(fd, buffer, 0, buffer.length, null);
+            if (bytesRead > 0)
+                hash.update(buffer.subarray(0, bytesRead));
+        } while (bytesRead > 0);
+    }
+    finally {
+        closeSync(fd);
+    }
+    return hash.digest('hex');
+}
+export function registerAsset(projectDir, asset) {
+    const dir = requireAbsolutePath(projectDir, 'projectDir');
+    loadProject(dir);
+    if (!path.isAbsolute(asset.path) || !existsSync(asset.path) || !statSync(asset.path).isFile()) {
+        throw new Error(`자산 파일은 존재하는 절대경로여야 합니다: ${asset.path}`);
+    }
+    const entry = parseFile(assetSchema, {
+        ...asset,
+        path: path.resolve(asset.path),
+        sha256: sha256File(asset.path),
+        createdAt: new Date().toISOString(),
+    }, '등록할 영상 자산');
+    const manifest = loadAssets(dir);
+    manifest.assets = [...manifest.assets.filter((item) => item.id !== entry.id), entry];
+    writeJsonAtomic(path.join(dir, ASSET_FILE), manifest);
+    return entry;
+}
+export function addLocalAsset(input) {
+    const projectDir = requireAbsolutePath(input.projectDir, 'projectDir');
+    if (!path.isAbsolute(input.filePath) || !existsSync(input.filePath)) {
+        throw new Error('filePath는 존재하는 절대경로여야 합니다.');
+    }
+    const id = `local-${randomUUID()}`;
+    const ext = path.extname(input.filePath).toLowerCase();
+    const destination = path.join(projectDir, 'assets', 'local', `${id}${ext}`);
+    mkdirSync(path.dirname(destination), { recursive: true });
+    copyFileSync(input.filePath, destination);
+    return registerAsset(projectDir, {
+        id,
+        kind: input.kind,
+        sourceType: input.sourceType,
+        path: destination,
+        license: input.license,
+        author: input.author,
+        attribution: input.attribution,
+        allowedForRendering: true,
+    });
+}
+export function buildTimeline(projectDir, scenes, audioAssetId) {
+    const dir = requireAbsolutePath(projectDir, 'projectDir');
+    const project = loadProject(dir);
+    const manifest = loadAssets(dir);
+    if (scenes.length === 0)
+        throw new Error('타임라인에는 장면이 한 개 이상 필요합니다.');
+    const byId = new Map(manifest.assets.map((asset) => [asset.id, asset]));
+    for (const scene of scenes) {
+        const asset = byId.get(scene.assetId);
+        if (!asset)
+            throw new Error(`등록되지 않은 assetId입니다: ${scene.assetId}`);
+        if (!asset.allowedForRendering || asset.sourceType === 'reference-only') {
+            throw new Error(`렌더링이 허용되지 않은 자산입니다: ${scene.assetId}`);
+        }
+        if (asset.kind !== 'image' && asset.kind !== 'video') {
+            throw new Error(`장면에는 이미지 또는 영상 자산만 사용할 수 있습니다: ${scene.assetId}`);
+        }
+        if (!Number.isFinite(scene.durationSec) || scene.durationSec <= 0) {
+            throw new Error(`장면 길이는 0보다 커야 합니다: ${scene.id}`);
+        }
+    }
+    if (audioAssetId) {
+        const audio = byId.get(audioAssetId);
+        if (!audio || audio.kind !== 'audio' || !audio.allowedForRendering) {
+            throw new Error(`사용할 수 없는 오디오 자산입니다: ${audioAssetId}`);
+        }
+    }
+    const totalDurationSec = scenes.reduce((sum, scene) => sum + scene.durationSec, 0);
+    if (totalDurationSec > 300)
+        throw new Error(`타임라인 총 길이는 300초를 넘을 수 없습니다: ${totalDurationSec}초`);
+    const timeline = parseFile(timelineSchema, {
+        version: 1,
+        projectId: project.projectId,
+        createdAt: new Date().toISOString(),
+        width: project.settings.width,
+        height: project.settings.height,
+        fps: project.settings.fps,
+        totalDurationSec,
+        scenes,
+        audioAssetId,
+    }, '생성할 영상 타임라인');
+    writeJsonAtomic(path.join(dir, TIMELINE_FILE), timeline);
+    return timeline;
+}
+export function loadTimeline(projectDir) {
+    const dir = requireAbsolutePath(projectDir, 'projectDir');
+    const project = loadProject(dir);
+    const filePath = path.join(dir, TIMELINE_FILE);
+    if (!existsSync(filePath))
+        throw new Error(`타임라인을 찾을 수 없습니다: ${filePath}`);
+    const timeline = parseFile(timelineSchema, readJson(filePath), filePath);
+    if (timeline.projectId !== project.projectId) {
+        throw new Error('timeline.json이 현재 project.json과 다른 프로젝트에 속합니다. 타임라인을 다시 생성하세요.');
+    }
+    if (timeline.width !== project.settings.width ||
+        timeline.height !== project.settings.height ||
+        timeline.fps !== project.settings.fps) {
+        throw new Error('timeline.json의 출력 설정이 현재 프로젝트 설정과 다릅니다. 타임라인을 다시 생성하세요.');
+    }
+    return timeline;
+}
+export const __testing = { dimensions, normalizeScenes };

package/dist/video/providers.d.ts

@@ -0,0 +1,104 @@
+import type { VideoAsset } from './types.js';
+export interface YouTubeReference {
+    videoId: string;
+    title: string;
+    description: string;
+    channelTitle: string;
+    publishedAt: string;
+    thumbnailUrl?: string;
+    url: string;
+    duration?: string;
+    viewCount?: string;
+    likeCount?: string;
+    license?: string;
+    sourceType: 'reference-only';
+    allowedForRendering: false;
+    untrustedExternalText: true;
+    query: string;
+}
+declare function sanitizeExternalText(value: string | undefined, maxLength: number): string;
+export interface ResearchYouTubeInput {
+    projectDir: string;
+    queries?: string[];
+    maxResultsPerQuery?: number;
+    regionCode?: string;
+    publishedAfter?: string;
+    creativeCommonsOnly?: boolean;
+    order?: 'relevance' | 'viewCount' | 'date';
+}
+export declare function researchYouTube(input: ResearchYouTubeInput): Promise<YouTubeReference[]>;
+export interface PexelsVideoResult {
+    id: number;
+    width: number;
+    height: number;
+    duration: number;
+    pageUrl: string;
+    author?: string;
+    authorUrl?: string;
+    previewImage?: string;
+    downloadUrl?: string;
+    downloadWidth?: number;
+    downloadHeight?: number;
+    license: 'Pexels License';
+    attribution: string;
+    query: string;
+}
+interface PexelsSearchResponse {
+    videos?: Array<{
+        id: number;
+        width: number;
+        height: number;
+        duration: number;
+        url: string;
+        image?: string;
+        user?: {
+            name?: string;
+            url?: string;
+        };
+        video_files?: Array<{
+            link?: string;
+            width?: number;
+            height?: number;
+            file_type?: string;
+        }>;
+    }>;
+}
+declare function bestPexelsFile(files?: NonNullable<PexelsSearchResponse['videos']>[number]['video_files']): {
+    link?: string;
+    width?: number;
+    height?: number;
+    file_type?: string;
+};
+export interface SearchStockInput {
+    projectDir: string;
+    queries?: string[];
+    orientation?: 'landscape' | 'portrait' | 'square';
+    perQuery?: number;
+}
+export declare function searchStock(input: SearchStockInput): Promise<PexelsVideoResult[]>;
+declare function validatePexelsUrl(value: string): URL;
+declare function hasMp4Signature(filePath: string): boolean;
+export interface DownloadStockSelection {
+    id: number;
+    downloadUrl: string;
+    pageUrl: string;
+    author?: string;
+    attribution?: string;
+}
+export declare function downloadStockAssets(projectDir: string, selections: DownloadStockSelection[]): Promise<VideoAsset[]>;
+export interface GenerateImageInput {
+    projectDir: string;
+    prompt: string;
+    name?: string;
+    model?: 'gpt-image-2' | 'gpt-image-1.5' | 'gpt-image-1' | 'gpt-image-1-mini';
+    quality?: 'low' | 'medium' | 'high' | 'auto';
+    size?: '1024x1024' | '1024x1536' | '1536x1024';
+}
+export declare function generateImage(input: GenerateImageInput): Promise<VideoAsset>;
+export declare const __testing: {
+    bestPexelsFile: typeof bestPexelsFile;
+    validatePexelsUrl: typeof validatePexelsUrl;
+    hasMp4Signature: typeof hasMp4Signature;
+    sanitizeExternalText: typeof sanitizeExternalText;
+};
+export {};