community-ff-mcp 0.4.0

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

@@ -0,0 +1,205 @@
+import { z } from "zod";
+import YAML from "yaml";
+import { cacheRead, cacheMeta, cacheAgeFooter, listCachedKeys, } from "../utils/cache.js";
+import { parseFolderMapping } from "../utils/parse-folders.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 { formatPageSummary } from "../utils/page-summary/formatter.js";
+import { resolveDataType } from "../utils/resolve-data-type.js";
+/**
+ * Resolve a page name or scaffold ID to its cache file key.
+ * Returns all available page names if no match found.
+ */
+export async function resolvePage(projectId, pageName, scaffoldId) {
+    if (scaffoldId) {
+        const pageFileKey = `page/id-${scaffoldId}`;
+        const content = await cacheRead(projectId, pageFileKey);
+        if (content) {
+            return { ok: true, page: { scaffoldId, pageFileKey } };
+        }
+    }
+    // List all cached page top-level files
+    const allKeys = await listCachedKeys(projectId, "page/id-Scaffold_");
+    // Filter to top-level page files only (not sub-files)
+    const pageKeys = allKeys.filter((k) => /^page\/id-Scaffold_\w+$/.test(k));
+    const available = [];
+    for (const key of pageKeys) {
+        const content = await cacheRead(projectId, key);
+        if (!content)
+            continue;
+        const nameMatch = content.match(/^name:\s*(.+)$/m);
+        const name = nameMatch ? nameMatch[1].trim() : "";
+        if (pageName && name.toLowerCase() === pageName.toLowerCase()) {
+            const sid = key.match(/^page\/id-(Scaffold_\w+)$/)?.[1] || "";
+            return { ok: true, page: { scaffoldId: sid, pageFileKey: key } };
+        }
+        if (name)
+            available.push(name);
+    }
+    return { ok: false, available };
+}
+// ---------------------------------------------------------------------------
+// Metadata extraction
+// ---------------------------------------------------------------------------
+/** Extract page metadata (name, params, state) from the top-level page YAML. */
+async function extractPageMeta(projectId, page, folder) {
+    const content = await cacheRead(projectId, page.pageFileKey);
+    if (!content) {
+        return {
+            pageName: page.scaffoldId,
+            scaffoldId: page.scaffoldId,
+            folder,
+            params: [],
+            stateFields: [],
+        };
+    }
+    const doc = YAML.parse(content);
+    const pageName = doc.name || page.scaffoldId;
+    // 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,
+            });
+        }
+    }
+    // State fields
+    const stateFields = [];
+    const classModel = doc.classModel;
+    const rawFields = classModel?.stateFields;
+    if (Array.isArray(rawFields)) {
+        for (const field of rawFields) {
+            const param = field.parameter;
+            if (!param)
+                continue;
+            const id = param.identifier;
+            const name = id?.name || "unknown";
+            const dt = param.dataType || {};
+            const defaultVals = field.serializedDefaultValue;
+            stateFields.push({
+                name,
+                dataType: resolveDataType(dt),
+                defaultValue: defaultVals?.[0],
+            });
+        }
+    }
+    return { pageName, scaffoldId: page.scaffoldId, folder, params, stateFields };
+}
+// ---------------------------------------------------------------------------
+// Tree enrichment
+// ---------------------------------------------------------------------------
+/**
+ * Recursively enrich an OutlineNode tree with node info and trigger summaries.
+ */
+async function enrichNode(projectId, pagePrefix, // e.g. "page/id-Scaffold_xxx/page-widget-tree-outline"
+outline) {
+    const nodeInfo = await extractNodeInfo(projectId, pagePrefix, outline.key);
+    // Check for triggers
+    const nodeFilePrefix = `${pagePrefix}/node/id-${outline.key}`;
+    const triggers = await summarizeTriggers(projectId, nodeFilePrefix);
+    // Enrich children
+    const children = await Promise.all(outline.children.map((child) => enrichNode(projectId, pagePrefix, child)));
+    return {
+        key: outline.key,
+        type: nodeInfo.type,
+        name: nodeInfo.name,
+        slot: outline.slot,
+        detail: nodeInfo.detail,
+        componentRef: nodeInfo.componentRef,
+        componentId: nodeInfo.componentId,
+        triggers,
+        children,
+    };
+}
+// ---------------------------------------------------------------------------
+// Tool registration
+// ---------------------------------------------------------------------------
+export function registerGetPageSummaryTool(server) {
+    server.tool("get_page_summary", "Get a readable summary of a FlutterFlow page from local cache — widget tree, actions, params, state. Component references are resolved to show [ComponentName] (ComponentId) instead of plain Container. Use the ComponentId with get_component_summary to drill into a component. No API calls. Run sync_project first if not cached.", {
+        projectId: z.string().describe("The FlutterFlow project ID"),
+        pageName: z
+            .string()
+            .optional()
+            .describe("Human-readable page name (e.g. 'PaywallPage'). Case-insensitive. Provide either pageName or scaffoldId."),
+        scaffoldId: z
+            .string()
+            .optional()
+            .describe("Scaffold ID (e.g. 'Scaffold_tydsj8ql'). Provide either pageName or scaffoldId."),
+    }, 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 page = resolved.page;
+        // Get folder mapping
+        const foldersContent = await cacheRead(projectId, "folders");
+        const folderMap = foldersContent
+            ? parseFolderMapping(foldersContent)
+            : {};
+        const folder = folderMap[page.scaffoldId] || "(unmapped)";
+        // Extract metadata
+        const pageMeta = await extractPageMeta(projectId, page, folder);
+        // Parse widget tree outline
+        const outlineKey = `${page.pageFileKey}/page-widget-tree-outline`;
+        const outlineContent = await cacheRead(projectId, outlineKey);
+        if (!outlineContent) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Page "${pageMeta.pageName}" 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 = formatPageSummary(pageMeta, enrichedTree);
+        return {
+            content: [{ type: "text", text: summary + cacheAgeFooter(meta) }],
+        };
+    });
+}

package/build/tools/get-project-config.d.ts

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

package/build/tools/get-project-config.js

@@ -0,0 +1,216 @@
+import { z } from "zod";
+import YAML from "yaml";
+import { cacheRead, cacheMeta, listCachedKeys } from "../utils/cache.js";
+async function resolvePageName(projectId, scaffoldId) {
+    const content = await cacheRead(projectId, `page/id-${scaffoldId}`);
+    if (!content)
+        return scaffoldId;
+    const nameMatch = content.match(/^name:\s*(.+)$/m);
+    return nameMatch ? nameMatch[1].trim() : scaffoldId;
+}
+export function registerGetProjectConfigTool(server) {
+    server.tool("get_project_config", "Get core project configuration — app name, entry pages, routing, nav bar, auth, permissions, services, main.dart lifecycle actions, and a project file map. 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 to download the project YAML files.`,
+                    },
+                ],
+            };
+        }
+        const [appDetailsRaw, navBarRaw, authRaw, permissionsRaw, revenueCatRaw] = await Promise.all([
+            cacheRead(projectId, "app-details"),
+            cacheRead(projectId, "nav-bar"),
+            cacheRead(projectId, "authentication"),
+            cacheRead(projectId, "permissions"),
+            cacheRead(projectId, "revenue-cat"),
+        ]);
+        const sections = ["# Project Configuration"];
+        // --- App Details ---
+        if (appDetailsRaw) {
+            const appDetails = YAML.parse(appDetailsRaw);
+            const appName = appDetails.name || "Unknown";
+            const initialPageKey = appDetails.initialPageKeyRef?.key;
+            const routing = appDetails.routingSettings;
+            const routingEnabled = routing?.enableRouting === true;
+            const subroutes = routing?.pagesAreSubroutesOfRoot === true;
+            let initialPageLine = "not set";
+            if (initialPageKey) {
+                const name = await resolvePageName(projectId, initialPageKey);
+                initialPageLine = `${name} (${initialPageKey})`;
+            }
+            sections.push(`\n## App Details`, `Name: ${appName}`, `Initial page: ${initialPageLine}`, `Routing: ${routingEnabled ? "enabled" : "disabled"}, pages are subroutes: ${subroutes ? "yes" : "no"}`);
+        }
+        else {
+            sections.push(`\n## App Details`, `(not cached)`);
+        }
+        // --- Authentication ---
+        if (authRaw) {
+            const auth = YAML.parse(authRaw);
+            const active = auth.active === true;
+            if (active) {
+                let provider = "Unknown";
+                const firebaseConfigs = auth.firebaseConfigFileInfos;
+                const supabase = auth.supabase;
+                if (firebaseConfigs && firebaseConfigs.length > 0) {
+                    provider = "Firebase";
+                }
+                else if (supabase && Object.keys(supabase).length > 0) {
+                    provider = "Supabase";
+                }
+                sections.push(`\n## Authentication`, `Status: Active`, `Provider: ${provider}`);
+            }
+            else {
+                sections.push(`\n## Authentication`, `Status: Inactive`);
+            }
+        }
+        else {
+            sections.push(`\n## Authentication`, `Status: Inactive`);
+        }
+        // Auth page info comes from app-details
+        if (appDetailsRaw) {
+            const appDetails = YAML.parse(appDetailsRaw);
+            const authPageInfo = appDetails.authPageInfo;
+            if (authPageInfo) {
+                const homeRef = authPageInfo.homePageNodeKeyRef?.key;
+                const signInRef = authPageInfo.signInPageNodeKeyRef?.key;
+                if (homeRef) {
+                    const name = await resolvePageName(projectId, homeRef);
+                    sections.push(`Home page: ${name} (${homeRef})`);
+                }
+                if (signInRef) {
+                    const name = await resolvePageName(projectId, signInRef);
+                    sections.push(`Sign-in page: ${name} (${signInRef})`);
+                }
+            }
+        }
+        // --- Nav Bar ---
+        if (navBarRaw) {
+            const navBar = YAML.parse(navBarRaw);
+            const visible = navBar.show === true;
+            if (visible) {
+                const navType = navBar.navBarType || "UNKNOWN";
+                const labels = navBar.labels === true;
+                const pageRefs = navBar.pageKeyRefOrder;
+                sections.push(`\n## Nav Bar`, `Visible: Yes`, `Type: ${navType}`, `Labels: ${labels ? "Yes" : "No"}`);
+                if (pageRefs && pageRefs.length > 0) {
+                    const tabs = [];
+                    for (let i = 0; i < pageRefs.length; i++) {
+                        const scaffoldId = pageRefs[i].key;
+                        const name = await resolvePageName(projectId, scaffoldId);
+                        tabs.push(`  ${i + 1}. ${name} (${scaffoldId})`);
+                    }
+                    sections.push(`Tabs:`, ...tabs);
+                }
+            }
+            else {
+                sections.push(`\n## Nav Bar`, `Visible: No`);
+            }
+        }
+        else {
+            sections.push(`\n## Nav Bar`, `Visible: No`);
+        }
+        // --- Permissions ---
+        if (permissionsRaw) {
+            const permissions = YAML.parse(permissionsRaw);
+            const builtIn = permissions.permissionMessages;
+            const custom = permissions.userDefinedPermissions;
+            const hasBuiltIn = builtIn && builtIn.length > 0;
+            const hasCustom = custom && custom.length > 0;
+            if (hasBuiltIn || hasCustom) {
+                sections.push(`\n## Permissions`);
+                if (hasBuiltIn) {
+                    sections.push(`Built-in:`);
+                    for (const perm of builtIn) {
+                        const permType = perm.permissionType || "UNKNOWN";
+                        const msg = perm.message?.textValue?.inputValue;
+                        sections.push(`  - ${permType}: ${msg ? `"${msg}"` : "(no message)"}`);
+                    }
+                }
+                if (hasCustom) {
+                    sections.push(`Custom:`);
+                    for (const perm of custom) {
+                        const names = perm.names;
+                        const iosName = names?.iosName || "?";
+                        const androidName = names?.androidName || "?";
+                        const msg = perm.message?.textValue?.inputValue;
+                        sections.push(`  - ${iosName} / ${androidName}: ${msg ? `"${msg}"` : "(no message)"}`);
+                    }
+                }
+            }
+        }
+        // --- Services ---
+        sections.push(`\n## Services`);
+        if (revenueCatRaw) {
+            const revenueCat = YAML.parse(revenueCatRaw);
+            sections.push(`RevenueCat: ${revenueCat.enabled === true ? "enabled" : "disabled"}`);
+        }
+        else {
+            sections.push(`RevenueCat: disabled`);
+        }
+        // --- Lifecycle Actions (main.dart) ---
+        sections.push(`\n## Lifecycle Actions (main.dart)`);
+        const mainFileRaw = await cacheRead(projectId, "custom-file/id-MAIN");
+        if (mainFileRaw) {
+            const mainFile = YAML.parse(mainFileRaw);
+            const actions = mainFile.actions;
+            if (actions && actions.length > 0) {
+                const initialActions = actions.filter((a) => a.type === "INITIAL_ACTION");
+                const finalActions = actions.filter((a) => a.type === "FINAL_ACTION");
+                const formatAction = (action, index) => {
+                    const identifier = action.identifier;
+                    const name = identifier?.name || "(unnamed)";
+                    const key = identifier?.key;
+                    const fromProject = identifier?.projectId;
+                    const fromSuffix = fromProject ? `, from: ${fromProject}` : "";
+                    return `  ${index + 1}. ${name} (key: ${key}${fromSuffix})`;
+                };
+                if (initialActions.length > 0) {
+                    sections.push(`Initial Actions:`);
+                    initialActions.forEach((a, i) => sections.push(formatAction(a, i)));
+                }
+                if (finalActions.length > 0) {
+                    sections.push(`Final Actions:`);
+                    finalActions.forEach((a, i) => sections.push(formatAction(a, i)));
+                }
+            }
+            else {
+                sections.push(`(none)`);
+            }
+        }
+        else {
+            sections.push(`(none)`);
+        }
+        // --- Project File Map ---
+        const allKeys = await listCachedKeys(projectId);
+        sections.push(`\n## Project File Map`);
+        const categoryPatterns = [
+            { label: "Pages", pattern: /^page\/id-[^/]+$/ },
+            { label: "Components", pattern: /^component\/id-[^/]+$/ },
+            { label: "Custom Actions", pattern: /^custom-actions\/id-[^/]+$/ },
+            { label: "Custom Functions", pattern: /^custom-functions\/id-[^/]+$/ },
+            { label: "Custom Widgets", pattern: /^custom-widgets\/id-[^/]+$/ },
+            { label: "Custom Files", pattern: /^custom-file\/id-[^/]+$/ },
+            { label: "App Action Components", pattern: /^app-action-components\/id-[^/]+$/ },
+            { label: "API Endpoints", prefix: "api-endpoint/" },
+            { label: "Collections", prefix: "collections/" },
+            { label: "AI Agents", pattern: /^agent\/id-[^/]+$/ },
+        ];
+        for (const cat of categoryPatterns) {
+            const count = cat.pattern
+                ? allKeys.filter((k) => cat.pattern.test(k)).length
+                : allKeys.filter((k) => k.startsWith(cat.prefix)).length;
+            if (count > 0) {
+                sections.push(`${cat.label}: ${count}`);
+            }
+        }
+        return {
+            content: [{ type: "text", text: sections.join("\n") }],
+        };
+    });
+}

package/build/tools/get-project-setup.d.ts

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

package/build/tools/get-project-setup.js

@@ -0,0 +1,212 @@
+import { z } from "zod";
+import YAML from "yaml";
+import { cacheRead, cacheMeta, cacheAgeFooter } from "../utils/cache.js";
+import { resolveDataType } from "../utils/resolve-data-type.js";
+export function registerGetProjectSetupTool(server) {
+    server.tool("get_project_setup", "Get Project Setup settings — Firebase services, Languages, Platforms, Permissions, Project Dependencies, Dev Environments. Mirrors the FlutterFlow 'Project Setup' settings section. Cache-based, no API calls. Run sync_project first.", {
+        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 [analyticsRaw, appCheckRaw, crashlyticsRaw, perfMonRaw, remoteConfigRaw, languagesRaw, platformsRaw, permissionsRaw, dependenciesRaw, customCodeDepsRaw, envSettingsRaw,] = await Promise.all([
+            cacheRead(projectId, "firebase-analytics"),
+            cacheRead(projectId, "firebase-app-check"),
+            cacheRead(projectId, "firebase-crashlytics"),
+            cacheRead(projectId, "firebase-performance-monitoring"),
+            cacheRead(projectId, "firebase-remote-config"),
+            cacheRead(projectId, "languages"),
+            cacheRead(projectId, "platforms"),
+            cacheRead(projectId, "permissions"),
+            cacheRead(projectId, "dependencies"),
+            cacheRead(projectId, "custom-code-dependencies"),
+            cacheRead(projectId, "environment-settings"),
+        ]);
+        const sections = ["# Project Setup"];
+        // --- Firebase ---
+        sections.push(`\n## Firebase`);
+        const anyFirebase = analyticsRaw || appCheckRaw || crashlyticsRaw || perfMonRaw || remoteConfigRaw;
+        if (anyFirebase) {
+            // Analytics
+            if (analyticsRaw) {
+                const analytics = YAML.parse(analyticsRaw);
+                const enabled = analytics.enabled === true;
+                sections.push(`Analytics: ${enabled ? "enabled" : "disabled"}`);
+                if (enabled) {
+                    const eventSettings = analytics.automaticEventSettings;
+                    if (eventSettings) {
+                        sections.push(`  onPageLoad: ${eventSettings.onPageLoad === true ? "Yes" : "No"}`, `  onActionsStart: ${eventSettings.onActionsStart === true ? "Yes" : "No"}`, `  onAuth: ${eventSettings.onAuth === true ? "Yes" : "No"}`);
+                    }
+                }
+            }
+            // App Check
+            if (appCheckRaw) {
+                const appCheck = YAML.parse(appCheckRaw);
+                sections.push(`App Check: ${appCheck.enabled === true ? "enabled" : "disabled"}`);
+            }
+            // Crashlytics
+            if (crashlyticsRaw) {
+                const crashlytics = YAML.parse(crashlyticsRaw);
+                sections.push(`Crashlytics: ${crashlytics.enabled === true ? "enabled" : "disabled"}`);
+            }
+            // Performance Monitoring
+            if (perfMonRaw) {
+                const perfMon = YAML.parse(perfMonRaw);
+                sections.push(`Performance Monitoring: ${perfMon.enabled === true ? "enabled" : "disabled"}`);
+            }
+            // Remote Config
+            if (remoteConfigRaw) {
+                const remoteConfig = YAML.parse(remoteConfigRaw);
+                const enabled = remoteConfig.enabled === true;
+                sections.push(`Remote Config: ${enabled ? "enabled" : "disabled"}`);
+                if (enabled) {
+                    const fields = remoteConfig.fields || [];
+                    if (fields.length > 0) {
+                        sections.push(`  Fields:`);
+                        for (const field of fields) {
+                            const name = field.parameter?.identifier?.name || "unknown";
+                            const dt = resolveDataType(field.parameter?.dataType || {});
+                            const defaultVal = field.serializedDefaultValue ?? "";
+                            sections.push(`    - ${name}: ${dt} (default: "${defaultVal}")`);
+                        }
+                    }
+                }
+            }
+        }
+        else {
+            sections.push(`(not configured)`);
+        }
+        // --- Languages ---
+        sections.push(`\n## Languages`);
+        if (languagesRaw) {
+            const langs = YAML.parse(languagesRaw);
+            const primaryLang = langs.primaryLanguage
+                ?.language;
+            const displayLang = langs.displayLanguage
+                ?.language;
+            const allLangs = langs.languages || [];
+            sections.push(`Primary: ${primaryLang || "not set"}`);
+            sections.push(`Display: ${displayLang || "not set"}`);
+            if (allLangs.length > 0) {
+                const langCodes = allLangs.map((l) => l.language).join(", ");
+                sections.push(`Available: ${langCodes}`);
+            }
+        }
+        else {
+            sections.push(`(not configured)`);
+        }
+        // --- Platforms ---
+        sections.push(`\n## Platforms`);
+        if (platformsRaw) {
+            const platforms = YAML.parse(platformsRaw);
+            sections.push(`Web: ${platforms.enableWeb === true ? "enabled" : "disabled"}`);
+        }
+        else {
+            sections.push(`(not configured)`);
+        }
+        // --- Permissions ---
+        sections.push(`\n## Permissions`);
+        if (permissionsRaw) {
+            const permissions = YAML.parse(permissionsRaw);
+            const builtIn = permissions.permissionMessages;
+            const custom = permissions.userDefinedPermissions;
+            const hasBuiltIn = builtIn && builtIn.length > 0;
+            const hasCustom = custom && custom.length > 0;
+            if (hasBuiltIn || hasCustom) {
+                if (hasBuiltIn) {
+                    sections.push(`Built-in:`);
+                    for (const perm of builtIn) {
+                        const permType = perm.permissionType || "UNKNOWN";
+                        const msg = perm.message?.textValue?.inputValue;
+                        sections.push(`  - ${permType}: ${msg ? `"${msg}"` : "(no message)"}`);
+                    }
+                }
+                if (hasCustom) {
+                    sections.push(`Custom:`);
+                    for (const perm of custom) {
+                        const names = perm.names;
+                        const iosName = names?.iosName || "?";
+                        const androidName = names?.androidName || "?";
+                        const msg = perm.message?.textValue?.inputValue;
+                        sections.push(`  - ${iosName} / ${androidName}: ${msg ? `"${msg}"` : "(no message)"}`);
+                    }
+                }
+            }
+            else {
+                sections.push(`(not configured)`);
+            }
+        }
+        else {
+            sections.push(`(not configured)`);
+        }
+        // --- Project Dependencies ---
+        sections.push(`\n## Project Dependencies`);
+        const hasDeps = dependenciesRaw || customCodeDepsRaw;
+        if (hasDeps) {
+            // FF library dependencies
+            if (dependenciesRaw) {
+                const deps = YAML.parse(dependenciesRaw);
+                const libDeps = deps.dependencies || [];
+                if (libDeps.length > 0) {
+                    sections.push(`FF Libraries:`);
+                    for (const dep of libDeps) {
+                        sections.push(`  - ${dep.name || "unnamed"} (${dep.projectId || "?"}, version: ${dep.version || "?"})`);
+                    }
+                }
+            }
+            // Pubspec dependencies
+            if (customCodeDepsRaw) {
+                const customDeps = YAML.parse(customCodeDepsRaw);
+                const pubspecDeps = customDeps.pubspecDependencies || [];
+                if (pubspecDeps.length > 0) {
+                    sections.push(`Pubspec Dependencies:`);
+                    for (const dep of pubspecDeps) {
+                        sections.push(`  - ${dep.name || "unnamed"}: ${dep.version || "any"}`);
+                    }
+                }
+            }
+        }
+        else {
+            sections.push(`(not configured)`);
+        }
+        // --- Dev Environments ---
+        sections.push(`\n## Dev Environments`);
+        if (envSettingsRaw) {
+            const doc = YAML.parse(envSettingsRaw);
+            const currentEnv = doc.currentEnvironment;
+            const envValues = doc.environmentValues || [];
+            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"));
+            }
+        }
+        else {
+            sections.push(`(not configured)`);
+        }
+        return {
+            content: [{ type: "text", text: sections.join("\n") + cacheAgeFooter(meta) }],
+        };
+    });
+}

package/build/tools/get-theme.d.ts

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