@playcraft/cli 0.0.11 → 0.0.12

package/dist/agent/agent.js

@@ -0,0 +1,202 @@
+import http from 'node:http';
+import path from 'node:path';
+import os from 'node:os';
+import pc from 'picocolors';
+import { Logger } from '../logger.js';
+import { createServer } from '../server.js';
+import { SocketServer } from '../socket.js';
+import { Watcher } from '../watcher.js';
+import { FSHandler } from '../fs-handler.js';
+import { createLocalBackendRouter } from './local-backend.js';
+import { CloudConnectionManager } from './cloud-connection.js';
+import { createApiProxyRouter } from './api-proxy.js';
+import { SyncManager } from '../sync/sync-manager.js';
+import { JwtService } from '@playcraft/common/auth';
+import { MessengerServer } from '@playcraft/common/messenger';
+import { ShareDBRealtimeServer } from '@playcraft/common/sharedb';
+export class PlayCraftAgent {
+    config;
+    isDaemon;
+    runtime = null;
+    constructor(config, isDaemon) {
+        this.config = config;
+        this.isDaemon = isDaemon;
+    }
+    get mode() {
+        return (this.config.mode || 'full-local');
+    }
+    async start() {
+        const logger = new Logger(this.config.projectId || 'default', this.isDaemon);
+        await logger.initialize();
+        await logger.info(`Starting agent (mode=${this.mode}) for project: ${this.config.projectId || 'default'}`);
+        await logger.info(`Directory: ${this.config.dir}`);
+        await logger.info(`Port: ${this.config.port}`);
+        if (!this.isDaemon) {
+            console.log(pc.cyan(`\n🚀 PlayCraft Agent 启动中...\n`));
+            console.log(`${pc.bold('模式:')}  ${this.mode === 'full-local' ? pc.green('full-local') : pc.yellow('hybrid')}`);
+            console.log(`${pc.bold('项目 ID:')} ${this.config.projectId || pc.yellow('未设置')}`);
+            console.log(`${pc.bold('目录:')}  ${this.config.dir}`);
+            console.log(`${pc.bold('端口:')}  ${this.config.port}\n`);
+        }
+        const fsHandler = new FSHandler(this.config);
+        const app = createServer(this.config, fsHandler);
+        const server = http.createServer(app);
+        let messenger;
+        let realtime;
+        let invalidateFsCache;
+        let cloudConnectionRef;
+        let syncManager;
+        if (this.mode === 'full-local') {
+            const jwt = new JwtService();
+            const emitSecret = process.env.EMIT_SECRET || 'dev-emit-secret-change-me';
+            // 1) Messenger (ws://localhost:<port>/messenger)
+            messenger = new MessengerServer({
+                path: '/messenger',
+                onAuth: async (token) => jwt.verify(token),
+                onMessage: async (_client, msg) => {
+                    // 最小实现：交给 local backend 的 /api/assets/move 等来处理（如果需要）
+                    // 现阶段先保留钩子，避免阻断协议演进
+                    void msg;
+                },
+            });
+            messenger.attach(server);
+            // 2) Local Backend (/api)
+            const dbPath = PlayCraftAgent.getDefaultDbPath();
+            const localBackend = createLocalBackendRouter({
+                projectId: this.config.projectId || 'default',
+                projectDir: this.config.dir,
+                dbPath,
+                emitSecret,
+                onEmit: (name, data, projectId) => {
+                    messenger?.broadcast(name, data, projectId);
+                },
+                onFileChange: (invalidate) => {
+                    invalidateFsCache = invalidate;
+                },
+            });
+            app.use('/api', localBackend.router);
+            // 3) /emit (internal emit compatibility)
+            app.post('/emit', (req, res) => {
+                const handler = messenger.createEmitHandler(emitSecret);
+                handler(req, res);
+            });
+            // 4) Realtime (ws://localhost:<port>/realtime)
+            realtime = new ShareDBRealtimeServer({
+                path: '/realtime',
+                backendUrl: `http://localhost:${this.config.port}`,
+                internalSecret: emitSecret,
+                onAuth: async (accessToken) => jwt.verify(accessToken),
+                onDocCreate: async (collection, id) => {
+                    // Prefer internal endpoints from local backend
+                    const url = `http://localhost:${this.config.port}/api/${collection}/internal/${id}`;
+                    const res = await fetch(url, { headers: { 'X-Internal-Secret': emitSecret } });
+                    if (res.ok)
+                        return await res.json();
+                    return null;
+                },
+            });
+            realtime.attach(server);
+            await logger.info(`Full Local services enabled: backend=/api realtime=/realtime messenger=/messenger`);
+        }
+        else if (this.mode === 'hybrid') {
+            if (!this.config.token || !this.config.url) {
+                throw new Error('Hybrid mode requires token and url in config');
+            }
+            const cloudConnection = new CloudConnectionManager({
+                url: this.config.url,
+                token: this.config.token,
+                projectId: this.config.projectId || 'default',
+                onMessage: (_source, data) => {
+                    void data;
+                },
+                onStateChange: (state) => {
+                    void logger.info(`Cloud connection state: ${state}`);
+                },
+                onDisconnect: () => {
+                    void logger.warn('Cloud connection lost');
+                },
+            });
+            await cloudConnection.connect();
+            const apiProxy = createApiProxyRouter({ connection: cloudConnection });
+            app.use('/api', apiProxy);
+            syncManager = new SyncManager({
+                cloudConnection,
+                projectDir: this.config.dir,
+            });
+            cloudConnectionRef = cloudConnection;
+            await logger.info(`Hybrid mode: cloud connected, API proxy at /api`);
+        }
+        let lastConnectionCount = 0;
+        const socketServer = new SocketServer(server, this.config, async (count) => {
+            if (count > lastConnectionCount) {
+                const message = `✅ 编辑器已连接 (共 ${count} 个连接)`;
+                await logger.info(message);
+                if (!this.isDaemon)
+                    console.log(pc.green(message));
+            }
+            else if (count < lastConnectionCount) {
+                const message = count === 0 ? '⚠️  编辑器已断开连接，等待重新连接...' : `⚠️  连接数减少 (剩余 ${count} 个连接)`;
+                await logger.info(message);
+                if (!this.isDaemon)
+                    console.log(pc.yellow(message));
+            }
+            lastConnectionCount = count;
+        });
+        const watcher = new Watcher(this.config, async (filePath, type) => {
+            await logger.info(`[${type.toUpperCase()}] ${filePath}`);
+            invalidateFsCache?.();
+            socketServer.notifyFileChange(filePath, type);
+            if (syncManager && (type === 'add' || type === 'modify')) {
+                void syncManager.upload(filePath);
+            }
+        });
+        await new Promise((resolve) => {
+            server.listen(this.config.port, async () => {
+                await logger.info(`Local server running at http://localhost:${this.config.port}`);
+                if (!this.isDaemon) {
+                    console.log(pc.green(`✅ 本地服务运行在 http://localhost:${this.config.port}`));
+                    console.log(pc.dim('等待编辑器连接...\n'));
+                }
+                resolve();
+            });
+        });
+        this.runtime = { server, socketServer, watcher, logger, messenger, realtime, cloudConnection: cloudConnectionRef, syncManager };
+    }
+    async stop() {
+        const rt = this.runtime;
+        if (!rt)
+            return;
+        if (!this.isDaemon)
+            console.log(pc.yellow('\n正在关闭 agent...'));
+        const forceExitTimeout = setTimeout(() => {
+            if (!this.isDaemon)
+                console.log(pc.red('强制退出...'));
+            process.exit(1);
+        }, 3000);
+        try {
+            await rt.watcher.close();
+            rt.socketServer.destroy();
+            await rt.cloudConnection?.disconnect();
+            rt.realtime?.close();
+            rt.messenger?.close();
+            await new Promise((resolve) => {
+                rt.server.close(() => resolve());
+                setTimeout(() => resolve(), 1000);
+            });
+            await rt.logger.close();
+            clearTimeout(forceExitTimeout);
+            this.runtime = null;
+            if (!this.isDaemon)
+                console.log(pc.green('✅ Agent 已关闭'));
+        }
+        catch (error) {
+            clearTimeout(forceExitTimeout);
+            if (!this.isDaemon)
+                console.error(pc.red('关闭时出错:'), error);
+            process.exit(1);
+        }
+    }
+    static getDefaultDbPath() {
+        return path.join(os.homedir(), '.playcraft', 'local-db.sqlite');
+    }
+}

package/dist/agent/api-proxy.js

@@ -0,0 +1,68 @@
+/**
+ * API Proxy – forwards REST requests from local agent to cloud backend in Hybrid mode.
+ * - Request forwarding with Bearer token (via CloudConnectionManager)
+ * - Optional response cache for GET requests
+ * - Error status and message pass-through
+ */
+import express from 'express';
+const CACHE_TTL_MS = 5_000;
+const MAX_CACHE_ENTRIES = 200;
+export function createApiProxyRouter(options) {
+    const router = express.Router();
+    const connection = options.connection;
+    const useCache = options.cache !== false;
+    const cacheTtl = options.cacheTtlMs ?? CACHE_TTL_MS;
+    const cache = new Map();
+    function cacheKey(method, path, query) {
+        return `${method}:${path}${query ? `?${query}` : ''}`;
+    }
+    function pruneCache() {
+        if (cache.size <= MAX_CACHE_ENTRIES)
+            return;
+        const now = Date.now();
+        for (const [key, entry] of cache) {
+            if (entry.expiresAt < now)
+                cache.delete(key);
+        }
+        if (cache.size > MAX_CACHE_ENTRIES) {
+            const keys = [...cache.keys()];
+            keys.slice(0, keys.length - MAX_CACHE_ENTRIES).forEach((k) => cache.delete(k));
+        }
+    }
+    router.use(express.json({ limit: '50mb' }));
+    router.all('*', async (req, res) => {
+        const method = req.method;
+        const path = req.path || '/';
+        const apiPath = `/api${path}`;
+        const query = req.url.includes('?') ? req.url.slice(req.url.indexOf('?') + 1) : '';
+        if (useCache && method === 'GET') {
+            const key = cacheKey(method, apiPath, query);
+            const hit = cache.get(key);
+            if (hit && hit.expiresAt > Date.now()) {
+                res.status(hit.status).json(hit.body);
+                return;
+            }
+        }
+        try {
+            const body = method !== 'GET' && method !== 'HEAD' ? req.body : undefined;
+            const fullPath = query ? `${apiPath}?${query}` : apiPath;
+            const result = await connection.request(method, fullPath, body);
+            if (useCache && method === 'GET') {
+                const key = cacheKey(method, apiPath, query);
+                cache.set(key, {
+                    body: result,
+                    status: 200,
+                    expiresAt: Date.now() + cacheTtl,
+                });
+                pruneCache();
+            }
+            res.status(200).json(result);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            const status = message.includes('401') ? 401 : message.includes('403') ? 403 : message.includes('404') ? 404 : 502;
+            res.status(status).json({ error: message });
+        }
+    });
+    return router;
+}

package/dist/agent/cloud-connection.js

@@ -0,0 +1,233 @@
+/**
+ * CloudConnectionManager – manages cloud connection lifecycle for Hybrid mode.
+ * - Connection state machine: disconnected → connecting → connected ↔ reconnecting
+ * - JWT token authentication (REST + WebSocket)
+ * - Heartbeat (30s) and exponential backoff reconnection
+ */
+import WebSocket from 'ws';
+const DEFAULT_HEARTBEAT_INTERVAL = 30_000;
+const DEFAULT_MAX_RECONNECT_DELAY = 60_000;
+const INITIAL_RECONNECT_DELAY = 1_000;
+function toWsUrl(httpUrl) {
+    const u = httpUrl.replace(/\/+$/, '');
+    if (u.startsWith('https://'))
+        return u.replace('https://', 'wss://');
+    if (u.startsWith('http://'))
+        return u.replace('http://', 'ws://');
+    return `wss://${u}`;
+}
+function baseUrl(url) {
+    return url.replace(/\/+$/, '');
+}
+export class CloudConnectionManager {
+    options;
+    restBaseUrl;
+    wsBaseUrl;
+    _connectionState = 'disconnected';
+    messengerWs = null;
+    heartbeatTimer = null;
+    reconnectTimer = null;
+    reconnectAttempts = 0;
+    lastPongAt = 0;
+    constructor(options) {
+        this.options = {
+            ...options,
+            heartbeatInterval: options.heartbeatInterval ?? DEFAULT_HEARTBEAT_INTERVAL,
+            maxReconnectDelay: options.maxReconnectDelay ?? DEFAULT_MAX_RECONNECT_DELAY,
+        };
+        this.restBaseUrl = baseUrl(options.url);
+        this.wsBaseUrl = toWsUrl(options.url);
+    }
+    get isConnected() {
+        return this._connectionState === 'connected';
+    }
+    get connectionState() {
+        return this._connectionState;
+    }
+    setState(state) {
+        if (this._connectionState === state)
+            return;
+        this._connectionState = state;
+        this.options.onStateChange?.(state);
+        if (state === 'disconnected' || state === 'reconnecting') {
+            this.options.onDisconnect?.();
+        }
+    }
+    async connect() {
+        if (this._connectionState === 'connected')
+            return;
+        if (this._connectionState === 'connecting')
+            return;
+        this.setState('connecting');
+        this.reconnectAttempts = 0;
+        try {
+            await this.connectMessenger();
+            this.setState('connected');
+            this.startHeartbeat();
+        }
+        catch (err) {
+            this.setState('reconnecting');
+            this.scheduleReconnect();
+            throw err;
+        }
+    }
+    get messengerUrl() {
+        const sep = this.wsBaseUrl.includes('?') ? '&' : '?';
+        return `${this.wsBaseUrl}/messenger${sep}token=${encodeURIComponent(this.options.token)}`;
+    }
+    connectMessenger() {
+        return new Promise((resolve, reject) => {
+            const ws = new WebSocket(this.messengerUrl, {
+                handshakeTimeout: 10_000,
+            });
+            const onOpen = () => {
+                ws.send(JSON.stringify({ name: 'authenticate', data: { token: this.options.token } }));
+                ws.send(JSON.stringify({ name: 'project.watch', data: { id: this.options.projectId } }));
+            };
+            const onMessage = (raw) => {
+                const text = raw.toString();
+                if (text === 'pong' || text === '"pong"') {
+                    this.lastPongAt = Date.now();
+                    return;
+                }
+                try {
+                    const msg = JSON.parse(text);
+                    if (msg && typeof msg === 'object' && msg.name) {
+                        this.options.onMessage?.('messenger', msg);
+                    }
+                }
+                catch {
+                    // ignore non-JSON
+                }
+            };
+            let resolved = false;
+            const resolveOnce = () => {
+                if (resolved)
+                    return;
+                resolved = true;
+                resolve();
+            };
+            ws.on('open', onOpen);
+            ws.on('message', (raw) => {
+                onMessage(raw);
+                try {
+                    const msg = JSON.parse(raw.toString());
+                    if (msg?.name === 'welcome' || msg?.name === 'project.permissions') {
+                        resolveOnce();
+                    }
+                }
+                catch {
+                    // ignore
+                }
+            });
+            const timeout = setTimeout(resolveOnce, 8000);
+            ws.once('close', () => {
+                clearTimeout(timeout);
+                this.cleanupMessenger();
+                if (this._connectionState === 'connected') {
+                    this.setState('reconnecting');
+                    this.scheduleReconnect();
+                }
+            });
+            ws.once('error', (err) => {
+                clearTimeout(timeout);
+                if (!resolved) {
+                    resolved = true;
+                    reject(err);
+                }
+            });
+            this.messengerWs = ws;
+        });
+    }
+    startHeartbeat() {
+        this.stopHeartbeat();
+        this.lastPongAt = Date.now();
+        this.heartbeatTimer = setInterval(() => {
+            if (this.messengerWs?.readyState === WebSocket.OPEN) {
+                this.messengerWs.send('ping');
+                const elapsed = Date.now() - this.lastPongAt;
+                if (elapsed > this.options.heartbeatInterval * 2) {
+                    this.cleanupMessenger();
+                    this.setState('reconnecting');
+                    this.scheduleReconnect();
+                }
+            }
+        }, this.options.heartbeatInterval);
+    }
+    stopHeartbeat() {
+        if (this.heartbeatTimer) {
+            clearInterval(this.heartbeatTimer);
+            this.heartbeatTimer = null;
+        }
+    }
+    scheduleReconnect() {
+        if (this.reconnectTimer)
+            return;
+        const delay = Math.min(INITIAL_RECONNECT_DELAY * Math.pow(2, this.reconnectAttempts), this.options.maxReconnectDelay);
+        this.reconnectAttempts += 1;
+        this.reconnectTimer = setTimeout(() => {
+            this.reconnectTimer = null;
+            this.connect().catch(() => {
+                // already handled in connect -> scheduleReconnect
+            });
+        }, delay);
+    }
+    cleanupMessenger() {
+        this.stopHeartbeat();
+        if (this.messengerWs) {
+            try {
+                this.messengerWs.removeAllListeners();
+                this.messengerWs.close();
+            }
+            catch {
+                // ignore
+            }
+            this.messengerWs = null;
+        }
+    }
+    async disconnect() {
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+        this.reconnectAttempts = 0;
+        this.cleanupMessenger();
+        this.setState('disconnected');
+    }
+    /**
+     * REST request to cloud API. Path should start with / (e.g. /api/health).
+     */
+    async request(method, path, data) {
+        const url = path.startsWith('http') ? path : `${this.restBaseUrl}${path.startsWith('/') ? '' : '/'}${path}`;
+        const headers = {
+            Authorization: `Bearer ${this.options.token}`,
+            'Content-Type': 'application/json',
+        };
+        const init = {
+            method,
+            headers,
+        };
+        if (data !== undefined && (method === 'POST' || method === 'PUT' || method === 'PATCH')) {
+            init.body = JSON.stringify(data);
+        }
+        const res = await fetch(url, init);
+        if (!res.ok) {
+            const text = await res.text();
+            throw new Error(`Cloud API ${method} ${path}: ${res.status} ${text}`);
+        }
+        const contentType = res.headers.get('content-type');
+        if (contentType?.includes('application/json')) {
+            return (await res.json());
+        }
+        return (await res.text());
+    }
+    sendToMessenger(name, data) {
+        if (this.messengerWs?.readyState !== WebSocket.OPEN)
+            return;
+        this.messengerWs.send(JSON.stringify({ name, data }));
+    }
+    /** Placeholder for future Realtime WebSocket client. */
+    sendToRealtime(_op) {
+        // Realtime client not implemented in MVP; SyncManager uses REST.
+    }
+}

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

@@ -0,0 +1,67 @@
+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);
+    });
+});