@playcraft/cli 0.0.1

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/port-utils.js

@@ -0,0 +1,27 @@
+import { createServer } from 'net';
+export async function isPortAvailable(port) {
+    return new Promise((resolve) => {
+        const server = createServer();
+        server.listen(port, () => {
+            server.once('close', () => resolve(true));
+            server.close();
+        });
+        server.on('error', (err) => {
+            if (err.code === 'EADDRINUSE') {
+                resolve(false);
+            }
+            else {
+                resolve(false);
+            }
+        });
+    });
+}
+export async function findAvailablePort(startPort, maxAttempts = 100) {
+    for (let i = 0; i < maxAttempts; i++) {
+        const port = startPort + i;
+        if (await isPortAvailable(port)) {
+            return port;
+        }
+    }
+    throw new Error(`Could not find an available port starting from ${startPort}`);
+}

package/dist/process-manager.js

@@ -0,0 +1,96 @@
+import fs from 'fs/promises';
+import path from 'path';
+import os from 'os';
+const PLAYCRAFT_DIR = path.join(os.homedir(), '.playcraft');
+const PIDS_DIR = path.join(PLAYCRAFT_DIR, 'pids');
+export class ProcessManager {
+    static async ensureDirectories() {
+        try {
+            await fs.mkdir(PLAYCRAFT_DIR, { recursive: true });
+            await fs.mkdir(PIDS_DIR, { recursive: true });
+        }
+        catch (error) {
+            if (error.code !== 'EEXIST') {
+                throw new Error(`Failed to create directories: ${error.message}`);
+            }
+        }
+    }
+    static getPidFilePath(projectId) {
+        return path.join(PIDS_DIR, `${projectId}.pid`);
+    }
+    static async savePid(projectId, pid) {
+        await this.ensureDirectories();
+        const pidFile = this.getPidFilePath(projectId);
+        await fs.writeFile(pidFile, pid.toString(), 'utf-8');
+    }
+    static async loadPid(projectId) {
+        try {
+            const pidFile = this.getPidFilePath(projectId);
+            const content = await fs.readFile(pidFile, 'utf-8');
+            const pid = parseInt(content.trim(), 10);
+            return isNaN(pid) ? null : pid;
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                return null;
+            }
+            throw error;
+        }
+    }
+    static async removePid(projectId) {
+        try {
+            const pidFile = this.getPidFilePath(projectId);
+            await fs.unlink(pidFile);
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT') {
+                throw error;
+            }
+        }
+    }
+    static isRunning(pid) {
+        try {
+            // 发送信号 0 来检查进程是否存在（不会实际发送信号）
+            process.kill(pid, 0);
+            return true;
+        }
+        catch (error) {
+            // ESRCH 表示进程不存在
+            return error.code !== 'ESRCH';
+        }
+    }
+    static async killProcess(pid, signal = 'SIGTERM') {
+        if (!this.isRunning(pid)) {
+            throw new Error(`Process ${pid} is not running`);
+        }
+        try {
+            process.kill(pid, signal);
+        }
+        catch (error) {
+            throw new Error(`Failed to kill process ${pid}: ${error.message}`);
+        }
+    }
+    static async getAllPids() {
+        await this.ensureDirectories();
+        try {
+            const files = await fs.readdir(PIDS_DIR);
+            const pids = [];
+            for (const file of files) {
+                if (file.endsWith('.pid')) {
+                    const projectId = file.replace('.pid', '');
+                    const pid = await this.loadPid(projectId);
+                    if (pid !== null) {
+                        pids.push({ projectId, pid });
+                    }
+                }
+            }
+            return pids;
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                return [];
+            }
+            throw error;
+        }
+    }
+}

package/dist/server.js

@@ -0,0 +1,128 @@
+import express from 'express';
+import cors from 'cors';
+export function createServer(config, fsHandler) {
+    const app = express();
+    app.use(cors());
+    app.use(express.json());
+    // Health check
+    app.get('/health', (req, res) => {
+        res.json({ status: 'ok', projectId: config.projectId });
+    });
+    // Get file content
+    app.get('/file', async (req, res) => {
+        const filePath = req.query.path;
+        if (!filePath) {
+            return res.status(400).json({ error: 'Missing path parameter' });
+        }
+        try {
+            const result = await fsHandler.readFile(filePath);
+            if (result.exists) {
+                res.json(result);
+            }
+            else {
+                res.status(404).json({ error: 'File not found' });
+            }
+        }
+        catch (error) {
+            res.status(500).json({ error: error.message });
+        }
+    });
+    // List directory
+    app.get('/list', async (req, res) => {
+        const dirPath = req.query.path || '.';
+        try {
+            const entries = await fsHandler.listDirectory(dirPath);
+            res.json({ entries });
+        }
+        catch (error) {
+            res.status(500).json({ error: error.message });
+        }
+    });
+    // Get project info
+    app.get('/info', (req, res) => {
+        res.json({
+            projectId: config.projectId,
+            version: '1.0.0',
+            dir: config.dir,
+            port: config.port,
+        });
+    });
+    // Get binary file
+    app.get('/file/binary', async (req, res) => {
+        const filePath = req.query.path;
+        if (!filePath) {
+            return res.status(400).json({ error: 'Missing path parameter' });
+        }
+        try {
+            const result = await fsHandler.readBinaryFile(filePath);
+            if (result.exists) {
+                // Set appropriate content type
+                const ext = filePath.split('.').pop()?.toLowerCase();
+                const contentType = getContentType(ext || '');
+                res.setHeader('Content-Type', contentType);
+                if (result.size !== undefined) {
+                    res.setHeader('Content-Length', result.size);
+                }
+                res.send(result.buffer);
+            }
+            else {
+                res.status(404).json({ error: 'File not found' });
+            }
+        }
+        catch (error) {
+            res.status(500).json({ error: error.message });
+        }
+    });
+    // Batch get files
+    app.post('/files', async (req, res) => {
+        const { paths } = req.body;
+        if (!Array.isArray(paths)) {
+            return res.status(400).json({ error: 'paths must be an array' });
+        }
+        try {
+            const files = await Promise.all(paths.map(async (filePath) => {
+                try {
+                    const result = await fsHandler.readFile(filePath);
+                    return {
+                        path: filePath,
+                        exists: result.exists,
+                        content: result.exists ? result.content : null,
+                        mtime: result.exists ? result.mtime : null,
+                        size: result.exists ? result.size : null,
+                    };
+                }
+                catch (error) {
+                    return {
+                        path: filePath,
+                        exists: false,
+                        error: error.message,
+                    };
+                }
+            }));
+            res.json({ files });
+        }
+        catch (error) {
+            res.status(500).json({ error: error.message });
+        }
+    });
+    return app;
+}
+function getContentType(ext) {
+    const contentTypes = {
+        png: 'image/png',
+        jpg: 'image/jpeg',
+        jpeg: 'image/jpeg',
+        gif: 'image/gif',
+        webp: 'image/webp',
+        hdr: 'image/vnd.radiance',
+        glb: 'model/gltf-binary',
+        gltf: 'model/gltf+json',
+        fbx: 'application/octet-stream',
+        mp3: 'audio/mpeg',
+        wav: 'audio/wav',
+        ogg: 'audio/ogg',
+        mp4: 'video/mp4',
+        webm: 'video/webm',
+    };
+    return contentTypes[ext] || 'application/octet-stream';
+}

package/dist/socket.js

@@ -0,0 +1,117 @@
+import { WebSocketServer, WebSocket } from 'ws';
+export class SocketServer {
+    config;
+    wss;
+    clients = new Set();
+    pingInterval = null;
+    onConnectionChange;
+    constructor(server, config, onConnectionChange) {
+        this.config = config;
+        this.wss = new WebSocketServer({ server });
+        this.onConnectionChange = onConnectionChange;
+        this.wss.on('connection', (ws) => {
+            this.clients.add(ws);
+            // Notify connection change
+            if (this.onConnectionChange) {
+                this.onConnectionChange(this.clients.size);
+            }
+            // Handle incoming messages
+            ws.on('message', (data) => {
+                try {
+                    const message = JSON.parse(data.toString());
+                    this.handleMessage(ws, message);
+                }
+                catch (error) {
+                    // Ignore invalid JSON
+                }
+            });
+            ws.on('close', () => {
+                this.clients.delete(ws);
+                // Notify connection change
+                if (this.onConnectionChange) {
+                    this.onConnectionChange(this.clients.size);
+                }
+            });
+            // Send initial hello
+            ws.send(JSON.stringify({
+                type: 'hello',
+                payload: {
+                    projectId: this.config.projectId,
+                    version: '1.0.0'
+                }
+            }));
+            // Send connection status
+            this.broadcast('connection_status', { connected: true });
+        });
+        // Start ping interval
+        this.startPingInterval();
+    }
+    handleMessage(ws, message) {
+        switch (message.type) {
+            case 'ping':
+                ws.send(JSON.stringify({ type: 'pong', payload: message.payload }));
+                break;
+            case 'subscribe':
+                // Store subscription patterns for this client (simplified implementation)
+                // In a full implementation, we would filter file change notifications
+                ws.send(JSON.stringify({
+                    type: 'subscribed',
+                    payload: { patterns: message.payload?.patterns || [] }
+                }));
+                break;
+        }
+    }
+    startPingInterval() {
+        if (this.pingInterval) {
+            clearInterval(this.pingInterval);
+        }
+        this.pingInterval = setInterval(() => {
+            for (const client of this.clients) {
+                if (client.readyState === WebSocket.OPEN) {
+                    try {
+                        client.send(JSON.stringify({ type: 'ping', payload: Date.now() }));
+                    }
+                    catch (error) {
+                        // Ignore send errors
+                    }
+                }
+            }
+        }, 30000); // Ping every 30 seconds
+    }
+    destroy() {
+        if (this.pingInterval) {
+            clearInterval(this.pingInterval);
+            this.pingInterval = null;
+        }
+        // Close all WebSocket connections
+        for (const client of this.clients) {
+            try {
+                client.close();
+            }
+            catch (error) {
+                // Ignore errors
+            }
+        }
+        this.clients.clear();
+        // Close WebSocket server
+        this.wss.close();
+    }
+    broadcast(type, payload) {
+        const message = JSON.stringify({ type, payload });
+        for (const client of this.clients) {
+            if (client.readyState === WebSocket.OPEN) {
+                client.send(message);
+            }
+        }
+    }
+    notifyFileChange(path, changeType) {
+        this.broadcast('file_changed', {
+            path,
+            changeType,
+            timestamp: new Date().toISOString()
+        });
+    }
+    getConnectionCount() {
+        return this.clients.size;
+    }
+}

package/dist/watcher.js

@@ -0,0 +1,33 @@
+import { watch } from 'chokidar';
+import path from 'path';
+export class Watcher {
+    config;
+    onChange;
+    watcher;
+    constructor(config, onChange) {
+        this.config = config;
+        this.onChange = onChange;
+        this.watcher = watch(this.config.dir, {
+            ignored: [
+                '**/node_modules/**',
+                '**/.git/**',
+                '**/dist/**',
+                '**/playcraft.agent.config.json',
+                '**/.DS_Store'
+            ],
+            persistent: true,
+            ignoreInitial: true,
+        });
+        this.watcher
+            .on('add', (filePath) => this.handleEvent(filePath, 'add'))
+            .on('change', (filePath) => this.handleEvent(filePath, 'modify'))
+            .on('unlink', (filePath) => this.handleEvent(filePath, 'delete'));
+    }
+    handleEvent(filePath, type) {
+        const relativePath = path.relative(this.config.dir, filePath);
+        this.onChange(relativePath, type);
+    }
+    close() {
+        return this.watcher.close();
+    }
+}

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@playcraft/cli",
+  "version": "0.0.1",
+  "private": false,
+  "type": "module",
+  "bin": {
+    "playcraft": "./dist/index.js"
+  },
+  "files": [
+    "dist",
+    "templates",
+    "README.md"
+  ],
+  "scripts": {
+    "dev": "tsc -w",
+    "build": "tsc",
+    "start": "node dist/index.js"
+  },
+  "dependencies": {
+    "@playcraft/build": "workspace:*",
+    "chokidar": "^4.0.3",
+    "commander": "^13.1.0",
+    "cors": "^2.8.5",
+    "cosmiconfig": "^9.0.0",
+    "dotenv": "^17.2.3",
+    "express": "^5.2.1",
+    "inquirer": "^9.2.12",
+    "ora": "^8.2.0",
+    "picocolors": "^1.1.1",
+    "ws": "^8.18.0",
+    "zod": "^3.24.1"
+  },
+  "devDependencies": {
+    "@types/cors": "^2.8.17",
+    "@types/express": "^5.0.0",
+    "@types/inquirer": "^9.0.7",
+    "@types/node": "^22.10.5",
+    "@types/ws": "^8.5.13",
+    "typescript": "^5.7.2"
+  }
+}

package/templates/playable-ad.html

@@ -0,0 +1,59 @@
+<!DOCTYPE html>
+<html lang="zh-CN">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0, user-scalable=no">
+  <meta name="apple-mobile-web-app-capable" content="yes">
+  <meta name="apple-mobile-web-app-status-bar-style" content="black-translucent">
+  <title>Playable Ad</title>
+  <style>
+    * {
+      margin: 0;
+      padding: 0;
+      box-sizing: border-box;
+    }
+    html, body {
+      width: 100%;
+      height: 100%;
+      overflow: hidden;
+      background: #000;
+      touch-action: none;
+      -webkit-touch-callout: none;
+      -webkit-user-select: none;
+      user-select: none;
+    }
+    #application-canvas {
+      display: block;
+      width: 100%;
+      height: 100%;
+      margin: 0 auto;
+      image-rendering: -webkit-optimize-contrast;
+      image-rendering: crisp-edges;
+    }
+    /* 加载指示器 */
+    #loading {
+      position: absolute;
+      top: 50%;
+      left: 50%;
+      transform: translate(-50%, -50%);
+      color: #fff;
+      font-family: Arial, sans-serif;
+      font-size: 14px;
+    }
+  </style>
+</head>
+<body>
+  <div id="loading">Loading...</div>
+  <canvas id="application-canvas"></canvas>
+  <!-- PlayCanvas Engine, Config 和 Start Script 将在这里注入 -->
+  <script>
+    // 隐藏加载指示器
+    window.addEventListener('load', function() {
+      const loading = document.getElementById('loading');
+      if (loading) {
+        loading.style.display = 'none';
+      }
+    });
+  </script>
+</body>
+</html>