flutterflow-mcp 0.1.0

package/build/tools/find-component-usages.js

@@ -0,0 +1,225 @@
+import { z } from "zod";
+import YAML from "yaml";
+import { cacheRead, cacheMeta, listCachedKeys, } from "../utils/cache.js";
+import { resolveComponent } from "./get-component-summary.js";
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+/** Batch-process items in groups to avoid overwhelming the file system. */
+async function batchProcess(items, batchSize, fn) {
+    const results = [];
+    for (let i = 0; i < items.length; i += batchSize) {
+        const batch = items.slice(i, i + batchSize);
+        const batchResults = await Promise.all(batch.map(fn));
+        results.push(...batchResults);
+    }
+    return results;
+}
+/**
+ * Resolve the value of a parameter pass to a readable string.
+ */
+function resolveParamValue(paramObj) {
+    // Check for variable source (e.g. INTERNATIONALIZATION)
+    const variable = paramObj.variable;
+    if (variable) {
+        const source = variable.source;
+        if (source === "INTERNATIONALIZATION") {
+            const fc = variable.functionCall;
+            const values = fc?.values;
+            if (values && values.length > 0) {
+                const first = values[0];
+                const iv = first.inputValue;
+                const sv = iv?.serializedValue;
+                return sv ? `"${sv}" (i18n)` : "[i18n]";
+            }
+            return "[i18n]";
+        }
+        if (source)
+            return `[${source}]`;
+        return "[dynamic]";
+    }
+    // Check for inputValue
+    const inputValue = paramObj.inputValue;
+    if (inputValue != null) {
+        if (typeof inputValue === "string" || typeof inputValue === "number") {
+            return `"${inputValue}"`;
+        }
+        if (typeof inputValue === "object") {
+            const ivo = inputValue;
+            if ("serializedValue" in ivo)
+                return `"${ivo.serializedValue}"`;
+            if ("themeColor" in ivo)
+                return `[theme:${ivo.themeColor}]`;
+        }
+    }
+    return "[dynamic]";
+}
+/**
+ * Extract parent context (page or component name + ID) from a file key path.
+ * Examples:
+ *   "page/id-Scaffold_xxx/page-widget-tree-outline/node/id-Widget_yyy"
+ *   "component/id-Container_xxx/component-widget-tree-outline/node/id-Widget_yyy"
+ */
+function parseParentFromKey(fileKey) {
+    const pageMatch = fileKey.match(/^page\/id-(Scaffold_\w+)\//);
+    if (pageMatch)
+        return { type: "page", id: pageMatch[1] };
+    const compMatch = fileKey.match(/^component\/id-(Container_\w+)\//);
+    if (compMatch)
+        return { type: "component", id: compMatch[1] };
+    return null;
+}
+/**
+ * Resolve the name of a page or component from its top-level YAML cache.
+ */
+async function resolveParentName(projectId, parentType, parentId) {
+    const prefix = parentType === "page" ? "page" : "component";
+    const fileKey = `${prefix}/id-${parentId}`;
+    const content = await cacheRead(projectId, fileKey);
+    if (!content)
+        return parentId;
+    const nameMatch = content.match(/^name:\s*(.+)$/m);
+    return nameMatch ? nameMatch[1].trim() : parentId;
+}
+// ---------------------------------------------------------------------------
+// Tool registration
+// ---------------------------------------------------------------------------
+export function registerFindComponentUsagesTool(server) {
+    server.tool("find_component_usages", "Find all pages and components where a given component is used, with parameter pass details. Cache-only, no API calls. Run sync_project first.", {
+        projectId: z.string().describe("The FlutterFlow project ID"),
+        componentName: z
+            .string()
+            .optional()
+            .describe("Human-readable component name (e.g. 'PremuimContentWall'). Case-insensitive."),
+        componentId: z
+            .string()
+            .optional()
+            .describe("Container ID (e.g. 'Container_ffzg5wc5')."),
+    }, async ({ projectId, componentName, componentId }) => {
+        // Check cache exists
+        const meta = await cacheMeta(projectId);
+        if (!meta) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `No cache found for project "${projectId}". Run sync_project first to download the project YAML files.`,
+                    },
+                ],
+            };
+        }
+        if (!componentName && !componentId) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: "Provide either componentName or componentId.",
+                    },
+                ],
+            };
+        }
+        // Resolve component to its key
+        const resolved = await resolveComponent(projectId, componentName, componentId);
+        if (!resolved.ok) {
+            const list = resolved.available.map((n) => `  - ${n}`).join("\n");
+            const searchTerm = componentName || componentId || "";
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Component "${searchTerm}" not found in cache. Available components:\n${list}`,
+                    },
+                ],
+            };
+        }
+        const targetId = resolved.component.containerId;
+        // Get component name for display
+        const componentContent = await cacheRead(projectId, resolved.component.componentFileKey);
+        const displayName = componentContent
+            ? (componentContent.match(/^name:\s*(.+)$/m)?.[1]?.trim() || targetId)
+            : targetId;
+        // Scan all node files for componentClassKeyRef matching this component
+        const allKeys = await listCachedKeys(projectId);
+        const nodeKeys = allKeys.filter((k) => /\/node\/id-[A-Z]/.test(k));
+        // Read node files in batches to check for component references
+        const usages = [];
+        await batchProcess(nodeKeys, 20, async (nodeKey) => {
+            const content = await cacheRead(projectId, nodeKey);
+            if (!content)
+                return;
+            // Quick string check before parsing YAML
+            if (!content.includes(targetId))
+                return;
+            let doc;
+            try {
+                doc = YAML.parse(content);
+            }
+            catch {
+                return;
+            }
+            // Check componentClassKeyRef
+            const classKeyRef = doc.componentClassKeyRef;
+            if (!classKeyRef)
+                return;
+            const refKey = classKeyRef.key;
+            if (refKey !== targetId)
+                return;
+            // Found a usage! Extract parent context
+            const parent = parseParentFromKey(nodeKey);
+            if (!parent)
+                return;
+            // Extract the widget key from the file key
+            const widgetKeyMatch = nodeKey.match(/\/node\/id-(\w+)$/);
+            const widgetKey = widgetKeyMatch ? widgetKeyMatch[1] : "unknown";
+            // Extract parameter passes
+            const params = [];
+            const parameterValues = doc.parameterValues;
+            if (parameterValues) {
+                for (const [, paramVal] of Object.entries(parameterValues)) {
+                    const paramId = paramVal.paramIdentifier;
+                    const value = resolveParamValue(paramVal);
+                    params.push({
+                        paramName: paramId || "unknown",
+                        value,
+                    });
+                }
+            }
+            // Resolve parent name
+            const parentName = await resolveParentName(projectId, parent.type, parent.id);
+            usages.push({
+                parentType: parent.type,
+                parentName,
+                parentId: parent.id,
+                widgetKey,
+                params,
+            });
+        });
+        // Format output
+        if (usages.length === 0) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Component: ${displayName} (${targetId})\nNo usages found in cached files.`,
+                    },
+                ],
+            };
+        }
+        const lines = [];
+        lines.push(`Component: ${displayName} (${targetId})`);
+        lines.push(`Found ${usages.length} usage${usages.length === 1 ? "" : "s"}:`);
+        lines.push("");
+        for (let i = 0; i < usages.length; i++) {
+            const u = usages[i];
+            const parentLabel = u.parentType === "page" ? u.parentName : `[component] ${u.parentName}`;
+            lines.push(`${i + 1}. ${parentLabel} (${u.parentId}) \u2192 ${u.widgetKey}`);
+            if (u.params.length > 0) {
+                const paramStrs = u.params.map((p) => `${p.paramName} = ${p.value}`);
+                lines.push(`   Params: ${paramStrs.join(", ")}`);
+            }
+        }
+        return {
+            content: [{ type: "text", text: lines.join("\n") }],
+        };
+    });
+}

package/build/tools/find-page-navigations.d.ts

@@ -0,0 +1,7 @@
+/**
+ * find_page_navigations tool — scans cached action files to find all places
+ * that navigate to a given page.
+ * Zero API calls: everything comes from the local .ff-cache.
+ */
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerFindPageNavigationsTool(server: McpServer): void;

package/build/tools/find-page-navigations.js

@@ -0,0 +1,228 @@
+import { z } from "zod";
+import YAML from "yaml";
+import { cacheRead, cacheMeta, listCachedKeys, } from "../utils/cache.js";
+import { resolvePage } from "./get-page-summary.js";
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+async function batchProcess(items, batchSize, fn) {
+    const results = [];
+    for (let i = 0; i < items.length; i += batchSize) {
+        const batch = items.slice(i, i + batchSize);
+        const batchResults = await Promise.all(batch.map(fn));
+        results.push(...batchResults);
+    }
+    return results;
+}
+/**
+ * Parse parent context from an action file key.
+ * Example: "page/id-Scaffold_XXX/page-widget-tree-outline/node/id-Widget_YYY/trigger_actions/id-ON_TAP/action/id-zzz"
+ */
+function parseActionContext(fileKey) {
+    // Page action
+    const pageMatch = fileKey.match(/^page\/id-(Scaffold_\w+)\/.*\/node\/id-(\w+)\/trigger_actions\/id-([^/]+)\/action\//);
+    if (pageMatch) {
+        return {
+            parentType: "page",
+            parentId: pageMatch[1],
+            widgetKey: pageMatch[2],
+            trigger: pageMatch[3],
+        };
+    }
+    // Component action
+    const compMatch = fileKey.match(/^component\/id-(Container_\w+)\/.*\/node\/id-(\w+)\/trigger_actions\/id-([^/]+)\/action\//);
+    if (compMatch) {
+        return {
+            parentType: "component",
+            parentId: compMatch[1],
+            widgetKey: compMatch[2],
+            trigger: compMatch[3],
+        };
+    }
+    return null;
+}
+/**
+ * Recursively search an object for a navigate action targeting the given scaffold ID.
+ * Returns navigate details if found, including whether it's inside a disableAction.
+ */
+function findNavigateAction(obj, targetScaffoldId, isDisabled, depth) {
+    if (!obj || typeof obj !== "object" || depth > 12)
+        return null;
+    const o = obj;
+    // Check for disableAction wrapper
+    if ("disableAction" in o) {
+        const da = o.disableAction;
+        return findNavigateAction(da, targetScaffoldId, true, depth + 1);
+    }
+    // Check for navigate action with matching pageNodeKeyRef
+    if ("navigate" in o) {
+        const nav = o.navigate;
+        const pageRef = nav.pageNodeKeyRef;
+        if (pageRef?.key === targetScaffoldId) {
+            const allowBack = nav.allowBack ?? true;
+            const passedParams = [];
+            const params = nav.passedParameters;
+            if (params) {
+                for (const [key, val] of Object.entries(params)) {
+                    if (key === "widgetClassNodeKeyRef")
+                        continue;
+                    passedParams.push(key);
+                }
+            }
+            return { disabled: isDisabled, allowBack, passedParams };
+        }
+    }
+    // Recurse into values
+    for (const val of Object.values(o)) {
+        if (val && typeof val === "object") {
+            const found = findNavigateAction(val, targetScaffoldId, isDisabled, depth + 1);
+            if (found)
+                return found;
+        }
+    }
+    return null;
+}
+/**
+ * Resolve the name of a page or component from its top-level YAML cache.
+ */
+async function resolveParentName(projectId, parentType, parentId) {
+    const prefix = parentType === "page" ? "page" : "component";
+    const fileKey = `${prefix}/id-${parentId}`;
+    const content = await cacheRead(projectId, fileKey);
+    if (!content)
+        return parentId;
+    const nameMatch = content.match(/^name:\s*(.+)$/m);
+    return nameMatch ? nameMatch[1].trim() : parentId;
+}
+// ---------------------------------------------------------------------------
+// Tool registration
+// ---------------------------------------------------------------------------
+export function registerFindPageNavigationsTool(server) {
+    server.tool("find_page_navigations", "Find all actions that navigate to a given page, showing source page, trigger, disabled status, and passed parameters. Cache-only, no API calls. Run sync_project first.", {
+        projectId: z.string().describe("The FlutterFlow project ID"),
+        pageName: z
+            .string()
+            .optional()
+            .describe("Human-readable page name (e.g. 'PaywallPage'). Case-insensitive."),
+        scaffoldId: z
+            .string()
+            .optional()
+            .describe("Scaffold ID (e.g. 'Scaffold_tydsj8ql')."),
+    }, async ({ projectId, pageName, scaffoldId }) => {
+        // Check cache exists
+        const meta = await cacheMeta(projectId);
+        if (!meta) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `No cache found for project "${projectId}". Run sync_project first to download the project YAML files.`,
+                    },
+                ],
+            };
+        }
+        if (!pageName && !scaffoldId) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: "Provide either pageName or scaffoldId.",
+                    },
+                ],
+            };
+        }
+        // Resolve page
+        const resolved = await resolvePage(projectId, pageName, scaffoldId);
+        if (!resolved.ok) {
+            const list = resolved.available.map((n) => `  - ${n}`).join("\n");
+            const searchTerm = pageName || scaffoldId || "";
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Page "${searchTerm}" not found in cache. Available pages:\n${list}`,
+                    },
+                ],
+            };
+        }
+        const targetScaffoldId = resolved.page.scaffoldId;
+        // Get target page name for display
+        const targetContent = await cacheRead(projectId, resolved.page.pageFileKey);
+        const displayName = targetContent
+            ? (targetContent.match(/^name:\s*(.+)$/m)?.[1]?.trim() || targetScaffoldId)
+            : targetScaffoldId;
+        // Scan all action files for navigate references
+        const allKeys = await listCachedKeys(projectId);
+        const actionKeys = allKeys.filter((k) => /\/action\/id-/.test(k));
+        const refs = [];
+        await batchProcess(actionKeys, 20, async (actionKey) => {
+            const content = await cacheRead(projectId, actionKey);
+            if (!content)
+                return;
+            // Quick string check before YAML parsing
+            if (!content.includes(targetScaffoldId))
+                return;
+            let doc;
+            try {
+                doc = YAML.parse(content);
+            }
+            catch {
+                return;
+            }
+            const navInfo = findNavigateAction(doc, targetScaffoldId, false, 0);
+            if (!navInfo)
+                return;
+            const ctx = parseActionContext(actionKey);
+            if (!ctx)
+                return;
+            const parentName = await resolveParentName(projectId, ctx.parentType, ctx.parentId);
+            refs.push({
+                parentType: ctx.parentType,
+                parentName,
+                parentId: ctx.parentId,
+                widgetKey: ctx.widgetKey,
+                trigger: ctx.trigger,
+                disabled: navInfo.disabled,
+                allowBack: navInfo.allowBack,
+                passedParams: navInfo.passedParams,
+            });
+        });
+        // Deduplicate (same parent + widget + trigger)
+        const seen = new Set();
+        const uniqueRefs = refs.filter((r) => {
+            const key = `${r.parentId}:${r.widgetKey}:${r.trigger}:${r.disabled}`;
+            if (seen.has(key))
+                return false;
+            seen.add(key);
+            return true;
+        });
+        // Format output
+        if (uniqueRefs.length === 0) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Page: ${displayName} (${targetScaffoldId})\nNo navigations found in cached action files.`,
+                    },
+                ],
+            };
+        }
+        const lines = [];
+        lines.push(`Page: ${displayName} (${targetScaffoldId})`);
+        lines.push(`Found ${uniqueRefs.length} navigation${uniqueRefs.length === 1 ? "" : "s"}:`);
+        lines.push("");
+        for (let i = 0; i < uniqueRefs.length; i++) {
+            const r = uniqueRefs[i];
+            const status = r.disabled ? "[DISABLED] " : "";
+            const parentLabel = r.parentType === "page" ? r.parentName : `[component] ${r.parentName}`;
+            const back = r.allowBack ? "" : " (no back)";
+            lines.push(`${i + 1}. ${status}${parentLabel} (${r.parentId}) → ${r.trigger} on ${r.widgetKey}${back}`);
+            if (r.passedParams.length > 0) {
+                lines.push(`   Params: ${r.passedParams.join(", ")}`);
+            }
+        }
+        return {
+            content: [{ type: "text", text: lines.join("\n") }],
+        };
+    });
+}

package/build/tools/get-component-summary.d.ts

@@ -0,0 +1,22 @@
+/**
+ * get_component_summary tool — assembles cached sub-files into a readable
+ * component summary. Zero API calls: everything comes from the local .ff-cache.
+ */
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+interface ResolvedComponent {
+    containerId: string;
+    componentFileKey: string;
+}
+/**
+ * Resolve a component name or container ID to its cache file key.
+ * Returns all available component names if no match found.
+ */
+export declare function resolveComponent(projectId: string, componentName?: string, componentId?: string): Promise<{
+    ok: true;
+    component: ResolvedComponent;
+} | {
+    ok: false;
+    available: string[];
+}>;
+export declare function registerGetComponentSummaryTool(server: McpServer): void;
+export {};

package/build/tools/get-component-summary.js

@@ -0,0 +1,193 @@
+import { z } from "zod";
+import YAML from "yaml";
+import { cacheRead, cacheMeta, listCachedKeys, } from "../utils/cache.js";
+import { parseTreeOutline } from "../utils/page-summary/tree-walker.js";
+import { extractNodeInfo } from "../utils/page-summary/node-extractor.js";
+import { summarizeTriggers } from "../utils/page-summary/action-summarizer.js";
+import { formatComponentSummary } from "../utils/page-summary/formatter.js";
+/**
+ * Resolve a component name or container ID to its cache file key.
+ * Returns all available component names if no match found.
+ */
+export async function resolveComponent(projectId, componentName, componentId) {
+    if (componentId) {
+        const componentFileKey = `component/id-${componentId}`;
+        const content = await cacheRead(projectId, componentFileKey);
+        if (content) {
+            return { ok: true, component: { containerId: componentId, componentFileKey } };
+        }
+    }
+    // List all cached component top-level files
+    const allKeys = await listCachedKeys(projectId, "component/id-");
+    // Filter to top-level component files only (not sub-files)
+    const componentKeys = allKeys.filter((k) => /^component\/id-Container_\w+$/.test(k));
+    const available = [];
+    for (const key of componentKeys) {
+        const content = await cacheRead(projectId, key);
+        if (!content)
+            continue;
+        const nameMatch = content.match(/^name:\s*(.+)$/m);
+        const name = nameMatch ? nameMatch[1].trim() : "";
+        if (componentName && name.toLowerCase() === componentName.toLowerCase()) {
+            const cid = key.match(/^component\/id-(Container_\w+)$/)?.[1] || "";
+            return { ok: true, component: { containerId: cid, componentFileKey: key } };
+        }
+        if (name)
+            available.push(name);
+    }
+    return { ok: false, available };
+}
+// ---------------------------------------------------------------------------
+// Metadata extraction
+// ---------------------------------------------------------------------------
+/** Resolve a scalar/list data type to a readable string. */
+function resolveDataType(dt) {
+    if (dt.listType) {
+        const inner = dt.listType;
+        return `List<${inner.scalarType || "unknown"}>`;
+    }
+    if (dt.scalarType === "DataStruct") {
+        const sub = dt.subType;
+        const dsi = sub?.dataStructIdentifier;
+        return dsi?.name ? `DataStruct:${dsi.name}` : "DataStruct";
+    }
+    if (dt.enumType) {
+        const en = dt.enumType;
+        const eid = en.enumIdentifier;
+        return eid?.name ? `Enum:${eid.name}` : "Enum";
+    }
+    return dt.scalarType || "unknown";
+}
+/** Extract component metadata (name, description, params) from the top-level YAML. */
+async function extractComponentMeta(projectId, component) {
+    const content = await cacheRead(projectId, component.componentFileKey);
+    if (!content) {
+        return {
+            componentName: component.containerId,
+            containerId: component.containerId,
+            description: "",
+            params: [],
+        };
+    }
+    const doc = YAML.parse(content);
+    const componentName = doc.name || component.containerId;
+    const description = doc.description || "";
+    // Params
+    const params = [];
+    const rawParams = doc.params;
+    if (rawParams) {
+        for (const val of Object.values(rawParams)) {
+            const id = val.identifier;
+            const name = id?.name || "unknown";
+            const dt = val.dataType || {};
+            const defaultVal = val.defaultValue;
+            params.push({
+                name,
+                dataType: resolveDataType(dt),
+                defaultValue: defaultVal?.serializedValue,
+            });
+        }
+    }
+    return { componentName, containerId: component.containerId, description, params };
+}
+// ---------------------------------------------------------------------------
+// Tree enrichment (reused from page summary)
+// ---------------------------------------------------------------------------
+/**
+ * Recursively enrich an OutlineNode tree with node info and trigger summaries.
+ */
+async function enrichNode(projectId, treePrefix, // e.g. "component/id-Container_xxx/component-widget-tree-outline"
+outline) {
+    const nodeInfo = await extractNodeInfo(projectId, treePrefix, outline.key);
+    // Check for triggers
+    const nodeFilePrefix = `${treePrefix}/node/id-${outline.key}`;
+    const triggers = await summarizeTriggers(projectId, nodeFilePrefix);
+    // Enrich children
+    const children = await Promise.all(outline.children.map((child) => enrichNode(projectId, treePrefix, child)));
+    return {
+        key: outline.key,
+        type: nodeInfo.type,
+        name: nodeInfo.name,
+        slot: outline.slot,
+        detail: nodeInfo.detail,
+        triggers,
+        children,
+    };
+}
+// ---------------------------------------------------------------------------
+// Tool registration
+// ---------------------------------------------------------------------------
+export function registerGetComponentSummaryTool(server) {
+    server.tool("get_component_summary", "Get a readable summary of a FlutterFlow component from local cache — widget tree, actions, params. No API calls. Run sync_project first if not cached.", {
+        projectId: z.string().describe("The FlutterFlow project ID"),
+        componentName: z
+            .string()
+            .optional()
+            .describe("Human-readable component name (e.g. 'PremuimContentWall'). Case-insensitive. Provide either componentName or componentId."),
+        componentId: z
+            .string()
+            .optional()
+            .describe("Container ID (e.g. 'Container_ffzg5wc5'). Provide either componentName or componentId."),
+    }, async ({ projectId, componentName, componentId }) => {
+        // Check cache exists
+        const meta = await cacheMeta(projectId);
+        if (!meta) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `No cache found for project "${projectId}". Run sync_project first to download the project YAML files.`,
+                    },
+                ],
+            };
+        }
+        if (!componentName && !componentId) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: "Provide either componentName or componentId.",
+                    },
+                ],
+            };
+        }
+        // Resolve component
+        const resolved = await resolveComponent(projectId, componentName, componentId);
+        if (!resolved.ok) {
+            const list = resolved.available.map((n) => `  - ${n}`).join("\n");
+            const searchTerm = componentName || componentId || "";
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Component "${searchTerm}" not found in cache. Available components:\n${list}`,
+                    },
+                ],
+            };
+        }
+        const component = resolved.component;
+        // Extract metadata
+        const componentMeta = await extractComponentMeta(projectId, component);
+        // Parse widget tree outline
+        const outlineKey = `${component.componentFileKey}/component-widget-tree-outline`;
+        const outlineContent = await cacheRead(projectId, outlineKey);
+        if (!outlineContent) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Component "${componentMeta.componentName}" found but widget tree outline is not cached. Re-run sync_project to fetch all sub-files.`,
+                    },
+                ],
+            };
+        }
+        const outlineTree = parseTreeOutline(outlineContent);
+        // Enrich the tree with node info and triggers
+        const enrichedTree = await enrichNode(projectId, outlineKey, outlineTree);
+        // Format output
+        const summary = formatComponentSummary(componentMeta, enrichedTree);
+        return {
+            content: [{ type: "text", text: summary }],
+        };
+    });
+}

package/build/tools/get-page-by-name.d.ts

@@ -0,0 +1,3 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { FlutterFlowClient } from "../api/flutterflow.js";
+export declare function registerGetPageByNameTool(server: McpServer, client: FlutterFlowClient): void;