fluidcad 0.0.5 → 0.0.7

package/server/dist/routes/properties.js

@@ -0,0 +1,46 @@
+import { Router } from 'express';
+import { getMaterials } from '../../../lib/dist/common/materials.js';
+export function createPropertiesRouter(fluidCadServer) {
+    const router = Router();
+    router.get('/materials', (_req, res) => {
+        res.json(getMaterials());
+    });
+    router.get('/shape-properties', (req, res) => {
+        const shapeId = req.query.shapeId || '';
+        const props = fluidCadServer.getShapeProperties(shapeId);
+        if (!props) {
+            res.status(404).json({ error: 'Shape not found' });
+            return;
+        }
+        res.json(props);
+    });
+    router.get('/face-properties', (req, res) => {
+        const shapeId = req.query.shapeId || '';
+        const faceIndex = parseInt(req.query.faceIndex || '', 10);
+        if (!shapeId || isNaN(faceIndex) || faceIndex < 0) {
+            res.status(400).json({ error: 'Missing or invalid shapeId / faceIndex' });
+            return;
+        }
+        const props = fluidCadServer.getFaceProperties(shapeId, faceIndex);
+        if (!props) {
+            res.status(404).json({ error: 'Face not found' });
+            return;
+        }
+        res.json(props);
+    });
+    router.get('/edge-properties', (req, res) => {
+        const shapeId = req.query.shapeId || '';
+        const edgeIndex = parseInt(req.query.edgeIndex || '', 10);
+        if (!shapeId || isNaN(edgeIndex) || edgeIndex < 0) {
+            res.status(400).json({ error: 'Missing or invalid shapeId / edgeIndex' });
+            return;
+        }
+        const props = fluidCadServer.getEdgeProperties(shapeId, edgeIndex);
+        if (!props) {
+            res.status(404).json({ error: 'Edge not found' });
+            return;
+        }
+        res.json(props);
+    });
+    return router;
+}

package/server/dist/routes/screenshot.d.ts

@@ -0,0 +1,2 @@
+import { Router } from 'express';
+export declare function createScreenshotRouter(requestScreenshot: (options: Record<string, unknown>) => Promise<Buffer>): Router;

package/server/dist/routes/screenshot.js

@@ -0,0 +1,76 @@
+import { Router } from 'express';
+export function createScreenshotRouter(requestScreenshot) {
+    const router = Router();
+    router.post('/screenshot', async (req, res) => {
+        const { width, height, showGrid, showAxes, transparent, autoCrop, fitToModel, margin } = req.body;
+        const options = {};
+        if (width !== undefined) {
+            if (typeof width !== 'number' || width < 1 || width > 8192) {
+                res.status(400).json({ error: 'width must be a number between 1 and 8192.' });
+                return;
+            }
+            options.width = width;
+        }
+        if (height !== undefined) {
+            if (typeof height !== 'number' || height < 1 || height > 8192) {
+                res.status(400).json({ error: 'height must be a number between 1 and 8192.' });
+                return;
+            }
+            options.height = height;
+        }
+        if (showGrid !== undefined) {
+            if (typeof showGrid !== 'boolean') {
+                res.status(400).json({ error: 'showGrid must be a boolean.' });
+                return;
+            }
+            options.showGrid = showGrid;
+        }
+        if (showAxes !== undefined) {
+            if (typeof showAxes !== 'boolean') {
+                res.status(400).json({ error: 'showAxes must be a boolean.' });
+                return;
+            }
+            options.showAxes = showAxes;
+        }
+        if (transparent !== undefined) {
+            if (typeof transparent !== 'boolean') {
+                res.status(400).json({ error: 'transparent must be a boolean.' });
+                return;
+            }
+            options.transparent = transparent;
+        }
+        if (autoCrop !== undefined) {
+            if (typeof autoCrop !== 'boolean') {
+                res.status(400).json({ error: 'autoCrop must be a boolean.' });
+                return;
+            }
+            options.autoCrop = autoCrop;
+        }
+        if (fitToModel !== undefined) {
+            if (typeof fitToModel !== 'boolean') {
+                res.status(400).json({ error: 'fitToModel must be a boolean.' });
+                return;
+            }
+            options.fitToModel = fitToModel;
+        }
+        if (margin !== undefined) {
+            if (typeof margin !== 'number' || margin < 0) {
+                res.status(400).json({ error: 'margin must be a non-negative number.' });
+                return;
+            }
+            options.margin = margin;
+        }
+        try {
+            const png = await requestScreenshot(options);
+            res.setHeader('Content-Type', 'image/png');
+            res.setHeader('Content-Disposition', 'inline; filename="screenshot.png"');
+            res.send(png);
+        }
+        catch (err) {
+            const message = err.message || String(err);
+            const status = message.includes('No UI client') || message.includes('timed out') ? 503 : 500;
+            res.status(status).json({ error: message });
+        }
+    });
+    return router;
+}

package/server/dist/vite-manager.d.ts

@@ -0,0 +1,10 @@
+import { type ViteDevServer } from 'vite';
+export declare class ViteManager {
+    server: ViteDevServer;
+    private rootPath;
+    private buffers;
+    init(rootPath: string): Promise<void>;
+    setBuffer(id: string, code: string): void;
+    loadModule(filePath: string): Promise<Record<string, any>>;
+    invalidateModule(): void;
+}

package/server/dist/vite-manager.js

@@ -0,0 +1,111 @@
+import { createServer } from 'vite';
+import { dirname, resolve, isAbsolute } from 'path';
+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;
+}
+const IMPORT_PATTERN = /\b(?:import|export)\s[\s\S]*?from\s+['"]([^'"]+)['"]|\bimport\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
+function scanForBlockedImports(code) {
+    let match;
+    IMPORT_PATTERN.lastIndex = 0;
+    while ((match = IMPORT_PATTERN.exec(code)) !== null) {
+        const specifier = match[1] || match[2];
+        const blocked = getBlockedNodeModule(specifier);
+        if (blocked) {
+            return specifier;
+        }
+    }
+    return null;
+}
+export class ViteManager {
+    server;
+    rootPath = '';
+    buffers = new Map();
+    async init(rootPath) {
+        this.rootPath = rootPath;
+        const that = this;
+        this.server = await createServer({
+            root: rootPath,
+            server: {
+                watch: {
+                    ignoreInitial: true,
+                    ignored: ['**/node_modules/**']
+                }
+            },
+            optimizeDeps: {
+                noDiscovery: true,
+                include: []
+            },
+            plugins: [
+                {
+                    name: 'virtual-module',
+                    resolveId(id, importer) {
+                        if (id.startsWith('virtual:')) {
+                            return id;
+                        }
+                        // Resolve relative imports from virtual modules against the real file path
+                        if (importer && importer.startsWith('virtual:live-render:') && !isAbsolute(id)) {
+                            const realImporter = importer.replace('virtual:live-render:', '');
+                            return resolve(dirname(realImporter), id);
+                        }
+                    },
+                    transform(code, id) {
+                        if (id.startsWith(rootPath) || id.startsWith('virtual:live-render')) {
+                            const blocked = scanForBlockedImports(code);
+                            if (blocked) {
+                                const moduleName = getBlockedNodeModule(blocked);
+                                throw new Error(`Module "${blocked}" is not allowed in FluidCAD scripts. ` +
+                                    `Access to Node.js "${moduleName}" module is restricted for security.`);
+                            }
+                        }
+                    },
+                    load(id) {
+                        if (id.startsWith('virtual:live-render')) {
+                            let mod = this.getModuleInfo(id);
+                            if (mod) {
+                                that.server.moduleGraph.invalidateModule(that.server.moduleGraph.getModuleById(id));
+                            }
+                            return that.buffers.get(id) || '';
+                        }
+                        else if (that.buffers.has(`virtual:live-render:${id}`)) {
+                            return that.buffers.get(`virtual:live-render:${id}`);
+                        }
+                    }
+                }
+            ]
+        });
+    }
+    setBuffer(id, code) {
+        this.buffers.set(id, code);
+    }
+    async loadModule(filePath) {
+        return this.server.ssrLoadModule(filePath);
+    }
+    invalidateModule() {
+        for (const [id, mod] of this.server.moduleGraph.idToModuleMap) {
+            if (id.startsWith(this.rootPath) || id.startsWith('virtual:live-render')) {
+                this.server.moduleGraph.invalidateModule(mod);
+            }
+        }
+    }
+}

package/server/dist/ws-protocol.d.ts

@@ -0,0 +1,138 @@
+export type ProcessFileMessage = {
+    type: 'process-file';
+    filePath: string;
+};
+export type LiveUpdateMessage = {
+    type: 'live-update';
+    fileName: string;
+    code: string;
+};
+export type RollbackMessage = {
+    type: 'rollback';
+    fileName: string;
+    index: number;
+};
+export type ImportFileMessage = {
+    type: 'import-file';
+    workspacePath: string;
+    fileName: string;
+    data: string;
+};
+export type HighlightShapeMessage = {
+    type: 'highlight-shape';
+    shapeId: string;
+};
+export type ClearHighlightMessage = {
+    type: 'clear-highlight';
+};
+export type ShowShapePropertiesMessage = {
+    type: 'show-shape-properties';
+    shapeId: string;
+};
+export type ExportSceneMessage = {
+    type: 'export-scene';
+    shapeIds: string[];
+    options: {
+        format: 'step' | 'stl';
+        includeColors?: boolean;
+        resolution?: string;
+        customLinearDeflection?: number;
+        customAngularDeflectionDeg?: number;
+    };
+};
+export type ExtensionMessage = ProcessFileMessage | LiveUpdateMessage | RollbackMessage | ImportFileMessage | HighlightShapeMessage | ClearHighlightMessage | ShowShapePropertiesMessage | ExportSceneMessage;
+export type ReadyMessage = {
+    type: 'ready';
+    port: number;
+    url: string;
+};
+export type InitCompleteMessage = {
+    type: 'init-complete';
+    success: boolean;
+    error?: string;
+};
+export type SceneRenderedMessage = {
+    type: 'scene-rendered';
+    absPath: string;
+    result: any[];
+    rollbackStop: number;
+};
+export type ErrorMessage = {
+    type: 'error';
+    message: string;
+};
+export type ImportCompleteMessage = {
+    type: 'import-complete';
+    success: boolean;
+};
+export type InsertPointMessage = {
+    type: 'insert-point';
+    point: [number, number];
+    sourceLocation: {
+        line: number;
+        column: number;
+    };
+};
+export type RemovePointMessage = {
+    type: 'remove-point';
+    point: [number, number];
+    sourceLocation: {
+        line: number;
+        column: number;
+    };
+};
+export type SetPickPointsMessage = {
+    type: 'set-pick-points';
+    points: [number, number][];
+    sourceLocation: {
+        line: number;
+        column: number;
+    };
+};
+export type ExportCompleteMessage = {
+    type: 'export-complete';
+    success: boolean;
+    data?: string;
+    fileName?: string;
+    error?: string;
+};
+export type ServerToExtensionMessage = ReadyMessage | InitCompleteMessage | SceneRenderedMessage | ErrorMessage | ImportCompleteMessage | InsertPointMessage | RemovePointMessage | SetPickPointsMessage | ExportCompleteMessage;
+export type UISceneRenderedMessage = {
+    type: 'scene-rendered';
+    result: any[];
+    absPath: string;
+    rollbackStop?: number;
+};
+export type UIHighlightShapeMessage = {
+    type: 'highlight-shape';
+    shapeId: string;
+};
+export type UIClearHighlightMessage = {
+    type: 'clear-highlight';
+};
+export type UIShowShapePropertiesMessage = {
+    type: 'show-shape-properties';
+    shapeId: string;
+};
+export type UIInitCompleteMessage = {
+    type: 'init-complete';
+    success: boolean;
+    error?: string;
+};
+export type UIProcessingFileMessage = {
+    type: 'processing-file';
+};
+export type UITakeScreenshotMessage = {
+    type: 'take-screenshot';
+    requestId: string;
+    options: {
+        width?: number;
+        height?: number;
+        showGrid?: boolean;
+        showAxes?: boolean;
+        transparent?: boolean;
+        autoCrop?: boolean;
+        margin?: number;
+    };
+};
+export type ServerToUIMessage = UIInitCompleteMessage | UIProcessingFileMessage | UISceneRenderedMessage | UIHighlightShapeMessage | UIClearHighlightMessage | UIShowShapePropertiesMessage | UITakeScreenshotMessage;

package/server/dist/ws-protocol.js

@@ -0,0 +1,4 @@
+// ---------------------------------------------------------------------------
+// IPC: Extension → Server messages
+// ---------------------------------------------------------------------------
+export {};