auvrynt 1.0.2 → 1.0.5

package/dist/integrations/blender/blender-catalog.js

@@ -0,0 +1,165 @@
+import * as z from "zod/v4";
+import { readFile } from "node:fs/promises";
+import { relative } from "node:path";
+import { existsSync } from "node:fs";
+import { getBlenderClient } from "./blender-client.js";
+import { inlineImageOrNotice } from "../../tool-result-budget.js";
+import { registerAppTool as registerAppToolImpl } from "../../server/mcp-tool-registrar.js";
+import { MUTATING_ANNOTATIONS, READ_ONLY_ANNOTATIONS, WORKSPACE_ID_SCHEMA, toolWidgetDescriptorMeta, } from "../../server/tool-registration-shared.js";
+function textResponse(text) {
+    return { content: [{ type: "text", text }] };
+}
+function errorResponse(text) {
+    return { content: [{ type: "text", text }], isError: true };
+}
+export function catalogResponse(res) {
+    return textResponse(JSON.stringify(res, null, 2));
+}
+export function artifactTimestamp() {
+    return new Date().toISOString().replace(/[:.]/g, "-");
+}
+function makeContext(registry, workspaceId) {
+    const workspace = registry.getWorkspace(workspaceId);
+    return {
+        workspaceRoot: workspace.root,
+        resolveArtifactPath: (relPath) => registry.resolveArtifactPath(workspace, relPath, "blender"),
+        artifactTimestamp,
+    };
+}
+export function runCatalogTool(registry, workspaceId, tool, input) {
+    const exec = async () => {
+        try {
+            const ctx = makeContext(registry, workspaceId);
+            let code;
+            try {
+                code = tool.build(input, ctx);
+            }
+            catch (err) {
+                return errorResponse(`${tool.name} argument build failed: ${err.message}`);
+            }
+            const client = getBlenderClient(workspaceId);
+            const res = await client.sendExecute(code);
+            if (tool.image) {
+                const path = res?.path;
+                if (typeof path === "string" && existsSync(path)) {
+                    const buffer = await readFile(path);
+                    const relativePath = relative(ctx.workspaceRoot, path).replace(/\\/g, "/");
+                    return {
+                        content: [
+                            ...inlineImageOrNotice(buffer, `Blender render ${relativePath}`, "image/png"),
+                            {
+                                type: "text",
+                                text: `Rendered image saved to ${relativePath}`,
+                            },
+                        ],
+                    };
+                }
+                return catalogResponse(res);
+            }
+            return catalogResponse(res);
+        }
+        catch (err) {
+            return errorResponse(`${tool.name} failed: ${err.message}`);
+        }
+    };
+    return exec();
+}
+// ─── Small python builders shared by catalog tools ────────────────────────────
+/** Python prelude that resolves an object by name or raises. */
+export function objPrelude(name, varName = "obj") {
+    return (`import bpy\n` +
+        `${varName}_name = ${JSON.stringify(name)}\n` +
+        `${varName} = bpy.data.objects.get(${varName}_name)\n` +
+        `if ${varName} is None:\n` +
+        `    raise RuntimeError('Object not found: ' + ${varName}_name)\n`);
+}
+/** Python prelude that resolves an object (objectName param) and enters edit mode. */
+export function editModePrelude(objVar = "obj") {
+    return (`import bpy\n` +
+        `${objVar} = bpy.context.active_object\n` +
+        `if ${objVar} is None:\n` +
+        `    raise RuntimeError('No active object')\n` +
+        `if ${objVar}.type != 'MESH':\n` +
+        `    raise RuntimeError('Active object is not a mesh')\n` +
+        `bpy.context.view_layer.objects.active = ${objVar}\n` +
+        `${objVar}.select_set(True)\n` +
+        `if bpy.context.object.mode != 'EDIT':\n` +
+        `    bpy.ops.object.mode_set(mode='EDIT')\n`);
+}
+/** Python prelude that ensures a material exists by name. */
+export function materialPrelude(name, matVar = "mat") {
+    return (`import bpy\n` +
+        `${matVar} = bpy.data.materials.get(${JSON.stringify(name)})\n` +
+        `if ${matVar} is None:\n` +
+        `    raise RuntimeError('Material not found: ' + ${JSON.stringify(name)})\n`);
+}
+/** Python helper to build a color array from input (defaults to white). */
+export function colorExpr(input, key = "color", fallback = [1, 1, 1, 1]) {
+    const c = input[key];
+    if (Array.isArray(c) && c.length >= 3) {
+        const r = Number(c[0] ?? 1);
+        const g = Number(c[1] ?? 1);
+        const b = Number(c[2] ?? 1);
+        const a = Number(c[3] ?? 1);
+        return `[${r}, ${g}, ${b}, ${a}]`;
+    }
+    return JSON.stringify(fallback);
+}
+/** Python helper: numeric value clamped to a range. */
+export function clampExpr(input, key, min, max, fallback) {
+    let v = Number(input[key] ?? fallback);
+    if (!Number.isFinite(v))
+        v = fallback;
+    v = Math.max(min, Math.min(max, v));
+    return String(v);
+}
+// ─── Zod schema building and registration ────────────────────────────────────
+function paramSchema(p) {
+    let schema;
+    switch (p.type) {
+        case "string":
+            schema = z.string();
+            break;
+        case "number":
+            schema = z.number();
+            break;
+        case "boolean":
+            schema = z.boolean();
+            break;
+        case "stringArray":
+            schema = z.array(z.string());
+            break;
+        case "numberArray":
+            schema = z.array(z.number());
+            break;
+        case "record":
+            schema = z.record(z.string(), z.unknown());
+            break;
+        case "enum":
+            schema = z.enum((p.enumValues ?? []));
+            break;
+        default:
+            schema = z.unknown();
+    }
+    if (p.optional)
+        schema = schema.optional();
+    else if (p.default !== undefined)
+        schema = schema.default(p.default);
+    return schema;
+}
+export function registerCatalogTools(server, config, workspaces, tools) {
+    for (const tool of tools) {
+        const inputShape = { workspaceId: WORKSPACE_ID_SCHEMA };
+        for (const p of tool.params) {
+            inputShape[p.name] = paramSchema(p);
+        }
+        const annotations = tool.readOnly ? READ_ONLY_ANNOTATIONS : MUTATING_ANNOTATIONS;
+        registerAppToolImpl(server, tool.name, {
+            title: tool.title,
+            description: tool.description,
+            inputSchema: z.object(inputShape),
+            ...toolWidgetDescriptorMeta(config, tool.readOnly ? "read" : "write"),
+            annotations,
+        }, async (input) => runCatalogTool(workspaces, input.workspaceId, tool, input));
+    }
+}

package/dist/integrations/blender/blender-client.js

@@ -0,0 +1,105 @@
+import { createConnection } from "node:net";
+export class BlenderClient {
+    static MAX_RESPONSE_BYTES = 8 * 1024 * 1024;
+    static activeExecutionPromise = Promise.resolve();
+    host;
+    port;
+    timeoutMs;
+    longTaskTimeoutMs;
+    constructor(config = {}) {
+        this.host = config.host || "127.0.0.1";
+        this.port = config.port ?? Number(process.env.AUVRYNT_BLENDER_MCP_PORT ?? 9876);
+        this.timeoutMs = config.timeoutMs ?? 180000;
+        this.longTaskTimeoutMs = config.longTaskTimeoutMs ?? 7200000;
+        const normalizedHost = this.host.toLowerCase().replace(/^\[|\]$/g, "");
+        if (!["127.0.0.1", "localhost", "::1"].includes(normalizedHost)) {
+            throw new Error(`Forbidden host: ${this.host}. Only loopback connection is allowed for Blender MCP.`);
+        }
+        if (!Number.isInteger(this.port) || this.port < 1 || this.port > 65535) {
+            throw new Error(`Invalid Blender MCP port: ${this.port}`);
+        }
+        if (!Number.isFinite(this.timeoutMs) || this.timeoutMs < 1 || !Number.isFinite(this.longTaskTimeoutMs) || this.longTaskTimeoutMs < 1) {
+            throw new Error("Blender MCP timeouts must be positive numbers.");
+        }
+    }
+    async sendExecute(code, strictJson = true, isLongTask = false) {
+        const action = () => this.sendExecuteInternal(code, strictJson, isLongTask);
+        const execution = BlenderClient.activeExecutionPromise.then(action, action);
+        BlenderClient.activeExecutionPromise = execution.then(() => undefined, () => undefined);
+        return execution;
+    }
+    async sendExecuteInternal(code, strictJson, isLongTask) {
+        const timeout = isLongTask ? this.longTaskTimeoutMs : this.timeoutMs;
+        const request = { type: "execute", code, strict_json: strictJson };
+        const payload = Buffer.concat([Buffer.from(JSON.stringify(request), "utf8"), Buffer.from([0])]);
+        if (payload.length > 1024 * 1024)
+            throw new Error("Payload size limit exceeded (max 1 MB)");
+        return new Promise((resolve, reject) => {
+            let client = null;
+            let buffer = Buffer.alloc(0);
+            let timeoutId = null;
+            const cleanup = () => {
+                if (timeoutId) {
+                    clearTimeout(timeoutId);
+                    timeoutId = null;
+                }
+                if (client) {
+                    client.destroy();
+                    client = null;
+                }
+            };
+            try {
+                client = createConnection({ host: this.host, port: this.port }, () => client?.write(payload));
+                timeoutId = setTimeout(() => {
+                    cleanup();
+                    reject(new Error(`Blender connection timed out after ${timeout}ms`));
+                }, timeout);
+                client.on("data", (chunk) => {
+                    buffer = Buffer.concat([buffer, Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk)]);
+                    if (buffer.length > BlenderClient.MAX_RESPONSE_BYTES) {
+                        cleanup();
+                        reject(new Error("Blender response exceeded the 8 MB limit"));
+                        return;
+                    }
+                    const nullIndex = buffer.indexOf(0);
+                    if (nullIndex !== -1) {
+                        const raw = buffer.subarray(0, nullIndex).toString("utf8").trim();
+                        cleanup();
+                        try {
+                            const parsed = JSON.parse(raw);
+                            if (parsed.status === "ok")
+                                resolve(parsed.result || {});
+                            else
+                                reject(new Error(parsed.message || "Unknown Blender execution error"));
+                        }
+                        catch (error) {
+                            reject(new Error(`Failed to parse Blender JSON response: ${error instanceof Error ? error.message : String(error)}`));
+                        }
+                    }
+                });
+                client.on("error", (error) => {
+                    cleanup();
+                    reject(new Error(`Blender connection error: ${error.message}`));
+                });
+            }
+            catch (error) {
+                cleanup();
+                reject(error instanceof Error ? error : new Error(String(error)));
+            }
+        });
+    }
+}
+const activeBlenderClients = new Map();
+export function getBlenderClient(workspaceId, config) {
+    let client = activeBlenderClients.get(workspaceId);
+    if (!client) {
+        if (activeBlenderClients.size >= 32)
+            throw new Error("Blender client capacity reached (max 32 workspaces).");
+        client = new BlenderClient(config);
+        activeBlenderClients.set(workspaceId, client);
+    }
+    return client;
+}
+export function clearBlenderClients() {
+    activeBlenderClients.clear();
+}