drawio-mcp-server 1.7.0 → 2.0.3

package/build/real-environment/layers-and-selection.test.js

@@ -0,0 +1,70 @@
+import { afterAll, beforeAll, describe, expect, it } from "@jest/globals";
+import { createRealEnvironmentContext, disposeRealEnvironmentContext, getCellById, resetDiagram, selectCell, } from "./harness.js";
+import { expectNoBrowserErrors, expectNoServerErrors, withVerificationScreenshot, } from "./assertions.js";
+import { callToolJson } from "./tools.js";
+import { expectToolSuccess, unwrapToolPayload } from "./test-helpers.js";
+describe("real environment/layers and selection", () => {
+    let context;
+    beforeAll(async () => {
+        context = await createRealEnvironmentContext();
+    }, 180000);
+    afterAll(async () => {
+        await disposeRealEnvironmentContext(context);
+    });
+    it("covers layer creation, activation, move-to-layer, selected cell, and paged model", async () => {
+        await resetDiagram(context);
+        context.browserMessages.length = 0;
+        const logCountBefore = context.logger.entries.length;
+        const { payload: rectangle } = await callToolJson(context, "add-rectangle", {
+            x: 120,
+            y: 110,
+            width: 150,
+            height: 90,
+            text: "Layered rectangle",
+        });
+        expectToolSuccess(rectangle);
+        const { payload: createdLayer } = await callToolJson(context, "create-layer", {
+            name: "Verification Layer",
+        });
+        expectToolSuccess(createdLayer);
+        const { payload: layersPayload } = await callToolJson(context, "list-layers", {});
+        const layers = unwrapToolPayload(layersPayload);
+        expect(Array.isArray(layers)).toBe(true);
+        expect(layers.some((layer) => layer.id === createdLayer.result.id)).toBe(true);
+        await callToolJson(context, "set-active-layer", {
+            layer_id: createdLayer.result.id,
+        });
+        const { payload: activeLayerPayload } = await callToolJson(context, "get-active-layer", {});
+        const activeLayer = unwrapToolPayload(activeLayerPayload);
+        expect(activeLayer?.id).toBe(createdLayer.result.id);
+        await callToolJson(context, "move-cell-to-layer", {
+            cell_id: rectangle.result.id,
+            target_layer_id: createdLayer.result.id,
+        });
+        await selectCell(context.page, rectangle.result.id);
+        const { payload: selectedCellPayload } = await callToolJson(context, "get-selected-cell", {});
+        const selectedCell = unwrapToolPayload(selectedCellPayload);
+        expect(String(selectedCell?.id ?? "")).toBe(rectangle.result.id);
+        const { payload: pagedModelPayload } = await callToolJson(context, "list-paged-model", {
+            page: 0,
+            page_size: 20,
+            filter: {
+                ids: [rectangle.result.id],
+            },
+        });
+        const pagedModel = unwrapToolPayload(pagedModelPayload);
+        const pagedCells = Array.isArray(pagedModel?.cells)
+            ? pagedModel.cells
+            : Array.isArray(pagedModel)
+                ? pagedModel
+                : [];
+        expect(pagedCells.some((cell) => cell.id === rectangle.result.id)).toBe(true);
+        await withVerificationScreenshot(context, "layers-and-selection", "before-live-state-verification", async () => {
+            const rectangleCell = await getCellById(context.page, rectangle.result.id);
+            expect(rectangleCell).not.toBeNull();
+            expect(rectangleCell?.parentId).toBe(createdLayer.result.id);
+        });
+        await expectNoBrowserErrors(context, "layers-and-selection");
+        await expectNoServerErrors(context, "layers-and-selection", logCountBefore);
+    }, 180000);
+});

package/build/real-environment/logger.js

@@ -0,0 +1,25 @@
+export class MemoryLogger {
+    entries = [];
+    log(level, message, ...data) {
+        this.entries.push({
+            level,
+            message: String(message ?? ""),
+            data,
+        });
+    }
+    debug(message, ...data) {
+        this.entries.push({
+            level: "debug",
+            message: String(message ?? ""),
+            data,
+        });
+    }
+    errors() {
+        return this.entries.filter((entry) => {
+            if (entry.level.toLowerCase() === "error") {
+                return true;
+            }
+            return entry.data.some((value) => value instanceof Error);
+        });
+    }
+}

package/build/real-environment/screenshot.js

@@ -0,0 +1,46 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+const ARTIFACTS_ROOT = join(process.cwd(), ".artifacts", "real-environment");
+function normalizeSegment(value) {
+    return value.replace(/[^a-zA-Z0-9-_]+/g, "-").replace(/-+/g, "-");
+}
+async function captureDiagramXml(page, xmlPath) {
+    const xml = await page.evaluate(() => {
+        const maybeWindow = window;
+        const editor = maybeWindow.ui?.editor;
+        if (!editor) {
+            return "";
+        }
+        if (typeof editor.getGraphXml === "function") {
+            const xmlNode = editor.getGraphXml();
+            const xmlText = window.mxUtils?.getXml?.(xmlNode);
+            return typeof xmlText === "string" ? xmlText : "";
+        }
+        const graph = editor.graph;
+        const encoder = new window.mxCodec();
+        const node = encoder.encode(graph.getModel());
+        return window.mxUtils?.getXml?.(node) ?? "";
+    });
+    await writeFile(xmlPath, xml, "utf-8");
+}
+export async function captureVerificationArtifact(artifactRunDir, page, testName, stepName) {
+    await mkdir(artifactRunDir, { recursive: true });
+    const fileName = `${normalizeSegment(testName)}-${normalizeSegment(stepName)}-${Date.now()}.png`;
+    const filePath = join(artifactRunDir, fileName);
+    const xmlPath = filePath.replace(/\.png$/, ".xml");
+    await page.screenshot({
+        path: filePath,
+        fullPage: true,
+    });
+    await captureDiagramXml(page, xmlPath);
+    return {
+        screenshotPath: filePath,
+        xmlPath,
+    };
+}
+export async function createArtifactRunDir() {
+    await mkdir(ARTIFACTS_ROOT, { recursive: true });
+    const runDir = join(ARTIFACTS_ROOT, `run-${Date.now()}`);
+    await mkdir(runDir, { recursive: true });
+    return runDir;
+}

package/build/real-environment/set-cell-parent.test.js

@@ -0,0 +1,64 @@
+import { afterAll, beforeAll, describe, expect, it } from "@jest/globals";
+import { createRealEnvironmentContext, disposeRealEnvironmentContext, getCells, resetDiagram, } from "./harness.js";
+import { expectNoBrowserErrors, expectNoServerErrors, withVerificationScreenshot, } from "./assertions.js";
+import { callToolJson } from "./tools.js";
+describe("real environment/set-cell-parent", () => {
+    let context;
+    beforeAll(async () => {
+        context = await createRealEnvironmentContext();
+    }, 180000);
+    afterAll(async () => {
+        await disposeRealEnvironmentContext(context);
+    });
+    it("reparents a child cell through MCP and verifies the live diagram state", async () => {
+        await resetDiagram(context);
+        context.browserMessages.length = 0;
+        const logCountBefore = context.logger.entries.length;
+        const { payload: parentPayload } = await callToolJson(context, "add-cell-of-shape", {
+            shape_name: "rectangle",
+            text: "Parent",
+            x: 320,
+            y: 160,
+            width: 220,
+            height: 140,
+        });
+        const { payload: childPayload } = await callToolJson(context, "add-cell-of-shape", {
+            shape_name: "rectangle",
+            text: "Child",
+            x: 120,
+            y: 80,
+            width: 100,
+            height: 60,
+        });
+        expect(parentPayload.success).toBe(true);
+        expect(childPayload.success).toBe(true);
+        const beforeCells = await getCells(context.page);
+        const childBefore = beforeCells.find((cell) => cell.id === childPayload.result.id);
+        expect(childBefore).toBeDefined();
+        expect(childBefore?.parentId).not.toBe(parentPayload.result.id);
+        const { payload } = await callToolJson(context, "set-cell-parent", {
+            cell_id: childPayload.result.id,
+            parent_id: parentPayload.result.id,
+        });
+        expect(payload.success).toBe(true);
+        expect(payload.result.cell_id).toBe(childPayload.result.id);
+        expect(payload.result.parent_id).toBe(parentPayload.result.id);
+        await context.page.waitForFunction(({ childId, parentId }) => {
+            const ui = window.ui;
+            const graph = ui?.editor?.graph;
+            const child = graph?.getModel?.().getCell?.(childId);
+            return child?.parent?.id === parentId;
+        }, {
+            childId: childPayload.result.id,
+            parentId: parentPayload.result.id,
+        });
+        await withVerificationScreenshot(context, "set-cell-parent", "before-live-state-verification", async () => {
+            const afterCells = await getCells(context.page);
+            const childAfter = afterCells.find((cell) => cell.id === childPayload.result.id);
+            expect(childAfter).toBeDefined();
+            expect(childAfter?.parentId).toBe(parentPayload.result.id);
+        });
+        await expectNoBrowserErrors(context, "set-cell-parent");
+        await expectNoServerErrors(context, "set-cell-parent", logCountBefore);
+    }, 180000);
+});

package/build/real-environment/shapes.test.js

@@ -0,0 +1,153 @@
+import { afterAll, beforeAll, describe, expect, it } from "@jest/globals";
+import { createRealEnvironmentContext, disposeRealEnvironmentContext, getCellById, resetDiagram, } from "./harness.js";
+import { expectNoBrowserErrors, expectNoServerErrors, withVerificationScreenshot, } from "./assertions.js";
+import { callToolJson } from "./tools.js";
+import { expectToolSuccess, unwrapToolPayload } from "./test-helpers.js";
+describe("real environment/shapes", () => {
+    let context;
+    beforeAll(async () => {
+        context = await createRealEnvironmentContext();
+    }, 180000);
+    afterAll(async () => {
+        await disposeRealEnvironmentContext(context);
+    });
+    it("covers shape discovery, rectangle creation, shape assignment, and cell data", async () => {
+        await resetDiagram(context);
+        context.browserMessages.length = 0;
+        const logCountBefore = context.logger.entries.length;
+        const { payload: shapeCategoriesPayload } = await callToolJson(context, "get-shape-categories", {});
+        const shapeCategories = unwrapToolPayload(shapeCategoriesPayload);
+        expect(shapeCategories).toBeDefined();
+        const { payload: shapesInCategoryPayload } = await callToolJson(context, "get-shapes-in-category", {
+            category_id: "General",
+        });
+        const shapesInCategory = unwrapToolPayload(shapesInCategoryPayload);
+        expect(shapesInCategory).toBeDefined();
+        const chosenShapeName = "rectangle";
+        const { payload: shapeByNamePayload } = await callToolJson(context, "get-shape-by-name", {
+            shape_name: chosenShapeName,
+        });
+        const shapeByName = unwrapToolPayload(shapeByNamePayload);
+        expect(shapeByName).toBeDefined();
+        const { payload: rectangle } = await callToolJson(context, "add-rectangle", {
+            x: 120,
+            y: 110,
+            width: 150,
+            height: 90,
+            text: "Rectangle tool",
+        });
+        expectToolSuccess(rectangle);
+        await callToolJson(context, "set-cell-shape", {
+            cell_id: rectangle.result.id,
+            shape_name: chosenShapeName,
+        });
+        await callToolJson(context, "set-cell-data", {
+            cell_id: rectangle.result.id,
+            key: "status",
+            value: "verified",
+        });
+        await withVerificationScreenshot(context, "shapes", "before-live-state-verification", async () => {
+            const rectangleCell = await getCellById(context.page, rectangle.result.id);
+            expect(rectangleCell).not.toBeNull();
+            expect(rectangleCell?.style.length).toBeGreaterThan(0);
+            expect(rectangleCell?.attributes.status).toBe("verified");
+        });
+        await expectNoBrowserErrors(context, "shapes");
+        await expectNoServerErrors(context, "shapes", logCountBefore);
+    }, 180000);
+    it("creates an AWS Lambda shaped cell with the expected AWS style", async () => {
+        await resetDiagram(context);
+        context.browserMessages.length = 0;
+        const logCountBefore = context.logger.entries.length;
+        const shapeName = "mxgraph.aws4.lambda";
+        const { payload: shapeByNamePayload } = await callToolJson(context, "get-shape-by-name", {
+            shape_name: shapeName,
+        });
+        const shapeByName = unwrapToolPayload(shapeByNamePayload);
+        expect(shapeByName).toBeDefined();
+        expect(String(shapeByName?.style ?? "")).toContain("shape=mxgraph.aws4.resourceIcon");
+        expect(String(shapeByName?.style ?? "")).toContain("resIcon=mxgraph.aws4.lambda");
+        expect(String(shapeByName?.style ?? "")).toContain("fillColor=#ED7100");
+        const { payload } = await callToolJson(context, "add-cell-of-shape", {
+            shape_name: shapeName,
+            text: "Lambda",
+            x: 180,
+            y: 140,
+            width: 120,
+            height: 120,
+        });
+        expectToolSuccess(payload);
+        await withVerificationScreenshot(context, "shapes-aws-lambda", "before-live-state-verification", async () => {
+            const liveCellState = await context.page.evaluate((cellId) => {
+                const maybeWindow = window;
+                const graph = maybeWindow.ui?.editor?.graph;
+                const cell = graph?.getModel?.().getCell?.(cellId);
+                return {
+                    cellStyle: cell?.style ?? null,
+                    stateStyle: graph?.view?.getState?.(cell)?.style ?? null,
+                };
+            }, payload.result.id);
+            const exportedXml = await context.page.evaluate(() => {
+                const maybeWindow = window;
+                const editor = maybeWindow.ui?.editor;
+                const xmlNode = editor?.getGraphXml?.();
+                return window.mxUtils?.getXml?.(xmlNode) ?? "";
+            });
+            const lambdaCell = await getCellById(context.page, payload.result.id);
+            expect(lambdaCell).not.toBeNull();
+            expect(String(liveCellState.cellStyle ?? "")).toContain("mxgraph.aws4.lambda");
+            expect(exportedXml).toContain(`id="${payload.result.id}"`);
+            expect(exportedXml).toContain("mxgraph.aws4.lambda");
+            const exportedLambda = await callToolJson(context, "list-paged-model", {
+                page: 0,
+                page_size: 20,
+                filter: {
+                    ids: [payload.result.id],
+                },
+            });
+            const lambdaEntry = unwrapToolPayload(exportedLambda.payload);
+            const lambdaCells = Array.isArray(lambdaEntry?.cells)
+                ? lambdaEntry.cells
+                : Array.isArray(lambdaEntry)
+                    ? lambdaEntry
+                    : [];
+            const lambdaCellFromTool = lambdaCells.find((cell) => cell.id === payload.result.id);
+            expect(lambdaCellFromTool).toBeDefined();
+            expect(exportedXml).toContain("mxgraph.aws4.lambda");
+        });
+        await expectNoBrowserErrors(context, "shapes-aws-lambda");
+        await expectNoServerErrors(context, "shapes-aws-lambda", logCountBefore);
+    }, 180000);
+    it("applies AWS Lambda style through set-cell-shape and preserves it in the live diagram", async () => {
+        await resetDiagram(context);
+        context.browserMessages.length = 0;
+        const logCountBefore = context.logger.entries.length;
+        const shapeName = "mxgraph.aws4.lambda";
+        const { payload: rectangle } = await callToolJson(context, "add-rectangle", {
+            x: 220,
+            y: 180,
+            width: 120,
+            height: 120,
+            text: "Lambda by shape",
+        });
+        expectToolSuccess(rectangle);
+        await callToolJson(context, "set-cell-shape", {
+            cell_id: rectangle.result.id,
+            shape_name: shapeName,
+        });
+        await withVerificationScreenshot(context, "shapes-aws-lambda-set-cell-shape", "before-live-state-verification", async () => {
+            const exportedXml = await context.page.evaluate(() => {
+                const maybeWindow = window;
+                const editor = maybeWindow.ui?.editor;
+                const xmlNode = editor?.getGraphXml?.();
+                return window.mxUtils?.getXml?.(xmlNode) ?? "";
+            });
+            const lambdaCell = await getCellById(context.page, rectangle.result.id);
+            expect(lambdaCell).not.toBeNull();
+            expect(exportedXml).toContain(`id="${rectangle.result.id}"`);
+            expect(exportedXml).toContain("mxgraph.aws4.lambda");
+        });
+        await expectNoBrowserErrors(context, "shapes-aws-lambda-set-cell-shape");
+        await expectNoServerErrors(context, "shapes-aws-lambda-set-cell-shape", logCountBefore);
+    }, 180000);
+});

package/build/real-environment/test-helpers.js

@@ -0,0 +1,10 @@
+import { expect } from "@jest/globals";
+export function unwrapToolPayload(payload) {
+    if (payload && typeof payload === "object" && "success" in payload) {
+        return payload.result;
+    }
+    return payload;
+}
+export function expectToolSuccess(payload) {
+    expect(payload?.success).toBe(true);
+}

package/build/real-environment/tools.js

@@ -0,0 +1,22 @@
+import { expect } from "@jest/globals";
+export async function callToolJson(context, name, args) {
+    const result = (await context.client.callTool({
+        name,
+        arguments: args,
+    }));
+    expect(result.isError).not.toBe(true);
+    const content = result.content;
+    expect(content[0]?.type).toBe("text");
+    return {
+        raw: result,
+        payload: JSON.parse(String(content[0]?.text ?? "{}")),
+    };
+}
+export async function callToolRaw(context, name, args) {
+    const result = (await context.client.callTool({
+        name,
+        arguments: args,
+    }));
+    expect(result.isError).not.toBe(true);
+    return result;
+}

package/build/real-environment/types.js

@@ -0,0 +1 @@
+export {};

package/build/tool.js

@@ -38,3 +38,49 @@ export function default_tool(name, context) {
     });
     return fn;
 }
+export function export_tool_handler(name, context) {
+    const fn = build_channel(context, name, (reply) => {
+        const { success, result, error } = reply;
+        if (!success) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Export failed: ${error || "Unknown error"}`,
+                    },
+                ],
+            };
+        }
+        const { format, mimeType, data, width, height, warning } = result;
+        const content = [];
+        if (warning) {
+            content.push({
+                type: "text",
+                text: `Warning: ${warning}`,
+            });
+        }
+        if (format === "png") {
+            content.push({
+                type: "image",
+                mimeType: "image/png",
+                data: data,
+            });
+        }
+        else {
+            content.push({
+                type: "text",
+                text: data,
+            });
+        }
+        const dimensions = width && height ? `, ${width}x${height}` : "";
+        content.push({
+            type: "text",
+            text: `Exported ${format} (${mimeType})${dimensions}`,
+        });
+        const response = {
+            content,
+        };
+        return response;
+    });
+    return fn;
+}

package/build/tools/add-cell-of-shape.js

@@ -0,0 +1,42 @@
+import { z } from "zod";
+import { default_tool } from "../tool.js";
+export const TOOL_add_cell_of_shape = "add-cell-of-shape";
+export const registerAddCellOfShapeTool = (server, context) => {
+    server.tool(TOOL_add_cell_of_shape, "This tool allows you to add new vertex cell (object) on the current page of a Draw.io diagram by its shape name. It accepts multiple optional input parameter.", {
+        shape_name: z
+            .string()
+            .describe("Name of the shape to retrieved from the shape library of the current diagram."),
+        x: z
+            .number()
+            .optional()
+            .describe("X-axis position of the vertex cell of the shape")
+            .default(100),
+        y: z
+            .number()
+            .optional()
+            .describe("Y-axis position of the vertex cell of the shape")
+            .default(100),
+        width: z
+            .number()
+            .optional()
+            .describe("Width of the vertex cell of the shape")
+            .default(200),
+        height: z
+            .number()
+            .optional()
+            .describe("Height of the vertex cell of the shape")
+            .default(100),
+        text: z
+            .string()
+            .optional()
+            .describe("Text content placed inside of the vertex cell of the shape"),
+        style: z
+            .string()
+            .optional()
+            .describe("Semi-colon separated list of Draw.io visual styles, in the form of `key=value`. Example: `whiteSpace=wrap;html=1;fillColor=#f5f5f5;strokeColor=#666666;`"),
+        parent_id: z
+            .string()
+            .optional()
+            .describe("ID of the parent cell. If provided, the new cell will be created as a child of this cell. If omitted, the cell is created at the diagram root level."),
+    }, default_tool(TOOL_add_cell_of_shape, context));
+};

package/build/tools/add-edge.js

@@ -0,0 +1,33 @@
+import { z } from "zod";
+import { default_tool } from "../tool.js";
+export const TOOL_add_edge = "add-edge";
+export const registerAddEdgeTool = (server, context) => {
+    server.tool(TOOL_add_edge, "This tool creates an edge, sometimes called also a relation, between two vertexes (cells). When source and target are the same shape (self-connector), a loop edge style is automatically applied if no custom style is provided.", {
+        source_id: z
+            .string()
+            .describe("Source ID of a cell. It is represented by `id` attribute."),
+        target_id: z
+            .string()
+            .describe("Target ID of a cell. It is represented by `id` attribute."),
+        text: z
+            .string()
+            .optional()
+            .describe("Text content placed over the edge cell"),
+        style: z
+            .string()
+            .optional()
+            .describe("Semi-colon separated list of Draw.io visual styles, in the form of `key=value`. Example: `edgeStyle=orthogonalEdgeStyle;rounded=0;orthogonalLoop=1;jettySize=auto;html=1;exitX=1;exitY=0.5;exitDx=0;exitDy=0;entryX=0;entryY=0.5;entryDx=0;entryDy=0;`")
+            .default("edgeStyle=orthogonalEdgeStyle;rounded=0;orthogonalLoop=1;jettySize=auto;html=1;exitX=1;exitY=0.5;exitDx=0;exitDy=0;entryX=0;entryY=0.5;entryDx=0;entryDy=0;"),
+        points: z
+            .array(z.object({
+            x: z.number().describe("X coordinate of the waypoint"),
+            y: z.number().describe("Y coordinate of the waypoint"),
+        }))
+            .optional()
+            .describe("Array of {x, y} waypoints to control edge routing. Useful for custom paths or self-connectors where straight lines are barely visible."),
+        parent_id: z
+            .string()
+            .optional()
+            .describe("ID of the parent cell. If provided, the new edge will be created as a child of this cell. If omitted, the edge is created at the diagram root level."),
+    }, default_tool(TOOL_add_edge, context));
+};

package/build/tools/add-rectangle.js

@@ -0,0 +1,41 @@
+import { z } from "zod";
+import { default_tool } from "../tool.js";
+export const TOOL_add_rectangle = "add-rectangle";
+export const registerAddRectangleTool = (server, context) => {
+    server.tool(TOOL_add_rectangle, "This tool allows you to add new Rectangle vertex cell (object) on the current page of a Draw.io diagram. It accepts multiple optional input parameter.", {
+        x: z
+            .number()
+            .optional()
+            .describe("X-axis position of the Rectangle vertex cell")
+            .default(100),
+        y: z
+            .number()
+            .optional()
+            .describe("Y-axis position of the Rectangle vertex cell")
+            .default(100),
+        width: z
+            .number()
+            .optional()
+            .describe("Width of the Rectangle vertex cell")
+            .default(200),
+        height: z
+            .number()
+            .optional()
+            .describe("Height of the Rectangle vertex cell")
+            .default(100),
+        text: z
+            .string()
+            .optional()
+            .describe("Text content placed inside of the Rectangle vertex cell")
+            .default("New Cell"),
+        style: z
+            .string()
+            .optional()
+            .describe("Semi-colon separated list of Draw.io visual styles, in the form of `key=value`. Example: `whiteSpace=wrap;html=1;fillColor=#f5f5f5;strokeColor=#666666;`")
+            .default("whiteSpace=wrap;html=1;fillColor=#dae8fc;strokeColor=#6c8ebf;"),
+        parent_id: z
+            .string()
+            .optional()
+            .describe("ID of the parent cell. If provided, the new rectangle will be created as a child of this cell. If omitted, the rectangle is created at the diagram root level."),
+    }, default_tool(TOOL_add_rectangle, context));
+};

package/build/tools/create-layer.js

@@ -0,0 +1,8 @@
+import { z } from "zod";
+import { default_tool } from "../tool.js";
+export const TOOL_create_layer = "create-layer";
+export const registerCreateLayerTool = (server, context) => {
+    server.tool(TOOL_create_layer, "Creates a new layer in the diagram.", {
+        name: z.string().describe("Name for the new layer"),
+    }, default_tool(TOOL_create_layer, context));
+};

package/build/tools/delete-cell-by-id.js

@@ -0,0 +1,10 @@
+import { z } from "zod";
+import { default_tool } from "../tool.js";
+export const TOOL_delete_cell_by_id = "delete-cell-by-id";
+export const registerDeleteCellByIdTool = (server, context) => {
+    server.tool(TOOL_delete_cell_by_id, "Deletes a cell, whether it is a vertex or edge.", {
+        cell_id: z
+            .string()
+            .describe("The ID of a cell to delete. The cell can be either vertex or edge. The ID is located in `id` attribute."),
+    }, default_tool(TOOL_delete_cell_by_id, context));
+};

package/build/tools/edit-cell.js

@@ -0,0 +1,28 @@
+import { z } from "zod";
+import { default_tool } from "../tool.js";
+export const TOOL_edit_cell = "edit-cell";
+export const registerEditCellTool = (server, context) => {
+    server.tool(TOOL_edit_cell, "Update properties of an existing vertex/shape cell by its ID. Only provided fields are modified; unspecified properties remain unchanged.", {
+        cell_id: z
+            .string()
+            .describe("Identifier (`id` attribute) of the cell to update. Applies to vertex/shape cells."),
+        text: z
+            .string()
+            .optional()
+            .describe("Replace the cell's text/label content."),
+        x: z
+            .number()
+            .optional()
+            .describe("Set a new X-axis position for the cell."),
+        y: z
+            .number()
+            .optional()
+            .describe("Set a new Y-axis position for the cell."),
+        width: z.number().optional().describe("Set a new width for the cell."),
+        height: z.number().optional().describe("Set a new height for the cell."),
+        style: z
+            .string()
+            .optional()
+            .describe("Replace the cell's style string (semi-colon separated `key=value` pairs)."),
+    }, default_tool(TOOL_edit_cell, context));
+};

package/build/tools/edit-edge.js

@@ -0,0 +1,30 @@
+import { z } from "zod";
+import { default_tool } from "../tool.js";
+export const TOOL_edit_edge = "edit-edge";
+export const registerEditEdgeTool = (server, context) => {
+    server.tool(TOOL_edit_edge, "Update properties of an existing edge by its ID. Only provided fields are modified; unspecified properties remain unchanged. Supports setting waypoints for edge geometry control.", {
+        cell_id: z
+            .string()
+            .describe("Identifier (`id` attribute) of the edge cell to update. The ID must reference an edge."),
+        text: z.string().optional().describe("Replace the edge's label text."),
+        source_id: z
+            .string()
+            .optional()
+            .describe("Reassign the edge's source terminal to a different cell ID."),
+        target_id: z
+            .string()
+            .optional()
+            .describe("Reassign the edge's target terminal to a different cell ID."),
+        style: z
+            .string()
+            .optional()
+            .describe("Replace the edge's style string (semi-colon separated `key=value` pairs)."),
+        points: z
+            .array(z.object({
+            x: z.number().describe("X coordinate of the waypoint"),
+            y: z.number().describe("Y coordinate of the waypoint"),
+        }))
+            .optional()
+            .describe("Array of {x, y} waypoints to set as edge geometry control points. Replaces existing waypoints. Use an empty array to clear waypoints."),
+    }, default_tool(TOOL_edit_edge, context));
+};