fluidcad 0.0.33 → 0.0.35

package/server/dist/{vite-manager.js → host/local-scene-host.js}

@@ -1,30 +1,7 @@
 import { createServer } from 'vite';
 import { dirname, resolve, isAbsolute } from 'path';
-import { normalizePath } from "./normalize-path.js";
-const BLOCKED_NODE_MODULES = new Set([
-    'fs',
-    'child_process',
-    'net',
-    'dgram',
-    'tls',
-    'http',
-    'https',
-    'http2',
-    'os',
-    'worker_threads',
-    'vm',
-    'cluster',
-    'dns',
-    'module',
-]);
-function getBlockedNodeModule(id) {
-    let name = id;
-    if (name.startsWith('node:')) {
-        name = name.slice(5);
-    }
-    const baseName = name.split('/')[0];
-    return BLOCKED_NODE_MODULES.has(baseName) ? baseName : null;
-}
+import { normalizePath } from "../normalize-path.js";
+import { getBlockedNodeModule } from "./blocked-imports.js";
 const IMPORT_PATTERN = /\b(?:import|export)\s[\s\S]*?from\s+['"]([^'"]+)['"]|\bimport\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
 function scanForBlockedImports(code) {
     let match;
@@ -38,7 +15,7 @@ function scanForBlockedImports(code) {
     }
     return null;
 }
-export class ViteManager {
+export class LocalSceneHost {
     server;
     rootPath = '';
     buffers = new Map();
@@ -102,6 +79,9 @@ export class ViteManager {
     setBuffer(id, code) {
         this.buffers.set(id, code);
     }
+    getBuffer(fileName) {
+        return this.buffers.get(`virtual:live-render:${fileName}`) ?? null;
+    }
     async loadModule(filePath) {
         const mod = await this.server.ssrLoadModule(filePath);
         for (const value of Object.values(mod)) {

package/server/dist/host/scene-host.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Source-of-truth + execution seam for a workspace's scene code.
+ *
+ * `FluidCadServer` owns the engine pipeline (param registry, scene cache,
+ * render orchestration) and does not care where `.fluid.js` source comes
+ * from or how it gets turned into a runnable module. That responsibility
+ * lives behind this interface.
+ *
+ * Implementations:
+ *   - LocalSceneHost: Vite SSR over the workspace directory (desktop).
+ *   - HubSceneHost (Phase 2): in-memory consumer of a packed model bundle.
+ */
+export interface SceneHost {
+    init(workspacePath: string): Promise<void>;
+    loadModule(filePath: string): Promise<Record<string, any>>;
+    setBuffer(id: string, code: string): void;
+    getBuffer(fileName: string): string | null;
+    invalidateModule(): void;
+}

package/server/dist/host/scene-host.js

@@ -0,0 +1 @@
+export {};

package/server/dist/index.js

@@ -1,19 +1,46 @@
-import crypto from 'crypto';
+import fs from 'fs';
 import http from 'http';
 import path from 'path';
 import express from 'express';
-import { WebSocketServer, WebSocket } from 'ws';
 import { FluidCadServer } from "./fluidcad-server.js";
+import { createServerCore } from "./server-core.js";
 import { createPropertiesRouter } from "./routes/properties.js";
-import { createActionsRouter } from "./routes/actions.js";
+import { createParamsRouter } from "./routes/params.js";
+import { createHitTestRouter } from "./routes/hit-test.js";
+import { createTimelineRouter } from "./routes/timeline.js";
+import { createSketchEditsRouter } from "./routes/sketch-edits.js";
 import { createExportRouter } from "./routes/export.js";
 import { createScreenshotRouter } from "./routes/screenshot.js";
 import { createPreferencesRouter } from "./routes/preferences.js";
+import { createHealthRouter } from "./routes/health.js";
+import { createSceneRouter } from "./routes/scene.js";
+import { createEditorRouter, DirtyBufferState } from "./routes/editor.js";
+import { createRenderRouter } from "./routes/render.js";
+import { createLintRouter } from "./routes/lint.js";
+import { createPackRouter } from "./routes/pack.js";
 import { normalizePath } from "./normalize-path.js";
+import { writeInstanceFile, deleteInstanceFile } from "./instance-file.js";
+import { addInstance, removeInstance } from "./global-registry.js";
 import { extractSourceLocation } from '../../lib/dist/index.js';
 const PORT = parseInt(process.env.FLUIDCAD_SERVER_PORT || '3100', 10);
 const WORKSPACE_PATH = normalizePath(process.env.FLUIDCAD_WORKSPACE_PATH || '');
 const UI_DIST = path.resolve(import.meta.dirname, '../../ui/dist');
+function readPackageVersion() {
+    try {
+        const pkgPath = path.resolve(import.meta.dirname, '../../package.json');
+        const raw = fs.readFileSync(pkgPath, 'utf8');
+        const parsed = JSON.parse(raw);
+        if (typeof parsed.version === 'string') {
+            return parsed.version;
+        }
+    }
+    catch {
+        // Fall through to unknown.
+    }
+    return '0.0.0';
+}
+const PACKAGE_VERSION = readPackageVersion();
+const STARTED_AT = new Date().toISOString();
 // ---------------------------------------------------------------------------
 // IPC helpers — communication with extension host process
 // ---------------------------------------------------------------------------
@@ -26,13 +53,35 @@ function sendToExtension(msg) {
 // Express app
 // ---------------------------------------------------------------------------
 const fluidCadServer = new FluidCadServer();
+const dirtyBufferState = new DirtyBufferState();
 const app = express();
 app.use(express.json({ limit: '50mb' }));
+// ---------------------------------------------------------------------------
+// HTTP + WebSocket server (set up early so routes can reference its helpers)
+// ---------------------------------------------------------------------------
+const httpServer = http.createServer(app);
+const core = createServerCore(httpServer);
+const broadcastToUI = core.broadcastToUI;
+const requestScreenshot = core.requestScreenshot;
+const getLastCameraState = core.getLastCameraState;
+app.use('/api', createHealthRouter({
+    version: PACKAGE_VERSION,
+    workspacePath: WORKSPACE_PATH,
+    startedAt: STARTED_AT,
+}));
 app.use('/api', createPropertiesRouter(fluidCadServer));
-app.use('/api', createActionsRouter(fluidCadServer, sendToExtension, broadcastToUI, WORKSPACE_PATH));
-app.use('/api', createExportRouter(fluidCadServer));
+app.use('/api', createParamsRouter(fluidCadServer, sendToExtension, broadcastToUI));
+app.use('/api', createHitTestRouter(fluidCadServer));
+app.use('/api', createTimelineRouter(fluidCadServer, sendToExtension, broadcastToUI));
+app.use('/api', createSketchEditsRouter(fluidCadServer, sendToExtension, WORKSPACE_PATH));
+app.use('/api', createExportRouter(fluidCadServer, WORKSPACE_PATH));
 app.use('/api', createScreenshotRouter(requestScreenshot));
 app.use('/api', createPreferencesRouter());
+app.use('/api', createSceneRouter(fluidCadServer, getLastCameraState));
+app.use('/api', createEditorRouter(dirtyBufferState));
+app.use('/api', createRenderRouter((fileName, code) => runLiveRender(fileName, code)));
+app.use('/api', createLintRouter());
+app.use('/api', createPackRouter(fluidCadServer, WORKSPACE_PATH, PACKAGE_VERSION, getLastCameraState));
 // Static files — serve UI build, with SPA fallback
 app.use(express.static(UI_DIST, {
     setHeaders(res, filePath) {
@@ -46,106 +95,14 @@ app.get('*splat', (_req, res) => {
     res.sendFile(path.join(UI_DIST, 'index.html'));
 });
 // ---------------------------------------------------------------------------
-// HTTP + WebSocket server
-// ---------------------------------------------------------------------------
-const httpServer = http.createServer(app);
-const wss = new WebSocketServer({ server: httpServer });
-const uiClients = new Set();
-let lastSceneMessage = null;
-let initCompleteMessage = null;
-function broadcastToUI(msg) {
-    const data = JSON.stringify(msg);
-    if (msg.type === 'scene-rendered') {
-        lastSceneMessage = data;
-    }
-    if (msg.type === 'init-complete') {
-        initCompleteMessage = data;
-    }
-    for (const client of uiClients) {
-        if (client.readyState === WebSocket.OPEN) {
-            client.send(data);
-        }
-    }
-}
-// ---------------------------------------------------------------------------
-// Screenshot request/response coordination
-// ---------------------------------------------------------------------------
-const SCREENSHOT_TIMEOUT_MS = 10_000;
-const pendingScreenshots = new Map();
-function requestScreenshot(options) {
-    return new Promise((resolve, reject) => {
-        if (uiClients.size === 0) {
-            reject(new Error('No UI client connected.'));
-            return;
-        }
-        const requestId = crypto.randomUUID();
-        const timeout = setTimeout(() => {
-            pendingScreenshots.delete(requestId);
-            reject(new Error('Screenshot request timed out.'));
-        }, SCREENSHOT_TIMEOUT_MS);
-        pendingScreenshots.set(requestId, {
-            resolve(data) {
-                clearTimeout(timeout);
-                pendingScreenshots.delete(requestId);
-                resolve(data);
-            },
-            reject(err) {
-                clearTimeout(timeout);
-                pendingScreenshots.delete(requestId);
-                reject(err);
-            },
-        });
-        broadcastToUI({ type: 'take-screenshot', requestId, options });
-    });
-}
-function handleUIMessage(raw) {
-    let msg;
-    try {
-        msg = JSON.parse(raw);
-    }
-    catch {
-        return;
-    }
-    if (msg.type === 'screenshot-result' && msg.requestId) {
-        const pending = pendingScreenshots.get(msg.requestId);
-        if (!pending) {
-            return;
-        }
-        if (msg.success && msg.data) {
-            pending.resolve(Buffer.from(msg.data, 'base64'));
-        }
-        else {
-            pending.reject(new Error(msg.error || 'Screenshot failed.'));
-        }
-    }
-}
-// ---------------------------------------------------------------------------
-// WebSocket connections
-// ---------------------------------------------------------------------------
-wss.on('connection', (ws) => {
-    uiClients.add(ws);
-    // Replay init-complete and last scene to newly connected UI client
-    if (initCompleteMessage) {
-        ws.send(initCompleteMessage);
-    }
-    if (lastSceneMessage) {
-        ws.send(lastSceneMessage);
-    }
-    ws.on('message', (data) => {
-        handleUIMessage(String(data));
-    });
-    ws.on('close', () => {
-        uiClients.delete(ws);
-    });
-});
-// ---------------------------------------------------------------------------
 // IPC message handling — extension host → server
 // ---------------------------------------------------------------------------
 let currentFile = null;
 let renderVersion = 0;
 const lastSceneByFile = new Map();
-function emitSuccess(absPath, result, rollbackStop, breakpointHit) {
+function emitSuccess(version, absPath, result, rollbackStop, breakpointHit, params) {
     lastSceneByFile.set(absPath, { result, rollbackStop });
+    fluidCadServer.setCompileError(null);
     sendToExtension({
         type: 'scene-rendered',
         absPath,
@@ -158,7 +115,9 @@ function emitSuccess(absPath, result, rollbackStop, breakpointHit) {
         absPath,
         rollbackStop,
         breakpointHit,
+        params,
     });
+    broadcastToUI({ type: 'render-version', version, state: 'end', absPath });
 }
 function buildCompileError(filePath, err) {
     const message = err?.message || String(err);
@@ -178,12 +137,13 @@ function buildCompileError(filePath, err) {
         sourceLocation: sourceLocation ?? undefined,
     };
 }
-function emitCompileError(filePath, err) {
+function emitCompileError(version, filePath, err) {
     const compileError = buildCompileError(filePath, err);
     const key = compileError.filePath ?? normalizePath(filePath).replace('virtual:live-render:', '');
     const prev = lastSceneByFile.get(key);
     const result = prev?.result ?? [];
     const rollbackStop = prev?.rollbackStop ?? -1;
+    fluidCadServer.setCompileError(compileError);
     sendToExtension({
         type: 'scene-rendered',
         absPath: key,
@@ -198,12 +158,59 @@ function emitCompileError(filePath, err) {
         rollbackStop,
         compileError,
     });
+    broadcastToUI({ type: 'render-version', version, state: 'error', absPath: key });
+    return compileError;
+}
+/**
+ * Render-orchestration chokepoint shared by the IPC `live-update` handler and
+ * the HTTP `/api/render` route. Bumps `renderVersion`, broadcasts the
+ * lifecycle pings, runs the dedupable `updateLiveCode`, and emits success /
+ * compile-error to the UI + extension. Returns a structured outcome so the
+ * HTTP caller (MCP) can hand it straight to the agent.
+ */
+async function runLiveRender(fileName, code) {
+    const startedAt = Date.now();
+    const myVersion = ++renderVersion;
+    broadcastToUI({ type: 'render-version', version: myVersion, state: 'start' });
+    if (fileName !== currentFile) {
+        broadcastToUI({ type: 'processing-file' });
+        currentFile = fileName;
+    }
+    try {
+        const data = await fluidCadServer.updateLiveCode(fileName, code);
+        if (myVersion !== renderVersion) {
+            return { state: 'superseded', version: myVersion, durationMs: Date.now() - startedAt };
+        }
+        if (!data) {
+            return { state: 'no-scene-manager', version: myVersion, durationMs: Date.now() - startedAt };
+        }
+        emitSuccess(myVersion, data.absPath, data.result, data.rollbackStop, data.breakpointHit, data.params);
+        return {
+            state: 'rendered',
+            version: myVersion,
+            absPath: data.absPath,
+            durationMs: Date.now() - startedAt,
+        };
+    }
+    catch (err) {
+        if (myVersion !== renderVersion) {
+            return { state: 'superseded', version: myVersion, durationMs: Date.now() - startedAt };
+        }
+        const compileError = emitCompileError(myVersion, fileName, err);
+        return {
+            state: 'compile-error',
+            version: myVersion,
+            durationMs: Date.now() - startedAt,
+            compileError,
+        };
+    }
 }
 async function handleExtensionMessage(msg) {
     try {
         switch (msg.type) {
             case 'process-file': {
                 const myVersion = ++renderVersion;
+                broadcastToUI({ type: 'render-version', version: myVersion, state: 'start' });
                 broadcastToUI({ type: 'processing-file' });
                 currentFile = msg.filePath;
                 try {
@@ -212,48 +219,30 @@ async function handleExtensionMessage(msg) {
                         return;
                     }
                     if (data) {
-                        emitSuccess(data.absPath, data.result, data.rollbackStop, data.breakpointHit);
+                        emitSuccess(myVersion, data.absPath, data.result, data.rollbackStop, data.breakpointHit, data.params);
                     }
                 }
                 catch (err) {
                     if (myVersion !== renderVersion) {
                         return;
                     }
-                    emitCompileError(msg.filePath, err);
+                    emitCompileError(myVersion, msg.filePath, err);
                 }
                 break;
             }
             case 'live-update': {
-                const myVersion = ++renderVersion;
-                if (msg.fileName !== currentFile) {
-                    broadcastToUI({ type: 'processing-file' });
-                    currentFile = msg.fileName;
-                }
-                try {
-                    const data = await fluidCadServer.updateLiveCode(msg.fileName, msg.code);
-                    if (myVersion !== renderVersion) {
-                        return;
-                    }
-                    if (data) {
-                        emitSuccess(data.absPath, data.result, data.rollbackStop, data.breakpointHit);
-                    }
-                }
-                catch (err) {
-                    if (myVersion !== renderVersion) {
-                        return;
-                    }
-                    emitCompileError(msg.fileName, err);
-                }
+                await runLiveRender(msg.fileName, msg.code);
                 break;
             }
             case 'rollback': {
                 const myVersion = ++renderVersion;
+                broadcastToUI({ type: 'render-version', version: myVersion, state: 'start' });
                 const data = await fluidCadServer.rollback(msg.fileName, msg.index);
                 if (myVersion !== renderVersion) {
                     return;
                 }
                 if (data) {
-                    emitSuccess(data.absPath, data.result, data.rollbackStop);
+                    emitSuccess(myVersion, data.absPath, data.result, data.rollbackStop);
                 }
                 break;
             }
@@ -279,6 +268,13 @@ async function handleExtensionMessage(msg) {
                 broadcastToUI({ type: 'show-shape-properties', shapeId: msg.shapeId });
                 break;
             }
+            case 'editor-dirty-state': {
+                if (Array.isArray(msg.dirtyFiles)) {
+                    const paths = msg.dirtyFiles.filter((p) => typeof p === 'string');
+                    dirtyBufferState.setDirtyFiles(paths);
+                }
+                break;
+            }
             case 'export-scene': {
                 try {
                     const result = fluidCadServer.exportShapes(msg.shapeIds, msg.options);
@@ -321,6 +317,36 @@ process.on('message', (msg) => {
 httpServer.listen(PORT, () => {
     const url = `http://localhost:${PORT}`;
     console.log(`FluidCAD server listening on ${url}`);
+    // Publish this instance so a standalone MCP process can discover us.
+    // Discovery is best-effort: an MCP-less workflow must keep working even if
+    // we can't write the file (read-only FS, permissions, …).
+    if (WORKSPACE_PATH) {
+        try {
+            writeInstanceFile({
+                schemaVersion: 1,
+                port: PORT,
+                pid: process.pid,
+                workspacePath: WORKSPACE_PATH,
+                version: PACKAGE_VERSION,
+                startedAt: STARTED_AT,
+            });
+        }
+        catch (err) {
+            console.warn(`Failed to write instance file: ${err?.message ?? err}`);
+        }
+        try {
+            addInstance({
+                workspacePath: WORKSPACE_PATH,
+                port: PORT,
+                pid: process.pid,
+                version: PACKAGE_VERSION,
+                startedAt: STARTED_AT,
+            });
+        }
+        catch (err) {
+            console.warn(`Failed to update global registry: ${err?.message ?? err}`);
+        }
+    }
     // Signal ready immediately so extension can show the webview
     sendToExtension({ type: 'ready', port: PORT, url });
     // Initialize FluidCAD server in the background
@@ -333,3 +359,29 @@ httpServer.listen(PORT, () => {
         broadcastToUI({ type: 'init-complete', success: false, error });
     });
 });
+// ---------------------------------------------------------------------------
+// Shutdown — clean up the instance file and registry entry
+// ---------------------------------------------------------------------------
+let cleanedUp = false;
+function cleanupDiscovery() {
+    if (cleanedUp || !WORKSPACE_PATH) {
+        return;
+    }
+    cleanedUp = true;
+    deleteInstanceFile(WORKSPACE_PATH, process.pid);
+    try {
+        removeInstance(WORKSPACE_PATH, process.pid);
+    }
+    catch {
+        // Registry cleanup is best-effort; stale entries are pruned by readers.
+    }
+}
+process.on('exit', cleanupDiscovery);
+process.on('SIGINT', () => {
+    cleanupDiscovery();
+    process.exit(0);
+});
+process.on('SIGTERM', () => {
+    cleanupDiscovery();
+    process.exit(0);
+});

package/server/dist/instance-file.d.ts

@@ -0,0 +1,31 @@
+export declare const INSTANCE_DIR_NAME = ".fluidcad";
+export declare const INSTANCE_FILE_NAME = "instance.json";
+export type InstanceFile = {
+    /** Schema version; bump when changing the shape. */
+    schemaVersion: 1;
+    /** Port the HTTP+WS server is listening on. */
+    port: number;
+    /** PID of the server process — used by MCP for liveness probes. */
+    pid: number;
+    /** Absolute path to the workspace this instance serves. */
+    workspacePath: string;
+    /** FluidCAD package version. */
+    version: string;
+    /** ISO 8601 timestamp captured when the server began listening. */
+    startedAt: string;
+};
+export declare function instanceFilePath(workspacePath: string): string;
+/**
+ * Atomically write the instance file. Uses a PID-suffixed tmp file plus
+ * `renameSync` so a concurrent reader never observes a half-written file.
+ */
+export declare function writeInstanceFile(entry: InstanceFile): void;
+/**
+ * Best-effort delete; never throws. Called from SIGINT/SIGTERM and `exit`
+ * handlers, where we cannot afford to interrupt shutdown over an I/O error.
+ *
+ * `expectedPid` guards against deleting another process's file on race —
+ * e.g., a second window started for the same workspace after a crash.
+ */
+export declare function deleteInstanceFile(workspacePath: string, expectedPid: number): void;
+export declare function readInstanceFile(workspacePath: string): InstanceFile | null;

package/server/dist/instance-file.js

@@ -0,0 +1,73 @@
+// Per-workspace instance discovery file at <workspace>/.fluidcad/instance.json.
+//
+// Written when the HTTP server is listening, deleted on graceful shutdown. A
+// standalone MCP process reads this file to learn the workspace's random port
+// without scanning. The on-disk format is intentionally small and stable.
+import fs from 'fs';
+import path from 'path';
+export const INSTANCE_DIR_NAME = '.fluidcad';
+export const INSTANCE_FILE_NAME = 'instance.json';
+function instanceDir(workspacePath) {
+    return path.join(workspacePath, INSTANCE_DIR_NAME);
+}
+export function instanceFilePath(workspacePath) {
+    return path.join(instanceDir(workspacePath), INSTANCE_FILE_NAME);
+}
+/**
+ * Atomically write the instance file. Uses a PID-suffixed tmp file plus
+ * `renameSync` so a concurrent reader never observes a half-written file.
+ */
+export function writeInstanceFile(entry) {
+    const dir = instanceDir(entry.workspacePath);
+    fs.mkdirSync(dir, { recursive: true });
+    const destination = path.join(dir, INSTANCE_FILE_NAME);
+    const tmp = path.join(dir, `${INSTANCE_FILE_NAME}.${entry.pid}.tmp`);
+    const payload = JSON.stringify(entry, null, 2) + '\n';
+    fs.writeFileSync(tmp, payload, { encoding: 'utf8', mode: 0o644 });
+    fs.renameSync(tmp, destination);
+}
+/**
+ * Best-effort delete; never throws. Called from SIGINT/SIGTERM and `exit`
+ * handlers, where we cannot afford to interrupt shutdown over an I/O error.
+ *
+ * `expectedPid` guards against deleting another process's file on race —
+ * e.g., a second window started for the same workspace after a crash.
+ */
+export function deleteInstanceFile(workspacePath, expectedPid) {
+    const file = instanceFilePath(workspacePath);
+    try {
+        const existing = readInstanceFile(workspacePath);
+        if (existing && existing.pid !== expectedPid) {
+            return;
+        }
+        fs.unlinkSync(file);
+    }
+    catch {
+        // File missing, permissions, partial write — nothing useful to do during shutdown.
+    }
+}
+export function readInstanceFile(workspacePath) {
+    try {
+        const raw = fs.readFileSync(instanceFilePath(workspacePath), 'utf8');
+        const parsed = JSON.parse(raw);
+        if (!isInstanceFile(parsed)) {
+            return null;
+        }
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+function isInstanceFile(value) {
+    if (typeof value !== 'object' || value === null) {
+        return false;
+    }
+    const v = value;
+    return (v.schemaVersion === 1 &&
+        typeof v.port === 'number' &&
+        typeof v.pid === 'number' &&
+        typeof v.workspacePath === 'string' &&
+        typeof v.version === 'string' &&
+        typeof v.startedAt === 'string');
+}

package/server/dist/lint-fluid-js.d.ts

@@ -0,0 +1,15 @@
+export type MissingImport = {
+    symbol: string;
+    module: string;
+    /** Zero-based line where the unbound use first appears. */
+    line: number;
+    /** Zero-based UTF-16 column where the unbound use first appears. */
+    column: number;
+};
+export type LintFluidJsResult = {
+    /** Free-variable usages of known symbols that lack an import. */
+    missing: MissingImport[];
+    /** A copy-pasteable block of suggested import statements, grouped by module. */
+    suggestion: string;
+};
+export declare function lintFluidJs(code: string): Promise<LintFluidJsResult>;