fluidcad 0.0.2 → 0.0.4

package/server/dist/fluidcad-server.d.ts

@@ -1,32 +0,0 @@
-export type SceneRenderedData = {
-    absPath: string;
-    result: any[];
-    rollbackStop: number;
-};
-export declare class FluidCadServer {
-    private viteManager;
-    private sceneManager;
-    private previousScenes;
-    private renderingCache;
-    private currentFileName;
-    init(workspacePath: string): Promise<void>;
-    processFile(filePath: string, ignoreCache?: boolean): Promise<SceneRenderedData | null>;
-    updateLiveCode(fileName: string, code: string): Promise<SceneRenderedData | null>;
-    rollbackFromUI(index: number): Promise<SceneRenderedData | null>;
-    rollback(fileName: string, index: number): Promise<SceneRenderedData | null>;
-    importFile(workspacePath: string, fileName: string, data: string): Promise<void>;
-    getShapeProperties(shapeId: string): any;
-    getFaceProperties(shapeId: string, faceIndex: number): any;
-    getEdgeProperties(shapeId: string, edgeIndex: number): any;
-    exportShapes(shapeIds: string[], options: {
-        format: 'step' | 'stl';
-        includeColors?: boolean;
-        resolution?: string;
-        customLinearDeflection?: number;
-        customAngularDeflectionDeg?: number;
-    }): {
-        data: string | Uint8Array;
-        fileName: string;
-    } | null;
-    hitTest(shapeId: string, rayOrigin: [number, number, number], rayDir: [number, number, number], edgeThreshold: number): any;
-}

package/server/dist/fluidcad-server.js

@@ -1,150 +0,0 @@
-import { join } from 'path';
-import { existsSync } from 'fs';
-import { ViteManager } from "./vite-manager.js";
-export class FluidCadServer {
-    viteManager = new ViteManager();
-    sceneManager;
-    previousScenes = new Map();
-    renderingCache = new Map();
-    currentFileName = '';
-    async init(workspacePath) {
-        await this.viteManager.init(workspacePath);
-        const initFilePath = join(workspacePath, 'init.js');
-        if (existsSync(initFilePath)) {
-            const { default: _sceneManager } = await this.viteManager.loadModule(initFilePath);
-            this.sceneManager = await _sceneManager;
-        }
-    }
-    async processFile(filePath, ignoreCache = false) {
-        if (!this.sceneManager) {
-            return null;
-        }
-        const normalizedFileName = filePath.replace('virtual:live-render:', '');
-        this.currentFileName = normalizedFileName;
-        if (!ignoreCache) {
-            const fromCache = this.renderingCache.get(normalizedFileName);
-            if (fromCache) {
-                return {
-                    absPath: normalizedFileName,
-                    result: fromCache,
-                    rollbackStop: fromCache.length - 1,
-                };
-            }
-        }
-        try {
-            let scene = this.sceneManager.startScene();
-            this.sceneManager.setCurrentFile(normalizedFileName);
-            this.viteManager.invalidateModule();
-            await this.viteManager.loadModule(filePath);
-            if (this.previousScenes.has(normalizedFileName)) {
-                const previousScene = this.previousScenes.get(normalizedFileName);
-                scene = this.sceneManager.compare(previousScene, scene);
-            }
-            this.previousScenes.set(normalizedFileName, scene);
-            this.sceneManager.renderScene(scene);
-            const result = scene.getRenderedObjects();
-            for (const obj of result) {
-                if (obj.sourceLocation) {
-                    obj.sourceLocation.filePath = obj.sourceLocation.filePath.replace('virtual:live-render:', '');
-                }
-            }
-            if (!filePath.startsWith('virtual:live-render')) {
-                this.renderingCache.set(normalizedFileName, result);
-            }
-            return {
-                absPath: normalizedFileName,
-                result,
-                rollbackStop: result.length - 1,
-            };
-        }
-        catch (error) {
-            this.viteManager.invalidateModule();
-            console.log('Error processing file:', error);
-            return null;
-        }
-    }
-    async updateLiveCode(fileName, code) {
-        const id = `virtual:live-render:${fileName}`;
-        this.viteManager.setBuffer(id, code);
-        this.renderingCache.delete(fileName);
-        return this.processFile(id, true);
-    }
-    async rollbackFromUI(index) {
-        return this.rollback(this.currentFileName, index);
-    }
-    async rollback(fileName, index) {
-        if (!this.sceneManager) {
-            return null;
-        }
-        const scene = this.previousScenes.get(fileName);
-        if (!scene) {
-            return null;
-        }
-        const totalObjects = scene.getAllSceneObjects().length;
-        const rollbackIndex = index >= totalObjects - 1 ? totalObjects - 1 : index;
-        this.sceneManager.rollbackScene(scene, rollbackIndex);
-        const result = scene.getRenderedObjects();
-        return {
-            absPath: fileName,
-            result,
-            rollbackStop: index,
-        };
-    }
-    async importFile(workspacePath, fileName, data) {
-        if (!this.sceneManager) {
-            throw new Error('SceneManager not initialized');
-        }
-        const binaryData = Buffer.from(data, 'base64');
-        await this.sceneManager.importFile(workspacePath, fileName, binaryData);
-    }
-    getShapeProperties(shapeId) {
-        if (!this.sceneManager) {
-            return null;
-        }
-        const scene = this.previousScenes.get(this.currentFileName);
-        if (!scene) {
-            return null;
-        }
-        return this.sceneManager.getShapeProperties(scene, shapeId);
-    }
-    getFaceProperties(shapeId, faceIndex) {
-        if (!this.sceneManager) {
-            return null;
-        }
-        const scene = this.previousScenes.get(this.currentFileName);
-        if (!scene) {
-            return null;
-        }
-        return this.sceneManager.getFaceProperties(scene, shapeId, faceIndex);
-    }
-    getEdgeProperties(shapeId, edgeIndex) {
-        if (!this.sceneManager) {
-            return null;
-        }
-        const scene = this.previousScenes.get(this.currentFileName);
-        if (!scene) {
-            return null;
-        }
-        return this.sceneManager.getEdgeProperties(scene, shapeId, edgeIndex);
-    }
-    exportShapes(shapeIds, options) {
-        if (!this.sceneManager) {
-            return null;
-        }
-        const scene = this.previousScenes.get(this.currentFileName);
-        if (!scene) {
-            return null;
-        }
-        return this.sceneManager.exportShapes(scene, shapeIds, options);
-    }
-    hitTest(shapeId, rayOrigin, rayDir, edgeThreshold) {
-        if (!this.sceneManager) {
-            return null;
-        }
-        const scene = this.previousScenes.get(this.currentFileName);
-        if (!scene) {
-            return null;
-        }
-        return this.sceneManager.hitTest(scene, shapeId, rayOrigin, rayDir, edgeThreshold);
-    }
-}

package/server/dist/index.d.ts

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

package/server/dist/index.js

@@ -1,290 +0,0 @@
-import crypto from 'crypto';
-import http from 'http';
-import path from 'path';
-import express from 'express';
-import { WebSocketServer, WebSocket } from 'ws';
-import { FluidCadServer } from "./fluidcad-server.js";
-import { createPropertiesRouter } from "./routes/properties.js";
-import { createActionsRouter } from "./routes/actions.js";
-import { createExportRouter } from "./routes/export.js";
-import { createScreenshotRouter } from "./routes/screenshot.js";
-const PORT = parseInt(process.env.FLUIDCAD_SERVER_PORT || '3100', 10);
-const WORKSPACE_PATH = process.env.FLUIDCAD_WORKSPACE_PATH || '';
-const UI_DIST = path.resolve(import.meta.dirname, '../../ui/dist');
-// ---------------------------------------------------------------------------
-// IPC helpers — communication with extension host process
-// ---------------------------------------------------------------------------
-function sendToExtension(msg) {
-    if (process.send) {
-        process.send(msg);
-    }
-}
-// ---------------------------------------------------------------------------
-// Express app
-// ---------------------------------------------------------------------------
-const fluidCadServer = new FluidCadServer();
-const app = express();
-app.use(express.json({ limit: '50mb' }));
-app.use('/api', createPropertiesRouter(fluidCadServer));
-app.use('/api', createActionsRouter(fluidCadServer, sendToExtension, broadcastToUI, WORKSPACE_PATH));
-app.use('/api', createExportRouter(fluidCadServer));
-app.use('/api', createScreenshotRouter(requestScreenshot));
-// Static files — serve UI build, with SPA fallback
-app.use(express.static(UI_DIST, {
-    setHeaders(res, filePath) {
-        if (path.extname(filePath) === '.html') {
-            res.setHeader('Cache-Control', 'no-cache');
-        }
-    },
-}));
-app.get('*splat', (_req, res) => {
-    res.setHeader('Cache-Control', 'no-cache');
-    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;
-async function handleExtensionMessage(msg) {
-    try {
-        switch (msg.type) {
-            case 'process-file': {
-                const myVersion = ++renderVersion;
-                broadcastToUI({ type: 'processing-file' });
-                currentFile = msg.filePath;
-                const data = await fluidCadServer.processFile(msg.filePath);
-                if (myVersion !== renderVersion) {
-                    return;
-                }
-                if (data) {
-                    sendToExtension({
-                        type: 'scene-rendered',
-                        absPath: data.absPath,
-                        result: data.result,
-                        rollbackStop: data.rollbackStop,
-                    });
-                    broadcastToUI({
-                        type: 'scene-rendered',
-                        result: data.result,
-                        absPath: data.absPath,
-                    });
-                }
-                break;
-            }
-            case 'live-update': {
-                const myVersion = ++renderVersion;
-                if (msg.fileName !== currentFile) {
-                    broadcastToUI({ type: 'processing-file' });
-                    currentFile = msg.fileName;
-                }
-                const data = await fluidCadServer.updateLiveCode(msg.fileName, msg.code);
-                if (myVersion !== renderVersion) {
-                    return;
-                }
-                if (data) {
-                    sendToExtension({
-                        type: 'scene-rendered',
-                        absPath: data.absPath,
-                        result: data.result,
-                        rollbackStop: data.rollbackStop,
-                    });
-                    broadcastToUI({
-                        type: 'scene-rendered',
-                        result: data.result,
-                        absPath: data.absPath,
-                    });
-                }
-                break;
-            }
-            case 'rollback': {
-                const myVersion = ++renderVersion;
-                const data = await fluidCadServer.rollback(msg.fileName, msg.index);
-                if (myVersion !== renderVersion) {
-                    return;
-                }
-                if (data) {
-                    sendToExtension({
-                        type: 'scene-rendered',
-                        absPath: data.absPath,
-                        result: data.result,
-                        rollbackStop: data.rollbackStop,
-                    });
-                    broadcastToUI({
-                        type: 'scene-rendered',
-                        result: data.result,
-                        absPath: data.absPath,
-                        rollbackStop: data.rollbackStop,
-                    });
-                }
-                break;
-            }
-            case 'import-file': {
-                try {
-                    await fluidCadServer.importFile(msg.workspacePath, msg.fileName, msg.data);
-                    sendToExtension({ type: 'import-complete', success: true });
-                }
-                catch (err) {
-                    sendToExtension({ type: 'error', message: err.stack || err.message || String(err) });
-                }
-                break;
-            }
-            case 'highlight-shape': {
-                broadcastToUI({ type: 'highlight-shape', shapeId: msg.shapeId });
-                break;
-            }
-            case 'clear-highlight': {
-                broadcastToUI({ type: 'clear-highlight' });
-                break;
-            }
-            case 'show-shape-properties': {
-                broadcastToUI({ type: 'show-shape-properties', shapeId: msg.shapeId });
-                break;
-            }
-            case 'export-scene': {
-                try {
-                    const result = fluidCadServer.exportShapes(msg.shapeIds, msg.options);
-                    if (result) {
-                        const data = typeof result.data === 'string'
-                            ? Buffer.from(result.data, 'utf-8').toString('base64')
-                            : Buffer.from(result.data).toString('base64');
-                        sendToExtension({
-                            type: 'export-complete',
-                            success: true,
-                            data,
-                            fileName: result.fileName,
-                        });
-                    }
-                    else {
-                        sendToExtension({ type: 'export-complete', success: false, error: 'No active scene to export.' });
-                    }
-                }
-                catch (err) {
-                    sendToExtension({ type: 'export-complete', success: false, error: err.message || String(err) });
-                }
-                break;
-            }
-        }
-    }
-    catch (err) {
-        sendToExtension({
-            type: 'error',
-            message: err.stack || err.message || String(err),
-        });
-    }
-}
-// Listen for IPC messages from extension host
-process.on('message', (msg) => {
-    handleExtensionMessage(msg);
-});
-// ---------------------------------------------------------------------------
-// Start
-// ---------------------------------------------------------------------------
-httpServer.listen(PORT, () => {
-    const url = `http://localhost:${PORT}`;
-    console.log(`FluidCAD server listening on ${url}`);
-    // Signal ready immediately so extension can show the webview
-    sendToExtension({ type: 'ready', port: PORT, url });
-    // Initialize FluidCAD server in the background
-    fluidCadServer.init(WORKSPACE_PATH).then(() => {
-        sendToExtension({ type: 'init-complete', success: true });
-        broadcastToUI({ type: 'init-complete', success: true });
-    }).catch((err) => {
-        const error = err.stack || err.message || String(err);
-        sendToExtension({ type: 'init-complete', success: false, error });
-        broadcastToUI({ type: 'init-complete', success: false, error });
-    });
-});

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

@@ -1,3 +0,0 @@
-import { Router } from 'express';
-import type { FluidCadServer } from '../fluidcad-server.ts';
-export declare function createActionsRouter(fluidCadServer: FluidCadServer, sendToExtension: (msg: any) => void, broadcastToUI: (msg: any) => void, workspacePath: string): Router;

package/server/dist/routes/actions.js

@@ -1,100 +0,0 @@
-import { Router } from 'express';
-export function createActionsRouter(fluidCadServer, sendToExtension, broadcastToUI, workspacePath) {
-    const router = Router();
-    router.post('/hit-test', (req, res) => {
-        const { shapeId, rayOrigin, rayDir, edgeThreshold } = req.body;
-        if (typeof shapeId !== 'string' ||
-            !Array.isArray(rayOrigin) || rayOrigin.length !== 3 ||
-            !Array.isArray(rayDir) || rayDir.length !== 3 ||
-            typeof edgeThreshold !== 'number') {
-            res.status(400).json({ error: 'Invalid request body' });
-            return;
-        }
-        const result = fluidCadServer.hitTest(shapeId, rayOrigin, rayDir, edgeThreshold);
-        res.json(result);
-    });
-    router.post('/insert-point', (req, res) => {
-        const { point, sourceLocation } = req.body;
-        if (!Array.isArray(point) || point.length !== 2 ||
-            !sourceLocation || typeof sourceLocation.line !== 'number' || typeof sourceLocation.column !== 'number') {
-            res.status(400).json({ error: 'Invalid request body' });
-            return;
-        }
-        sendToExtension({
-            type: 'insert-point',
-            point: point,
-            sourceLocation,
-        });
-        res.json({ success: true });
-    });
-    router.post('/remove-point', (req, res) => {
-        const { point, sourceLocation } = req.body;
-        if (!Array.isArray(point) || point.length !== 2 ||
-            !sourceLocation || typeof sourceLocation.line !== 'number' || typeof sourceLocation.column !== 'number') {
-            res.status(400).json({ error: 'Invalid request body' });
-            return;
-        }
-        sendToExtension({
-            type: 'remove-point',
-            point: point,
-            sourceLocation,
-        });
-        res.json({ success: true });
-    });
-    router.post('/rollback', async (req, res) => {
-        const { index } = req.body;
-        if (typeof index !== 'number' || index < 0) {
-            res.status(400).json({ error: 'Invalid index' });
-            return;
-        }
-        const data = await fluidCadServer.rollbackFromUI(index);
-        if (!data) {
-            res.status(404).json({ error: 'No active scene' });
-            return;
-        }
-        sendToExtension({
-            type: 'scene-rendered',
-            absPath: data.absPath,
-            result: data.result,
-            rollbackStop: data.rollbackStop,
-        });
-        broadcastToUI({
-            type: 'scene-rendered',
-            result: data.result,
-            absPath: data.absPath,
-            rollbackStop: data.rollbackStop,
-        });
-        res.json({ success: true });
-    });
-    router.post('/set-pick-points', (req, res) => {
-        const { points, sourceLocation } = req.body;
-        if (!Array.isArray(points) ||
-            !sourceLocation || typeof sourceLocation.line !== 'number' || typeof sourceLocation.column !== 'number') {
-            res.status(400).json({ error: 'Invalid request body' });
-            return;
-        }
-        sendToExtension({
-            type: 'set-pick-points',
-            points: points,
-            sourceLocation,
-        });
-        res.json({ success: true });
-    });
-    router.post('/import-file', async (req, res) => {
-        const { fileName, data } = req.body;
-        if (typeof fileName !== 'string' || typeof data !== 'string') {
-            res.status(400).json({ error: 'Invalid request body' });
-            return;
-        }
-        try {
-            await fluidCadServer.importFile(workspacePath, fileName, data);
-        }
-        catch (err) {
-            res.status(500).json({ error: err.message || String(err) });
-            return;
-        }
-        const loadName = fileName.replace(/\.(step|stp)$/i, '');
-        res.json({ success: true, fileName: loadName });
-    });
-    return router;
-}

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

@@ -1,3 +0,0 @@
-import { Router } from 'express';
-import type { FluidCadServer } from '../fluidcad-server.ts';
-export declare function createExportRouter(fluidCadServer: FluidCadServer): Router;

package/server/dist/routes/export.js

@@ -1,55 +0,0 @@
-import { Router } from 'express';
-export function createExportRouter(fluidCadServer) {
-    const router = Router();
-    router.post('/export', (req, res) => {
-        const { format, shapeIds, includeColors, resolution, customAngularDeflectionDeg, customLinearDeflection } = req.body;
-        if (format !== 'step' && format !== 'stl') {
-            res.status(400).json({ error: 'Invalid format. Must be "step" or "stl".' });
-            return;
-        }
-        if (!Array.isArray(shapeIds) || shapeIds.length === 0) {
-            res.status(400).json({ error: 'shapeIds must be a non-empty array.' });
-            return;
-        }
-        if (format === 'stl') {
-            const validResolutions = ['coarse', 'medium', 'fine', 'custom'];
-            if (resolution && !validResolutions.includes(resolution)) {
-                res.status(400).json({ error: 'Invalid resolution.' });
-                return;
-            }
-            if (resolution === 'custom') {
-                if (typeof customLinearDeflection !== 'number' || typeof customAngularDeflectionDeg !== 'number') {
-                    res.status(400).json({ error: 'Custom resolution requires customLinearDeflection and customAngularDeflectionDeg.' });
-                    return;
-                }
-            }
-        }
-        try {
-            const result = fluidCadServer.exportShapes(shapeIds, {
-                format,
-                includeColors,
-                resolution: resolution || 'medium',
-                customLinearDeflection,
-                customAngularDeflectionDeg,
-            });
-            if (!result) {
-                res.status(404).json({ error: 'No active scene to export.' });
-                return;
-            }
-            const ext = format === 'step' ? '.step' : '.stl';
-            const mimeType = format === 'step' ? 'application/step' : 'application/sla';
-            res.setHeader('Content-Type', mimeType);
-            res.setHeader('Content-Disposition', `attachment; filename="export${ext}"`);
-            if (typeof result.data === 'string') {
-                res.send(Buffer.from(result.data, 'utf-8'));
-            }
-            else {
-                res.send(Buffer.from(result.data));
-            }
-        }
-        catch (err) {
-            res.status(500).json({ error: err.message || String(err) });
-        }
-    });
-    return router;
-}

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

@@ -1,3 +0,0 @@
-import { Router } from 'express';
-import type { FluidCadServer } from '../fluidcad-server.ts';
-export declare function createPropertiesRouter(fluidCadServer: FluidCadServer): Router;