@playcraft/cli 0.0.11 → 0.0.13

package/dist/agent/fs-backend.js

@@ -0,0 +1,158 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+/**
+ * File-system backed data source for local development.
+ * Reads project data from manifest.json and scene/asset files.
+ * Supports both PlayCraft and PlayCanvas project formats.
+ */
+export class FileSystemBackend {
+    projectDir;
+    manifestCache = null;
+    manifestMtime = 0;
+    constructor(projectDir) {
+        this.projectDir = projectDir;
+    }
+    /**
+     * Read and parse manifest.json (with cache).
+     */
+    async getManifest() {
+        const manifestPath = path.join(this.projectDir, 'manifest.json');
+        try {
+            const stat = await fs.stat(manifestPath);
+            if (this.manifestCache && stat.mtimeMs === this.manifestMtime) {
+                return this.manifestCache;
+            }
+            const content = await fs.readFile(manifestPath, 'utf-8');
+            this.manifestCache = JSON.parse(content);
+            this.manifestMtime = stat.mtimeMs;
+            return this.manifestCache;
+        }
+        catch (e) {
+            if (e?.code === 'ENOENT')
+                return null;
+            throw e;
+        }
+    }
+    /**
+     * Detect project format from manifest.
+     */
+    detectFormat(manifest) {
+        if (manifest.format === 'playcraft' || Array.isArray(manifest.assets)) {
+            return 'playcraft';
+        }
+        return 'playcanvas';
+    }
+    /**
+     * Get all assets from manifest.
+     */
+    async getAssets() {
+        const manifest = await this.getManifest();
+        if (!manifest)
+            return [];
+        const format = this.detectFormat(manifest);
+        if (format === 'playcraft') {
+            return Array.isArray(manifest.assets) ? manifest.assets : [];
+        }
+        const assets = manifest.assets;
+        if (typeof assets === 'object' && assets !== null && !Array.isArray(assets)) {
+            return Object.values(assets);
+        }
+        return [];
+    }
+    /**
+     * Get a single asset by id or uniqueId (for Realtime).
+     */
+    async getAsset(assetId) {
+        const assets = await this.getAssets();
+        const idStr = String(assetId);
+        return (assets.find((a) => String(a.id) === idStr ||
+            String(a.uniqueId) === idStr ||
+            (a.uniqueId && String(a.uniqueId) === idStr)) ?? null);
+    }
+    /**
+     * Get all scenes from manifest.
+     */
+    async getScenes() {
+        const manifest = await this.getManifest();
+        if (!manifest)
+            return [];
+        const format = this.detectFormat(manifest);
+        if (format === 'playcraft') {
+            return Array.isArray(manifest.scenes) ? manifest.scenes : [];
+        }
+        const scenes = manifest.scenes;
+        if (typeof scenes === 'object' && scenes !== null && !Array.isArray(scenes)) {
+            return Object.values(scenes);
+        }
+        return [];
+    }
+    /**
+     * Get a single scene metadata by id or uniqueId.
+     */
+    async getScene(sceneId) {
+        const scenes = await this.getScenes();
+        const idStr = String(sceneId);
+        return (scenes.find((s) => String(s.id) === idStr ||
+            String(s.uniqueId) === idStr ||
+            (s.uniqueId && String(s.uniqueId) === idStr)) ?? null);
+    }
+    /**
+     * Get scene data (entities, settings) from scenes/{id}.json.
+     */
+    async getSceneData(sceneId) {
+        const scenePath = path.join(this.projectDir, 'scenes', `${sceneId}.json`);
+        try {
+            const content = await fs.readFile(scenePath, 'utf-8');
+            return JSON.parse(content);
+        }
+        catch (e) {
+            if (e?.code === 'ENOENT')
+                return null;
+            throw e;
+        }
+    }
+    /**
+     * Get document (script) content by asset id.
+     */
+    async getDocumentContent(assetId) {
+        const asset = await this.getAsset(assetId);
+        if (!asset)
+            return null;
+        const file = asset.file ?? asset;
+        const filename = file.filename ?? file.fileFilename;
+        if (!filename)
+            return null;
+        const relativePath = this.buildAssetFilePath(asset, filename);
+        const fullPath = path.join(this.projectDir, relativePath);
+        try {
+            return await fs.readFile(fullPath, 'utf-8');
+        }
+        catch (e) {
+            if (e?.code === 'ENOENT')
+                return null;
+            throw e;
+        }
+    }
+    /**
+     * Build relative file path for an asset.
+     */
+    buildAssetFilePath(asset, filename) {
+        // PlayCraft: treePath is string like "assets/scripts"
+        if (asset.treePath) {
+            const base = typeof asset.treePath === 'string' ? asset.treePath : path.join(...(asset.treePath || []));
+            return path.join(base, filename);
+        }
+        // PlayCanvas: path is array of folder ids; we use filename under assets
+        if (Array.isArray(asset.path) && asset.path.length > 0) {
+            return path.join('assets', ...asset.path.map(String), filename);
+        }
+        return path.join('assets', filename);
+    }
+    /**
+     * Invalidate cache (call when files change).
+     */
+    invalidateCache() {
+        this.manifestCache = null;
+        this.manifestMtime = 0;
+    }
+}

package/dist/agent/local-backend.js

@@ -0,0 +1,359 @@
+import express from 'express';
+import crypto from 'node:crypto';
+import path from 'node:path';
+import fs from 'node:fs/promises';
+import { eq, inArray } from 'drizzle-orm';
+import pc from 'picocolors';
+import { createSqliteAdapter } from '@playcraft/common/database';
+import { AssetModel, ProjectModel, SceneModel } from '@playcraft/common/models';
+import { FileSystemBackend } from './fs-backend.js';
+function nowDate() {
+    return new Date();
+}
+function parseJson(s, fallback) {
+    if (!s)
+        return fallback;
+    try {
+        return JSON.parse(s);
+    }
+    catch {
+        return fallback;
+    }
+}
+export function createLocalBackendRouter(options) {
+    const router = express.Router();
+    router.use(express.json({ limit: '50mb' }));
+    const fsBackend = new FileSystemBackend(options.projectDir);
+    options.onFileChange?.(() => fsBackend.invalidateCache());
+    const { db, schema, client } = createSqliteAdapter(options.dbPath);
+    // Ensure default project exists
+    router.use(async (_req, _res, next) => {
+        try {
+            const [p] = await db.select().from(schema.projectsSqlite).where(eq(schema.projectsSqlite.id, options.projectId));
+            if (!p) {
+                const now = nowDate();
+                await db.insert(schema.projectsSqlite).values({
+                    id: options.projectId,
+                    externalId: null,
+                    name: 'local-project',
+                    description: null,
+                    ownerId: null,
+                    settingsJson: '{}',
+                    private: true,
+                    privateSourceAssets: false,
+                    createdAt: now,
+                    updatedAt: now,
+                });
+            }
+        }
+        catch (e) {
+            console.warn(pc.yellow('[agent][backend] failed ensuring default project:'), e);
+        }
+        next();
+    });
+    // Health
+    router.get('/health', (_req, res) => res.json({ ok: true, service: 'agent-backend' }));
+    // Projects
+    router.get('/projects/:id', async (req, res) => {
+        const id = req.params.id;
+        const [row] = await db.select().from(schema.projectsSqlite).where(eq(schema.projectsSqlite.id, id));
+        if (!row)
+            return res.status(404).json({ error: 'Project not found' });
+        const project = {
+            id: row.id,
+            externalId: row.externalId,
+            name: row.name,
+            description: row.description,
+            ownerId: row.ownerId,
+            settings: parseJson(row.settingsJson, {}),
+            private: row.private,
+            privateSourceAssets: row.privateSourceAssets,
+            createdAt: row.createdAt,
+            updatedAt: row.updatedAt,
+        };
+        return res.json({ result: ProjectModel.toRecord(project) });
+    });
+    // Scenes (file-system first for local dev)
+    router.get('/scenes/internal/:id', async (req, res) => {
+        const secret = req.headers['x-internal-secret'];
+        if (options.emitSecret && secret !== options.emitSecret) {
+            return res.status(403).json({ error: 'forbidden' });
+        }
+        const id = req.params.id;
+        const data = await fsBackend.getSceneData(id);
+        if (!data)
+            return res.status(404).json({ error: 'Scene not found' });
+        return res.json(data);
+    });
+    router.get('/scenes/:id', async (req, res) => {
+        const id = req.params.id;
+        const sceneMeta = await fsBackend.getScene(id);
+        if (!sceneMeta)
+            return res.status(404).json({ error: 'Scene not found' });
+        const sceneRecord = {
+            id: sceneMeta.id ?? id,
+            numericId: typeof sceneMeta.id === 'number' ? sceneMeta.id : (sceneMeta.numericId ?? 0),
+            externalId: sceneMeta.externalId ?? null,
+            projectId: sceneMeta.projectId ?? options.projectId,
+            name: sceneMeta.name ?? 'Untitled',
+            data: sceneMeta.data,
+            createdAt: sceneMeta.createdAt,
+            updatedAt: sceneMeta.updatedAt,
+        };
+        return res.json({ result: SceneModel.toRecord(sceneRecord) });
+    });
+    router.post('/scenes', async (req, res) => {
+        const { projectId, name } = req.body || {};
+        if (!projectId || !name)
+            return res.status(400).json({ error: 'Missing projectId or name' });
+        const id = crypto.randomUUID();
+        const now = nowDate();
+        const numericId = 20000000 + Math.floor(Math.random() * 1000000);
+        await db.insert(schema.scenesSqlite).values({
+            id,
+            numericId,
+            externalId: null,
+            projectId,
+            name,
+            dataJson: JSON.stringify(SceneModel.getDefaultData(numericId)),
+            createdAt: now,
+            updatedAt: now,
+        });
+        const [row] = await db.select().from(schema.scenesSqlite).where(eq(schema.scenesSqlite.id, id));
+        const scene = {
+            id: row.id,
+            numericId: row.numericId ?? numericId,
+            externalId: row.externalId,
+            projectId: row.projectId,
+            name: row.name,
+            data: parseJson(row.dataJson, undefined),
+            createdAt: row.createdAt,
+            updatedAt: row.updatedAt,
+        };
+        options.onEmit?.('scene.create', { scene: SceneModel.toRecord(scene) }, projectId);
+        return res.json({ result: SceneModel.toRecord(scene) });
+    });
+    // Assets (file-system first for local dev)
+    router.get('/assets/internal/:id/file', async (req, res) => {
+        const secret = req.headers['x-internal-secret'];
+        if (options.emitSecret && secret !== options.emitSecret) {
+            return res.status(403).json({ error: 'forbidden' });
+        }
+        const id = req.params.id;
+        const content = await fsBackend.getDocumentContent(id);
+        if (content === null)
+            return res.status(404).send('File not found');
+        res.type('text/plain').send(content);
+    });
+    router.get('/assets/internal/:id', async (req, res) => {
+        const secret = req.headers['x-internal-secret'];
+        if (options.emitSecret && secret !== options.emitSecret) {
+            return res.status(403).json({ error: 'forbidden' });
+        }
+        const id = req.params.id;
+        const asset = await fsBackend.getAsset(id);
+        if (!asset)
+            return res.status(404).json({ error: 'Asset not found' });
+        return res.json(asset);
+    });
+    router.get('/assets', async (req, res) => {
+        const projectId = String(req.query.projectId || options.projectId);
+        const assets = await fsBackend.getAssets();
+        const out = assets.map((a) => {
+            const file = a.file ?? {};
+            const row = {
+                id: a.id ?? a.uniqueId ?? '',
+                numericId: typeof a.id === 'number' ? a.id : (a.numericId ?? 0),
+                externalId: a.externalId ?? null,
+                projectId: a.projectId ?? projectId,
+                name: a.name ?? 'asset',
+                type: a.type ?? 'unknown',
+                tags: a.tags ?? [],
+                path: a.path ?? [],
+                data: a.data ?? {},
+                preload: a.preload !== false,
+                exclude: a.exclude ?? false,
+                source: a.source,
+                sourceId: a.sourceId,
+                i18n: a.i18n ?? {},
+                task: a.task ?? null,
+                meta: a.meta ?? null,
+                revision: a.revision ?? 1,
+                fileFilename: file.filename ?? file.fileFilename ?? null,
+                fileSize: file.size ?? file.fileSize ?? null,
+                fileHash: file.hash ?? file.fileHash ?? null,
+                fileUrl: file.url ?? file.fileUrl ?? null,
+                createdAt: a.createdAt ? new Date(a.createdAt) : new Date(),
+                modifiedAt: a.modifiedAt ? new Date(a.modifiedAt) : new Date(),
+            };
+            return AssetModel.toRecord(row);
+        });
+        return res.json({ result: out });
+    });
+    router.post('/assets', async (req, res) => {
+        const body = req.body || {};
+        const projectId = String(body.projectId || options.projectId);
+        const name = String(body.name || 'asset');
+        const type = String(body.type || 'unknown');
+        const tags = Array.isArray(body.tags) ? body.tags : [];
+        const assetPath = Array.isArray(body.path) ? body.path : [];
+        const data = body.data ?? {};
+        const preload = body.preload ?? true;
+        const exclude = body.exclude ?? false;
+        const source = body.source ?? false;
+        const id = crypto.randomUUID();
+        const now = nowDate();
+        const file = body.file || null;
+        const fileFilename = file?.filename || null;
+        const fileSize = file?.size ?? null;
+        const fileHash = file?.hash ?? null;
+        // Local file URL: default to /file/binary?path=assets/<filename> if exists
+        let fileUrl = null;
+        if (fileFilename) {
+            const guessRel = path.posix.join('assets', fileFilename);
+            fileUrl = `/file/binary?path=${encodeURIComponent(guessRel)}`;
+        }
+        const numericId = 30000000 + Math.floor(Math.random() * 1000000);
+        await db.insert(schema.assetsSqlite).values({
+            id,
+            numericId,
+            externalId: null,
+            projectId,
+            name,
+            type,
+            tagsJson: JSON.stringify(tags),
+            pathJson: JSON.stringify(assetPath),
+            dataJson: JSON.stringify(data),
+            preload,
+            exclude,
+            source,
+            sourceId: null,
+            i18nJson: JSON.stringify({}),
+            task: null,
+            metaJson: body.meta ? JSON.stringify(body.meta) : null,
+            revision: 1,
+            fileFilename,
+            fileSize,
+            fileHash,
+            fileUrl,
+            createdAt: now,
+            modifiedAt: now,
+        });
+        const [row] = await db.select().from(schema.assetsSqlite).where(eq(schema.assetsSqlite.id, id));
+        const asset = {
+            id: row.id,
+            numericId: row.numericId ?? numericId,
+            externalId: row.externalId,
+            projectId: row.projectId,
+            name: row.name,
+            type: row.type,
+            tags: parseJson(row.tagsJson, []),
+            path: parseJson(row.pathJson, []),
+            data: parseJson(row.dataJson, {}),
+            preload: row.preload,
+            exclude: row.exclude,
+            source: row.source,
+            sourceId: row.sourceId,
+            i18n: parseJson(row.i18nJson, {}),
+            task: row.task,
+            meta: parseJson(row.metaJson, null),
+            revision: row.revision,
+            fileFilename: row.fileFilename,
+            fileSize: row.fileSize,
+            fileHash: row.fileHash,
+            fileUrl: row.fileUrl,
+            createdAt: row.createdAt,
+            modifiedAt: row.modifiedAt,
+        };
+        options.onEmit?.('asset.create', { asset: AssetModel.toRecord(asset) }, projectId);
+        return res.json({ result: AssetModel.toRecord(asset) });
+    });
+    router.delete('/assets', async (req, res) => {
+        const idsParam = String(req.query.ids || '');
+        const ids = idsParam.split(',').map((s) => s.trim()).filter(Boolean);
+        if (ids.length === 0)
+            return res.status(400).json({ error: 'Missing ids' });
+        const projectId = String(req.query.projectId || options.projectId);
+        // delete
+        await db.delete(schema.assetsSqlite).where(inArray(schema.assetsSqlite.id, ids));
+        options.onEmit?.('asset.delete', { ids }, projectId);
+        return res.json({ ok: true });
+    });
+    router.post('/assets/move', async (req, res) => {
+        const { ids, to, projectId } = req.body || {};
+        if (!Array.isArray(ids) || !Array.isArray(to))
+            return res.status(400).json({ error: 'Missing ids/to' });
+        // update pathJson
+        for (const id of ids) {
+            await db
+                .update(schema.assetsSqlite)
+                .set({ pathJson: JSON.stringify(to), modifiedAt: nowDate() })
+                .where(eq(schema.assetsSqlite.id, id));
+        }
+        options.onEmit?.('asset.move', { ids, to }, String(projectId || options.projectId));
+        return res.json({ ok: true });
+    });
+    router.get('/assets/:id/file/:filename', async (req, res) => {
+        // Minimal local file serving for editor compatibility.
+        const filename = req.params.filename;
+        const full = path.join(options.projectDir, 'assets', filename);
+        try {
+            const buf = await fs.readFile(full);
+            res.setHeader('Content-Type', 'application/octet-stream');
+            res.send(buf);
+        }
+        catch (e) {
+            if (e?.code === 'ENOENT')
+                return res.status(404).send('not found');
+            return res.status(500).send('error');
+        }
+    });
+    router.get('/assets/:id/file', async (req, res) => {
+        // Fallback when editor requests /assets/:id/file/:filename via other paths
+        return res.status(400).json({ error: 'filename required' });
+    });
+    // Documents (code editor)
+    router.post('/documents/:id/save', async (req, res) => {
+        const id = req.params.id;
+        const { content } = req.body || {};
+        if (typeof content !== 'string') {
+            return res.status(400).json({ error: 'Invalid content' });
+        }
+        try {
+            // Get asset info to find file path
+            const asset = await fsBackend.getAsset(id);
+            if (!asset) {
+                return res.status(404).json({ error: 'Asset not found' });
+            }
+            const file = asset.file ?? asset;
+            const filename = file.filename ?? file.fileFilename;
+            if (!filename) {
+                return res.status(400).json({ error: 'Asset has no file' });
+            }
+            // Build file path
+            let filePath;
+            if (asset.treePath) {
+                const base = typeof asset.treePath === 'string' ? asset.treePath : path.join(...(asset.treePath || []));
+                filePath = path.join(base, filename);
+            }
+            else if (Array.isArray(asset.path) && asset.path.length > 0) {
+                filePath = path.join('assets', ...asset.path.map(String), filename);
+            }
+            else {
+                filePath = path.join('assets', filename);
+            }
+            // Write to file system
+            const fullPath = path.join(options.projectDir, filePath);
+            const dir = path.dirname(fullPath);
+            await fs.mkdir(dir, { recursive: true });
+            await fs.writeFile(fullPath, content, 'utf-8');
+            console.log(`[local-backend] ✅ Saved document: ${filePath}`);
+            return res.json({ success: true, path: filePath });
+        }
+        catch (error) {
+            console.error('[local-backend] Failed to save document:', error);
+            return res.status(500).json({ error: error.message || 'Save failed' });
+        }
+    });
+    return { router, db, schema, client };
+}

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

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