@playcraft/cli 0.0.49 → 0.0.52

package/dist/utils/playcraft-http-client.js

@@ -0,0 +1,172 @@
+import { randomUUID } from 'node:crypto';
+import { loadGlobalConfig } from '../config.js';
+import { DEFAULT_PLAYCRAFT_CLOUD_BASE } from '../commands/login.js';
+export class PlayCraftApiError extends Error {
+    code;
+    status;
+    details;
+    retryable;
+    constructor(options) {
+        super(options.message);
+        this.name = 'PlayCraftApiError';
+        this.code = options.code;
+        this.status = options.status;
+        this.details = options.details;
+        this.retryable = options.retryable ?? false;
+    }
+}
+function resolveBaseUrl(url) {
+    const globalConfig = loadGlobalConfig();
+    return (url ||
+        process.env.PLAYCRAFT_API_URL ||
+        process.env.PLAYCRAFT_URL ||
+        globalConfig.backendUrl ||
+        globalConfig.url ||
+        DEFAULT_PLAYCRAFT_CLOUD_BASE).replace(/\/+$/, '');
+}
+function resolveToken(token) {
+    const globalConfig = loadGlobalConfig();
+    const resolved = token || process.env.PLAYCRAFT_TOKEN || globalConfig.token;
+    if (!resolved) {
+        throw new PlayCraftApiError({
+            code: 'AUTH_REQUIRED',
+            message: 'Authentication required. Run `playcraft login` or provide PLAYCRAFT_TOKEN.',
+            details: { loginCommand: 'playcraft login' },
+        });
+    }
+    return resolved;
+}
+function humanizeNetworkError(error) {
+    const raw = error instanceof Error ? error.message : String(error);
+    if (raw.includes('网络请求失败'))
+        return raw;
+    if (/fetch failed|ECONNRESET|ETIMEDOUT|ENOTFOUND|ECONNREFUSED|socket hang up|UND_ERR/i.test(raw)) {
+        return `网络请求失败（${raw}）。请稍后重试。`;
+    }
+    return raw;
+}
+function statusCode(status) {
+    if (status === 401)
+        return 'AUTH_EXPIRED';
+    if (status === 403)
+        return 'FORBIDDEN';
+    if (status === 404)
+        return 'PROJECT_NOT_FOUND';
+    return 'AGENT_REQUEST_FAILED';
+}
+export class PlayCraftHttpClient {
+    baseUrl;
+    token;
+    requestId;
+    constructor(options = {}) {
+        this.baseUrl = resolveBaseUrl(options.url);
+        this.token = resolveToken(options.token);
+        this.requestId = options.requestId || randomUUID();
+    }
+    url(path) {
+        const normalized = path.startsWith('/') ? path : `/${path}`;
+        const apiPath = normalized === '/api' || normalized.startsWith('/api/')
+            ? normalized
+            : `/api${normalized}`;
+        return new URL(apiPath, this.baseUrl).toString();
+    }
+    async request(path, init = {}) {
+        const headers = new Headers(init.headers);
+        headers.set('Authorization', `Bearer ${this.token}`);
+        headers.set('X-Request-Id', this.requestId);
+        if (init.body && !headers.has('Content-Type'))
+            headers.set('Content-Type', 'application/json');
+        const maxRetries = 3;
+        const retryDelays = [1000, 2000, 4000]; // 指数退避：1s, 2s, 4s
+        let lastError;
+        for (let attempt = 0; attempt < maxRetries; attempt++) {
+            try {
+                const response = await fetch(this.url(path), { ...init, headers });
+                const contentType = response.headers.get('content-type') || '';
+                const raw = await response.text();
+                let payload = undefined;
+                if (raw) {
+                    try {
+                        payload = contentType.includes('json') ? JSON.parse(raw) : raw;
+                    }
+                    catch {
+                        payload = raw;
+                    }
+                }
+                if (!response.ok) {
+                    const error = payload?.error;
+                    const code = typeof error?.code === 'string' ? error.code : statusCode(response.status);
+                    const message = typeof error?.message === 'string'
+                        ? error.message
+                        : typeof payload?.message === 'string'
+                            ? payload.message
+                            : typeof payload === 'string'
+                                ? payload
+                                : response.statusText || 'PlayCraft request failed';
+                    throw new PlayCraftApiError({
+                        code,
+                        message,
+                        status: response.status,
+                        details: error?.details ?? payload,
+                        retryable: response.status >= 500,
+                    });
+                }
+                if (!raw)
+                    return undefined;
+                return payload;
+            }
+            catch (error) {
+                lastError = isPlayCraftApiError(error)
+                    ? error
+                    : new PlayCraftApiError({
+                        code: 'AGENT_REQUEST_FAILED',
+                        message: humanizeNetworkError(error),
+                        retryable: true,
+                    });
+                // 如果是客户端错误（4xx）或不可重试的错误，立即抛出
+                if (isPlayCraftApiError(error) && !error.retryable) {
+                    throw error;
+                }
+                // 最后一次尝试失败，抛出错误
+                if (attempt === maxRetries - 1) {
+                    break;
+                }
+                // 等待后重试
+                await new Promise(resolve => setTimeout(resolve, retryDelays[attempt]));
+            }
+        }
+        // 所有重试都失败了
+        if (isPlayCraftApiError(lastError)) {
+            throw new PlayCraftApiError({
+                code: lastError.code,
+                message: humanizeNetworkError(lastError),
+                status: lastError.status,
+                details: lastError.details,
+                retryable: true,
+            });
+        }
+        throw new PlayCraftApiError({
+            code: 'AGENT_REQUEST_FAILED',
+            message: humanizeNetworkError(lastError),
+            retryable: true,
+        });
+    }
+    get(path, params, init = {}) {
+        const url = new URL(this.url(path));
+        for (const [key, value] of Object.entries(params || {})) {
+            if (value !== undefined && value !== '')
+                url.searchParams.set(key, value);
+        }
+        return this.request(url.pathname + url.search, { ...init, method: 'GET' });
+    }
+    post(path, body, init = {}) {
+        return this.request(path, {
+            ...init,
+            method: 'POST',
+            body: body === undefined ? undefined : JSON.stringify(body),
+        });
+    }
+}
+export function isPlayCraftApiError(error) {
+    return error instanceof PlayCraftApiError;
+}

package/dist/utils/remix-image-attachments.js

@@ -0,0 +1,125 @@
+import { readFileSync, statSync } from 'node:fs';
+import { basename, extname } from 'node:path';
+import { PlayCraftApiError } from './playcraft-http-client.js';
+const MAX_IMAGES = 4;
+const MAX_IMAGE_BYTES = 5 * 1024 * 1024;
+const IMAGE_MIME_BY_EXTENSION = {
+    '.gif': 'image/gif',
+    '.jpeg': 'image/jpeg',
+    '.jpg': 'image/jpeg',
+    '.png': 'image/png',
+    '.webp': 'image/webp',
+};
+function attachmentError(code, message, details, retryable = false) {
+    return new PlayCraftApiError({ code, message, details, retryable });
+}
+export function readImageAttachments(paths) {
+    if (!paths)
+        return [];
+    const candidates = Array.isArray(paths) ? paths : [paths];
+    if (candidates.length > MAX_IMAGES) {
+        throw attachmentError('ATTACHMENT_LIMIT_EXCEEDED', `最多只能传输 ${MAX_IMAGES} 张图片。`, { maxImages: MAX_IMAGES });
+    }
+    return candidates.map((sourcePath) => {
+        const extension = extname(sourcePath).toLowerCase();
+        const mimeType = IMAGE_MIME_BY_EXTENSION[extension];
+        if (!mimeType) {
+            throw attachmentError('ATTACHMENT_TYPE_UNSUPPORTED', `不支持的图片格式：${sourcePath}。仅支持 JPEG (Joint Photographic Experts Group, 联合图像专家组)、PNG (Portable Network Graphics, 便携式网络图形)、WebP 和 GIF (Graphics Interchange Format, 图形交换格式)。`, { path: sourcePath, supportedExtensions: Object.keys(IMAGE_MIME_BY_EXTENSION) });
+        }
+        let size;
+        try {
+            size = statSync(sourcePath).size;
+        }
+        catch {
+            throw attachmentError('ATTACHMENT_NOT_FOUND', `图片文件不存在或无法读取：${sourcePath}`, { path: sourcePath });
+        }
+        if (size <= 0) {
+            throw attachmentError('ATTACHMENT_INVALID', `图片文件为空：${sourcePath}`, { path: sourcePath });
+        }
+        if (size > MAX_IMAGE_BYTES) {
+            throw attachmentError('ATTACHMENT_TOO_LARGE', `图片超过 5 MB (Megabyte, 兆字节) 限制：${sourcePath}`, { path: sourcePath, maxBytes: MAX_IMAGE_BYTES, actualBytes: size });
+        }
+        try {
+            return {
+                sourcePath,
+                fileName: basename(sourcePath),
+                mimeType,
+                bytes: readFileSync(sourcePath),
+            };
+        }
+        catch {
+            throw attachmentError('ATTACHMENT_NOT_FOUND', `图片文件不存在或无法读取：${sourcePath}`, { path: sourcePath });
+        }
+    });
+}
+async function serializeFormData(form, url) {
+    const request = new Request(url, { method: 'POST', body: form });
+    const contentType = request.headers.get('content-type');
+    if (!contentType) {
+        throw attachmentError('ATTACHMENT_UPLOAD_FAILED', '无法构造图片上传请求。');
+    }
+    return {
+        body: await request.arrayBuffer(),
+        contentType,
+    };
+}
+export async function uploadImageAttachments(client, projectId, branch, attachments) {
+    const uploaded = [];
+    for (const attachment of attachments) {
+        const form = new FormData();
+        form.append('file', new Blob([new Uint8Array(attachment.bytes)], { type: attachment.mimeType }), attachment.fileName);
+        const path = `/projects/${encodeURIComponent(projectId)}/sandbox/upload-image`;
+        const url = new URL(client.url(path));
+        url.searchParams.set('branch', branch);
+        const multipart = await serializeFormData(form, url.toString());
+        let response;
+        try {
+            response = await client.request(`${path}?${url.searchParams.toString()}`, {
+                method: 'POST',
+                body: multipart.body,
+                headers: { 'Content-Type': multipart.contentType },
+            });
+        }
+        catch (error) {
+            const upstream = error instanceof PlayCraftApiError
+                ? { code: error.code, status: error.status, details: error.details }
+                : { message: error instanceof Error ? error.message : String(error) };
+            throw attachmentError('ATTACHMENT_UPLOAD_FAILED', `图片上传失败：${attachment.sourcePath}${error instanceof Error ? `：${error.message}` : ''}`, { path: attachment.sourcePath, upstream }, error instanceof PlayCraftApiError ? error.retryable : false);
+        }
+        if (!response?.path) {
+            throw attachmentError('ATTACHMENT_UPLOAD_FAILED', `图片上传成功但服务端未返回沙箱路径：${attachment.sourcePath}`, { path: attachment.sourcePath });
+        }
+        uploaded.push({
+            sourcePath: attachment.sourcePath,
+            fileName: attachment.fileName,
+            sandboxPath: response.path,
+        });
+    }
+    return uploaded;
+}
+export function buildReferenceImagesPrompt(prompt, attachments) {
+    if (attachments.length === 0)
+        return prompt;
+    const pathList = attachments.map((attachment) => `- ${attachment.sandboxPath}`).join('\n');
+    return [
+        prompt,
+        '',
+        '[Reference Images]',
+        `The user attached ${attachments.length} image(s) at these sandbox filesystem paths:`,
+        pathList,
+        '',
+        'These files have already been written to the sandbox filesystem.',
+        '',
+        '**IMPORTANT:** Do NOT read, open, or inspect any of these image files. Do NOT use tools like read_file, cat, or any other file reader on them. The paths themselves are all you need.',
+        '',
+        "Infer each image's purpose from the user's message (e.g. reference for style/composition, UI mockup, screenshot illustrating an issue, asset to import, etc.). For any image you judge to be a visual reference, pass its path directly to `playcraft-generate-image` — do NOT ask the user to confirm, and do NOT attempt to examine the image content first.",
+        '',
+        'When passing references to `playcraft-generate-image`:',
+        '- Put the first reference in `referenceImagePath`, remaining ones in `additionalReferenceImagePaths` as a comma-separated string.',
+        '- Preserve the original order.',
+        '- Up to 8 references total; paths must not contain commas.',
+        '- Save generated images under `src/theme/draft/assets/` unless the user explicitly asks for another project asset location.',
+        '- When reporting saved image paths back to the user, prefer `/project/<repo-relative-path>` such as `/project/src/theme/draft/assets/level-ref.png`, not the full `/projects/<projectId>/<branch>/...` path.',
+    ].join('\n');
+}
+export const IMAGE_OPTION_HELP = '一个或多个图片路径（最多 4 张；JPEG (Joint Photographic Experts Group, 联合图像专家组)、PNG (Portable Network Graphics, 便携式网络图形)、WebP、GIF (Graphics Interchange Format, 图形交换格式)，每张不超过 5 MB (Megabyte, 兆字节)）';

package/package.json

@@ -1,8 +1,11 @@
 {
   "name": "@playcraft/cli",
-  "version": "0.0.49",
+  "version": "0.0.52",
   "private": false,
   "type": "module",
+  "engines": {
+    "node": ">=20"
+  },
   "bin": {
     "playcraft": "./dist/index.js",
     "playcraft-test": "./dist/index.js"
@@ -13,6 +16,7 @@
     "project-template",
     "engine-packs",
     "project-templates",
+    "REMIX.md",
     "README.md"
   ],
   "scripts": {
@@ -41,8 +45,8 @@
     "@gltf-transform/core": "^4.3.0",
     "@gltf-transform/extensions": "^4.3.0",
     "@gltf-transform/functions": "^4.3.0",
-    "@playcraft/build": "^0.0.49",
-    "@playcraft/common": "^0.0.36",
+    "@playcraft/build": "^0.0.52",
+    "@playcraft/common": "^0.0.52",
     "chokidar": "^4.0.3",
     "commander": "^13.1.0",
     "cors": "^2.8.6",
@@ -53,6 +57,7 @@
     "express": "^5.2.1",
     "fluent-ffmpeg": "^2.1.3",
     "inquirer": "^9.3.8",
+    "inquirer-autocomplete-prompt": "^3.0.1",
     "js-yaml": "^4.1.1",
     "json5": "^2.2.3",
     "latest-version": "^7.0.0",

package/dist/agent/cloud-connection.test.js

@@ -1,67 +0,0 @@
-import { afterAll, beforeAll, describe, expect, it } from 'vitest';
-import http from 'node:http';
-import { CloudConnectionManager } from './cloud-connection.js';
-describe('CloudConnectionManager', () => {
-    let server;
-    let baseUrl;
-    beforeAll(async () => {
-        server = http.createServer((req, res) => {
-            const auth = req.headers.authorization;
-            if (auth !== 'Bearer test-token') {
-                res.writeHead(401);
-                res.end(JSON.stringify({ error: 'unauthorized' }));
-                return;
-            }
-            if (req.method === 'GET' && req.url === '/api/health') {
-                res.writeHead(200, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({ ok: true }));
-                return;
-            }
-            if (req.method === 'POST' && req.url === '/api/sync/upload') {
-                let body = '';
-                req.on('data', (c) => (body += c));
-                req.on('end', () => {
-                    res.writeHead(200, { 'Content-Type': 'application/json' });
-                    res.end(JSON.stringify({ success: true }));
-                });
-                return;
-            }
-            res.writeHead(404);
-            res.end('not found');
-        });
-        await new Promise((resolve) => {
-            server.listen(0, '127.0.0.1', () => resolve());
-        });
-        const addr = server.address();
-        baseUrl = `http://127.0.0.1:${addr.port}`;
-    });
-    afterAll(async () => {
-        await new Promise((resolve) => server.close(() => resolve()));
-    });
-    it('request() sends Bearer token and returns JSON', async () => {
-        const conn = new CloudConnectionManager({
-            url: baseUrl,
-            token: 'test-token',
-            projectId: 'test-project',
-        });
-        const result = await conn.request('GET', '/api/health');
-        expect(result).toEqual({ ok: true });
-    });
-    it('request() throws on 401', async () => {
-        const conn = new CloudConnectionManager({
-            url: baseUrl,
-            token: 'wrong-token',
-            projectId: 'test-project',
-        });
-        await expect(conn.request('GET', '/api/health')).rejects.toThrow(/401/);
-    });
-    it('connectionState is disconnected when not connected', () => {
-        const conn = new CloudConnectionManager({
-            url: baseUrl,
-            token: 'test-token',
-            projectId: 'test-project',
-        });
-        expect(conn.connectionState).toBe('disconnected');
-        expect(conn.isConnected).toBe(false);
-    });
-});

package/dist/agent/local-backend.test.js

@@ -1,52 +0,0 @@
-import { afterAll, beforeAll, describe, expect, it } from 'vitest';
-import express from 'express';
-import http from 'node:http';
-import os from 'node:os';
-import path from 'node:path';
-import fs from 'node:fs/promises';
-import { createLocalBackendRouter } from './local-backend.js';
-describe('createLocalBackendRouter', () => {
-    let server;
-    let baseUrl;
-    let tmpDir;
-    beforeAll(async () => {
-        tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'playcraft-agent-test-'));
-        const dbPath = path.join(tmpDir, 'local-db.sqlite');
-        const app = express();
-        const projectId = 'test-project';
-        const { router } = createLocalBackendRouter({
-            projectId,
-            projectDir: tmpDir,
-            dbPath,
-            emitSecret: 'test-secret',
-        });
-        app.use('/api', router);
-        server = http.createServer(app);
-        await new Promise((resolve) => {
-            server.listen(0, '127.0.0.1', () => resolve());
-        });
-        const addr = server.address();
-        baseUrl = `http://127.0.0.1:${addr.port}`;
-    });
-    afterAll(async () => {
-        if (server) {
-            await new Promise((resolve) => server.close(() => resolve()));
-        }
-        if (tmpDir) {
-            await fs.rm(tmpDir, { recursive: true, force: true });
-        }
-    });
-    it('responds health', async () => {
-        const res = await fetch(`${baseUrl}/api/health`);
-        expect(res.ok).toBe(true);
-        const json = await res.json();
-        expect(json).toHaveProperty('ok', true);
-    });
-    it('creates default project lazily and can fetch it', async () => {
-        const res = await fetch(`${baseUrl}/api/projects/test-project`);
-        expect(res.ok).toBe(true);
-        const json = await res.json();
-        expect(json).toHaveProperty('result');
-        expect(json.result).toHaveProperty('uuid', 'test-project');
-    });
-});