fluidcad 0.0.33 → 0.0.35

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

@@ -0,0 +1,24 @@
+import { Router } from 'express';
+export type DirtyFileEntry = {
+    /** Absolute, normalized path of the dirty file. */
+    path: string;
+    /** Editor-observed mtime when the file was last seen on disk, or 0 if unknown. */
+    lastModifiedMs: number;
+};
+/**
+ * Holds the set of files the editor currently considers dirty (unsaved
+ * changes). The MCP source-editing tools query this before writing so a
+ * remote agent never silently clobbers a user's in-flight changes.
+ *
+ * The set is volatile by design — it gets replaced wholesale on every
+ * `editor-dirty-state` IPC and resets when the server restarts. Editors
+ * resend their state on startup.
+ */
+export declare class DirtyBufferState {
+    private files;
+    setDirtyFiles(paths: string[]): void;
+    list(): DirtyFileEntry[];
+    isDirty(absPath: string): boolean;
+    private readMtime;
+}
+export declare function createEditorRouter(state: DirtyBufferState): Router;

package/server/dist/routes/editor.js

@@ -0,0 +1,44 @@
+import fs from 'fs';
+import { Router } from 'express';
+import { normalizePath } from "../normalize-path.js";
+/**
+ * Holds the set of files the editor currently considers dirty (unsaved
+ * changes). The MCP source-editing tools query this before writing so a
+ * remote agent never silently clobbers a user's in-flight changes.
+ *
+ * The set is volatile by design — it gets replaced wholesale on every
+ * `editor-dirty-state` IPC and resets when the server restarts. Editors
+ * resend their state on startup.
+ */
+export class DirtyBufferState {
+    files = new Map();
+    setDirtyFiles(paths) {
+        const next = new Map();
+        for (const p of paths) {
+            const normalized = normalizePath(p);
+            next.set(normalized, this.readMtime(normalized));
+        }
+        this.files = next;
+    }
+    list() {
+        return Array.from(this.files, ([path, lastModifiedMs]) => ({ path, lastModifiedMs }));
+    }
+    isDirty(absPath) {
+        return this.files.has(normalizePath(absPath));
+    }
+    readMtime(absPath) {
+        try {
+            return fs.statSync(absPath).mtimeMs;
+        }
+        catch {
+            return 0;
+        }
+    }
+}
+export function createEditorRouter(state) {
+    const router = Router();
+    router.get('/editor/dirty-files', (_req, res) => {
+        res.json(state.list());
+    });
+    return router;
+}

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

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

package/server/dist/routes/export.js

@@ -1,8 +1,20 @@
+import fs from 'fs';
+import path from 'path';
 import { Router } from 'express';
-export function createExportRouter(fluidCadServer) {
+export function createExportRouter(fluidCadServer, workspacePath) {
     const router = Router();
+    // Resolve the workspace root once so symlink checks below match the path
+    // we actually allow writes into.
+    const workspaceRoot = (() => {
+        try {
+            return fs.realpathSync(workspacePath);
+        }
+        catch {
+            return path.resolve(workspacePath);
+        }
+    })();
     router.post('/export', (req, res) => {
-        const { format, shapeIds, includeColors, resolution, customAngularDeflectionDeg, customLinearDeflection } = req.body;
+        const { format, shapeIds, includeColors, resolution, customAngularDeflectionDeg, customLinearDeflection, saveAsPath } = req.body;
         if (format !== 'step' && format !== 'stl') {
             res.status(400).json({ error: 'Invalid format. Must be "step" or "stl".' });
             return;
@@ -24,6 +36,10 @@ export function createExportRouter(fluidCadServer) {
                 }
             }
         }
+        if (saveAsPath !== undefined && typeof saveAsPath !== 'string') {
+            res.status(400).json({ error: 'saveAsPath must be a string.' });
+            return;
+        }
         try {
             const result = fluidCadServer.exportShapes(shapeIds, {
                 format,
@@ -38,14 +54,35 @@ export function createExportRouter(fluidCadServer) {
             }
             const ext = format === 'step' ? '.step' : '.stl';
             const mimeType = format === 'step' ? 'application/step' : 'application/sla';
+            const bytes = typeof result.data === 'string'
+                ? Buffer.from(result.data, 'utf-8')
+                : Buffer.from(result.data);
+            if (saveAsPath) {
+                // Resolve against the workspace root, then verify the canonical path
+                // (after symlink resolution of the parent) still lives inside it.
+                const candidate = path.resolve(workspaceRoot, saveAsPath);
+                const parent = path.dirname(candidate);
+                let parentReal;
+                try {
+                    parentReal = fs.realpathSync(parent);
+                }
+                catch {
+                    res.status(400).json({ error: `Parent directory does not exist: ${parent}` });
+                    return;
+                }
+                const canonical = path.join(parentReal, path.basename(candidate));
+                const rel = path.relative(workspaceRoot, canonical);
+                if (rel.startsWith('..') || path.isAbsolute(rel)) {
+                    res.status(400).json({ error: `saveAsPath escapes workspace root: ${saveAsPath}` });
+                    return;
+                }
+                fs.writeFileSync(canonical, bytes);
+                res.json({ savedTo: canonical, bytesWritten: bytes.length });
+                return;
+            }
             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));
-            }
+            res.send(bytes);
         }
         catch (err) {
             res.status(500).json({ error: err.message || String(err) });

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

@@ -0,0 +1,7 @@
+import { Router } from 'express';
+export type HealthInfo = {
+    version: string;
+    workspacePath: string;
+    startedAt: string;
+};
+export declare function createHealthRouter(info: HealthInfo): Router;

package/server/dist/routes/health.js

@@ -0,0 +1,14 @@
+import { Router } from 'express';
+export function createHealthRouter(info) {
+    const router = Router();
+    router.get('/health', (_req, res) => {
+        res.json({
+            ok: true,
+            version: info.version,
+            workspacePath: info.workspacePath,
+            startedAt: info.startedAt,
+            pid: process.pid,
+        });
+    });
+    return router;
+}

package/server/dist/routes/hit-test.d.ts

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

package/server/dist/routes/hit-test.js

@@ -0,0 +1,17 @@
+import { Router } from 'express';
+export function createHitTestRouter(fluidCadServer) {
+    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);
+    });
+    return router;
+}

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

@@ -0,0 +1,10 @@
+import { Router } from 'express';
+/**
+ * `POST /api/lint-fluid-js` — static import lint for a `.fluid.js` payload.
+ * Used by the MCP server before it writes a file so the agent learns to add
+ * imports on retry instead of failing at runtime with `ReferenceError`.
+ *
+ * Request body: `{ code: string }`
+ * Response:     `{ missing: MissingImport[], suggestion: string }`
+ */
+export declare function createLintRouter(): Router;

package/server/dist/routes/lint.js

@@ -0,0 +1,28 @@
+import { Router } from 'express';
+import { lintFluidJs } from "../lint-fluid-js.js";
+/**
+ * `POST /api/lint-fluid-js` — static import lint for a `.fluid.js` payload.
+ * Used by the MCP server before it writes a file so the agent learns to add
+ * imports on retry instead of failing at runtime with `ReferenceError`.
+ *
+ * Request body: `{ code: string }`
+ * Response:     `{ missing: MissingImport[], suggestion: string }`
+ */
+export function createLintRouter() {
+    const router = Router();
+    router.post('/lint-fluid-js', async (req, res) => {
+        const { code } = req.body ?? {};
+        if (typeof code !== 'string') {
+            res.status(400).json({ error: '`code` must be a string.' });
+            return;
+        }
+        try {
+            const result = await lintFluidJs(code);
+            res.json(result);
+        }
+        catch (err) {
+            res.status(500).json({ error: err?.message ?? String(err) });
+        }
+    });
+    return router;
+}

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

@@ -0,0 +1,10 @@
+import { Router } from 'express';
+import type { FluidCadServer } from '../fluidcad-server.ts';
+import type { CameraStateMessage } from '../ws-protocol.ts';
+/**
+ * `POST /api/pack` — produce a `.fluidpkg` (zip) archive of the currently
+ * rendered file. Pulls live param overrides and the last-known camera state
+ * from the running server so the archive matches what the user is seeing.
+ * Returns the binary archive directly (application/zip).
+ */
+export declare function createPackRouter(fluidCadServer: FluidCadServer, workspacePath: string, fluidcadVersion: string, getLastCameraState: () => CameraStateMessage | null): Router;

package/server/dist/routes/pack.js

@@ -0,0 +1,47 @@
+import { Router } from 'express';
+import { packModel } from "../model-package/pack.js";
+/**
+ * `POST /api/pack` — produce a `.fluidpkg` (zip) archive of the currently
+ * rendered file. Pulls live param overrides and the last-known camera state
+ * from the running server so the archive matches what the user is seeing.
+ * Returns the binary archive directly (application/zip).
+ */
+export function createPackRouter(fluidCadServer, workspacePath, fluidcadVersion, getLastCameraState) {
+    const router = Router();
+    router.post('/pack', async (req, res) => {
+        const currentFile = fluidCadServer.getCurrentFileName();
+        if (!currentFile) {
+            res.status(404).json({ error: 'No active scene to pack' });
+            return;
+        }
+        const { name, description } = (req.body ?? {});
+        const cameraMsg = getLastCameraState();
+        const camera = cameraMsg
+            ? {
+                position: cameraMsg.position,
+                target: cameraMsg.target,
+                up: cameraMsg.up,
+                projection: cameraMsg.projection,
+            }
+            : undefined;
+        try {
+            const result = await packModel({
+                entryPath: currentFile,
+                workspacePath,
+                fluidcadVersion,
+                name,
+                description,
+                paramOverrides: fluidCadServer.getParamOverrides(currentFile),
+                camera,
+            });
+            res.setHeader('Content-Type', 'application/zip');
+            res.setHeader('X-FluidCAD-Package-Name', result.manifest.name);
+            res.setHeader('Content-Disposition', `attachment; filename="${encodeURIComponent(result.manifest.name)}.fluidpkg"`);
+            res.send(result.zip);
+        }
+        catch (err) {
+            res.status(500).json({ error: err?.message ?? String(err) });
+        }
+    });
+    return router;
+}

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

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

package/server/dist/routes/params.js

@@ -0,0 +1,75 @@
+import { Router } from 'express';
+export function createParamsRouter(fluidCadServer, sendToExtension, broadcastToUI) {
+    const router = Router();
+    router.post('/recompute', async (_req, res) => {
+        const data = await fluidCadServer.recomputeCurrentFile();
+        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,
+            breakpointHit: data.breakpointHit,
+            params: data.params,
+        });
+        res.json({ success: true });
+    });
+    router.post('/set-param', async (req, res) => {
+        const { label, value } = req.body;
+        if (typeof label !== 'string') {
+            res.status(400).json({ error: 'Invalid label' });
+            return;
+        }
+        fluidCadServer.setParam(fluidCadServer.getCurrentFileName(), label, value);
+        const data = await fluidCadServer.recomputeCurrentFile();
+        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,
+            params: data.params,
+        });
+        res.json({ success: true });
+    });
+    router.post('/reset-params', async (_req, res) => {
+        fluidCadServer.resetParams(fluidCadServer.getCurrentFileName());
+        const data = await fluidCadServer.recomputeCurrentFile();
+        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,
+            params: data.params,
+        });
+        res.json({ success: true });
+    });
+    return router;
+}

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

@@ -0,0 +1,33 @@
+import { Router } from 'express';
+import type { CompileError } from '../ws-protocol.ts';
+export type RenderOutcome = {
+    state: 'rendered';
+    version: number;
+    absPath: string;
+    durationMs: number;
+} | {
+    state: 'compile-error';
+    version: number;
+    durationMs: number;
+    compileError: CompileError;
+} | {
+    state: 'superseded';
+    version: number;
+    durationMs: number;
+} | {
+    state: 'no-scene-manager';
+    version: number;
+    durationMs: number;
+};
+/**
+ * `POST /api/render` — synchronous render trigger used by the MCP server
+ * after it writes a `.fluid.js` file. The body carries the post-write
+ * contents so the server doesn't need to re-read disk and so dedup against
+ * `lastRendered` is exact. Returns the render outcome (rendered / compile-
+ * error / superseded / no-scene-manager) once the OCC pass settles.
+ *
+ * Whoever invokes this is responsible for the on-disk write — we only run
+ * the render. Pairing both in one HTTP round-trip is what lets MCP
+ * `write_file` return a synchronous { written, render } to the agent.
+ */
+export declare function createRenderRouter(runLiveRender: (fileName: string, code: string) => Promise<RenderOutcome>): Router;

package/server/dist/routes/render.js

@@ -0,0 +1,34 @@
+import { Router } from 'express';
+/**
+ * `POST /api/render` — synchronous render trigger used by the MCP server
+ * after it writes a `.fluid.js` file. The body carries the post-write
+ * contents so the server doesn't need to re-read disk and so dedup against
+ * `lastRendered` is exact. Returns the render outcome (rendered / compile-
+ * error / superseded / no-scene-manager) once the OCC pass settles.
+ *
+ * Whoever invokes this is responsible for the on-disk write — we only run
+ * the render. Pairing both in one HTTP round-trip is what lets MCP
+ * `write_file` return a synchronous { written, render } to the agent.
+ */
+export function createRenderRouter(runLiveRender) {
+    const router = Router();
+    router.post('/render', async (req, res) => {
+        const { filePath, code } = req.body ?? {};
+        if (typeof filePath !== 'string' || filePath.length === 0) {
+            res.status(400).json({ error: '`filePath` must be a non-empty string.' });
+            return;
+        }
+        if (typeof code !== 'string') {
+            res.status(400).json({ error: '`code` must be a string.' });
+            return;
+        }
+        try {
+            const outcome = await runLiveRender(filePath, code);
+            res.json(outcome);
+        }
+        catch (err) {
+            res.status(500).json({ error: err?.message ?? String(err) });
+        }
+    });
+    return router;
+}

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

@@ -0,0 +1,5 @@
+import { Router } from 'express';
+import type { FluidCadServer } from '../fluidcad-server.ts';
+import type { CameraStateMessage } from '../ws-protocol.ts';
+export type CameraStateGetter = () => CameraStateMessage | null;
+export declare function createSceneRouter(fluidCadServer: FluidCadServer, getCameraState?: CameraStateGetter): Router;

package/server/dist/routes/scene.js

@@ -0,0 +1,48 @@
+import { Router } from 'express';
+export function createSceneRouter(fluidCadServer, getCameraState = () => null) {
+    const router = Router();
+    router.get('/scene/summary', (_req, res) => {
+        try {
+            const summary = fluidCadServer.getSceneSummary();
+            if (!summary) {
+                res.status(404).json({ error: 'No scene available — the workspace has not rendered a file yet.' });
+                return;
+            }
+            res.json(summary);
+        }
+        catch (err) {
+            res.status(500).json({ error: err?.message ?? String(err) });
+        }
+    });
+    router.get('/scene/shapes', (_req, res) => {
+        try {
+            const shapes = fluidCadServer.getShapesList();
+            if (!shapes) {
+                res.status(404).json({ error: 'No scene available — the workspace has not rendered a file yet.' });
+                return;
+            }
+            res.json(shapes);
+        }
+        catch (err) {
+            res.status(500).json({ error: err?.message ?? String(err) });
+        }
+    });
+    router.get('/scene/compile-error', (_req, res) => {
+        try {
+            const compileError = fluidCadServer.getCompileError();
+            res.json({ compileError });
+        }
+        catch (err) {
+            res.status(500).json({ error: err?.message ?? String(err) });
+        }
+    });
+    router.get('/camera/state', (_req, res) => {
+        const state = getCameraState();
+        if (!state) {
+            res.status(404).json({ error: 'No camera state available yet — the UI has not connected, or no view change has been observed.' });
+            return;
+        }
+        res.json(state);
+    });
+    return router;
+}

package/server/dist/routes/screenshot.js

@@ -1,8 +1,13 @@
 import { Router } from 'express';
+const NAMED_VIEWS = new Set([
+    'front', 'back', 'left', 'right', 'top', 'bottom',
+    'iso-ftr', 'iso-fbr', 'iso-ftl', 'iso-fbl',
+    'iso-btr', 'iso-bbr', 'iso-btl', 'iso-bbl',
+]);
 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 { width, height, showGrid, showAxes, transparent, autoCrop, fitToModel, margin, view, multi, } = req.body;
         const options = {};
         if (width !== undefined) {
             if (typeof width !== 'number' || width < 1 || width > 8192) {
@@ -60,6 +65,21 @@ export function createScreenshotRouter(requestScreenshot) {
             }
             options.margin = margin;
         }
+        if (multi !== undefined) {
+            if (typeof multi !== 'boolean') {
+                res.status(400).json({ error: 'multi must be a boolean.' });
+                return;
+            }
+            options.multi = multi;
+        }
+        if (view !== undefined) {
+            const validated = validateView(view);
+            if (typeof validated === 'string') {
+                res.status(400).json({ error: validated });
+                return;
+            }
+            options.view = validated;
+        }
         try {
             const png = await requestScreenshot(options);
             res.setHeader('Content-Type', 'image/png');
@@ -74,3 +94,50 @@ export function createScreenshotRouter(requestScreenshot) {
     });
     return router;
 }
+/** Validate the `view` payload. Returns the parsed view on success or an
+ *  error-message string on failure. */
+function validateView(raw) {
+    if (raw === null || typeof raw !== 'object') {
+        return 'view must be an object.';
+    }
+    const v = raw;
+    switch (v.kind) {
+        case 'current':
+            return { kind: 'current' };
+        case 'named': {
+            if (typeof v.name !== 'string' || !NAMED_VIEWS.has(v.name)) {
+                return `view.name must be one of: ${Array.from(NAMED_VIEWS).join(', ')}.`;
+            }
+            return { kind: 'named', name: v.name };
+        }
+        case 'orbit-from-current': {
+            if (typeof v.azimuthDeg !== 'number' || !Number.isFinite(v.azimuthDeg)) {
+                return 'view.azimuthDeg must be a finite number.';
+            }
+            if (typeof v.elevationDeg !== 'number' || !Number.isFinite(v.elevationDeg)) {
+                return 'view.elevationDeg must be a finite number.';
+            }
+            return { kind: 'orbit-from-current', azimuthDeg: v.azimuthDeg, elevationDeg: v.elevationDeg };
+        }
+        case 'look-from': {
+            if (!isVec3(v.eye)) {
+                return 'view.eye must be a 3-element array of finite numbers.';
+            }
+            if (v.target !== undefined && !isVec3(v.target)) {
+                return 'view.target must be a 3-element array of finite numbers when provided.';
+            }
+            return {
+                kind: 'look-from',
+                eye: v.eye,
+                target: v.target,
+            };
+        }
+        default:
+            return `view.kind must be one of: current, named, orbit-from-current, look-from.`;
+    }
+}
+function isVec3(value) {
+    return (Array.isArray(value) &&
+        value.length === 3 &&
+        value.every((n) => typeof n === 'number' && Number.isFinite(n)));
+}

package/server/dist/routes/sketch-edits.d.ts

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