fluidcad 0.0.32 → 0.0.34

package/server/dist/index.js

@@ -1,4 +1,5 @@
 import crypto from 'crypto';
+import fs from 'fs';
 import http from 'http';
 import path from 'path';
 import express from 'express';
@@ -9,11 +10,34 @@ import { createActionsRouter } from "./routes/actions.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 { 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 +50,23 @@ function sendToExtension(msg) {
 // Express app
 // ---------------------------------------------------------------------------
 const fluidCadServer = new FluidCadServer();
+const dirtyBufferState = new DirtyBufferState();
 const app = express();
 app.use(express.json({ limit: '50mb' }));
+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', createExportRouter(fluidCadServer, WORKSPACE_PATH));
 app.use('/api', createScreenshotRouter(requestScreenshot));
 app.use('/api', createPreferencesRouter());
+app.use('/api', createSceneRouter(fluidCadServer, () => lastCameraState));
+app.use('/api', createEditorRouter(dirtyBufferState));
+app.use('/api', createRenderRouter((fileName, code) => runLiveRender(fileName, code)));
+app.use('/api', createLintRouter());
 // Static files — serve UI build, with SPA fallback
 app.use(express.static(UI_DIST, {
     setHeaders(res, filePath) {
@@ -53,6 +87,7 @@ const wss = new WebSocketServer({ server: httpServer });
 const uiClients = new Set();
 let lastSceneMessage = null;
 let initCompleteMessage = null;
+let lastCameraState = null;
 function broadcastToUI(msg) {
     const data = JSON.stringify(msg);
     if (msg.type === 'scene-rendered') {
@@ -117,6 +152,21 @@ function handleUIMessage(raw) {
         else {
             pending.reject(new Error(msg.error || 'Screenshot failed.'));
         }
+        return;
+    }
+    if (msg.type === 'camera-state') {
+        // Trust UI structure — we own both ends. Just shape-check arrays.
+        if (Array.isArray(msg.position) && msg.position.length === 3 &&
+            Array.isArray(msg.target) && msg.target.length === 3 &&
+            Array.isArray(msg.up) && msg.up.length === 3) {
+            lastCameraState = {
+                type: 'camera-state',
+                position: msg.position,
+                target: msg.target,
+                up: msg.up,
+                projection: msg.projection === 'perspective' ? 'perspective' : 'orthographic',
+            };
+        }
     }
 }
 // ---------------------------------------------------------------------------
@@ -144,8 +194,9 @@ wss.on('connection', (ws) => {
 let currentFile = null;
 let renderVersion = 0;
 const lastSceneByFile = new Map();
-function emitSuccess(absPath, result, rollbackStop, breakpointHit) {
+function emitSuccess(version, absPath, result, rollbackStop, breakpointHit) {
     lastSceneByFile.set(absPath, { result, rollbackStop });
+    fluidCadServer.setCompileError(null);
     sendToExtension({
         type: 'scene-rendered',
         absPath,
@@ -159,6 +210,7 @@ function emitSuccess(absPath, result, rollbackStop, breakpointHit) {
         rollbackStop,
         breakpointHit,
     });
+    broadcastToUI({ type: 'render-version', version, state: 'end', absPath });
 }
 function buildCompileError(filePath, err) {
     const message = err?.message || String(err);
@@ -178,12 +230,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 +251,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);
+        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 +312,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);
                     }
                 }
                 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 +361,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 +410,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 +452,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>;