flowpad-mcp 0.1.0 → 0.1.1

package/dist/server.js

@@ -1,956 +0,0 @@
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import { z } from 'zod';
-import { isProposedEdit } from './client.js';
-import { buildSimpleNode, diffIsEmpty, newNodeId, rescueTextContent, } from './diff.js';
-import { canConnectNodes } from 'flowpad-core';
-import { describeEngine, previewLayout, validateLocal, } from './local-engine.js';
-import { MCP_VERSION } from './version.js';
-const ok = (text) => ({
-    content: [{ type: 'text', text }],
-});
-// The owner was viewing the project, so the edit became a proposal in their
-// accept/reject preview rather than a direct save. Tell the agent plainly so it
-// never claims a save that hasn't landed.
-const proposed = (summary) => ok(`Proposed for the user's review: ${summary}. They are viewing this project, so the change is waiting in their accept/reject preview — nothing is saved until they approve it.`);
-const fail = (e) => ({
-    content: [
-        {
-            type: 'text',
-            text: `Error: ${e instanceof Error ? e.message : String(e)}`,
-        },
-    ],
-    isError: true,
-});
-const boundsSchema = z
-    .object({
-    x: z.number().optional(),
-    y: z.number().optional(),
-    width: z.number().optional(),
-    height: z.number().optional(),
-})
-    .describe('Position/size. Missing fields default to x:0 y:0 w:240 h:120.');
-const edgePortEnum = z.enum(['top', 'right', 'bottom', 'left']);
-const edgeSchema = z
-    .object({
-    id: z
-        .string()
-        .optional()
-        .describe('Edge id; a fresh one is minted if omitted.'),
-    to: z.string().describe('Target node id this edge points to.'),
-    fromPort: edgePortEnum.optional(),
-    toPort: edgePortEnum.optional(),
-})
-    .describe('A connection FROM this node TO another node. Direction rule: you may NOT point an edge INTO a task node — connect task→regular, never regular→task or task→task (invalid edges are dropped server-side).');
-const layoutSchema = z
-    .object({
-    flexDirection: z
-        .enum(['row', 'row-reverse', 'column', 'column-reverse'])
-        .optional(),
-    flexWrap: z.enum(['nowrap', 'wrap', 'wrap-reverse']).optional(),
-    justifyContent: z
-        .enum([
-        'flex-start',
-        'center',
-        'flex-end',
-        'space-between',
-        'space-around',
-        'space-evenly',
-    ])
-        .optional(),
-    alignItems: z
-        .enum(['flex-start', 'center', 'flex-end', 'stretch', 'baseline'])
-        .optional(),
-    alignSelf: z
-        .enum(['flex-start', 'center', 'flex-end', 'stretch', 'baseline', 'auto'])
-        .optional(),
-    gap: z.number().optional(),
-    padding: z.number().optional(),
-    paddingTop: z.number().optional(),
-    paddingRight: z.number().optional(),
-    paddingBottom: z.number().optional(),
-    paddingLeft: z.number().optional(),
-    margin: z.number().optional(),
-    marginTop: z.number().optional(),
-    marginRight: z.number().optional(),
-    marginBottom: z.number().optional(),
-    marginLeft: z.number().optional(),
-    flexGrow: z.number().optional(),
-    flexShrink: z.number().optional(),
-})
-    .describe("Flexbox layout (standard CSS semantics). CONTAINER props position this node's children: flexDirection, justifyContent (main axis), alignItems (cross axis), gap, padding. PER-CHILD props control how THIS node behaves inside its parent: flexGrow, flexShrink, alignSelf, margin. Engine defaults are browser-parity — flexShrink 1, flexWrap nowrap, alignItems stretch — so set flexShrink:0 / a fixed bound only when you want NO shrinking. Use flexGrow:1 on siblings to share a row/column equally without computing widths. A node is a flex container only when isAutoLayout:true.");
-// STYLE fields the canvas renderer actually paints today (mirror, not a CSS
-// universe). These are FLAT on the node — matching the client node model exactly
-// (flowpad/src/engine/types/node.ts) — so they pass straight through to the
-// backend's JSONB latestData and the renderer reads them as-is. Each field is
-// type-specific (a textColor on a view node is simply ignored); the doc tells
-// the agent which goes where. Colors are raw hex, sizes raw px — the app has no
-// design-token scale for these, so mirroring it = raw values. Anything NOT here
-// (fontWeight, fontFamily, …) is unpainted, so it is intentionally absent.
-const styleShape = {
-    // text nodes
-    textColor: z
-        .string()
-        .optional()
-        .describe('Text fill color as hex, e.g. "#FFFFFF" (text nodes).'),
-    fontSize: z
-        .number()
-        .min(6)
-        .max(200)
-        .optional()
-        .describe('Font size in px, 6–200 (text nodes).'),
-    textAlign: z
-        .enum(['left', 'center', 'right'])
-        .optional()
-        .describe('Horizontal text alignment within the node (text nodes).'),
-    // view / container nodes
-    backgroundColor: z
-        .string()
-        .optional()
-        .describe('Fill color as hex (view/container nodes).'),
-    borderColor: z
-        .string()
-        .optional()
-        .describe('Border color as hex (view nodes).'),
-    borderWidth: z
-        .number()
-        .min(0)
-        .optional()
-        .describe('Border thickness in px (view nodes).'),
-    borderRadius: z
-        .number()
-        .min(0)
-        .optional()
-        .describe('Corner radius in px (view/container nodes).'),
-    borderStyle: z
-        .enum(['solid', 'dashed', 'dotted'])
-        .optional()
-        .describe('Border line style (view nodes).'),
-    // shared renderer-level clip (view + text)
-    overflow: z
-        .enum(['hidden', 'visible'])
-        .optional()
-        .describe('Clip content to the node bounds (view & text nodes).'),
-    // image nodes
-    iconColor: z
-        .string()
-        .optional()
-        .describe('Tint for FontAwesome icon sources as hex; ignored for raster/SVG (image nodes).'),
-    resizeMode: z
-        .enum(['cover', 'contain', 'fill', 'none'])
-        .optional()
-        .describe('How the image fits its bounds (image nodes).'),
-    // sticky nodes
-    stickyColor: z
-        .enum(['yellow', 'pink', 'green', 'blue', 'orange', 'purple'])
-        .optional()
-        .describe('Sticky note color (sticky nodes).'),
-    stickyVariant: z
-        .enum(['note', 'node'])
-        .optional()
-        .describe('Sticky note presentation (sticky nodes): "note" = folded sticky-paper look (default), "node" = clean flat card with the color as a thin border accent.'),
-};
-// CONTENT fields the renderer paints as the node's VISIBLE BODY — distinct from
-// name/description (metadata, NOT painted). A text node renders `content`; a
-// sticky renders `title` (+ description). These were unwritable before, so an
-// agent-made text node showed blank on canvas. Flat strings, same passthrough
-// as styleShape.
-const contentShape = {
-    content: z
-        .string()
-        .optional()
-        .describe("A TEXT node's visible body — THIS is what renders on canvas. name/description are metadata and are NOT painted; set `content` for visible text."),
-    title: z
-        .string()
-        .optional()
-        .describe("A STICKY note's heading text (sticky nodes)."),
-};
-// Both content + style flow through one picker into the node (flat fields).
-const WRITABLE_EXTRA_KEYS = [
-    ...Object.keys(contentShape),
-    ...Object.keys(styleShape),
-];
-/** Copy the defined content + style fields off a validated tool input. */
-function pickStyle(src) {
-    const out = {};
-    for (const key of WRITABLE_EXTRA_KEYS) {
-        if (src[key] !== undefined)
-            out[key] = src[key];
-    }
-    return out;
-}
-/** Mint ids for edges that omit one (the canvas requires a stable edge id). */
-function mintEdges(edges) {
-    return (edges ?? []).map((e) => ({
-        id: e.id ?? newNodeId(),
-        to: e.to,
-        ...(e.fromPort ? { fromPort: e.fromPort } : {}),
-        ...(e.toPort ? { toPort: e.toPort } : {}),
-    }));
-}
-/**
- * Build a fully-wired McpServer for ONE acting user. The `client` carries that
- * user's credential, so every tool here operates on that user's canvas.
- *
- * stdio runs a single process-wide server (one user). The HTTP transport calls
- * this once PER SESSION (multi-tenant) so each connection edits its own user's
- * canvas — there is no shared, env-baked key. Keep all tool registrations here;
- * `index.ts` only chooses the transport.
- */
-// Guidance is a static backend constant; fetch it once per process and reuse it
-// across sessions (the HTTP transport builds a fresh server per session, so without
-// this every session would re-login + re-fetch the same string on its init path).
-let cachedGuidance;
-export async function createServer(client) {
-    // The design contract is fetched from be at runtime (GET /mcp/guidance) so it is
-    // never bundled into the published public tool, and can change without a republish.
-    // Best-effort: a fetch failure degrades to a minimal fallback, never a crash.
-    let instructions;
-    if (cachedGuidance !== undefined) {
-        instructions = cachedGuidance;
-    }
-    else {
-        try {
-            instructions = await client.guidance();
-            cachedGuidance = instructions; // cache only the successful fetch
-        }
-        catch (err) {
-            console.error('flowpad-mcp: could not fetch guidance from backend; using minimal fallback.', err);
-            // Do NOT cache the fallback — a transient failure should retry next session.
-            instructions =
-                'Flowpad is a visual canvas of nodes. Read a project (get_project / ' +
-                    'get_outline) before editing, then write changes with apply_edit / add_node / ' +
-                    'connect_nodes. (Full design guidance was unavailable.)';
-        }
-    }
-    // Soft version gate (Faz 2): if the backend flagged a newer tool during the
-    // guidance fetch, fold it into the instructions so the agent nudges the user.
-    // Appended to the per-session string, never to the shared cachedGuidance.
-    const advisory = client.getUpdateAdvisory();
-    if (advisory) {
-        instructions +=
-            `\n\n⚠ UPDATE AVAILABLE: a newer flowpad-mcp (v${advisory}) is out. ` +
-                `Tell the user to update with: npx flowpad-mcp@latest.`;
-    }
-    const server = new McpServer({ name: 'flowpad-mcp', version: MCP_VERSION }, { instructions });
-    // Capture the initializing host (Cursor / Claude Desktop / CLI / …) from the
-    // protocol `clientInfo` and hand it to the client, which forwards it to the
-    // backend on every call for audit + presence attribution. Fires once per
-    // session, after `initialize` — works for both stdio and HTTP transports.
-    server.server.oninitialized = () => {
-        client.setClientName(server.server.getClientVersion()?.name);
-    };
-    // -------------------------------------------------------------------------
-    // list_projects
-    // -------------------------------------------------------------------------
-    server.tool('list_projects', 'List Flowpad projects for the logged-in user. Optionally filter by a substring of the project name. Returns id + name for each match.', {
-        query: z
-            .string()
-            .optional()
-            .describe('Case-insensitive substring to match against project names.'),
-    }, async ({ query }) => {
-        try {
-            const { data } = await client.listProjects(query);
-            if (data.length === 0) {
-                return ok(query ? `No projects matching "${query}".` : 'No projects found.');
-            }
-            const lines = data.map((p) => `- ${p.name} (id: ${p.id})`);
-            return ok(`${data.length} project(s):\n${lines.join('\n')}`);
-        }
-        catch (e) {
-            return fail(e);
-        }
-    });
-    // -------------------------------------------------------------------------
-    // get_project
-    // -------------------------------------------------------------------------
-    server.tool('get_project', 'Get a single Flowpad project: its current revision and a summary of its canvas nodes (id, type, name, parent). Use this to understand the canvas before editing.', {
-        projectId: z.string().describe('The project UUID.'),
-    }, async ({ projectId }) => {
-        try {
-            const project = await client.getProjectRaw(projectId);
-            const nodes = project.latestData ?? [];
-            const header = `Project "${project.name}" (id: ${project.id})\nrevision: ${project.version}\nnodes: ${nodes.length}`;
-            if (nodes.length === 0)
-                return ok(`${header}\n(empty canvas)`);
-            const lines = nodes
-                .slice(0, 200)
-                .map((n) => `- #${n.id} ${n.type ?? 'node'}${n.name ? ` "${n.name}"` : ''}${n.parent !== null && n.parent !== undefined
-                ? ` (parent #${n.parent})`
-                : ''}`);
-            return ok(`${header}\n${lines.join('\n')}`);
-        }
-        catch (e) {
-            return fail(e);
-        }
-    });
-    // -------------------------------------------------------------------------
-    // Agentic retrieval tools — let an external agent (Cursor/Claude/Antigravity)
-    // navigate a large canvas without ever loading the whole thing into context.
-    // The MCP fetches the full node list once (cached by revision) and returns only
-    // compact slices.  Analogy: get_outline = `ls -R`, search_nodes = `grep`,
-    // get_node = `cat`, apply_edit = targeted edit.
-    // -------------------------------------------------------------------------
-    server.tool('get_outline', "Get a compact, depth-limited outline of a project's canvas (node ids, types, names, child counts). Like `ls -R` for the canvas — use it to understand structure before drilling in. Scales to large canvases.", {
-        projectId: z.string().describe('The project UUID.'),
-        maxDepth: z
-            .number()
-            .int()
-            .min(0)
-            .max(4)
-            .optional()
-            .describe('How deep to expand the tree. Default 2.'),
-    }, async ({ projectId, maxDepth }) => {
-        try {
-            return ok(await client.outline(projectId, maxDepth));
-        }
-        catch (e) {
-            return fail(e);
-        }
-    });
-    server.tool('search_nodes', "Search a project's canvas for nodes by name/description substring, type, parent id, and/or faceted labels (category bucket, tag). Paginated. Like `grep` for the canvas — use it to locate the nodes you need to read or edit. Run get_outline first to see which categories/tags exist.", {
-        projectId: z.string().describe('The project UUID.'),
-        query: z
-            .string()
-            .optional()
-            .describe('Case-insensitive substring matched against name/description.'),
-        type: z
-            .string()
-            .optional()
-            .describe("Restrict to a node type, e.g. 'text', 'view', 'container'."),
-        parentId: z
-            .string()
-            .optional()
-            .describe('Restrict to direct children of this node id.'),
-        category: z
-            .string()
-            .optional()
-            .describe("Exact-match a node's coarse `category` bucket, e.g. 'auth'."),
-        tag: z
-            .string()
-            .optional()
-            .describe("Match nodes whose `tags` include this tag, e.g. 'platform:ios'."),
-        limit: z
-            .number()
-            .int()
-            .min(1)
-            .max(100)
-            .optional()
-            .describe('Default 20.'),
-        offset: z.number().int().min(0).optional().describe('For pagination.'),
-    }, async ({ projectId, query, type, parentId, category, tag, limit, offset, }) => {
-        try {
-            const out = await client.searchNodes(projectId, {
-                query,
-                type,
-                parentId,
-                category,
-                tag,
-                limit,
-                offset,
-            });
-            return ok(out);
-        }
-        catch (e) {
-            return fail(e);
-        }
-    });
-    server.tool('get_node', "Get a single node's full fields plus its subtree to a given depth. Like `cat` for a canvas node — use after get_outline/search_nodes to read just the part you care about.", {
-        projectId: z.string().describe('The project UUID.'),
-        nodeId: z.string().describe('The node id to inspect.'),
-        depth: z
-            .number()
-            .int()
-            .min(0)
-            .max(4)
-            .optional()
-            .describe('How many child levels to include. Default 1.'),
-    }, async ({ projectId, nodeId, depth }) => {
-        try {
-            return ok(await client.getNode(projectId, nodeId, depth));
-        }
-        catch (e) {
-            return fail(e);
-        }
-    });
-    server.tool('analyze_project', "Analyze a project's canvas: structural stats (node/type counts, root count, max nesting depth) plus deterministic layout-overflow warnings (flex containers whose children can't fit). Lead with this to gauge the shape and health of a project before editing.", {
-        projectId: z.string().describe('The project UUID.'),
-    }, async ({ projectId }) => {
-        try {
-            return ok(await client.analyze(projectId));
-        }
-        catch (e) {
-            return fail(e);
-        }
-    });
-    server.tool('query_connections', 'Answer relationship/rollup questions about a project canvas using edges + work items — e.g. "how many bugs are attached to the header", "what is connected to this feature", project-wide work-item counts by type/status. Pass nodeId OR nodeName to focus on one node; omit both for a project-wide rollup. Use this instead of inferring relationships from the raw node tree. (To CREATE work items or connections, use apply_edit: add a `type:"task"` node — the backend creates its task record automatically — and put an edge in the source node\'s `edges` array.)', {
-        projectId: z.string().describe('The project UUID.'),
-        nodeId: z
-            .string()
-            .optional()
-            .describe('Focus node id. Omit for a project-wide rollup.'),
-        nodeName: z
-            .string()
-            .optional()
-            .describe('Focus node by name. Omit for a project-wide rollup.'),
-    }, async ({ projectId, nodeId, nodeName }) => {
-        try {
-            return ok(await client.connections(projectId, { nodeId, nodeName }));
-        }
-        catch (e) {
-            return fail(e);
-        }
-    });
-    // -------------------------------------------------------------------------
-    // describe_engine  (local engine knowledge — no network)
-    // -------------------------------------------------------------------------
-    server.tool('describe_engine', 'Describe the Flowpad layout engine you are designing for: allowed node types, bounds/layout/edge rules and limits. Read this BEFORE building a non-trivial design so what you produce is valid on the first try. Answered locally from the bundled engine (no network, instant).', {}, async () => {
-        try {
-            return ok(describeEngine());
-        }
-        catch (e) {
-            return fail(e);
-        }
-    });
-    // -------------------------------------------------------------------------
-    // validate_design  (local pre-flight — check a diff BEFORE apply_edit)
-    // -------------------------------------------------------------------------
-    server.tool('validate_design', "Check a canvas diff against the engine rules LOCALLY, before sending it. Pass the same added/updated/removedIds you intend to give apply_edit; get back either OK or a precise, fixable reason. Runs on your machine via the bundled engine (no network) — use it to self-correct before committing a change. apply_edit runs this same check, so a passing result means apply_edit won't reject the shape.", {
-        added: z
-            .array(z.record(z.unknown()))
-            .optional()
-            .describe('Nodes you plan to add (same shape as apply_edit.added).'),
-        updated: z
-            .array(z.record(z.unknown()))
-            .optional()
-            .describe('Node patches you plan to apply (same shape as apply_edit.updated).'),
-        removedIds: z
-            .array(z.string())
-            .optional()
-            .describe('Node ids you plan to remove.'),
-        existingNodeCount: z
-            .number()
-            .int()
-            .min(0)
-            .optional()
-            .describe('Current node count in the project (for size-limit checks). Omit if unknown.'),
-    }, async ({ added, updated, removedIds, existingNodeCount, }) => {
-        try {
-            const result = validateLocal({ added, updated, removedIds }, existingNodeCount ?? 0);
-            if (result.valid) {
-                return ok('✓ Valid — this design satisfies the engine rules. Safe to apply_edit.');
-            }
-            return ok(`✗ Invalid (rule: ${result.rule}): ${result.message}\nFix this and re-check before apply_edit.`);
-        }
-        catch (e) {
-            return fail(e);
-        }
-    });
-    // -------------------------------------------------------------------------
-    // preview_layout  (local — compute where auto-layout children will land)
-    // -------------------------------------------------------------------------
-    server.tool('preview_layout', "Preview where an auto-layout container's children will be positioned, using the REAL layout engine — locally, no network. Pass the container + its children (same node shape as apply_edit, with bounds/layout/isAutoLayout/children/parent). Returns each node's computed bounds so you can verify a frame tree renders as intended BEFORE apply_edit, instead of hand-computing x/y. Only nodes inside an isAutoLayout container are repositioned.", {
-        nodes: z
-            .array(z.record(z.unknown()))
-            .describe('The container + children to lay out (apply_edit node shape: bounds, layout, isAutoLayout, children, parent).'),
-    }, async ({ nodes }) => {
-        try {
-            const { nodes: laid, overflows } = previewLayout(nodes);
-            const lines = laid.map((n) => `- #${n.id}: x=${Math.round(n.bounds.x)} y=${Math.round(n.bounds.y)} w=${Math.round(n.bounds.width)} h=${Math.round(n.bounds.height)}`);
-            const overflowText = overflows.length
-                ? `\n\n⚠ Overflow (${overflows.length}):\n${overflows.map((w) => `- ${w}`).join('\n')}`
-                : '\n\n✓ No overflow — children fit their containers.';
-            return ok(`Computed layout (${laid.length} node(s)):\n${lines.join('\n')}${overflowText}`);
-        }
-        catch (e) {
-            return fail(e);
-        }
-    });
-    server.tool('apply_edit', "Apply a targeted edit to a project's canvas: add, update, and/or remove nodes in one diff. Build the edit yourself from what you read via get_outline/search_nodes/get_node. New nodes get ids assigned automatically if omitted. On a revision conflict the edit is NOT force-written — re-read the latest and reapply.", {
-        projectId: z.string().describe('The project UUID.'),
-        added: z
-            .array(z.object({
-            id: z.string().optional(),
-            type: z.string().optional(),
-            name: z.string().optional(),
-            description: z
-                .string()
-                .optional()
-                .describe('Metadata, NOT painted. A TEXT node’s visible string lives in `content`.'),
-            parent: z.string().nullable().optional(),
-            children: z.array(z.string()).optional(),
-            bounds: boundsSchema.optional(),
-            category: z
-                .string()
-                .optional()
-                .describe("Coarse discovery bucket, e.g. 'auth'."),
-            tags: z
-                .array(z.string())
-                .optional()
-                .describe("Faceted labels, e.g. ['platform:ios','type:dialog']."),
-            edges: z
-                .array(edgeSchema)
-                .optional()
-                .describe('Connections FROM this node to other nodes. For a task node, use this to attach it to what it relates to.'),
-            isAutoLayout: z
-                .boolean()
-                .optional()
-                .describe('Set true to make this node a flexbox container that auto-positions its children (then give it a `layout`). A container WITHOUT isAutoLayout leaves children at their absolute bounds — almost always wrong for real UI.'),
-            layout: layoutSchema.optional(),
-            ...contentShape,
-            ...styleShape,
-        }))
-            .optional()
-            .describe('New nodes to add.'),
-        updated: z
-            .array(z.object({
-            id: z.string().describe('Existing node id to update.'),
-            type: z.string().optional(),
-            name: z.string().optional(),
-            description: z
-                .string()
-                .optional()
-                .describe('Metadata, NOT painted. A TEXT node’s visible string lives in `content`.'),
-            parent: z.string().nullable().optional(),
-            bounds: boundsSchema.optional(),
-            category: z
-                .string()
-                .optional()
-                .describe('Coarse discovery bucket.'),
-            tags: z
-                .array(z.string())
-                .optional()
-                .describe("Replaces the node's tags."),
-            edges: z
-                .array(edgeSchema)
-                .optional()
-                .describe("Replaces the node's outgoing connections."),
-            isAutoLayout: z
-                .boolean()
-                .optional()
-                .describe('Toggle whether this node is a flexbox container.'),
-            layout: layoutSchema
-                .optional()
-                .describe("Merged onto the node's existing layout."),
-            ...contentShape,
-            ...styleShape,
-        }))
-            .optional()
-            .describe('Patches to existing nodes (merged onto current values).'),
-        removedIds: z
-            .array(z.string())
-            .optional()
-            .describe('Ids of nodes to delete.'),
-    }, async ({ projectId, added, updated, removedIds }) => {
-        try {
-            const project = await client.getProjectRawCached(projectId);
-            const existing = project.latestData ?? [];
-            // Key by String(id): legacy projects store NUMERIC node ids, but tool
-            // inputs are strings — a raw `n.id` map would miss `"1"` vs `1`. We look
-            // up by string, then write back each node's ORIGINAL id (number or
-            // string) so the backend's diff-merge matches it.
-            const byId = new Map(existing.map((n) => [String(n.id), n]));
-            // Reserve ids: existing + any explicit ids on the new nodes.
-            const usedIds = new Set(byId.keys());
-            for (const a of added ?? [])
-                if (a.id != null)
-                    usedIds.add(a.id);
-            const nextFree = () => {
-                let id = newNodeId();
-                while (usedIds.has(id))
-                    id = newNodeId();
-                usedIds.add(id);
-                return id;
-            };
-            const addedNodes = (added ?? []).map((a) => rescueTextContent({
-                id: a.id ?? nextFree(),
-                bounds: {
-                    x: a.bounds?.x ?? 0,
-                    y: a.bounds?.y ?? 0,
-                    width: a.bounds?.width ?? 240,
-                    height: a.bounds?.height ?? 120,
-                },
-                children: a.children ?? [],
-                parent: a.parent ?? null,
-                edges: mintEdges(a.edges),
-                ...(a.type ? { type: a.type } : {}),
-                ...(a.name ? { name: a.name } : {}),
-                ...(a.description ? { description: a.description } : {}),
-                ...(a.category ? { category: a.category } : {}),
-                ...(a.tags ? { tags: a.tags } : {}),
-                ...(a.isAutoLayout != null ? { isAutoLayout: a.isAutoLayout } : {}),
-                ...(a.layout ? { layout: a.layout } : {}),
-                ...pickStyle(a),
-            }));
-            const updatedNodes = [];
-            const unknownUpdates = [];
-            for (const u of updated ?? []) {
-                const base = byId.get(String(u.id));
-                if (!base) {
-                    unknownUpdates.push(u.id);
-                    continue;
-                }
-                const merged = { ...base };
-                if (u.name !== undefined)
-                    merged.name = u.name;
-                if (u.description !== undefined)
-                    merged.description = u.description;
-                if (u.type !== undefined)
-                    merged.type = u.type;
-                if (u.parent !== undefined)
-                    merged.parent = u.parent;
-                if (u.bounds)
-                    merged.bounds = { ...base.bounds, ...u.bounds };
-                if (u.category !== undefined)
-                    merged.category = u.category;
-                if (u.tags !== undefined)
-                    merged.tags = u.tags;
-                if (u.edges !== undefined)
-                    merged.edges = mintEdges(u.edges);
-                if (u.isAutoLayout !== undefined)
-                    merged.isAutoLayout = u.isAutoLayout;
-                if (u.layout !== undefined) {
-                    const baseLayout = (base.layout ?? {});
-                    merged.layout = { ...baseLayout, ...u.layout };
-                }
-                Object.assign(merged, pickStyle(u));
-                updatedNodes.push(merged);
-            }
-            // Resolve each requested id to the node's ORIGINAL id (preserves numeric
-            // legacy ids) so the backend matches them; unknown ids are dropped.
-            const removed = (removedIds ?? [])
-                .map((id) => byId.get(String(id))?.id)
-                .filter((id) => id !== undefined);
-            const diff = {};
-            if (addedNodes.length)
-                diff.added = addedNodes;
-            if (updatedNodes.length)
-                diff.updated = updatedNodes;
-            if (removed.length)
-                diff.removedIds = removed;
-            const notes = unknownUpdates.length
-                ? ` (skipped unknown update ids: ${unknownUpdates.join(', ')})`
-                : '';
-            if (diffIsEmpty(diff))
-                return ok(`Nothing to apply.${notes}`);
-            // Local pre-flight: validate with the bundled engine BEFORE the network
-            // round-trip — same check validate_design exposes and the web client runs.
-            // Catch a malformed diff on the user's machine and hand back a fixable
-            // reason instead of spending a request to have the backend reject it.
-            const verdict = validateLocal(diff, existing.length);
-            if (!verdict.valid) {
-                return ok(`Edit not sent — local validation failed (rule: ${verdict.rule}): ${verdict.message}. ` +
-                    `This was caught on your machine before any save. Fix the nodes and retry; ` +
-                    `run validate_design to re-check.`);
-            }
-            try {
-                const summary = [
-                    addedNodes.length
-                        ? `${addedNodes.length} added (#${addedNodes.map((n) => n.id).join(', #')})`
-                        : null,
-                    updatedNodes.length ? `${updatedNodes.length} updated` : null,
-                    removed.length ? `${removed.length} removed` : null,
-                ]
-                    .filter(Boolean)
-                    .join(', ');
-                const saved = await client.updateProject(projectId, {
-                    diff,
-                    baseRevision: project.version,
-                });
-                if (isProposedEdit(saved))
-                    return proposed(summary);
-                return ok(`Applied: ${summary}. New revision: ${saved.version}.${notes}`);
-            }
-            catch (e) {
-                if (e instanceof Error && /409|conflict|revision/i.test(e.message)) {
-                    client.invalidate(projectId);
-                    return ok(`Revision conflict: the project changed since you last read it (your baseRevision ${project.version} is stale). Re-read with get_outline/get_node and reapply your edit. (Non-overlapping edits will merge automatically once server-side node-merge lands.)`);
-                }
-                throw e;
-            }
-        }
-        catch (e) {
-            return fail(e);
-        }
-    });
-    // -------------------------------------------------------------------------
-    // add_node  (deterministic — no AI, builds a single node directly)
-    // -------------------------------------------------------------------------
-    server.tool('add_node', 'Add a single node to a Flowpad project directly. Use for a deterministic single-node addition when you know its content. For multi-node structures build the tree yourself and use apply_edit. To make this node lay its children out with flexbox, pass isAutoLayout:true + layout.', {
-        projectId: z.string().describe('The project UUID.'),
-        name: z
-            .string()
-            .optional()
-            .describe('Node title (metadata, NOT painted).'),
-        description: z
-            .string()
-            .optional()
-            .describe('Node description (metadata, NOT painted on canvas). For a TEXT node’s VISIBLE string use `content`, not this.'),
-        type: z
-            .string()
-            .optional()
-            .describe("Node type, e.g. 'view'. Defaults to a plain node."),
-        parentId: z
-            .string()
-            .optional()
-            .describe('Existing node id to attach this node under.'),
-        x: z.number().optional().describe('Top-left x. Default 0.'),
-        y: z.number().optional().describe('Top-left y. Default 0.'),
-        width: z.number().optional().describe('Width. Default 240.'),
-        height: z.number().optional().describe('Height. Default 120.'),
-        isAutoLayout: z
-            .boolean()
-            .optional()
-            .describe('Make this node a flexbox container (pair with `layout`).'),
-        layout: layoutSchema.optional(),
-        ...contentShape,
-        ...styleShape,
-    }, async (args) => {
-        const { projectId, name, description, type, parentId, x, y, width, height, isAutoLayout, layout, } = args;
-        try {
-            const project = await client.getProjectRaw(projectId);
-            const id = newNodeId();
-            const node = buildSimpleNode({
-                id,
-                type,
-                name,
-                description,
-                parentId: parentId ?? null,
-                bounds: { x, y, width, height },
-                isAutoLayout,
-                layout,
-                style: pickStyle(args),
-            });
-            const saved = await client.updateProject(projectId, {
-                diff: { added: [node] },
-                baseRevision: project.version,
-            });
-            if (isProposedEdit(saved)) {
-                return proposed(`1 node added${name ? ` ("${name}")` : ''}`);
-            }
-            return ok(`Added node #${id}${name ? ` "${name}"` : ''}. New revision: ${saved.version}.`);
-        }
-        catch (e) {
-            return fail(e);
-        }
-    });
-    // -------------------------------------------------------------------------
-    // create_project  (a fresh, empty project to design a NEW thing into)
-    // -------------------------------------------------------------------------
-    server.tool('create_project', 'Create a NEW, empty project (a fresh canvas) for the user. Use this when the request is a new app/design that does NOT belong in an existing project — never dump unrelated screens into whatever project happens to be open. Returns the new project id; pass it as projectId to add_node/apply_edit to design into it. Applies immediately (a new empty project is non-destructive).', {
-        name: z
-            .string()
-            .describe('The project name, e.g. "Mobile App — Onboarding".'),
-        isTemplateProject: z
-            .boolean()
-            .optional()
-            .describe('Mark as a reusable template project. Default false.'),
-    }, async ({ name, isTemplateProject }) => {
-        try {
-            const res = await client.createProject({
-                name,
-                ...(isTemplateProject != null ? { isTemplateProject } : {}),
-            });
-            if ('proposed' in res) {
-                return proposed(`create project "${name}" (the user confirms/edits the name on their screen)`);
-            }
-            return ok(`Created project "${name}" (#${res.id}). Design into it by passing projectId:"${res.id}" to add_node / apply_edit.`);
-        }
-        catch (err) {
-            return fail(err instanceof Error ? err : new Error(String(err)));
-        }
-    });
-    // -------------------------------------------------------------------------
-    // delete_project  (DESTRUCTIVE — confirm-gated when the owner is viewing)
-    // -------------------------------------------------------------------------
-    server.tool('delete_project', 'Delete a project by id. DESTRUCTIVE. If the owner is currently viewing that project, the deletion is routed to their accept/reject confirm — nothing is deleted until they approve. Otherwise it deletes immediately. Use the UUID from list_projects; never guess.', {
-        projectId: z.string().describe('The project UUID to delete.'),
-    }, async ({ projectId }) => {
-        try {
-            const res = await client.deleteProject(projectId);
-            if (res.proposed)
-                return proposed(`delete project ${projectId}`);
-            return ok(`Deleted project ${projectId}.`);
-        }
-        catch (err) {
-            return fail(err instanceof Error ? err : new Error(String(err)));
-        }
-    });
-    // -------------------------------------------------------------------------
-    // bind_template  (install a template project; confirm-gated when viewing)
-    // -------------------------------------------------------------------------
-    server.tool('bind_template', 'Install a template project INTO a project so its template nodes become available there. If the owner is viewing the target project, the bind is routed to their confirm dialog; otherwise it applies. Find template project ids via list_projects (template projects) or the project catalog. Both ids are UUIDs.', {
-        projectId: z
-            .string()
-            .describe('The project UUID to install the template into.'),
-        templateProjectId: z
-            .string()
-            .describe('The template project UUID to install.'),
-    }, async ({ projectId, templateProjectId }) => {
-        try {
-            const res = await client.bindTemplate(projectId, templateProjectId);
-            if (res.proposed) {
-                return proposed(`install template ${templateProjectId} into ${projectId}`);
-            }
-            return ok(`Installed template ${templateProjectId} into project ${projectId}.`);
-        }
-        catch (err) {
-            return fail(err instanceof Error ? err : new Error(String(err)));
-        }
-    });
-    // -------------------------------------------------------------------------
-    // list_templates  (the BINDABLE catalog — pick one for bind_template)
-    // -------------------------------------------------------------------------
-    server.tool('list_templates', "List the BINDABLE templates you can install into a project: bundled built-ins + the user's own template projects. Returns id + name + source for each — pick one and pass its id as bind_template's templateProjectId. (Templates already INSTALLED on a project are shown by get_project; THIS is the catalog of what you CAN add.)", {}, async () => {
-        try {
-            const { data } = await client.listTemplates();
-            if (!data.length)
-                return ok('No bindable templates available.');
-            const lines = data.map((t) => `- ${t.name} (id: ${t.id}, ${t.source})${t.description ? ` — ${t.description}` : ''}`);
-            return ok(`${data.length} template(s) you can bind:\n${lines.join('\n')}`);
-        }
-        catch (err) {
-            return fail(err instanceof Error ? err : new Error(String(err)));
-        }
-    });
-    // -------------------------------------------------------------------------
-    // create_task  (deterministic — work item + auto-linked task record)
-    // -------------------------------------------------------------------------
-    server.tool('create_task', "Create a work item (task / feature / bug) on a project canvas. Adds a first-class task node; the backend auto-creates the backing task record and resolves taskType/taskStatus to the workspace's tag ids by name. Optionally connect it to an existing node in one shot. This is the deterministic equivalent of the in-app AI's <AddTask> — use it to plan/track work, not just draw UI.", {
-        projectId: z.string().describe('The project UUID.'),
-        title: z.string().describe('Short imperative summary (the task title).'),
-        description: z
-            .string()
-            .optional()
-            .describe('More detail about the work.'),
-        taskType: z
-            .string()
-            .optional()
-            .describe('Work-item kind, e.g. "bug" / "feat" / "chore". Resolved to a workspace task-type tag by name; omit if unknown (run analyze_project / get_outline to learn the workspace vocabulary).'),
-        taskStatus: z
-            .string()
-            .optional()
-            .describe('Progress, e.g. "todo" / "in-progress" / "done". Resolved to a workspace progress tag by name; omit if unknown.'),
-        connectTo: z
-            .string()
-            .optional()
-            .describe('Existing node id to attach this task to. Creates an edge FROM the task TO that node (e.g. a bug attached to the header it affects).'),
-        parentId: z
-            .string()
-            .optional()
-            .describe('Existing node id to nest under.'),
-        x: z.number().optional().describe('Top-left x. Default 0.'),
-        y: z.number().optional().describe('Top-left y. Default 0.'),
-    }, async ({ projectId, title, description, taskType, taskStatus, connectTo, parentId, x, y, }) => {
-        try {
-            const project = await client.getProjectRaw(projectId);
-            const connectTarget = connectTo
-                ? (project.latestData ?? []).find((n) => String(n.id) === connectTo)
-                : undefined;
-            if (connectTo && !connectTarget) {
-                return fail(new Error(`connectTo node ${connectTo} not found in project.`));
-            }
-            // EDGE_RULES.NO_EDGE_INTO_TASK (flowpad-core canConnectNodes): the edge is
-            // FROM this new task TO connectTo, so connectTo may not itself be a task.
-            // Catch it locally with a clear message instead of letting the backend
-            // silently drop the edge (dropInvalidTaskEdges).
-            if (connectTarget &&
-                !canConnectNodes({ type: 'task' }, connectTarget)) {
-                return fail(new Error(`Cannot connect task "${title}" to ${connectTo}: an edge may not point INTO a task node. Connect a task to a regular node, not another task.`));
-            }
-            const id = newNodeId();
-            // taskId:null → the backend reconciler creates + links the Task record and
-            // resolves the aiTaskType/aiTaskStatus hints to tag ids, then strips them.
-            const node = {
-                id,
-                type: 'task',
-                name: title,
-                bounds: { x: x ?? 0, y: y ?? 0, width: 100, height: 100 },
-                children: [],
-                parent: parentId ?? null,
-                edges: connectTo ? [{ id: newNodeId(), to: connectTo }] : [],
-                taskId: null,
-                taskVersionNumber: null,
-                ...(description ? { description } : {}),
-                ...(taskType ? { aiTaskType: taskType } : {}),
-                ...(taskStatus ? { aiTaskStatus: taskStatus } : {}),
-            };
-            const saved = await client.updateProject(projectId, {
-                diff: { added: [node] },
-                baseRevision: project.version,
-            });
-            const conn = connectTo ? `, connected to ${connectTo}` : '';
-            if (isProposedEdit(saved)) {
-                return proposed(`task "${title}" created${conn}`);
-            }
-            return ok(`Created task "${title}" (#${id}${taskType ? `, ${taskType}` : ''}${taskStatus ? `, ${taskStatus}` : ''}${conn}). New revision: ${saved.version}.`);
-        }
-        catch (e) {
-            return fail(e);
-        }
-    });
-    // -------------------------------------------------------------------------
-    // connect_nodes  (deterministic — draw an edge between two existing nodes)
-    // -------------------------------------------------------------------------
-    server.tool('connect_nodes', 'Draw a connection (edge) between two EXISTING nodes — e.g. attach a bug to the feature it affects, or link a task to a design region. The edge points FROM fromId TO toId. Direction rule: you may NOT point an edge INTO a task node (connect task→regular, never regular→task or task→task). Idempotent: re-running with the same pair is a no-op.', {
-        projectId: z.string().describe('The project UUID.'),
-        fromId: z.string().describe('Source node id (the edge starts here).'),
-        toId: z.string().describe('Target node id (the edge points here).'),
-        fromPort: edgePortEnum.optional(),
-        toPort: edgePortEnum.optional(),
-    }, async ({ projectId, fromId, toId, fromPort, toPort, }) => {
-        try {
-            if (fromId === toId) {
-                return fail(new Error('Cannot connect a node to itself.'));
-            }
-            const project = await client.getProjectRaw(projectId);
-            const nodes = project.latestData ?? [];
-            const source = nodes.find((n) => String(n.id) === fromId);
-            if (!source)
-                return fail(new Error(`Source node ${fromId} not found.`));
-            const target = nodes.find((n) => String(n.id) === toId);
-            if (!target) {
-                return fail(new Error(`Target node ${toId} not found.`));
-            }
-            // EDGE_RULES.NO_EDGE_INTO_TASK (flowpad-core canConnectNodes): an edge may
-            // not point INTO a task node. Catch it locally with a clear message rather
-            // than letting the backend silently drop it (dropInvalidTaskEdges).
-            if (!canConnectNodes(source, target)) {
-                return fail(new Error(`Cannot connect ${fromId} → ${toId}: an edge may not point INTO a task node. Connect a task to a regular node, not another task.`));
-            }
-            const existing = Array.isArray(source.edges) ? source.edges : [];
-            const dup = existing.some((e) => {
-                const edge = e;
-                return (edge.to === toId &&
-                    edge.fromPort === fromPort &&
-                    edge.toPort === toPort);
-            });
-            if (dup)
-                return ok(`Edge ${fromId} → ${toId} already exists.`);
-            const merged = {
-                ...source,
-                edges: [
-                    ...existing,
-                    {
-                        id: newNodeId(),
-                        to: toId,
-                        ...(fromPort ? { fromPort } : {}),
-                        ...(toPort ? { toPort } : {}),
-                    },
-                ],
-            };
-            const saved = await client.updateProject(projectId, {
-                diff: { updated: [merged] },
-                baseRevision: project.version,
-            });
-            if (isProposedEdit(saved)) {
-                return proposed(`edge ${fromId} → ${toId}`);
-            }
-            return ok(`Connected ${fromId} → ${toId}. New revision: ${saved.version}.`);
-        }
-        catch (e) {
-            return fail(e);
-        }
-    });
-    return server;
-}
-//# sourceMappingURL=server.js.map