@cocoviral/cli 1.5.4

package/dist/client.js

@@ -0,0 +1,339 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CocoViralClient = exports.IMAGE_MODEL_ALIASES = exports.IMAGE_MODEL_ALIAS_MAP = exports.CINEMA_FRAME_MODELS = exports.CINEMA_SHOT_MODELS = exports.VIDEO_MODEL_ID_MAP = void 0;
+const axios_1 = __importDefault(require("axios"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+/** Enough of a mime map for what the upload endpoint accepts. */
+function mimeTypeFor(filePath) {
+    const extension = node_path_1.default.extname(filePath).slice(1).toLowerCase();
+    const map = {
+        png: 'image/png', jpg: 'image/jpeg', jpeg: 'image/jpeg', webp: 'image/webp', gif: 'image/gif',
+        mp4: 'video/mp4', webm: 'video/webm', mov: 'video/quicktime',
+        mp3: 'audio/mpeg', wav: 'audio/wav', m4a: 'audio/mp4', ogg: 'audio/ogg',
+    };
+    return map[extension] || 'application/octet-stream';
+}
+exports.VIDEO_MODEL_ID_MAP = {
+    // Veo 3.1
+    'veo3.1': 'google/veo-3.1',
+    'veo3.1-fast': 'google/veo-3.1-fast',
+    // Kling 3.0
+    kling3: 'fal-ai/kling-video/v3/standard/text-to-video',
+    'kling3-standard': 'fal-ai/kling-video/v3/standard/text-to-video',
+    'kling3-standard-i2v': 'fal-ai/kling-video/v3/standard/image-to-video',
+    'kling3-pro': 'fal-ai/kling-video/v3/pro/text-to-video',
+    'kling3-pro-i2v': 'fal-ai/kling-video/v3/pro/image-to-video',
+    'kling3-4k': 'fal-ai/kling-video/v3/4k/text-to-video',
+    'kling3-4k-i2v': 'fal-ai/kling-video/v3/4k/image-to-video',
+    // Seedance 2.0 — standard, fast and mini tiers
+    seedance2: 'bytedance/seedance-2.0/text-to-video',
+    'seedance2-i2v': 'bytedance/seedance-2.0/image-to-video',
+    'seedance2-omni': 'bytedance/seedance-2.0/reference-to-video',
+    seedance2_fast: 'bytedance/seedance-2.0/fast/text-to-video',
+    'seedance2-fast': 'bytedance/seedance-2.0/fast/text-to-video',
+    'seedance2-i2v-fast': 'bytedance/seedance-2.0/fast/image-to-video',
+    'seedance2-omni-fast': 'bytedance/seedance-2.0/fast/reference-to-video',
+    'seedance2-mini': 'bytedance/seedance-2.0/mini/text-to-video',
+    'seedance2-i2v-mini': 'bytedance/seedance-2.0/mini/image-to-video',
+    'seedance2-omni-mini': 'bytedance/seedance-2.0/mini/reference-to-video',
+    // Seedance 2.5 — 30s single pass, up to 50 multimodal references
+    'seedance2.5': 'bytedance/seedance-2.5/text-to-video',
+    'seedance2.5-i2v': 'bytedance/seedance-2.5/image-to-video',
+    'seedance2.5-omni': 'bytedance/seedance-2.5/reference-to-video',
+    // FLUX 3 (Black Forest Labs) — native audio. An end frame on -i2v routes to
+    // first-last-frame-to-video upstream.
+    flux3: 'black-forest-labs/flux-3/text-to-video',
+    'flux3-i2v': 'black-forest-labs/flux-3/image-to-video',
+    'flux3-keyframes': 'black-forest-labs/flux-3/keyframes-to-video',
+    'flux3-extend': 'black-forest-labs/flux-3/extend-video',
+    // MiniMax H3 (Hailuo 3.0) — native 2K, native audio
+    'minimax-h3': 'minimax/hailuo-3.0/text-to-video',
+    'minimax-h3-i2v': 'minimax/hailuo-3.0/image-to-video',
+    'minimax-h3-ref': 'minimax/hailuo-3.0/reference-to-video',
+    h3: 'minimax/hailuo-3.0/text-to-video',
+    'h3-i2v': 'minimax/hailuo-3.0/image-to-video',
+    'h3-ref': 'minimax/hailuo-3.0/reference-to-video',
+    // MiniMax H3 Max — max 768p, native audio, ~half H3's per-second cost
+    'minimax-h3-max': 'minimax/h3-max/text-to-video',
+    'minimax-h3-max-i2v': 'minimax/h3-max/image-to-video',
+    'minimax-h3-max-ref': 'minimax/h3-max/reference-to-video',
+    'h3-max': 'minimax/h3-max/text-to-video',
+    'h3-max-i2v': 'minimax/h3-max/image-to-video',
+    'h3-max-ref': 'minimax/h3-max/reference-to-video',
+};
+/** Image-to-video models offered for `cviral shot` / the cinema MCP tools. */
+exports.CINEMA_SHOT_MODELS = [
+    'kling3-pro-i2v',
+    'kling3-standard-i2v',
+    'seedance2-i2v',
+    'seedance2.5-i2v',
+    'minimax-h3-i2v',
+    'minimax-h3-max-i2v',
+    'flux3-i2v',
+];
+/** Image models that render a cinematic still frame well. */
+exports.CINEMA_FRAME_MODELS = [
+    'nano-banana-pro',
+    'nano-banana-2',
+    'seedream-v5-pro',
+    'flux-2-pro',
+    'gpt-image-2',
+    'gpt-image-2.5',
+    'midjourney-v8',
+];
+// Alias → real model ID used by the image API
+exports.IMAGE_MODEL_ALIAS_MAP = {
+    'flux-2-pro': 'black-forest-labs/flux-2-pro',
+    'gpt-image-2': 'openai/gpt-image-2',
+    'nano-banana-2': 'fal-ai/nano-banana-2',
+    'nano-banana-pro': 'google/nano-banana-pro',
+    'midjourney-v8': 'midjourney/v8.2',
+    'gpt-image-2.5': 'openai/gpt-image-2.5-flare/text-to-image',
+    'gpt-image-2.5-sunburst': 'openai/gpt-image-2.5-sunburst/text-to-image',
+    'seedream-v5-lite': 'fal-ai/bytedance/seedream/v5/lite/text-to-image',
+    'seedream-v5-pro': 'fal-ai/bytedance/seedream/v5/pro/text-to-image',
+};
+exports.IMAGE_MODEL_ALIASES = Object.keys(exports.IMAGE_MODEL_ALIAS_MAP);
+class CocoViralClient {
+    constructor({ apiKey, apiUrl = 'https://www.cocoviral.ai' }) {
+        this.apiKey = apiKey;
+        this.http = axios_1.default.create({
+            baseURL: `${apiUrl}/api`,
+            headers: {
+                'x-api-key': apiKey,
+                'Content-Type': 'application/json',
+            },
+            timeout: 60000,
+        });
+    }
+    async validate() {
+        try {
+            const res = await this.http.post('/api-keys/validate', { apiKey: this.apiKey });
+            return res.data?.valid === true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async listVideos(params = {}) {
+        const res = await this.http.get('/videos', { params: { limit: 10, page: 1, ...params } });
+        return res.data?.data || [];
+    }
+    async getCredits() {
+        const res = await this.http.get('/credits/balance');
+        return res.data;
+    }
+    resolveQuality(modelId, quality) {
+        const isGptModel = CocoViralClient.GPT_IMAGE_MODEL_IDS.has(modelId);
+        if (quality)
+            return quality;
+        return isGptModel ? 'low' : 'hd';
+    }
+    async generateImage(opts) {
+        const alias = opts.model || 'flux-2-pro';
+        const modelId = exports.IMAGE_MODEL_ALIAS_MAP[alias] ?? exports.IMAGE_MODEL_ALIAS_MAP['flux-2-pro'];
+        const quality = this.resolveQuality(modelId, opts.quality);
+        const res = await this.http.post('/ai-generation/image', {
+            model: modelId,
+            quality,
+            input: {
+                prompt: opts.prompt,
+                aspect_ratio: opts.aspectRatio || '1:1',
+                ...(opts.outputFormat ? { output_format: opts.outputFormat } : {}),
+                ...(opts.referenceImages?.length ? { input_images: opts.referenceImages } : {}),
+            },
+        });
+        return res.data;
+    }
+    async editImage(opts) {
+        const alias = opts.model || 'nano-banana-2';
+        const modelId = exports.IMAGE_MODEL_ALIAS_MAP[alias] ?? exports.IMAGE_MODEL_ALIAS_MAP['nano-banana-2'];
+        const quality = this.resolveQuality(modelId, opts.quality);
+        const res = await this.http.post('/ai-generation/image', {
+            model: modelId,
+            quality,
+            input: {
+                prompt: opts.prompt,
+                aspect_ratio: opts.aspectRatio || '1:1',
+                input_images: [opts.imageUrl],
+            },
+        });
+        return res.data;
+    }
+    async generateVideo(opts) {
+        const modelId = exports.VIDEO_MODEL_ID_MAP[opts.model || 'veo3.1'] ?? exports.VIDEO_MODEL_ID_MAP['veo3.1'];
+        const res = await this.http.post('/ai-generation/video', {
+            prompt: opts.prompt,
+            model: modelId,
+            resolution: opts.resolution || 'hd',
+            aspect_ratio: opts.aspectRatio || '9:16',
+            duration: opts.duration || 5,
+            source: 'cli',
+            ...(opts.startImageUrl ? { start_image_url: opts.startImageUrl } : {}),
+            ...(opts.endImageUrl ? { end_image_url: opts.endImageUrl } : {}),
+            ...(opts.referenceImages?.length ? { reference_images: opts.referenceImages } : {}),
+            ...(opts.referenceVideos?.length ? { reference_videos: opts.referenceVideos } : {}),
+            ...(opts.referenceAudios?.length ? { reference_audios: opts.referenceAudios } : {}),
+        });
+        return res.data;
+    }
+    async checkVideoStatus(predictionId) {
+        const res = await this.http.get(`/ai-generation/video/${predictionId}/status`);
+        return res.data;
+    }
+    /** @deprecated use checkVideoStatus */
+    async checkStatus(predictionId) {
+        return this.checkVideoStatus(predictionId);
+    }
+    async checkImageStatus(predictionId) {
+        const res = await this.http.get('/ai-generation/image', { params: { id: predictionId } });
+        return res.data;
+    }
+    async analyzeVideo(videoUrl, prompt) {
+        const analysisPrompt = prompt ||
+            'Analyze this video: 1) Concept & hook, 2) Visual style & pacing, 3) Audio/music, 4) Text overlays, 5) Key scenes.';
+        const res = await this.http.post('/tools/gemini-video-vision', {
+            prompt: analysisPrompt,
+            videoUrl,
+            limitCharacters: true,
+        });
+        return res.data?.content || res.data?.result || '';
+    }
+    async buildRemixVariants(opts) {
+        const res = await this.http.post('/video-clone-bulk/build-variants', {
+            basePrompt: opts.basePrompt,
+            modificationInstructions: opts.modificationInstructions || '',
+            productDescription: opts.productDescription || '',
+            count: Math.min(10, Math.max(1, opts.count || 3)),
+        });
+        return res.data?.variants || res.data || [];
+    }
+    async translateVideo(opts) {
+        const res = await this.http.post('/video-translate/jobs', {
+            sourceUrl: opts.sourceUrl,
+            targetLanguage: opts.targetLanguage,
+            tone: opts.tone || 'casual',
+            voiceStyle: opts.voiceStyle || '',
+            translationMode: 'auto',
+        });
+        return res.data;
+    }
+    async getTranslateJobStatus(jobId) {
+        const res = await this.http.get(`/video-translate/jobs/${jobId}`);
+        return res.data;
+    }
+    // ── Director Studio ────────────────────────────────────────────────────────
+    // Presets and prompt composition live in the API so the CLI, the MCP server
+    // and the web studio can never drift apart on what a preset means.
+    async listCinemaPresets(params = {}) {
+        const res = await this.http.get('/director-studio/presets', { params });
+        return res.data;
+    }
+    async composeCinemaPrompt(opts) {
+        const res = await this.http.post('/director-studio/compose', opts);
+        return res.data;
+    }
+    /** Compose the frame prompt from the presets, then generate the still. */
+    async generateCinemaFrame(opts) {
+        const composed = await this.composeCinemaPrompt({
+            mode: 'frame',
+            scene: opts.scene,
+            lookIds: [opts.look, opts.lighting, opts.palette].filter(Boolean),
+            shotSizeId: opts.shotSize,
+            cameraBodyId: opts.cameraBody,
+            lensId: opts.lens,
+            apertureId: opts.aperture,
+        });
+        const data = await this.generateImage({
+            prompt: composed.prompt,
+            model: opts.model || 'nano-banana-pro',
+            aspectRatio: opts.aspectRatio || '16:9',
+            // A cinema frame is a master to animate from, so keep it lossless.
+            outputFormat: 'png',
+        });
+        return { ...data, composed };
+    }
+    /** Compose the motion prompt from the camera move, then animate the frame. */
+    async animateCinemaShot(opts) {
+        const composed = await this.composeCinemaPrompt({
+            mode: 'shot',
+            scene: opts.scene,
+            motionId: opts.motion,
+            direction: opts.direction,
+        });
+        const duration = opts.duration ?? composed.recommendedDuration ?? 5;
+        const data = await this.generateVideo({
+            prompt: composed.prompt,
+            model: opts.model || 'kling3-pro-i2v',
+            aspectRatio: opts.aspectRatio || '16:9',
+            duration,
+            resolution: opts.resolution || 'fhd',
+            startImageUrl: opts.startImageUrl,
+        });
+        return { ...data, composed, duration };
+    }
+    async getCharacters(limit = 20) {
+        const res = await this.http.get('/characters', { params: { limit } });
+        return res.data?.characters || res.data || [];
+    }
+    // ── Viral Flow ────────────────────────────────────────────────────────────
+    async listFlows() {
+        const res = await this.http.get('/viral-flow/sessions');
+        return res.data?.sessions || [];
+    }
+    async getFlow(flowId) {
+        const res = await this.http.get(`/viral-flow/sessions/${encodeURIComponent(flowId)}/graph`);
+        return res.data?.flow;
+    }
+    /**
+     * Upload a file from disk.
+     *
+     * This is the CLI's reason to exist: a hosted tool call carries JSON, so the
+     * remote server can only take a URL that is already public. Here the bytes
+     * are right there on the same machine.
+     */
+    async uploadFile(filePath) {
+        const form = new FormData();
+        const buffer = await node_fs_1.default.promises.readFile(filePath);
+        const type = mimeTypeFor(filePath);
+        form.append('file', new Blob([buffer], { type }), node_path_1.default.basename(filePath));
+        const res = await this.http.post('/viral-flow/upload', form, {
+            // Let the runtime set the multipart boundary; the client default of
+            // application/json would make the server reject this as a URL import.
+            headers: { 'Content-Type': undefined },
+            maxBodyLength: Infinity,
+            maxContentLength: Infinity,
+            timeout: 300000,
+        });
+        return res.data;
+    }
+    async runFlowNode(flowId, nodeId) {
+        const res = await this.http.post(`/viral-flow/sessions/${encodeURIComponent(flowId)}/nodes/${encodeURIComponent(nodeId)}/run`, {});
+        return res.data;
+    }
+    async flowNodeStatus(flowId, nodeId) {
+        const res = await this.http.get(`/viral-flow/sessions/${encodeURIComponent(flowId)}/nodes/${encodeURIComponent(nodeId)}/status`);
+        return res.data;
+    }
+    async listFlowAssets(flowId) {
+        const res = await this.http.get(`/viral-flow/sessions/${encodeURIComponent(flowId)}/assets`);
+        return res.data?.assets || [];
+    }
+    /** Stream an asset to disk. Assets are public, so this needs no auth header. */
+    async downloadTo(url, filePath) {
+        const res = await axios_1.default.get(url, { responseType: 'arraybuffer', timeout: 300000 });
+        await node_fs_1.default.promises.writeFile(filePath, Buffer.from(res.data));
+    }
+}
+exports.CocoViralClient = CocoViralClient;
+// GPT Image model IDs that require quality values: auto | low | medium | high
+CocoViralClient.GPT_IMAGE_MODEL_IDS = new Set([
+    'openai/gpt-image-2',
+    'openai/gpt-image-2/edit',
+    'fal-ai/gpt-image-1/text-to-image',
+    'fal-ai/gpt-image-1.5',
+]);

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@cocoviral/cli",
+  "version": "1.5.4",
+  "description": "CocoViral CLI - generate AI images and video, drive Director Studio, and build, run and deliver Viral Flow graphs from your terminal.",
+  "bin": {
+    "cviral": "dist/cli.js"
+  },
+  "files": [
+    "dist/**/*",
+    "README.md"
+  ],
+  "scripts": {
+    "prepack": "bash ./sync-dist.sh"
+  },
+  "dependencies": {
+    "axios": "^1.6.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "cli",
+    "ai",
+    "video",
+    "image-generation",
+    "video-generation",
+    "cocoviral"
+  ],
+  "license": "MIT",
+  "homepage": "https://www.cocoviral.ai/mcp-skills",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Jet1217/CloneViral.git",
+    "directory": "cli"
+  }
+}