fluidcad 0.0.32 → 0.0.34

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

@@ -1,16 +1,55 @@
+import type { CompileError } from './ws-protocol.ts';
 export type SceneRenderedData = {
     absPath: string;
     result: any[];
     rollbackStop: number;
     breakpointHit?: boolean;
 };
+export type SceneSummaryObject = {
+    index: number;
+    id: string;
+    kind: string;
+    uniqueKind: string;
+    name: string;
+    params: any;
+    sourceLocation?: {
+        filePath: string;
+        line: number;
+        column: number;
+    };
+    shapeIds: string[];
+    fromCache: boolean;
+    hasError: boolean;
+    errorMessage?: string;
+    containerId: string | null;
+    isContainer: boolean;
+    visible: boolean;
+};
+export type SceneSummary = {
+    schemaVersion: 1;
+    file: string;
+    objects: SceneSummaryObject[];
+    rollbackStop: number;
+    compileError: CompileError | null;
+};
+export type ShapeListEntry = {
+    shapeId: string;
+    type: string;
+    sceneObjectId: string;
+};
+export type ShapeList = {
+    shapes: ShapeListEntry[];
+};
 export declare class FluidCadServer {
     private viteManager;
     private sceneManager;
     private previousScenes;
     private renderingCache;
+    private lastRendered;
     private currentFileName;
     private currentFilePath;
+    private lastRollbackStop;
+    private compileError;
     init(workspacePath: string): Promise<void>;
     processFile(filePath: string, ignoreCache?: boolean): Promise<SceneRenderedData | null>;
     updateLiveCode(fileName: string, code: string): Promise<SceneRenderedData | null>;
@@ -32,4 +71,15 @@ export declare class FluidCadServer {
         fileName: string;
     } | null;
     hitTest(shapeId: string, rayOrigin: [number, number, number], rayDir: [number, number, number], edgeThreshold: number): any;
+    setCompileError(err: CompileError | null): void;
+    getCompileError(): CompileError | null;
+    getCurrentFileName(): string;
+    /**
+     * Test-only seam: stage a scene under the given file name so the inspection
+     * accessors can read it without running the vite pipeline. Production code
+     * never calls this — `processFile` populates the same map.
+     */
+    _setSceneForTesting(fileName: string, scene: any, rollbackStop?: number): void;
+    getSceneSummary(): SceneSummary | null;
+    getShapesList(): ShapeList | null;
 }

package/server/dist/fluidcad-server.js

@@ -1,3 +1,4 @@
+import { createHash } from 'crypto';
 import { join } from 'path';
 import { existsSync } from 'fs';
 import { ViteManager } from "./vite-manager.js";
@@ -8,8 +9,16 @@ export class FluidCadServer {
     sceneManager;
     previousScenes = new Map();
     renderingCache = new Map();
+    // Per-file hash + full result of the most recent successful render. Any
+    // incoming render request — IPC live-update from the extension, watcher-
+    // driven live-update under `fluidcad serve`, or HTTP /api/render from the
+    // MCP — short-circuits here when the new code hashes to the same value.
+    // Avoids redundant OCC work when multiple producers see the same write.
+    lastRendered = new Map();
     currentFileName = '';
     currentFilePath = '';
+    lastRollbackStop = -1;
+    compileError = null;
     async init(workspacePath) {
         await this.viteManager.init(workspacePath);
         const initFilePath = normalizePath(join(workspacePath, 'init.js'));
@@ -29,6 +38,8 @@ export class FluidCadServer {
         if (!ignoreCache) {
             const fromCache = this.renderingCache.get(normalizedFileName);
             if (fromCache) {
+                this.lastRollbackStop = fromCache.length - 1;
+                this.compileError = null;
                 return {
                     absPath: normalizedFileName,
                     result: fromCache,
@@ -67,6 +78,8 @@ export class FluidCadServer {
             if (!filePath.startsWith('virtual:live-render')) {
                 this.renderingCache.set(normalizedFileName, result);
             }
+            this.lastRollbackStop = result.length - 1;
+            this.compileError = null;
             return {
                 absPath: normalizedFileName,
                 result,
@@ -82,10 +95,27 @@ export class FluidCadServer {
     }
     async updateLiveCode(fileName, code) {
         fileName = normalizePath(fileName);
+        // Dedup against the last successful render of this file. Multiple
+        // producers (editor live-update, save-triggered process-file, watcher,
+        // MCP /api/render) commonly hand us identical content; without this
+        // short-circuit each one would trigger a redundant OCC pass.
+        const hash = hashCode(code);
+        const cached = this.lastRendered.get(fileName);
+        if (cached && cached.hash === hash) {
+            this.compileError = null;
+            this.currentFileName = fileName;
+            this.currentFilePath = `virtual:live-render:${fileName}`;
+            this.lastRollbackStop = cached.data.rollbackStop;
+            return cached.data;
+        }
         const id = `virtual:live-render:${fileName}`;
         this.viteManager.setBuffer(id, code);
         this.renderingCache.delete(fileName);
-        return this.processFile(id, true);
+        const result = await this.processFile(id, true);
+        if (result) {
+            this.lastRendered.set(fileName, { hash, data: result });
+        }
+        return result;
     }
     async rollbackFromUI(index) {
         return this.rollback(this.currentFileName, index);
@@ -96,6 +126,7 @@ export class FluidCadServer {
         }
         this.previousScenes.delete(this.currentFileName);
         this.renderingCache.delete(this.currentFileName);
+        this.lastRendered.delete(this.currentFileName);
         return this.processFile(this.currentFilePath, true);
     }
     async rollback(fileName, index) {
@@ -110,6 +141,7 @@ export class FluidCadServer {
         const rollbackIndex = index >= totalObjects - 1 ? totalObjects - 1 : index;
         this.sceneManager.rollbackScene(scene, rollbackIndex);
         const result = scene.getRenderedObjects();
+        this.lastRollbackStop = index;
         return {
             absPath: fileName,
             result,
@@ -173,4 +205,124 @@ export class FluidCadServer {
         }
         return this.sceneManager.hitTest(scene, shapeId, rayOrigin, rayDir, edgeThreshold);
     }
+    setCompileError(err) {
+        this.compileError = err;
+    }
+    getCompileError() {
+        return this.compileError;
+    }
+    getCurrentFileName() {
+        return this.currentFileName;
+    }
+    /**
+     * Test-only seam: stage a scene under the given file name so the inspection
+     * accessors can read it without running the vite pipeline. Production code
+     * never calls this — `processFile` populates the same map.
+     */
+    _setSceneForTesting(fileName, scene, rollbackStop = -1) {
+        this.currentFileName = fileName;
+        this.previousScenes.set(fileName, scene);
+        this.lastRollbackStop = rollbackStop;
+    }
+    getSceneSummary() {
+        if (!this.currentFileName) {
+            return null;
+        }
+        const scene = this.previousScenes.get(this.currentFileName);
+        if (!scene) {
+            return null;
+        }
+        const rendered = scene.getRenderedObjects();
+        const objects = rendered.map((r, index) => ({
+            index,
+            id: r.id,
+            kind: r.type,
+            uniqueKind: r.uniqueType,
+            name: r.name,
+            params: sanitizeParams(r.object),
+            sourceLocation: r.sourceLocation,
+            shapeIds: (r.sceneShapes ?? []).map((s) => s.shapeId),
+            fromCache: !!r.fromCache,
+            hasError: !!r.hasError,
+            errorMessage: r.errorMessage,
+            containerId: r.parentId ?? null,
+            isContainer: !!r.isContainer,
+            visible: r.visible !== false,
+        }));
+        return {
+            schemaVersion: 1,
+            file: this.currentFileName,
+            objects,
+            rollbackStop: this.lastRollbackStop,
+            compileError: this.compileError,
+        };
+    }
+    getShapesList() {
+        if (!this.currentFileName) {
+            return null;
+        }
+        const scene = this.previousScenes.get(this.currentFileName);
+        if (!scene) {
+            return null;
+        }
+        const rendered = scene.getRenderedObjects();
+        const shapes = [];
+        for (const r of rendered) {
+            const sceneShapes = (r.sceneShapes ?? []);
+            for (const s of sceneShapes) {
+                shapes.push({
+                    shapeId: s.shapeId,
+                    type: s.shapeType,
+                    sceneObjectId: r.id,
+                });
+            }
+        }
+        return { shapes };
+    }
+}
+/**
+ * Hash a `.fluid.js` source for dedup. Newlines are normalised to LF so a
+ * round-trip through an editor (CRLF) and a disk write (LF) hashes the
+ * same. SHA1 is plenty here — we just need a stable equality check, not
+ * collision resistance against an adversary.
+ */
+function hashCode(code) {
+    return createHash('sha1').update(code.replace(/\r\n/g, '\n')).digest('hex');
+}
+const MAX_PARAM_DEPTH = 6;
+function sanitizeParams(value, depth = 0) {
+    if (value === null || value === undefined) {
+        return value ?? null;
+    }
+    if (typeof value === 'number') {
+        return Number.isFinite(value) ? value : null;
+    }
+    if (typeof value === 'string' || typeof value === 'boolean') {
+        return value;
+    }
+    if (depth >= MAX_PARAM_DEPTH) {
+        return null;
+    }
+    if (Array.isArray(value)) {
+        return value.map((v) => sanitizeParams(v, depth + 1));
+    }
+    if (typeof value === 'object') {
+        // A scene-object reference. Render as { ref: id } so the agent can chase
+        // it through other tools without us shipping the whole subtree.
+        const maybeId = value.id;
+        const isSceneObjectRef = typeof maybeId === 'string' &&
+            typeof value.getType === 'function';
+        if (isSceneObjectRef) {
+            return { ref: maybeId };
+        }
+        const out = {};
+        for (const [k, v] of Object.entries(value)) {
+            if (typeof v === 'function') {
+                continue;
+            }
+            out[k] = sanitizeParams(v, depth + 1);
+        }
+        return out;
+    }
+    return null;
 }

package/server/dist/global-registry.d.ts

@@ -0,0 +1,30 @@
+export declare const REGISTRY_DIR_NAME = ".fluidcad";
+export declare const REGISTRY_FILE_NAME = "instances.json";
+export type RegistryEntry = {
+    workspacePath: string;
+    port: number;
+    pid: number;
+    version: string;
+    startedAt: string;
+};
+export declare function registryFilePath(): string;
+/**
+ * Add or replace an entry keyed by `workspacePath`. A new entry for an
+ * existing workspace (second window) supersedes the prior one.
+ */
+export declare function addInstance(entry: RegistryEntry): void;
+/**
+ * Remove the entry that matches both workspacePath and pid. Matching on pid
+ * prevents a clean shutdown from clobbering a freshly-restarted instance.
+ */
+export declare function removeInstance(workspacePath: string, pid: number): void;
+/**
+ * Read the registry, prune entries whose PIDs are no longer alive, and
+ * persist the pruned result. Returns the live entries.
+ *
+ * Liveness is `process.kill(pid, 0)` — sending signal 0 doesn't deliver
+ * anything but throws ESRCH if the process is gone. EPERM (running but owned
+ * by another user) counts as alive.
+ */
+export declare function readInstances(): RegistryEntry[];
+export declare function isPidAlive(pid: number): boolean;

package/server/dist/global-registry.js

@@ -0,0 +1,126 @@
+// Global instance registry at ~/.fluidcad/instances.json — lets a single MCP
+// process enumerate every running FluidCAD workspace on this machine.
+//
+// Read-modify-write is not crash-safe across multiple writers (we have no
+// file lock), but the worst case is a dropped registry entry that the next
+// successful write or stale-prune restores. Atomicity for the file itself is
+// via tmp + rename.
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+export const REGISTRY_DIR_NAME = '.fluidcad';
+export const REGISTRY_FILE_NAME = 'instances.json';
+const EMPTY = { schemaVersion: 1, instances: [] };
+function registryDir() {
+    return path.join(os.homedir(), REGISTRY_DIR_NAME);
+}
+export function registryFilePath() {
+    return path.join(registryDir(), REGISTRY_FILE_NAME);
+}
+function readRaw() {
+    try {
+        const raw = fs.readFileSync(registryFilePath(), 'utf8');
+        const parsed = JSON.parse(raw);
+        if (isRegistryFile(parsed)) {
+            return parsed;
+        }
+        return EMPTY;
+    }
+    catch {
+        return EMPTY;
+    }
+}
+function writeRaw(file) {
+    const dir = registryDir();
+    fs.mkdirSync(dir, { recursive: true });
+    const destination = registryFilePath();
+    const tmp = path.join(dir, `${REGISTRY_FILE_NAME}.${process.pid}.tmp`);
+    const payload = JSON.stringify(file, null, 2) + '\n';
+    fs.writeFileSync(tmp, payload, { encoding: 'utf8', mode: 0o644 });
+    fs.renameSync(tmp, destination);
+}
+/**
+ * Add or replace an entry keyed by `workspacePath`. A new entry for an
+ * existing workspace (second window) supersedes the prior one.
+ */
+export function addInstance(entry) {
+    const file = readRaw();
+    const filtered = file.instances.filter((e) => e.workspacePath !== entry.workspacePath);
+    filtered.push(entry);
+    writeRaw({ schemaVersion: 1, instances: filtered });
+}
+/**
+ * Remove the entry that matches both workspacePath and pid. Matching on pid
+ * prevents a clean shutdown from clobbering a freshly-restarted instance.
+ */
+export function removeInstance(workspacePath, pid) {
+    const file = readRaw();
+    const filtered = file.instances.filter((e) => !(e.workspacePath === workspacePath && e.pid === pid));
+    if (filtered.length === file.instances.length) {
+        return;
+    }
+    writeRaw({ schemaVersion: 1, instances: filtered });
+}
+/**
+ * Read the registry, prune entries whose PIDs are no longer alive, and
+ * persist the pruned result. Returns the live entries.
+ *
+ * Liveness is `process.kill(pid, 0)` — sending signal 0 doesn't deliver
+ * anything but throws ESRCH if the process is gone. EPERM (running but owned
+ * by another user) counts as alive.
+ */
+export function readInstances() {
+    const file = readRaw();
+    const alive = [];
+    const dead = [];
+    for (const entry of file.instances) {
+        if (isPidAlive(entry.pid)) {
+            alive.push(entry);
+        }
+        else {
+            dead.push(entry);
+        }
+    }
+    if (dead.length > 0) {
+        try {
+            writeRaw({ schemaVersion: 1, instances: alive });
+        }
+        catch {
+            // Pruning is best-effort; readers still get the live set.
+        }
+    }
+    return alive;
+}
+export function isPidAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (err) {
+        if (err && err.code === 'EPERM') {
+            return true;
+        }
+        return false;
+    }
+}
+function isRegistryFile(value) {
+    if (typeof value !== 'object' || value === null) {
+        return false;
+    }
+    const v = value;
+    if (v.schemaVersion !== 1 || !Array.isArray(v.instances)) {
+        return false;
+    }
+    return v.instances.every(isRegistryEntry);
+}
+function isRegistryEntry(value) {
+    if (typeof value !== 'object' || value === null) {
+        return false;
+    }
+    const v = value;
+    return (typeof v.workspacePath === 'string' &&
+        typeof v.port === 'number' &&
+        typeof v.pid === 'number' &&
+        typeof v.version === 'string' &&
+        typeof v.startedAt === 'string');
+}