fluidcad 0.0.32 → 0.0.34

package/mcp/dist/tools/screenshot.js

@@ -0,0 +1,263 @@
+// Screenshot tools — render the running FluidCAD scene as a PNG and return
+// MCP `image` content blocks. Views are stateless: the agent picks a vantage
+// (named view, orbit-from-current, or look-from) and the user's interactive
+// camera is never touched.
+import { resolveClient } from "./inspection.js";
+import { HttpError } from "../client.js";
+import { err, ok } from "../types.js";
+const NAMED_VIEWS = [
+    'front', 'back', 'left', 'right', 'top', 'bottom',
+    'iso-ftr', 'iso-fbr', 'iso-ftl', 'iso-fbl',
+    'iso-btr', 'iso-bbr', 'iso-btl', 'iso-bbl',
+];
+export async function screenshot(input) {
+    const validated = validateScreenshotInput(input);
+    if (validated.ok === false) {
+        return validated;
+    }
+    return runScreenshot(input, validated.data, /* multi */ false);
+}
+export async function screenshotMulti(input) {
+    const validated = validateScreenshotInput({ ...input, view: { kind: 'current' } });
+    if (validated.ok === false) {
+        return validated;
+    }
+    return runScreenshot(input, validated.data, /* multi */ true);
+}
+export async function screenshotShape(input) {
+    if (!input?.shapeId || typeof input.shapeId !== 'string') {
+        return err('invalid-input', '`shapeId` is required and must be a non-empty string.');
+    }
+    const margin = input.margin ?? 1.2;
+    if (typeof margin !== 'number' || !Number.isFinite(margin) || margin <= 0) {
+        return err('invalid-input', '`margin` must be a positive finite number when provided.');
+    }
+    const resolved = resolveClient(input);
+    if (resolved.ok === false) {
+        return resolved;
+    }
+    const { client } = resolved.data;
+    try {
+        // Fetch the shape's bounding box so we can build an iso framing.
+        const props = await client.getJson(`/api/shape-properties?shapeId=${encodeURIComponent(input.shapeId)}`);
+        const bbox = extractBoundingBox(props);
+        if (!bbox) {
+            return err('invalid-input', `Shape "${input.shapeId}" has no bounding box — cannot frame it.`, { properties: props });
+        }
+        const cx = (bbox.min[0] + bbox.max[0]) / 2;
+        const cy = (bbox.min[1] + bbox.max[1]) / 2;
+        const cz = (bbox.min[2] + bbox.max[2]) / 2;
+        const sx = bbox.max[0] - bbox.min[0];
+        const sy = bbox.max[1] - bbox.min[1];
+        const sz = bbox.max[2] - bbox.min[2];
+        const diameter = Math.sqrt(sx * sx + sy * sy + sz * sz);
+        const distance = Math.max(diameter * margin, 1);
+        // Iso-ftr direction: (1, -1, 1) / sqrt(3).
+        const k = distance / Math.sqrt(3);
+        const view = {
+            kind: 'look-from',
+            eye: [cx + k, cy - k, cz + k],
+            target: [cx, cy, cz],
+        };
+        const body = { view };
+        if (input.width !== undefined) {
+            body.width = input.width;
+        }
+        if (input.height !== undefined) {
+            body.height = input.height;
+        }
+        if (input.showGrid !== undefined) {
+            body.showGrid = input.showGrid;
+        }
+        if (input.showAxes !== undefined) {
+            body.showAxes = input.showAxes;
+        }
+        if (input.transparent !== undefined) {
+            body.transparent = input.transparent;
+        }
+        return await postScreenshot(client, body);
+    }
+    catch (e) {
+        return wrapError(e);
+    }
+    finally {
+        await client.close().catch(() => { });
+    }
+}
+export async function getCameraState(input) {
+    const resolved = resolveClient(input);
+    if (resolved.ok === false) {
+        return resolved;
+    }
+    const { client } = resolved.data;
+    try {
+        const data = await client.getJson('/api/camera/state');
+        return ok({
+            position: data.position,
+            target: data.target,
+            up: data.up,
+            projection: data.projection,
+        });
+    }
+    catch (e) {
+        return wrapError(e);
+    }
+    finally {
+        await client.close().catch(() => { });
+    }
+}
+function validateScreenshotInput(input) {
+    const opts = {};
+    if (input.width !== undefined) {
+        const w = input.width;
+        if (typeof w !== 'number' || !Number.isInteger(w) || w < 1 || w > 8192) {
+            return err('invalid-input', '`width` must be an integer between 1 and 8192.');
+        }
+        opts.width = w;
+    }
+    if (input.height !== undefined) {
+        const h = input.height;
+        if (typeof h !== 'number' || !Number.isInteger(h) || h < 1 || h > 8192) {
+            return err('invalid-input', '`height` must be an integer between 1 and 8192.');
+        }
+        opts.height = h;
+    }
+    for (const k of ['showGrid', 'showAxes', 'transparent', 'autoCrop', 'fitToModel']) {
+        const v = input[k];
+        if (v !== undefined) {
+            if (typeof v !== 'boolean') {
+                return err('invalid-input', `\`${k}\` must be a boolean when provided.`);
+            }
+            opts[k] = v;
+        }
+    }
+    if (input.margin !== undefined) {
+        const m = input.margin;
+        if (typeof m !== 'number' || !Number.isFinite(m) || m < 0) {
+            return err('invalid-input', '`margin` must be a non-negative finite number.');
+        }
+        opts.margin = m;
+    }
+    const view = input.view;
+    if (view !== undefined) {
+        const validatedView = validateView(view);
+        if (typeof validatedView === 'string') {
+            return err('invalid-input', validatedView);
+        }
+        opts.view = validatedView;
+    }
+    return ok(opts);
+}
+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.includes(v.name)) {
+                return `\`view.name\` must be one of: ${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)));
+}
+async function runScreenshot(input, opts, multi) {
+    const resolved = resolveClient(input);
+    if (resolved.ok === false) {
+        return resolved;
+    }
+    const { client } = resolved.data;
+    const body = { ...opts };
+    if (multi) {
+        body.multi = true;
+    }
+    try {
+        return await postScreenshot(client, body);
+    }
+    catch (e) {
+        return wrapError(e);
+    }
+    finally {
+        await client.close().catch(() => { });
+    }
+}
+async function postScreenshot(client, body) {
+    const res = await client.postRaw('/api/screenshot', body);
+    if (res.statusCode >= 400) {
+        const text = res.data.toString('utf8');
+        return err('http-error', `HTTP ${res.statusCode}: ${text.slice(0, 200)}`, {
+            statusCode: res.statusCode,
+        });
+    }
+    const mime = res.contentType.split(';')[0].trim() || 'image/png';
+    return ok({
+        image: {
+            mimeType: mime,
+            base64: res.data.toString('base64'),
+        },
+    });
+}
+function wrapError(e) {
+    if (e instanceof HttpError) {
+        return err('http-error', `HTTP ${e.statusCode}: ${e.body.slice(0, 200)}`, {
+            statusCode: e.statusCode,
+        });
+    }
+    return err('internal', e?.message ?? String(e));
+}
+function extractBoundingBox(props) {
+    if (!props || typeof props !== 'object') {
+        return null;
+    }
+    const bbox = props.boundingBox ?? props.bbox ?? null;
+    if (!bbox || typeof bbox !== 'object') {
+        return null;
+    }
+    const min = bbox.min;
+    const max = bbox.max;
+    const isTriple = (v) => Array.isArray(v) && v.length === 3 && v.every((n) => typeof n === 'number' && Number.isFinite(n));
+    if (isTriple(min) && isTriple(max)) {
+        return { min: min, max: max };
+    }
+    // Some payloads use `xMin/yMin/zMin` etc.
+    const fields = ['xMin', 'yMin', 'zMin', 'xMax', 'yMax', 'zMax'];
+    if (fields.every((f) => typeof bbox[f] === 'number')) {
+        return {
+            min: [bbox.xMin, bbox.yMin, bbox.zMin],
+            max: [bbox.xMax, bbox.yMax, bbox.zMax],
+        };
+    }
+    return null;
+}

package/mcp/dist/tools/source.d.ts

@@ -0,0 +1,84 @@
+import { type ToolResult } from '../types.ts';
+export type WorkspaceArg = {
+    workspace?: string;
+};
+/**
+ * Render outcome as reported by `POST /api/render`. Mirrored from
+ * `server/src/routes/render.ts` — kept hand-typed here so the MCP package
+ * doesn't take a build-time dep on the server package.
+ */
+export type RenderOutcome = {
+    state: 'rendered';
+    version: number;
+    absPath: string;
+    durationMs: number;
+} | {
+    state: 'compile-error';
+    version: number;
+    durationMs: number;
+    compileError: {
+        message: string;
+        filePath?: string;
+        sourceLocation?: {
+            filePath: string;
+            line: number;
+            column: number;
+        };
+    };
+} | {
+    state: 'superseded';
+    version: number;
+    durationMs: number;
+} | {
+    state: 'no-scene-manager';
+    version: number;
+    durationMs: number;
+} | {
+    state: 'render-failed';
+    error: string;
+};
+export type ReadFileInput = WorkspaceArg & {
+    path: string;
+};
+export type ReadFileOutput = {
+    path: string;
+    content: string;
+};
+export declare function readFile(input: ReadFileInput): Promise<ToolResult<ReadFileOutput>>;
+export type WriteFileInput = WorkspaceArg & {
+    path: string;
+    content: string;
+    force?: boolean;
+};
+export type WriteFileOutput = {
+    path: string;
+    bytesWritten: number;
+    render: RenderOutcome;
+};
+export declare function writeFile(input: WriteFileInput): Promise<ToolResult<WriteFileOutput>>;
+export type Position = {
+    line: number;
+    column: number;
+};
+export type EditRangeInput = WorkspaceArg & {
+    path: string;
+    start: Position;
+    end: Position;
+    newText: string;
+    force?: boolean;
+};
+export type EditRangeOutput = {
+    path: string;
+    bytesWritten: number;
+    replacedRange: {
+        start: Position;
+        end: Position;
+    };
+    render: RenderOutcome;
+};
+export declare function editRange(input: EditRangeInput): Promise<ToolResult<EditRangeOutput>>;
+export type ListFluidFilesInput = WorkspaceArg;
+export type ListFluidFilesOutput = {
+    files: string[];
+};
+export declare function listFluidFiles(input: ListFluidFilesInput): Promise<ToolResult<ListFluidFilesOutput>>;