@scenoco-three/editor 0.2.0

package/dist/server.js

@@ -0,0 +1,264 @@
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { createServer as createNetServer } from 'node:net';
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import chokidar from 'chokidar';
+import { createServer } from 'vite';
+import { WebSocketServer } from 'ws';
+import { bundlePrefab, bundleScene, compilePrefabXml, compileSceneXml, loadComponents, patchSceneXml, scanComponents, } from '@scenoco-three/compiler';
+import { WS_PATH } from './protocol.js';
+const appDir = fileURLToPath(new URL('../app', import.meta.url));
+/** Loads `src=` resources from disk, relative to the referencing file. */
+const fsResolver = (request, referrer) => {
+    const path = resolve(referrer ? dirname(referrer) : '.', request);
+    return existsSync(path) ? { path, contents: readFileSync(path, 'utf8') } : null;
+};
+/**
+ * Start the editor's Vite dev server: serves the app, registers all project
+ * components/packages, compiles any scene/prefab on demand, and bridges the page
+ * to the MCP server over a WebSocket.
+ */
+export async function startEditorServer(opts = {}) {
+    const componentRoots = opts.componentRoots ?? ['src'];
+    const packages = opts.packages ?? [];
+    const port = opts.port ?? (await freePort());
+    const cwd = opts.cwd ?? process.cwd();
+    const watcher = createFileWatcher();
+    const server = await createServer({
+        configFile: false,
+        root: appDir,
+        logLevel: 'warn',
+        server: { host: true, port, strictPort: true, fs: { strict: false } },
+        plugins: [allComponentsPlugin(componentRoots, packages, cwd), bundleEndpointPlugin(componentRoots, packages, cwd, watcher)],
+    });
+    await server.listen();
+    const bridge = attachBridge(server);
+    watcher.setPush((msg) => bridge.push(msg));
+    const url = server.resolvedUrls?.local[0] ?? `http://localhost:${port}/`;
+    const networkUrl = server.resolvedUrls?.network[0];
+    return {
+        url,
+        ...(networkUrl ? { networkUrl } : {}),
+        bridge,
+        close: async () => {
+            await watcher.close();
+            await server.close();
+        },
+    };
+}
+/**
+ * A push-based file watcher: tracks the open file plus its `src=` dependencies,
+ * and notifies the editor when one changes on disk. Changes whose content matches
+ * what we last compiled/wrote are ignored — so the editor's own save (and no-op
+ * touches) don't masquerade as external edits.
+ */
+function createFileWatcher() {
+    const w = chokidar.watch([], { ignoreInitial: true, awaitWriteFinish: true });
+    const content = new Map(); // abs path → last-known content
+    let openFile = '';
+    let push = () => { };
+    const onChange = (changed) => {
+        const abs = resolve(changed);
+        if (!content.has(abs))
+            return; // not in our set
+        let text;
+        try {
+            text = readFileSync(abs, 'utf8');
+        }
+        catch {
+            return; // deleted mid-event; ignore
+        }
+        if (text === content.get(abs))
+            return; // our own write or a no-op touch
+        content.set(abs, text);
+        push({ push: 'fileChanged', file: abs, role: abs === openFile ? 'open' : 'dep' });
+    };
+    w.on('change', onChange);
+    w.on('add', onChange);
+    return {
+        arm(file, openContents, deps) {
+            const abs = resolve(file);
+            const next = new Map([[abs, openContents]]);
+            for (const d of deps)
+                next.set(resolve(d.path), d.contents);
+            for (const old of content.keys())
+                if (!next.has(old))
+                    w.unwatch(old);
+            for (const p of next.keys())
+                if (!content.has(p))
+                    w.add(p);
+            content.clear();
+            for (const [k, v] of next)
+                content.set(k, v);
+            openFile = abs;
+        },
+        note(file, contents) {
+            content.set(resolve(file), contents);
+        },
+        setPush(fn) {
+            push = fn;
+        },
+        close: () => w.close(),
+    };
+}
+/** `virtual:scenoco-components` → import every project component + package + built-in nodes. */
+function allComponentsPlugin(roots, packages, cwd) {
+    const id = 'virtual:scenoco-components';
+    const resolved = '\0' + id;
+    return {
+        name: 'scenoco:all-components',
+        resolveId: (source) => (source === id ? resolved : null),
+        load(source) {
+            if (source !== resolved)
+                return null;
+            const files = [...scanComponents(roots, cwd).files.keys()].map((f) => `import ${JSON.stringify(`/@fs${f}`)};`);
+            const pkgs = packages.map((p) => `import ${JSON.stringify(p)};`);
+            return ['import "@scenoco-three/core/nodes";', ...pkgs, ...files].join('\n');
+        },
+    };
+}
+/** `GET /@scenoco/bundle?file=<abs>` → the compiled runtime bundle (JSON). */
+function bundleEndpointPlugin(roots, packages, cwd, watcher) {
+    return {
+        name: 'scenoco:bundle-endpoint',
+        async configureServer(server) {
+            // Register components in this Node process so compilation/validation works.
+            await loadComponents(roots, cwd, { packages }).catch(() => { });
+            // POST /@scenoco/save — surgical, attribute-level write-back to the source.
+            server.middlewares.use((req, res, next) => {
+                if (req.method !== 'POST' || !req.url || !req.url.startsWith('/@scenoco/save'))
+                    return next();
+                void readJsonBody(req)
+                    .then((body) => {
+                    const { file, edits } = (body ?? {});
+                    if (!file || !Array.isArray(edits))
+                        throw new Error('expected { file, edits }');
+                    const abs = resolve(cwd, file);
+                    const { text, changed, unresolved } = patchSceneXml(readFileSync(abs, 'utf8'), edits);
+                    if (changed > 0)
+                        writeFileSync(abs, text);
+                    watcher.note(abs, text); // our own write — don't report it back as an external change
+                    res.setHeader('Content-Type', 'application/json');
+                    res.end(JSON.stringify({ ok: true, changed, unresolved: unresolved.length }));
+                })
+                    .catch((e) => {
+                    res.statusCode = 400;
+                    res.setHeader('Content-Type', 'application/json');
+                    res.end(JSON.stringify({ error: e instanceof Error ? e.message : String(e) }));
+                });
+            });
+            server.middlewares.use((req, res, next) => {
+                if (!req.url || !req.url.startsWith('/@scenoco/bundle'))
+                    return next();
+                try {
+                    const file = new URL(req.url, 'http://x').searchParams.get('file');
+                    if (!file)
+                        throw new Error('missing ?file=');
+                    const abs = resolve(cwd, file);
+                    const xml = readFileSync(abs, 'utf8');
+                    const isPrefab = abs.endsWith('.prefab.xml');
+                    // Track which src= files the compile touches, so we can watch them too.
+                    const deps = [];
+                    const trackingResolver = (request, referrer) => {
+                        const r = fsResolver(request, referrer);
+                        if (r)
+                            deps.push({ path: r.path, contents: r.contents });
+                        return r;
+                    };
+                    const result = isPrefab
+                        ? compilePrefabXml(xml, { path: abs, resolve: trackingResolver })
+                        : compileSceneXml(xml, { path: abs, resolve: trackingResolver });
+                    if (!result.ok) {
+                        res.statusCode = 400;
+                        res.setHeader('Content-Type', 'application/json');
+                        res.end(JSON.stringify({ error: 'compile failed', diagnostics: result.diagnostics }));
+                        return;
+                    }
+                    watcher.arm(abs, xml, deps); // watch this file + its src deps for changes
+                    const bundle = isPrefab ? bundlePrefab(result.scene) : bundleScene(result.scene);
+                    res.setHeader('Content-Type', 'application/json');
+                    res.end(JSON.stringify({ bundle, provenance: result.provenance }));
+                }
+                catch (e) {
+                    res.statusCode = 400;
+                    res.setHeader('Content-Type', 'application/json');
+                    res.end(JSON.stringify({ error: e instanceof Error ? e.message : String(e) }));
+                }
+            });
+        },
+    };
+}
+/** WebSocket bridge: one editor page ↔ the MCP server, with id-correlated replies. */
+function attachBridge(server) {
+    const wss = new WebSocketServer({ noServer: true });
+    let editor;
+    const pending = new Map();
+    server.httpServer?.on('upgrade', (req, socket, head) => {
+        // Only our path; Vite's HMR upgrades (vite-hmr subprotocol) fall through to it.
+        if (!req.url || !req.url.startsWith(WS_PATH))
+            return;
+        wss.handleUpgrade(req, socket, head, (ws) => {
+            editor = ws;
+            ws.on('message', (data) => {
+                try {
+                    const r = JSON.parse(String(data));
+                    pending.get(r.id)?.(r);
+                    pending.delete(r.id);
+                }
+                catch {
+                    /* ignore malformed */
+                }
+            });
+            ws.on('close', () => {
+                if (editor === ws)
+                    editor = undefined;
+            });
+        });
+    });
+    return {
+        connected: () => !!editor && editor.readyState === editor.OPEN,
+        send: (cmd) => new Promise((res, rej) => {
+            if (!editor || editor.readyState !== editor.OPEN) {
+                rej(new Error('no editor connected — open the editor page in a browser first'));
+                return;
+            }
+            pending.set(cmd.id, res);
+            editor.send(JSON.stringify(cmd));
+            setTimeout(() => {
+                if (pending.delete(cmd.id))
+                    rej(new Error('editor did not respond in time'));
+            }, 15000);
+        }),
+        push: (msg) => {
+            if (editor && editor.readyState === editor.OPEN)
+                editor.send(JSON.stringify(msg));
+        },
+    };
+}
+/** Read a request's JSON body (for the save endpoint). */
+function readJsonBody(req) {
+    return new Promise((resolve, reject) => {
+        let data = '';
+        req.on('data', (c) => (data += c));
+        req.on('end', () => {
+            try {
+                resolve(data ? JSON.parse(data) : undefined);
+            }
+            catch (e) {
+                reject(e instanceof Error ? e : new Error(String(e)));
+            }
+        });
+        req.on('error', reject);
+    });
+}
+/** Ask the OS for a free TCP port (avoids Vite's 5173-default collisions). */
+function freePort() {
+    return new Promise((res, rej) => {
+        const probe = createNetServer();
+        probe.on('error', rej);
+        probe.listen(0, () => {
+            const port = probe.address().port;
+            probe.close(() => res(port));
+        });
+    });
+}

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@scenoco-three/editor",
+  "version": "0.2.0",
+  "description": "Local preview + headless frame render for SceNoCo scenes/prefabs (for multimodal LLMs)",
+  "type": "module",
+  "license": "MIT",
+  "bin": {
+    "scenoco-editor": "./dist/cli/index.js"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "app"
+  ],
+  "keywords": [
+    "three",
+    "threejs",
+    "scenoco",
+    "editor",
+    "preview",
+    "render",
+    "gamedev"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "typecheck": "npm --prefix ../core run build && npm --prefix ../compiler run build && npm --prefix ../vite run build && tsc --noEmit -p tsconfig.json"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.12.0",
+    "@scenoco-three/compiler": "^0.2.0",
+    "@scenoco-three/vite": "^0.2.0",
+    "chokidar": "^4.0.3",
+    "ws": "^8.18.0"
+  },
+  "peerDependencies": {
+    "@scenoco-three/core": "^0.2.0",
+    "three": ">=0.160",
+    "vite": ">=5"
+  },
+  "devDependencies": {
+    "@types/ws": "^8.5.13"
+  }
+}