flutterflow-mcp 0.2.3 → 0.2.5

package/build/index.js

@@ -21,6 +21,12 @@ import { registerModifyComponentPrompt } from "./prompts/modify-component.js";
 import { registerInspectProjectPrompt } from "./prompts/inspect-project.js";
 import { registerDevWorkflowPrompt } from "./prompts/dev-workflow.js";
 import { registerGetYamlDocsTool } from "./tools/get-yaml-docs.js";
+import { registerGetAppStateTool } from "./tools/get-app-state.js";
+import { registerGetApiEndpointsTool } from "./tools/get-api-endpoints.js";
+import { registerGetDataModelsTool } from "./tools/get-data-models.js";
+import { registerGetCustomCodeTool } from "./tools/get-custom-code.js";
+import { registerGetProjectConfigTool } from "./tools/get-project-config.js";
+import { registerGetThemeTool } from "./tools/get-theme.js";
 const server = new McpServer({
     name: "ff-mcp",
     version: "0.1.0",
@@ -40,6 +46,12 @@ registerGetComponentSummaryTool(server);
 registerFindComponentUsagesTool(server);
 registerFindPageNavigationsTool(server);
 registerGetYamlDocsTool(server);
+registerGetAppStateTool(server);
+registerGetApiEndpointsTool(server);
+registerGetDataModelsTool(server);
+registerGetCustomCodeTool(server);
+registerGetProjectConfigTool(server);
+registerGetThemeTool(server);
 // Register resources
 registerResources(server, client);
 registerDocsResources(server);

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

@@ -2,19 +2,10 @@ import { z } from "zod";
 import YAML from "yaml";
 import { cacheRead, cacheMeta, listCachedKeys, } from "../utils/cache.js";
 import { resolveComponent } from "./get-component-summary.js";
+import { batchProcess } from "../utils/batch-process.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.
  */

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

@@ -2,18 +2,10 @@ import { z } from "zod";
 import YAML from "yaml";
 import { cacheRead, cacheMeta, listCachedKeys, } from "../utils/cache.js";
 import { resolvePage } from "./get-page-summary.js";
+import { batchProcess } from "../utils/batch-process.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"

package/build/tools/get-api-endpoints.d.ts

@@ -0,0 +1,2 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerGetApiEndpointsTool(server: McpServer): void;

package/build/tools/get-api-endpoints.js

@@ -0,0 +1,126 @@
+import { z } from "zod";
+import YAML from "yaml";
+import { cacheRead, cacheMeta, listCachedKeys } from "../utils/cache.js";
+import { batchProcess } from "../utils/batch-process.js";
+function parseEndpoint(content) {
+    const doc = YAML.parse(content);
+    if (!doc)
+        return null;
+    const identifier = doc.identifier;
+    const name = identifier?.name || "Unknown";
+    const method = doc.callType || "GET";
+    const url = doc.url || "";
+    const bodyType = doc.bodyType;
+    const body = doc.body;
+    const variables = [];
+    const rawVars = doc.variables;
+    if (Array.isArray(rawVars)) {
+        for (const v of rawVars) {
+            const vid = v.identifier;
+            const vName = vid?.name || "unknown";
+            const vType = v.type || "String";
+            variables.push({ name: vName, type: vType });
+        }
+    }
+    const headers = [];
+    const rawHeaders = doc.headers;
+    if (Array.isArray(rawHeaders)) {
+        headers.push(...rawHeaders);
+    }
+    const responseFields = [];
+    const rawJsonPaths = doc.jsonPathDefinitions;
+    if (Array.isArray(rawJsonPaths)) {
+        for (const jp of rawJsonPaths) {
+            const jpId = jp.identifier;
+            const jpName = jpId?.name || "unknown";
+            const jpDef = jp.jsonPath;
+            const path = jpDef?.jsonPath || "";
+            const returnParam = jpDef?.returnParameter;
+            const dt = returnParam?.dataType;
+            const scalarType = dt?.scalarType || "String";
+            responseFields.push({ name: jpName, type: scalarType, jsonPath: path });
+        }
+    }
+    return { name, method, url, bodyType, body, variables, headers, responseFields };
+}
+function formatEndpoints(endpoints) {
+    if (endpoints.length === 0)
+        return "No API endpoints found in cache.";
+    const lines = [`# API Endpoints (${endpoints.length})`];
+    for (const ep of endpoints) {
+        lines.push("");
+        lines.push(`## ${ep.name}`);
+        lines.push(`Method: ${ep.method}`);
+        lines.push(`URL: ${ep.url}`);
+        if (ep.bodyType)
+            lines.push(`Body type: ${ep.bodyType}`);
+        if (ep.variables.length > 0) {
+            lines.push("Variables:");
+            for (const v of ep.variables) {
+                lines.push(`  - ${v.name}: ${v.type}`);
+            }
+        }
+        if (ep.headers.length > 0) {
+            lines.push("Headers:");
+            for (const h of ep.headers) {
+                lines.push(`  - ${h}`);
+            }
+        }
+        if (ep.responseFields.length > 0) {
+            lines.push("Response fields:");
+            for (const rf of ep.responseFields) {
+                lines.push(`  - ${rf.name}: ${rf.type} (${rf.jsonPath})`);
+            }
+        }
+    }
+    return lines.join("\n");
+}
+export function registerGetApiEndpointsTool(server) {
+    server.tool("get_api_endpoints", "Get API endpoint definitions from local cache — method, URL, variables, headers, response fields. No API calls. Run sync_project first if not cached.", {
+        projectId: z.string().describe("The FlutterFlow project ID"),
+        name: z
+            .string()
+            .optional()
+            .describe("Case-insensitive filter on endpoint name"),
+    }, async ({ projectId, name }) => {
+        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.`,
+                    },
+                ],
+            };
+        }
+        const allKeys = await listCachedKeys(projectId, "api-endpoint/id-");
+        const topLevelKeys = allKeys.filter((k) => /^api-endpoint\/id-[a-z0-9]+$/i.test(k));
+        const parsed = await batchProcess(topLevelKeys, 10, async (key) => {
+            const content = await cacheRead(projectId, key);
+            if (!content)
+                return null;
+            return parseEndpoint(content);
+        });
+        let endpoints = parsed.filter((ep) => ep !== null);
+        if (name) {
+            const lower = name.toLowerCase();
+            const filtered = endpoints.filter((ep) => ep.name.toLowerCase().includes(lower));
+            if (filtered.length === 0) {
+                const available = endpoints.map((ep) => ep.name).join(", ");
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `No API endpoints matching '${name}' found. Available: ${available}`,
+                        },
+                    ],
+                };
+            }
+            endpoints = filtered;
+        }
+        return {
+            content: [{ type: "text", text: formatEndpoints(endpoints) }],
+        };
+    });
+}

package/build/tools/get-app-state.d.ts

@@ -0,0 +1,2 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerGetAppStateTool(server: McpServer): void;

package/build/tools/get-app-state.js

@@ -0,0 +1,96 @@
+import { z } from "zod";
+import YAML from "yaml";
+import { cacheRead, cacheMeta } from "../utils/cache.js";
+import { resolveDataType } from "../utils/resolve-data-type.js";
+export function registerGetAppStateTool(server) {
+    server.tool("get_app_state", "Get app state variables, constants, and environment settings from local cache. No API calls. Run sync_project first if not cached.", {
+        projectId: z.string().describe("The FlutterFlow project ID"),
+    }, async ({ projectId }) => {
+        const meta = await cacheMeta(projectId);
+        if (!meta) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `No cache found for project "${projectId}". Run sync_project first.`,
+                    },
+                ],
+            };
+        }
+        const sections = ["# App State"];
+        // --- State Variables ---
+        const appStateYaml = await cacheRead(projectId, "app-state");
+        if (appStateYaml) {
+            const doc = YAML.parse(appStateYaml);
+            const fields = doc.fields || [];
+            const lines = [];
+            for (const field of fields) {
+                const name = field.parameter?.identifier?.name || "unknown";
+                const dt = resolveDataType(field.parameter?.dataType || {});
+                const parts = [`- ${name}: ${dt}`];
+                if (field.persisted)
+                    parts.push("(persisted)");
+                if (field.serializedDefaultValue && field.serializedDefaultValue.length > 0) {
+                    const joined = field.serializedDefaultValue
+                        .map((v) => `"${v}"`)
+                        .join(", ");
+                    parts.push(`[default: ${joined}]`);
+                }
+                lines.push(parts.join(" "));
+            }
+            sections.push("\n## State Variables");
+            if (lines.length > 0) {
+                sections.push(lines.join("\n"));
+            }
+            const secure = doc.securePersistedValues ?? false;
+            sections.push(`\nSecure persisted values: ${secure ? "Yes" : "No"}`);
+        }
+        // --- Constants ---
+        const constantsYaml = await cacheRead(projectId, "app-constants");
+        if (constantsYaml) {
+            const doc = YAML.parse(constantsYaml);
+            const fields = doc.fields || [];
+            const lines = [];
+            for (const field of fields) {
+                const name = field.parameter?.identifier?.name || "unknown";
+                const dt = resolveDataType(field.parameter?.dataType || {});
+                const vals = field.serializedValue || [];
+                const formatted = vals.map((v) => `"${v}"`).join(", ");
+                lines.push(`- ${name}: ${dt} = [${formatted}]`);
+            }
+            sections.push("\n## Constants");
+            if (lines.length > 0) {
+                sections.push(lines.join("\n"));
+            }
+        }
+        // --- Environment Settings ---
+        const envYaml = await cacheRead(projectId, "environment-settings");
+        if (envYaml) {
+            const doc = YAML.parse(envYaml);
+            const currentEnv = doc.currentEnvironment;
+            const envValues = doc.environmentValues || [];
+            sections.push("\n## Environment Settings");
+            if (currentEnv) {
+                sections.push(`Current: ${currentEnv.name || "unknown"} (${currentEnv.key || "?"})`);
+            }
+            const lines = [];
+            for (const ev of envValues) {
+                const name = ev.parameter?.identifier?.name || "unknown";
+                const dt = resolveDataType(ev.parameter?.dataType || {});
+                const privateTag = ev.isPrivate ? " (private)" : "";
+                lines.push(`- ${name}: ${dt}${privateTag}`);
+                const valuesMap = ev.valuesMap || {};
+                for (const [envKey, envVal] of Object.entries(valuesMap)) {
+                    const display = ev.isPrivate ? "****" : (envVal.serializedValue ?? "");
+                    lines.push(`  ${envKey}: ${display}`);
+                }
+            }
+            if (lines.length > 0) {
+                sections.push(lines.join("\n"));
+            }
+        }
+        return {
+            content: [{ type: "text", text: sections.join("\n") }],
+        };
+    });
+}

package/build/tools/get-custom-code.d.ts

@@ -0,0 +1,2 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerGetCustomCodeTool(server: McpServer): void;

package/build/tools/get-custom-code.js

@@ -0,0 +1,284 @@
+import { z } from "zod";
+import YAML from "yaml";
+import { cacheRead, cacheMeta, listCachedKeys } from "../utils/cache.js";
+import { batchProcess } from "../utils/batch-process.js";
+import { resolveDataType } from "../utils/resolve-data-type.js";
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function formatArg(arg) {
+    return arg.required ? `${arg.name}: ${arg.type} (required)` : `${arg.name}: ${arg.type}?`;
+}
+function formatAction(action) {
+    const lines = [];
+    lines.push(`### ${action.name}`);
+    lines.push(`Key: ${action.key} | File: \`${action.fileKey}\``);
+    if (action.args.length === 0) {
+        lines.push("Args: (none)");
+    }
+    else {
+        lines.push(`Args: ${action.args.map(formatArg).join(", ")}`);
+    }
+    lines.push(`Returns: ${action.returnType ?? "void"}`);
+    lines.push(`Context: ${action.includeContext ? "Yes" : "No"}`);
+    if (action.code !== undefined) {
+        lines.push("");
+        lines.push("```dart");
+        lines.push(action.code);
+        lines.push("```");
+    }
+    return lines.join("\n");
+}
+function formatFunction(fn) {
+    const lines = [];
+    lines.push(`### ${fn.name}`);
+    lines.push(`Key: ${fn.key} | File: \`${fn.fileKey}\``);
+    if (fn.args.length === 0) {
+        lines.push("Args: (none)");
+    }
+    else {
+        lines.push(`Args: ${fn.args.map(formatArg).join(", ")}`);
+    }
+    lines.push(`Returns: ${fn.returnType ?? "void"}`);
+    if (fn.code !== undefined) {
+        lines.push("");
+        lines.push("```dart");
+        lines.push(fn.code);
+        lines.push("```");
+    }
+    return lines.join("\n");
+}
+function formatWidget(widget) {
+    const lines = [];
+    lines.push(`### ${widget.name}`);
+    lines.push(`Key: ${widget.key} | File: \`${widget.fileKey}\``);
+    if (widget.params.length === 0) {
+        lines.push("Params: (none)");
+    }
+    else {
+        lines.push("Params:");
+        for (const p of widget.params) {
+            const suffix = p.required ? " (required)" : "";
+            lines.push(`  - ${p.name}: ${p.type}${suffix}`);
+        }
+    }
+    if (widget.code !== undefined) {
+        lines.push("");
+        lines.push("```dart");
+        lines.push(widget.code);
+        lines.push("```");
+    }
+    return lines.join("\n");
+}
+function formatAgent(agent) {
+    const lines = [];
+    lines.push(`### ${agent.displayName} [${agent.status}]`);
+    lines.push(`Key: ${agent.key} | File: \`${agent.fileKey}\``);
+    lines.push(`Provider: ${agent.provider} (${agent.model})`);
+    lines.push(`Input: ${agent.requestTypes.join(", ")}`);
+    lines.push(`Output: ${agent.responseType}`);
+    if (agent.description) {
+        lines.push(`Description: ${agent.description}`);
+    }
+    return lines.join("\n");
+}
+function resolveReturnType(returnParam) {
+    if (!returnParam)
+        return null;
+    const dt = returnParam.dataType;
+    if (!dt)
+        return null;
+    const resolved = resolveDataType(dt);
+    const nonNullable = dt.nonNullable ?? false;
+    return nonNullable ? `${resolved} (required)` : `${resolved}?`;
+}
+function parseArgs(rawArgs) {
+    if (!Array.isArray(rawArgs))
+        return [];
+    return rawArgs.map((arg) => {
+        const id = arg.identifier;
+        const name = id?.name || "unknown";
+        const dt = arg.dataType || {};
+        const type = resolveDataType(dt);
+        const required = dt.nonNullable ?? false;
+        return { name, type, required };
+    });
+}
+// ---------------------------------------------------------------------------
+// Category processors
+// ---------------------------------------------------------------------------
+async function processActions(projectId, nameFilter, includeCode) {
+    const allKeys = await listCachedKeys(projectId, "custom-actions/id-");
+    const topKeys = allKeys.filter((k) => /^custom-actions\/id-[a-z0-9]+$/i.test(k));
+    return batchProcess(topKeys, 10, async (fileKey) => {
+        const content = await cacheRead(projectId, fileKey);
+        if (!content)
+            return null;
+        const doc = YAML.parse(content);
+        const id = doc.identifier;
+        const name = id?.name || "unknown";
+        if (nameFilter && name.toLowerCase() !== nameFilter.toLowerCase())
+            return null;
+        const idKey = id?.key || fileKey.match(/id-([a-z0-9]+)$/i)?.[1] || "unknown";
+        const args = parseArgs(doc.arguments);
+        const returnType = resolveReturnType(doc.returnParameter);
+        const includeContext = doc.includeContext ?? false;
+        let code;
+        if (includeCode) {
+            const codeContent = await cacheRead(projectId, `custom-actions/id-${idKey}/action-code.dart`);
+            if (codeContent)
+                code = codeContent;
+        }
+        return { name, key: idKey, fileKey, args, returnType, includeContext, code };
+    }).then((results) => results.filter((r) => r !== null));
+}
+async function processFunctions(projectId, nameFilter, includeCode) {
+    const allKeys = await listCachedKeys(projectId, "custom-functions/id-");
+    const topKeys = allKeys.filter((k) => /^custom-functions\/id-[a-z0-9]+$/i.test(k));
+    return batchProcess(topKeys, 10, async (fileKey) => {
+        const content = await cacheRead(projectId, fileKey);
+        if (!content)
+            return null;
+        const doc = YAML.parse(content);
+        const id = doc.identifier;
+        const name = id?.name || "unknown";
+        if (nameFilter && name.toLowerCase() !== nameFilter.toLowerCase())
+            return null;
+        const idKey = id?.key || fileKey.match(/id-([a-z0-9]+)$/i)?.[1] || "unknown";
+        const args = parseArgs(doc.arguments);
+        const returnType = resolveReturnType(doc.returnParameter);
+        let code;
+        if (includeCode) {
+            const codeContent = await cacheRead(projectId, `custom-functions/id-${idKey}/function-code.dart`);
+            if (codeContent)
+                code = codeContent;
+        }
+        return { name, key: idKey, fileKey, args, returnType, code };
+    }).then((results) => results.filter((r) => r !== null));
+}
+async function processWidgets(projectId, nameFilter, includeCode) {
+    const allKeys = await listCachedKeys(projectId, "custom-widgets/id-");
+    const topKeys = allKeys.filter((k) => /^custom-widgets\/id-[a-z0-9]+$/i.test(k));
+    return batchProcess(topKeys, 10, async (fileKey) => {
+        const content = await cacheRead(projectId, fileKey);
+        if (!content)
+            return null;
+        const doc = YAML.parse(content);
+        const id = doc.identifier;
+        const name = id?.name || "unknown";
+        if (nameFilter && name.toLowerCase() !== nameFilter.toLowerCase())
+            return null;
+        const idKey = id?.key || fileKey.match(/id-([a-z0-9]+)$/i)?.[1] || "unknown";
+        const rawParams = doc.parameters;
+        const params = parseArgs(rawParams);
+        const description = doc.description || "";
+        let code;
+        if (includeCode) {
+            const codeContent = await cacheRead(projectId, `custom-widgets/id-${idKey}/widget-code.dart`);
+            if (codeContent)
+                code = codeContent;
+        }
+        return { name, key: idKey, fileKey, params, description, code };
+    }).then((results) => results.filter((r) => r !== null));
+}
+async function processAgents(projectId, nameFilter) {
+    const allKeys = await listCachedKeys(projectId, "agent/id-");
+    const topKeys = allKeys.filter((k) => /^agent\/id-[a-z0-9]+$/i.test(k));
+    return batchProcess(topKeys, 10, async (fileKey) => {
+        const content = await cacheRead(projectId, fileKey);
+        if (!content)
+            return null;
+        const doc = YAML.parse(content);
+        const id = doc.identifier;
+        const identifierName = id?.name || "unknown";
+        if (nameFilter && identifierName.toLowerCase() !== nameFilter.toLowerCase())
+            return null;
+        const idKey = id?.key || fileKey.match(/id-([a-z0-9]+)$/i)?.[1] || "unknown";
+        const displayName = doc.name || identifierName;
+        const status = doc.status || "UNKNOWN";
+        const aiModel = doc.aiModel;
+        const provider = aiModel?.provider || "UNKNOWN";
+        const model = aiModel?.model || "unknown";
+        const reqOpts = doc.requestOptions;
+        const requestTypes = reqOpts?.requestTypes || [];
+        const resOpts = doc.responseOptions;
+        const responseType = resOpts?.responseType || "UNKNOWN";
+        const description = doc.description || "";
+        return { name: identifierName, key: idKey, fileKey, displayName, status, provider, model, requestTypes, responseType, description };
+    }).then((results) => results.filter((r) => r !== null));
+}
+// ---------------------------------------------------------------------------
+// Tool registration
+// ---------------------------------------------------------------------------
+export function registerGetCustomCodeTool(server) {
+    server.tool("get_custom_code", "Get custom actions, functions, widgets, and AI agents from local cache — signatures, arguments, return types, and optionally Dart source code. No API calls. Run sync_project first if not cached.", {
+        projectId: z.string().describe("The FlutterFlow project ID"),
+        type: z
+            .enum(["actions", "functions", "widgets", "agents", "all"])
+            .optional()
+            .default("all")
+            .describe("Type of custom code to retrieve"),
+        name: z
+            .string()
+            .optional()
+            .describe("Case-insensitive filter on identifier name"),
+        includeCode: z
+            .boolean()
+            .optional()
+            .default(false)
+            .describe("Include Dart source code in output"),
+    }, async ({ projectId, type, name, includeCode }) => {
+        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.`,
+                    },
+                ],
+            };
+        }
+        const categories = type === "all"
+            ? ["actions", "functions", "widgets", "agents"]
+            : [type];
+        const sections = [];
+        for (const cat of categories) {
+            if (cat === "actions") {
+                const items = await processActions(projectId, name, includeCode);
+                if (items.length > 0) {
+                    sections.push(`## Custom Actions (${items.length})\n\n${items.map(formatAction).join("\n\n")}`);
+                }
+            }
+            else if (cat === "functions") {
+                const items = await processFunctions(projectId, name, includeCode);
+                if (items.length > 0) {
+                    sections.push(`## Custom Functions (${items.length})\n\n${items.map(formatFunction).join("\n\n")}`);
+                }
+            }
+            else if (cat === "widgets") {
+                const items = await processWidgets(projectId, name, includeCode);
+                if (items.length > 0) {
+                    sections.push(`## Custom Widgets (${items.length})\n\n${items.map(formatWidget).join("\n\n")}`);
+                }
+            }
+            else if (cat === "agents") {
+                const items = await processAgents(projectId, name);
+                if (items.length > 0) {
+                    sections.push(`## AI Agents (${items.length})\n\n${items.map(formatAgent).join("\n\n")}`);
+                }
+            }
+        }
+        if (sections.length === 0) {
+            return {
+                content: [
+                    { type: "text", text: "No custom code found in cache." },
+                ],
+            };
+        }
+        const output = `# Custom Code\n\n${sections.join("\n\n")}`;
+        return {
+            content: [{ type: "text", text: output }],
+        };
+    });
+}

package/build/tools/get-data-models.d.ts

@@ -0,0 +1,2 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerGetDataModelsTool(server: McpServer): void;