@playcraft/cli 0.0.40 → 0.0.42

package/dist/commands/tools-3d.js

@@ -0,0 +1,473 @@
+import { writeFileSync, mkdirSync, readFileSync } from 'fs';
+import { dirname } from 'path';
+import { AgentApiClient } from '../utils/agent-api-client.js';
+import { mimeTypeForImagePath, handleError } from './tools-utils.js';
+const AVATAR_TEMPLATES = [
+    'basketball', 'badminton', 'pingpong', 'gymnastics', 'pilidance',
+    'tennis', 'athletics', 'footballboykicking1', 'footballboykicking2',
+    'guitar', 'footballboy', 'skateboard', 'futuresoilder', 'explorer',
+    'beardollgirl', 'bibpantsboy', 'womansitpose', 'womanstandpose2',
+    'mysteriousprincess', 'manstandpose2',
+];
+export function register3DCommands(tools) {
+    tools.command('list-3d-models')
+        .description('List available 3D model generation configs (modelKind=3d)')
+        .option('--json', 'Output as JSON')
+        .action(async (opts) => {
+        try {
+            const client = new AgentApiClient();
+            const models = await client.get('/3d-models');
+            if (opts.json) {
+                console.log(JSON.stringify({ models }, null, 2));
+                return;
+            }
+            if (!models.length) {
+                console.log('No 3D model configs found.');
+                console.log('Add one at Settings → AI Config → 3D Model Generation');
+                console.log('\nRecommended: Tencent Cloud HunyuanTo3D');
+                console.log('  Provider: tencent-cloud');
+                console.log('  Model:    hy-3d-3.0  (quality) or hy-3d-express (fast)');
+                return;
+            }
+            console.log('\nAvailable 3D Model Configs:\n');
+            for (const m of models) {
+                const mark = m.isDefault ? ' [default]' : '';
+                console.log(`  ${m.modelRef}${mark}`);
+                console.log(`    ${m.capability}`);
+            }
+            console.log('\nUsage: playcraft tools generate-3d --prompt "..." --output model.glb');
+        }
+        catch (e) {
+            handleError(e);
+        }
+    });
+    tools.command('generate-3d')
+        .description('Generate a 3D model from a text prompt or input image (uses HunyuanTo3D or configured provider)')
+        .option('--prompt <text>', 'Text description of the 3D model to generate')
+        .option('--input <path>', 'Input image (local path or URL) for image-to-3D generation')
+        .requiredOption('--output <path>', 'Output model file path')
+        .option('--model <ref>', 'Model ref in provider/model-id format (e.g. tencent-cloud/hy-3d-3.1)')
+        .option('--format <fmt>', 'Output format: glb|obj|stl|fbx|usdz (default: glb)', 'glb')
+        .option('--generate-type <type>', 'Generation mode: Normal|Geometry|LowPoly|Sketch (Geometry = white model without texture)')
+        .option('--face-count <n>', 'Target polygon count (3000–1500000, default: 500000)', parseInt)
+        .option('--enable-pbr', 'Enable PBR material generation (base color + normal + roughness + metalness maps)')
+        .option('--polygon-type <type>', 'Polygon mesh type for LowPoly mode: triangle|quadrilateral')
+        .option('--input-mime <mime>', 'MIME type of input image (default: auto-detected or image/png)')
+        .option('--save-preview <path>', 'Save preview image to this path (PNG)')
+        .action(async (opts) => {
+        try {
+            if (!opts.prompt && !opts.input) {
+                console.error('Error: --prompt or --input is required');
+                process.exit(1);
+            }
+            const client = new AgentApiClient();
+            const payload = {
+                outputFormat: opts.format ?? 'glb',
+            };
+            if (opts.prompt)
+                payload.prompt = opts.prompt;
+            if (opts.model)
+                payload.modelRef = opts.model;
+            if (opts.generateType)
+                payload.generateType = opts.generateType;
+            if (opts.faceCount != null)
+                payload.faceCount = opts.faceCount;
+            if (opts.enablePbr)
+                payload.enablePBR = true;
+            if (opts.polygonType)
+                payload.polygonType = opts.polygonType;
+            if (opts.input) {
+                let inputImageBase64;
+                let inputImageMimeType = opts.inputMime;
+                const isUrl = opts.input.startsWith('http://') || opts.input.startsWith('https://');
+                if (isUrl) {
+                    console.log(`Downloading input image from URL...`);
+                    try {
+                        const response = await fetch(opts.input);
+                        if (!response.ok) {
+                            console.error(`Error: Failed to download image from URL (HTTP ${response.status})`);
+                            process.exit(1);
+                        }
+                        if (!inputImageMimeType) {
+                            const ct = response.headers.get('content-type') ?? '';
+                            inputImageMimeType = ct.split(';')[0].trim() || 'image/png';
+                        }
+                        const buffer = Buffer.from(await response.arrayBuffer());
+                        inputImageBase64 = buffer.toString('base64');
+                    }
+                    catch (downloadErr) {
+                        const msg = downloadErr instanceof Error ? downloadErr.message : String(downloadErr);
+                        console.error(`Error: Failed to download image from URL: ${msg}`);
+                        process.exit(1);
+                    }
+                }
+                else {
+                    if (!inputImageMimeType) {
+                        inputImageMimeType = mimeTypeForImagePath(opts.input);
+                    }
+                    try {
+                        inputImageBase64 = readFileSync(opts.input).toString('base64');
+                    }
+                    catch {
+                        console.error(`Error: Input image file not found: ${opts.input}`);
+                        process.exit(1);
+                    }
+                }
+                payload.inputImageBase64 = inputImageBase64;
+                if (inputImageMimeType)
+                    payload.inputImageMimeType = inputImageMimeType;
+            }
+            const modelRef = opts.model ?? 'default configured 3D model';
+            console.log(`Generating 3D model...`);
+            console.log(`  Model: ${modelRef}`);
+            if (opts.prompt)
+                console.log(`  Prompt: ${opts.prompt}`);
+            if (opts.input)
+                console.log(`  Input image: ${opts.input}`);
+            if (opts.generateType)
+                console.log(`  Generate type: ${opts.generateType}`);
+            if (opts.faceCount)
+                console.log(`  Face count: ${opts.faceCount}`);
+            if (opts.enablePbr)
+                console.log(`  PBR: enabled`);
+            console.log(`  (This may take 1–5 minutes for quality models)`);
+            const t0 = Date.now();
+            const result = await client.post('/generate-3d', payload);
+            const elapsed = ((Date.now() - t0) / 1000).toFixed(1);
+            const glbBuffer = Buffer.from(result.modelBase64, 'base64');
+            const outputDir = dirname(opts.output);
+            mkdirSync(outputDir, { recursive: true });
+            writeFileSync(opts.output, glbBuffer);
+            const sizeMB = (glbBuffer.length / 1024 / 1024).toFixed(2);
+            console.log(`\n3D model generated: ${opts.output} (${sizeMB}MB, ${elapsed}s)`);
+            console.log(`  Provider: ${result.provider} / ${result.model}`);
+            if (opts.savePreview && result.previewImageBase64) {
+                const previewBuf = Buffer.from(result.previewImageBase64, 'base64');
+                const previewDir = dirname(opts.savePreview);
+                mkdirSync(previewDir, { recursive: true });
+                writeFileSync(opts.savePreview, previewBuf);
+                console.log(`  Preview saved: ${opts.savePreview}`);
+            }
+            console.log(`\nNext steps:`);
+            console.log(`  Inspect:        playcraft 3d info ${opts.output}`);
+            console.log(`  Apply texture:  playcraft tools generate-texture --model-url <url> --reference-image <img> --output out.glb`);
+            console.log(`  Optimize:       playcraft tools retopology --model-url <url> --face-level medium --output optimized.glb`);
+        }
+        catch (e) {
+            handleError(e);
+        }
+    });
+    // ─── generate-texture ─────────────────────────────────────────────────────
+    tools.command('generate-texture')
+        .description('Generate PBR textures for an existing 3D model (SubmitTextureTo3DJob).')
+        .requiredOption('--model-url <url>', 'Input 3D model URL (GLB or OBJ, ≤60MB)')
+        .option('--model-format <fmt>', 'Model format: GLB|OBJ (auto-detected from URL if omitted)')
+        .option('--reference-image <path>', 'Texture reference image (local path or URL)')
+        .option('--prompt <text>', 'Text description for texture generation (alternative to reference image)')
+        .option('--model-version <ver>', 'HunyuanTo3D model version: 3.0|3.1 (default: 3.0)', '3.0')
+        .requiredOption('--output <path>', 'Output model file path (.glb)')
+        .action(async (opts) => {
+        try {
+            if (!opts.referenceImage && !opts.prompt) {
+                console.error('Error: --reference-image or --prompt is required');
+                process.exit(1);
+            }
+            const client = new AgentApiClient();
+            const payload = {
+                modelUrl: opts.modelUrl,
+                model: opts.modelVersion,
+            };
+            if (opts.modelFormat) {
+                payload.modelFormat = opts.modelFormat.toUpperCase();
+            }
+            if (opts.prompt)
+                payload.prompt = opts.prompt;
+            if (opts.referenceImage) {
+                const isUrl = opts.referenceImage.startsWith('http://') || opts.referenceImage.startsWith('https://');
+                if (isUrl) {
+                    payload.referenceImageUrl = opts.referenceImage;
+                }
+                else {
+                    payload.referenceImageBase64 = readFileSync(opts.referenceImage).toString('base64');
+                }
+            }
+            console.log('Generating textures for 3D model...');
+            console.log(`  Input model: ${opts.modelUrl}`);
+            if (opts.referenceImage)
+                console.log(`  Reference image: ${opts.referenceImage}`);
+            if (opts.prompt)
+                console.log(`  Prompt: ${opts.prompt}`);
+            console.log('  (This may take 1–5 minutes)');
+            const t0 = Date.now();
+            const result = await client.post('/generate-texture', payload);
+            const elapsed = ((Date.now() - t0) / 1000).toFixed(1);
+            if (!result.modelBase64) {
+                console.error('Error: No model data in response');
+                process.exit(1);
+            }
+            const buf = Buffer.from(result.modelBase64, 'base64');
+            const outDir = dirname(opts.output);
+            mkdirSync(outDir, { recursive: true });
+            writeFileSync(opts.output, buf);
+            const sizeMB = (buf.length / 1024 / 1024).toFixed(2);
+            console.log(`\nTextured model saved: ${opts.output} (${sizeMB}MB, ${elapsed}s)`);
+            if (result.resultUrl)
+                console.log(`  Source URL: ${result.resultUrl}`);
+        }
+        catch (e) {
+            handleError(e);
+        }
+    });
+    // ─── retopology ───────────────────────────────────────────────────────────
+    tools.command('retopology')
+        .description('Reduce polygon count with smart retopology (SubmitReduceFaceJob).')
+        .requiredOption('--model-url <url>', 'Input 3D model URL (GLB or OBJ, ≤60MB)')
+        .option('--model-format <fmt>', 'Model format: GLB|OBJ (auto-detected from URL if omitted)')
+        .option('--face-level <level>', 'Target polygon level: high|medium|low (default: medium)', 'medium')
+        .option('--polygon-type <type>', 'Mesh type: triangle|quadrilateral (default: triangle)', 'triangle')
+        .requiredOption('--output <path>', 'Output model file path (.glb)')
+        .action(async (opts) => {
+        try {
+            const client = new AgentApiClient();
+            const payload = {
+                modelUrl: opts.modelUrl,
+                faceLevel: opts.faceLevel,
+                polygonType: opts.polygonType,
+            };
+            if (opts.modelFormat) {
+                payload.modelFormat = opts.modelFormat.toUpperCase();
+            }
+            console.log('Running smart retopology...');
+            console.log(`  Input model: ${opts.modelUrl}`);
+            console.log(`  Face level: ${opts.faceLevel}`);
+            console.log(`  Polygon type: ${opts.polygonType}`);
+            console.log('  (This may take 1–3 minutes)');
+            const t0 = Date.now();
+            const result = await client.post('/retopology', payload);
+            const elapsed = ((Date.now() - t0) / 1000).toFixed(1);
+            if (!result.modelBase64) {
+                console.error('Error: No model data in response');
+                process.exit(1);
+            }
+            const buf = Buffer.from(result.modelBase64, 'base64');
+            const outDir = dirname(opts.output);
+            mkdirSync(outDir, { recursive: true });
+            writeFileSync(opts.output, buf);
+            const sizeMB = (buf.length / 1024 / 1024).toFixed(2);
+            console.log(`\nRetopologized model saved: ${opts.output} (${sizeMB}MB, ${elapsed}s)`);
+        }
+        catch (e) {
+            handleError(e);
+        }
+    });
+    // ─── uv-unwrap ────────────────────────────────────────────────────────────
+    tools.command('uv-unwrap')
+        .description('Auto UV unwrap a 3D model (SubmitHunyuanTo3DUVJob).')
+        .requiredOption('--model-url <url>', 'Input 3D model URL (FBX / OBJ / GLB, ≤60MB)')
+        .option('--model-format <fmt>', 'Model format: FBX|OBJ|GLB (auto-detected from URL if omitted)')
+        .requiredOption('--output <path>', 'Output model file path')
+        .action(async (opts) => {
+        try {
+            const client = new AgentApiClient();
+            const payload = {
+                modelUrl: opts.modelUrl,
+            };
+            if (opts.modelFormat) {
+                payload.modelFormat = opts.modelFormat.toUpperCase();
+            }
+            console.log('Running UV unwrap...');
+            console.log(`  Input model: ${opts.modelUrl}`);
+            console.log('  (This may take 1–3 minutes)');
+            const t0 = Date.now();
+            const result = await client.post('/uv-unwrap', payload);
+            const elapsed = ((Date.now() - t0) / 1000).toFixed(1);
+            if (!result.modelBase64) {
+                console.error('Error: No model data in response');
+                process.exit(1);
+            }
+            const buf = Buffer.from(result.modelBase64, 'base64');
+            const outDir = dirname(opts.output);
+            mkdirSync(outDir, { recursive: true });
+            writeFileSync(opts.output, buf);
+            const sizeMB = (buf.length / 1024 / 1024).toFixed(2);
+            console.log(`\nUV-unwrapped model saved: ${opts.output} (${sizeMB}MB, ${elapsed}s)`);
+        }
+        catch (e) {
+            handleError(e);
+        }
+    });
+    // ─── convert-3d ───────────────────────────────────────────────────────────
+    tools.command('convert-3d')
+        .description('Convert 3D model format synchronously (Convert3DFormat).')
+        .requiredOption('--model-url <url>', 'Input 3D model URL (GLB / OBJ / FBX, ≤60MB)')
+        .requiredOption('--format <fmt>', 'Target format: STL|USDZ|FBX|MP4|GIF')
+        .requiredOption('--output <path>', 'Output file path')
+        .action(async (opts) => {
+        try {
+            const client = new AgentApiClient();
+            const payload = {
+                modelUrl: opts.modelUrl,
+                format: opts.format.toUpperCase(),
+            };
+            console.log(`Converting 3D model to ${opts.format.toUpperCase()}...`);
+            console.log(`  Input: ${opts.modelUrl}`);
+            const t0 = Date.now();
+            const result = await client.post('/convert-3d', payload);
+            const elapsed = ((Date.now() - t0) / 1000).toFixed(1);
+            console.log(`  Downloading result from: ${result.resultUrl}`);
+            const dlRes = await fetch(result.resultUrl);
+            if (!dlRes.ok) {
+                console.error(`Error: Failed to download result file (HTTP ${dlRes.status})`);
+                process.exit(1);
+            }
+            const buf = Buffer.from(await dlRes.arrayBuffer());
+            const outDir = dirname(opts.output);
+            mkdirSync(outDir, { recursive: true });
+            writeFileSync(opts.output, buf);
+            const sizeMB = (buf.length / 1024 / 1024).toFixed(2);
+            console.log(`\nConverted model saved: ${opts.output} (${sizeMB}MB, ${elapsed}s)`);
+            console.log(`  Format: ${result.format.toUpperCase()}`);
+        }
+        catch (e) {
+            handleError(e);
+        }
+    });
+    // ─── generate-3d-parts ────────────────────────────────────────────────────
+    tools.command('generate-3d-parts')
+        .description('Auto-generate 3D components from a model (SubmitHunyuan3DPartJob). FBX only.')
+        .requiredOption('--model-url <url>', 'Input FBX model URL (≤60MB)')
+        .option('--model-version <ver>', 'Model version (default: 1.5)', '1.5')
+        .requiredOption('--output <path>', 'Output model file path (.fbx)')
+        .action(async (opts) => {
+        try {
+            const client = new AgentApiClient();
+            const payload = {
+                modelUrl: opts.modelUrl,
+                model: opts.modelVersion,
+            };
+            console.log('Generating 3D parts...');
+            console.log(`  Input model: ${opts.modelUrl}`);
+            console.log('  (This may take 1–5 minutes)');
+            const t0 = Date.now();
+            const result = await client.post('/generate-3d-parts', payload);
+            const elapsed = ((Date.now() - t0) / 1000).toFixed(1);
+            if (!result.modelBase64) {
+                console.error('Error: No model data in response');
+                process.exit(1);
+            }
+            const buf = Buffer.from(result.modelBase64, 'base64');
+            const outDir = dirname(opts.output);
+            mkdirSync(outDir, { recursive: true });
+            writeFileSync(opts.output, buf);
+            const sizeMB = (buf.length / 1024 / 1024).toFixed(2);
+            console.log(`\n3D parts model saved: ${opts.output} (${sizeMB}MB, ${elapsed}s)`);
+        }
+        catch (e) {
+            handleError(e);
+        }
+    });
+    // ─── generate-motion ──────────────────────────────────────────────────────
+    tools.command('generate-motion')
+        .description('Generate 3D character motion from text (SubmitHunyuanTo3DMotionJob). Outputs animated FBX.')
+        .requiredOption('--prompt <text>', 'Text description of the motion (max 128 chars)')
+        .option('--duration <n>', 'Animation duration in seconds (1–12, default: 5)', parseInt)
+        .option('--retarget-model-url <url>', 'Apply motion to this FBX model URL (must be from HunyuanTo3D)')
+        .option('--no-mesh', 'Exclude skinned mesh from output FBX')
+        .requiredOption('--output <path>', 'Output FBX file path')
+        .action(async (opts) => {
+        try {
+            const client = new AgentApiClient();
+            const payload = {
+                prompt: opts.prompt,
+                duration: opts.duration,
+                enableMesh: opts.mesh !== false,
+            };
+            if (opts.retargetModelUrl)
+                payload.retargetModelUrl = opts.retargetModelUrl;
+            console.log('Generating 3D motion...');
+            console.log(`  Prompt: ${opts.prompt}`);
+            if (opts.duration)
+                console.log(`  Duration: ${opts.duration}s`);
+            if (opts.retargetModelUrl)
+                console.log(`  Retarget model: ${opts.retargetModelUrl}`);
+            console.log('  (This may take 1–5 minutes)');
+            const t0 = Date.now();
+            const result = await client.post('/generate-motion', payload);
+            const elapsed = ((Date.now() - t0) / 1000).toFixed(1);
+            if (!result.modelBase64) {
+                console.error('Error: No model data in response');
+                process.exit(1);
+            }
+            const buf = Buffer.from(result.modelBase64, 'base64');
+            const outDir = dirname(opts.output);
+            mkdirSync(outDir, { recursive: true });
+            writeFileSync(opts.output, buf);
+            const sizeMB = (buf.length / 1024 / 1024).toFixed(2);
+            console.log(`\nMotion FBX saved: ${opts.output} (${sizeMB}MB, ${elapsed}s)`);
+        }
+        catch (e) {
+            handleError(e);
+        }
+    });
+    // ─── generate-avatar ──────────────────────────────────────────────────────
+    tools.command('generate-avatar')
+        .description('Generate a 3D character from a portrait photo (SubmitProfileTo3DJob).')
+        .option('--profile-image <path>', 'Portrait photo (local path or URL)')
+        .option('--template <name>', `Character template: ${AVATAR_TEMPLATES.slice(0, 5).join('|')}... (run with --list-templates to see all)`)
+        .option('--list-templates', 'Print all available avatar templates and exit')
+        .requiredOption('--output <path>', 'Output model file path')
+        .action(async (opts) => {
+        try {
+            if (opts.listTemplates) {
+                console.log('Available avatar templates:');
+                const descriptions = {
+                    basketball: '动感球手', badminton: '羽扬中华', pingpong: '国球荣耀',
+                    gymnastics: '勇攀巅峰', pilidance: '舞动青春', tennis: '网球甜心',
+                    athletics: '东方疾风', footballboykicking1: '激情逐风', footballboykicking2: '绿茵之星',
+                    guitar: '甜酷弦音', footballboy: '足球小将', skateboard: '滑跃青春',
+                    futuresoilder: '未来战士', explorer: '逐梦旷野', beardollgirl: '可爱女孩',
+                    bibpantsboy: '都市白领', womansitpose: '职业丽影', womanstandpose2: '悠闲时光',
+                    mysteriousprincess: '海洋公主', manstandpose2: '演讲之星',
+                };
+                AVATAR_TEMPLATES.forEach((t) => console.log(`  ${t.padEnd(24)} ${descriptions[t] ?? ''}`));
+                process.exit(0);
+            }
+            if (!opts.profileImage) {
+                console.error('Error: --profile-image is required');
+                process.exit(1);
+            }
+            const client = new AgentApiClient();
+            const payload = {};
+            if (opts.template)
+                payload.template = opts.template;
+            const isUrl = opts.profileImage.startsWith('http://') || opts.profileImage.startsWith('https://');
+            if (isUrl) {
+                payload.profileImageUrl = opts.profileImage;
+            }
+            else {
+                payload.profileImageBase64 = readFileSync(opts.profileImage).toString('base64');
+            }
+            console.log('Generating 3D avatar...');
+            console.log(`  Profile: ${opts.profileImage}`);
+            if (opts.template)
+                console.log(`  Template: ${opts.template}`);
+            console.log('  (This may take 1–5 minutes)');
+            const t0 = Date.now();
+            const result = await client.post('/generate-avatar', payload);
+            const elapsed = ((Date.now() - t0) / 1000).toFixed(1);
+            if (!result.modelBase64) {
+                console.error('Error: No model data in response');
+                process.exit(1);
+            }
+            const buf = Buffer.from(result.modelBase64, 'base64');
+            const outDir = dirname(opts.output);
+            mkdirSync(outDir, { recursive: true });
+            writeFileSync(opts.output, buf);
+            const sizeMB = (buf.length / 1024 / 1024).toFixed(2);
+            console.log(`\n3D avatar saved: ${opts.output} (${sizeMB}MB, ${elapsed}s)`);
+        }
+        catch (e) {
+            handleError(e);
+        }
+    });
+}