@playcraft/cli 0.0.18 → 0.0.21

package/dist/playable/vite-builder.js

@@ -0,0 +1,125 @@
+import { build as viteBuild } from 'vite';
+import fs from 'fs/promises';
+import path from 'path';
+import { ViteConfigBuilder } from './vite/config-builder.js';
+import { PLATFORM_CONFIGS } from './vite/platform-configs.js';
+/**
+ * Vite 构建器 - 使用 Vite 构建 Playable Ads
+ *
+ * 职责：
+ * 1. 验证输入是有效的基础构建
+ * 2. 创建 Vite 配置
+ * 3. 执行 Vite 构建
+ * 4. 验证输出大小
+ * 5. 生成报告
+ */
+export class ViteBuilder {
+    baseBuildDir;
+    options;
+    sizeReport;
+    constructor(baseBuildDir, options) {
+        this.baseBuildDir = baseBuildDir;
+        this.options = options;
+        const platformConfig = PLATFORM_CONFIGS[options.platform];
+        this.sizeReport = {
+            engine: 0,
+            assets: {},
+            total: 0,
+            limit: platformConfig.sizeLimit,
+        };
+    }
+    /**
+     * 执行构建
+     */
+    async build() {
+        // 1. 验证输入
+        await this.validateBaseBuild();
+        // 2. 创建 Vite 配置
+        const configBuilder = new ViteConfigBuilder(this.baseBuildDir, this.options.platform, this.options);
+        const viteConfig = configBuilder.create();
+        // 3. 执行 Vite 构建
+        await viteBuild(viteConfig);
+        // 4. 验证输出大小
+        const outputPath = this.getOutputPath();
+        await this.validateSize(outputPath);
+        // 5. 生成报告
+        this.generateReport(outputPath);
+        return outputPath;
+    }
+    /**
+     * 验证基础构建
+     */
+    async validateBaseBuild() {
+        const requiredFiles = [
+            'index.html',
+            'config.json',
+            '__start__.js',
+        ];
+        const missingFiles = [];
+        for (const file of requiredFiles) {
+            try {
+                await fs.access(path.join(this.baseBuildDir, file));
+            }
+            catch (error) {
+                missingFiles.push(file);
+            }
+        }
+        if (missingFiles.length > 0) {
+            throw new Error(`基础构建产物缺少必需文件: ${missingFiles.join(', ')}\n` +
+                `请确保输入目录包含完整的多文件构建产物。`);
+        }
+    }
+    /**
+     * 获取输出路径
+     */
+    getOutputPath() {
+        const platformConfig = PLATFORM_CONFIGS[this.options.platform];
+        const outputDir = this.options.outputDir || './dist';
+        if (platformConfig.outputFormat === 'zip') {
+            return path.join(outputDir, 'playable.zip');
+        }
+        return path.join(outputDir, platformConfig.outputFileName);
+    }
+    /**
+     * 验证输出大小
+     */
+    async validateSize(outputPath) {
+        try {
+            const stats = await fs.stat(outputPath);
+            this.sizeReport.total = stats.size;
+            this.sizeReport.assets[path.basename(outputPath)] = stats.size;
+            if (stats.size > this.sizeReport.limit) {
+                const sizeMB = (stats.size / 1024 / 1024).toFixed(2);
+                const limitMB = (this.sizeReport.limit / 1024 / 1024).toFixed(2);
+                console.warn(`⚠️  警告: 文件大小 ${sizeMB} MB 超过限制 ${limitMB} MB`);
+            }
+        }
+        catch (error) {
+            console.warn(`警告: 无法读取输出文件: ${outputPath}`);
+        }
+    }
+    /**
+     * 生成报告
+     */
+    generateReport(outputPath) {
+        // 报告已在 validateSize 中生成
+        // 这里可以添加额外的报告逻辑
+    }
+    /**
+     * 获取大小报告
+     */
+    getSizeReport() {
+        return this.sizeReport;
+    }
+    /**
+     * 格式化字节数
+     */
+    formatBytes(bytes) {
+        if (bytes === 0)
+            return '0 Bytes';
+        const k = 1024;
+        const sizes = ['Bytes', 'KB', 'MB', 'GB'];
+        const i = Math.floor(Math.log(bytes) / Math.log(k));
+        return Math.round(bytes / Math.pow(k, i) * 100) / 100 + ' ' + sizes[i];
+    }
+}

package/dist/utils/agent-api-client.js

@@ -0,0 +1,82 @@
+import { readFileSync, existsSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+/**
+ * Lightweight HTTP client for calling PlayCraft backend APIs from inside a sandbox.
+ * Reads credentials from environment variables or .playcraft.json.
+ */
+export class AgentApiClient {
+    apiUrl;
+    token;
+    constructor() {
+        let apiUrl = process.env.PLAYCRAFT_API_URL || '';
+        let token = process.env.PLAYCRAFT_SANDBOX_TOKEN || '';
+        if (!apiUrl || !token) {
+            const config = AgentApiClient.loadConfig();
+            apiUrl = apiUrl || config.apiUrl;
+            token = token || config.token;
+        }
+        if (!apiUrl || !token) {
+            throw new Error('Missing PlayCraft API credentials. Set PLAYCRAFT_API_URL and PLAYCRAFT_SANDBOX_TOKEN, ' +
+                'or create a .playcraft.json file.');
+        }
+        this.apiUrl = apiUrl.replace(/\/+$/, '');
+        this.token = token;
+    }
+    /** Absolute pathname under /api/agent/tools (path may omit leading slash). */
+    toolsRequestUrl(path) {
+        const p = path.startsWith('/') ? path : `/${path}`;
+        return new URL(`/api/agent/tools${p}`, this.apiUrl);
+    }
+    async post(path, body) {
+        const url = this.toolsRequestUrl(path).href;
+        const res = await fetch(url, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'X-Sandbox-Token': this.token,
+            },
+            body: JSON.stringify(body),
+        });
+        if (!res.ok) {
+            const text = await res.text().catch(() => res.statusText);
+            throw new Error(`API ${res.status}: ${text}`);
+        }
+        return res.json();
+    }
+    async get(path, params) {
+        const url = this.toolsRequestUrl(path);
+        if (params) {
+            for (const [k, v] of Object.entries(params)) {
+                if (v !== undefined && v !== '')
+                    url.searchParams.set(k, v);
+            }
+        }
+        const res = await fetch(url, {
+            headers: { 'X-Sandbox-Token': this.token },
+        });
+        if (!res.ok) {
+            const text = await res.text().catch(() => res.statusText);
+            throw new Error(`API ${res.status}: ${text}`);
+        }
+        return res.json();
+    }
+    static loadConfig() {
+        const searchPaths = [
+            join(process.cwd(), '.playcraft.json'),
+            '/project/.playcraft.json',
+            join(homedir(), '.playcraft.json'),
+        ];
+        for (const p of searchPaths) {
+            if (existsSync(p)) {
+                try {
+                    return JSON.parse(readFileSync(p, 'utf-8'));
+                }
+                catch {
+                    continue;
+                }
+            }
+        }
+        return { apiUrl: '', token: '' };
+    }
+}

package/dist/utils/audio-processor.js

@@ -0,0 +1,269 @@
+import path from 'path';
+import os from 'os';
+import fsp from 'fs/promises';
+import ffmpeg from 'fluent-ffmpeg';
+import * as musicMetadata from 'music-metadata';
+/**
+ * Parse a human-readable size string like "30KB", "1.5MB" into bytes.
+ */
+function parseSizeToBytes(sizeStr) {
+    const match = sizeStr.trim().match(/^(\d+(?:\.\d+)?)\s*(B|KB|MB|GB)?$/i);
+    if (!match)
+        throw new Error(`Invalid size format: ${sizeStr}. Use e.g. "30KB", "1.5MB"`);
+    const value = parseFloat(match[1]);
+    const unit = (match[2] ?? 'B').toUpperCase();
+    const multipliers = { B: 1, KB: 1024, MB: 1024 * 1024, GB: 1024 * 1024 * 1024 };
+    return Math.round(value * (multipliers[unit] ?? 1));
+}
+/**
+ * Calculate the bitrate needed to hit a target file size for an audio file.
+ * targetBytes: desired file size in bytes
+ * durationSeconds: audio duration
+ * Returns bitrate in kbps (clamped to 8-320).
+ */
+function calcBitrateForSize(targetBytes, durationSeconds) {
+    if (durationSeconds <= 0)
+        return 64;
+    const targetBits = targetBytes * 8;
+    const bitrateKbps = Math.floor(targetBits / durationSeconds / 1000);
+    return Math.max(8, Math.min(320, bitrateKbps));
+}
+/**
+ * Wrap an ffmpeg command in a Promise.
+ */
+function runFfmpeg(cmd) {
+    return new Promise((resolve, reject) => {
+        cmd
+            .on('end', () => resolve())
+            .on('error', (err) => reject(err))
+            .run();
+    });
+}
+/**
+ * Get audio file metadata (duration, format, bitrate, sample rate, channels).
+ */
+export async function getAudioInfo(inputPath) {
+    const resolvedPath = path.resolve(inputPath);
+    let stat;
+    try {
+        stat = await fsp.stat(resolvedPath);
+    }
+    catch (err) {
+        const code = err.code;
+        if (code === 'ENOENT') {
+            throw new Error(`File not found: ${resolvedPath}`);
+        }
+        throw err;
+    }
+    const meta = await musicMetadata.parseFile(resolvedPath);
+    return {
+        duration: meta.format.duration ?? 0,
+        fileSize: stat.size,
+        format: meta.format.container ?? path.extname(resolvedPath).replace('.', ''),
+        bitrate: Math.round((meta.format.bitrate ?? 0) / 1000),
+        sampleRate: meta.format.sampleRate ?? 44100,
+        channels: meta.format.numberOfChannels ?? 2,
+    };
+}
+/**
+ * Compress audio file. Supports manual parameters or --target-size auto mode.
+ */
+export async function compressAudio(inputPath, outputPath, options) {
+    const resolvedInput = path.resolve(inputPath);
+    const resolvedOutput = path.resolve(outputPath);
+    await ensureOutputDir(resolvedOutput);
+    let bitrate = options.bitrate ?? 128;
+    const sampleRate = options.sampleRate;
+    const mono = options.mono ?? false;
+    if (options.targetSize) {
+        const targetBytes = parseSizeToBytes(options.targetSize);
+        const info = await getAudioInfo(resolvedInput);
+        bitrate = calcBitrateForSize(targetBytes, info.duration);
+        console.log(`Auto bitrate for ${options.targetSize}: ${bitrate}kbps (duration=${info.duration.toFixed(1)}s)`);
+    }
+    const cmd = ffmpeg(resolvedInput).audioBitrate(bitrate);
+    if (sampleRate) {
+        cmd.audioFrequency(sampleRate);
+    }
+    if (mono) {
+        cmd.audioChannels(1);
+    }
+    cmd.output(resolvedOutput);
+    await runFfmpeg(cmd);
+}
+/**
+ * Trim audio to a specific time range.
+ */
+export async function trimAudio(inputPath, outputPath, start, end) {
+    const resolvedInput = path.resolve(inputPath);
+    const resolvedOutput = path.resolve(outputPath);
+    await ensureOutputDir(resolvedOutput);
+    const duration = end - start;
+    if (duration <= 0)
+        throw new Error(`end must be greater than start (start=${start}, end=${end})`);
+    const cmd = ffmpeg(resolvedInput)
+        .setStartTime(start)
+        .setDuration(duration)
+        .output(resolvedOutput);
+    await runFfmpeg(cmd);
+}
+/**
+ * Convert audio format (e.g. WAV → MP3).
+ */
+export async function convertAudio(inputPath, outputPath, bitrate) {
+    const resolvedInput = path.resolve(inputPath);
+    const resolvedOutput = path.resolve(outputPath);
+    await ensureOutputDir(resolvedOutput);
+    const cmd = ffmpeg(resolvedInput);
+    if (bitrate) {
+        cmd.audioBitrate(bitrate);
+    }
+    cmd.output(resolvedOutput);
+    await runFfmpeg(cmd);
+}
+/**
+ * Add fade-in and/or fade-out effects.
+ */
+export async function fadeAudio(inputPath, outputPath, options) {
+    const resolvedInput = path.resolve(inputPath);
+    const resolvedOutput = path.resolve(outputPath);
+    await ensureOutputDir(resolvedOutput);
+    const info = await getAudioInfo(resolvedInput);
+    const duration = info.duration;
+    const filters = [];
+    if (options.fadeIn && options.fadeIn > 0) {
+        filters.push(`afade=t=in:st=0:d=${options.fadeIn}`);
+    }
+    if (options.fadeOut && options.fadeOut > 0) {
+        const fadeOutStart = Math.max(0, duration - options.fadeOut);
+        filters.push(`afade=t=out:st=${fadeOutStart}:d=${options.fadeOut}`);
+    }
+    if (!filters.length) {
+        throw new Error('At least one of --fade-in or --fade-out must be specified');
+    }
+    const cmd = ffmpeg(resolvedInput)
+        .audioFilters(filters)
+        .output(resolvedOutput);
+    await runFfmpeg(cmd);
+}
+/**
+ * Concatenate multiple audio files into one.
+ */
+export async function concatAudio(options) {
+    const resolvedOutputPath = path.resolve(options.output);
+    await ensureOutputDir(resolvedOutputPath);
+    const tempListFile = path.join(os.tmpdir(), `playcraft_concat_${Date.now()}.txt`);
+    const lines = options.inputs
+        .map((p) => `file '${path.resolve(p).replace(/'/g, "'\\''")}'`)
+        .join('\n');
+    await fsp.writeFile(tempListFile, lines, 'utf-8');
+    try {
+        const cmd = ffmpeg()
+            .input(tempListFile)
+            .inputOptions(['-f', 'concat', '-safe', '0'])
+            .audioCodec('libmp3lame')
+            .output(resolvedOutputPath);
+        await runFfmpeg(cmd);
+    }
+    finally {
+        await fsp.rm(tempListFile, { force: true }).catch(() => { });
+    }
+}
+/**
+ * Normalize audio loudness to a target LUFS level.
+ */
+export async function normalizeAudio(inputPath, outputPath, targetLoudness) {
+    const resolvedInput = path.resolve(inputPath);
+    const resolvedOutput = path.resolve(outputPath);
+    await ensureOutputDir(resolvedOutput);
+    const cmd = ffmpeg(resolvedInput)
+        .audioFilters(`loudnorm=I=${targetLoudness}:LRA=11:TP=-1.5`)
+        .output(resolvedOutput);
+    await runFfmpeg(cmd);
+}
+/**
+ * Create a seamless loop by crossfading the beginning and end of the audio.
+ * Strategy: mix the faded-out tail over the faded-in beginning so the loop point is seamless.
+ */
+export async function loopAudio(inputPath, outputPath, crossfadeDuration) {
+    const resolvedInput = path.resolve(inputPath);
+    const resolvedOutput = path.resolve(outputPath);
+    await ensureOutputDir(resolvedOutput);
+    const info = await getAudioInfo(resolvedInput);
+    const duration = info.duration;
+    if (crossfadeDuration <= 0) {
+        throw new Error('crossfade must be greater than 0');
+    }
+    if (crossfadeDuration * 2 >= duration) {
+        throw new Error(`crossfade (${crossfadeDuration}s) is too long for audio duration (${duration.toFixed(1)}s)`);
+    }
+    const ts = Date.now();
+    const tempMain = path.join(os.tmpdir(), `playcraft_loop_main_${ts}.mp3`);
+    const tempTail = path.join(os.tmpdir(), `playcraft_loop_tail_${ts}.mp3`);
+    const tempTailFaded = path.join(os.tmpdir(), `playcraft_loop_tailf_${ts}.mp3`);
+    try {
+        // Main: original without the last crossfade section, fade-out at end
+        await trimAudio(resolvedInput, tempMain, 0, duration - crossfadeDuration);
+        await fadeAudio(tempMain, tempMain, { fadeOut: crossfadeDuration });
+        // Tail: last crossfade seconds, fade-in
+        await trimAudio(resolvedInput, tempTail, duration - crossfadeDuration, duration);
+        await fadeAudio(tempTail, tempTailFaded, { fadeIn: crossfadeDuration });
+        // Mix: overlay tail (starts at t=0) on main beginning, output duration = main duration
+        const mixCmd = ffmpeg()
+            .input(tempMain)
+            .input(tempTailFaded)
+            .complexFilter([
+            `[0:a][1:a]amix=inputs=2:duration=first:dropout_transition=0[out]`,
+        ])
+            .outputOptions(['-map', '[out]'])
+            .output(resolvedOutput);
+        await runFfmpeg(mixCmd);
+    }
+    finally {
+        await Promise.all([tempMain, tempTail, tempTailFaded].map((tmp) => fsp.rm(tmp, { force: true }).catch(() => { })));
+    }
+}
+/**
+ * Mix multiple audio tracks together with optional volume and time offset per track.
+ */
+export async function mixAudio(tracks, outputPath) {
+    if (tracks.length < 2) {
+        throw new Error('At least 2 input tracks are required for mixing');
+    }
+    const resolvedOutputPath = path.resolve(outputPath);
+    await ensureOutputDir(resolvedOutputPath);
+    const cmd = ffmpeg();
+    for (const track of tracks) {
+        cmd.input(path.resolve(track.input));
+    }
+    const filterParts = [];
+    const mixInputs = [];
+    for (let i = 0; i < tracks.length; i++) {
+        const track = tracks[i];
+        const volume = track.volume ?? 1.0;
+        const offset = track.offset ?? 0;
+        let label = `[${i}:a]`;
+        if (offset > 0) {
+            const delayedLabel = `[a${i}_delayed]`;
+            filterParts.push(`${label}adelay=${Math.round(offset * 1000)}|${Math.round(offset * 1000)}${delayedLabel}`);
+            label = delayedLabel;
+        }
+        if (volume !== 1.0) {
+            const volLabel = `[a${i}_vol]`;
+            filterParts.push(`${label}volume=${volume}${volLabel}`);
+            label = volLabel;
+        }
+        mixInputs.push(label);
+    }
+    filterParts.push(`${mixInputs.join('')}amix=inputs=${tracks.length}:duration=longest:dropout_transition=0[out]`);
+    // FFmpeg filtergraph: separate chains with `;` (do not rely on fluent-ffmpeg array joining).
+    cmd
+        .complexFilter(filterParts.join(';'))
+        .outputOptions(['-map', '[out]'])
+        .output(resolvedOutputPath);
+    await runFfmpeg(cmd);
+}
+async function ensureOutputDir(filePath) {
+    const dir = path.dirname(filePath);
+    await fsp.mkdir(dir, { recursive: true });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@playcraft/cli",
-  "version": "0.0.18",
+  "version": "0.0.21",
   "private": false,
   "type": "module",
   "bin": {
@@ -17,13 +17,13 @@
     "build": "tsc",
     "start": "node dist/index.js",
     "test": "vitest run",
-    "link": "pnpm build && npm link",
+    "link": "node scripts/bump-local.js && pnpm build && npm link",
     "unlink": "npm unlink -g @playcraft/cli",
     "release": "node scripts/release.js"
   },
   "dependencies": {
-    "@playcraft/common": "^0.0.8",
-    "@playcraft/build": "^0.0.15",
+    "@playcraft/build": "^0.0.19",
+    "@playcraft/common": "^0.0.10",
     "chokidar": "^4.0.3",
     "commander": "^13.1.0",
     "cors": "^2.8.6",
@@ -32,10 +32,13 @@
     "drizzle-orm": "^0.45.1",
     "execa": "^9.6.1",
     "express": "^5.2.1",
+    "fluent-ffmpeg": "^2.1.3",
     "inquirer": "^9.3.8",
     "latest-version": "^7.0.0",
+    "music-metadata": "^11.12.3",
     "ora": "^8.2.0",
     "picocolors": "^1.1.1",
+    "sharp": "^0.34.5",
     "update-notifier": "^7.3.1",
     "ws": "^8.19.0",
     "zod": "^3.25.76"
@@ -43,8 +46,10 @@
   "devDependencies": {
     "@types/cors": "^2.8.19",
     "@types/express": "^5.0.6",
+    "@types/fluent-ffmpeg": "^2.1.28",
     "@types/inquirer": "^9.0.9",
     "@types/node": "^22.19.8",
+    "@types/sharp": "^0.32.0",
     "@types/update-notifier": "^6.0.8",
     "@types/ws": "^8.18.1",
     "typescript": "^5.9.3",