@trops/dash-core 0.1.172 → 0.1.173

package/dist/electron/index.js

@@ -169,7 +169,7 @@ const THEME_LIST_COMPLETE = "theme-list-complete";
 const THEME_LIST_ERROR = "theme-list-error";
 
 const THEME_SAVE$1 = "theme-save";
-const THEME_SAVE_COMPLETE = "theme-save-complete";
+const THEME_SAVE_COMPLETE$1 = "theme-save-complete";
 const THEME_SAVE_ERROR = "theme-save-error";
 
 const THEME_DELETE$1 = "theme-delete";
@@ -185,7 +185,7 @@ var themeEvents$1 = {
   THEME_LIST_COMPLETE,
   THEME_LIST_ERROR,
   THEME_SAVE: THEME_SAVE$1,
-  THEME_SAVE_COMPLETE,
+  THEME_SAVE_COMPLETE: THEME_SAVE_COMPLETE$1,
   THEME_SAVE_ERROR,
   THEME_DELETE: THEME_DELETE$1,
   THEME_DELETE_COMPLETE,
@@ -304,7 +304,7 @@ const SETTINGS_GET_COMPLETE = "settings-get-complete";
 const SETTINGS_GET_ERROR = "settings-get-error";
 
 const SETTINGS_SAVE$1 = "settings-save";
-const SETTINGS_SAVE_COMPLETE = "settings-save-complete";
+const SETTINGS_SAVE_COMPLETE$1 = "settings-save-complete";
 const SETTINGS_SAVE_ERROR = "settings-save-error";
 
 const SETTINGS_GET_DATA_DIR$1 = "settings-get-data-dir";
@@ -324,7 +324,7 @@ var settingsEvents$1 = {
   SETTINGS_GET_COMPLETE,
   SETTINGS_GET_ERROR,
   SETTINGS_SAVE: SETTINGS_SAVE$1,
-  SETTINGS_SAVE_COMPLETE,
+  SETTINGS_SAVE_COMPLETE: SETTINGS_SAVE_COMPLETE$1,
   SETTINGS_SAVE_ERROR,
   SETTINGS_GET_DATA_DIR: SETTINGS_GET_DATA_DIR$1,
   SETTINGS_GET_DATA_DIR_COMPLETE,
@@ -4294,7 +4294,7 @@ function copyDirectory(source, destination) {
   }
 }
 
-const settingsController$2 = {
+const settingsController$3 = {
   /**
    * saveSettingsForApplication
    * Save the settings object to a file (settings.json)
@@ -4526,7 +4526,7 @@ const settingsController$2 = {
   },
 };
 
-var settingsController_1 = settingsController$2;
+var settingsController_1 = settingsController$3;
 
 /**
  * responseCache.js
@@ -39626,13 +39626,13 @@ async function extractColorsFromUrl({
   };
 }
 
-const themeFromUrlController$1 = {
+const themeFromUrlController$2 = {
   extractColorsFromUrl,
   extractFaviconUrls,
   extractFaviconColors,
 };
 
-var themeFromUrlController_1 = themeFromUrlController$1;
+var themeFromUrlController_1 = themeFromUrlController$2;
 
 /**
  * themeGenerator.js
@@ -40289,13 +40289,13 @@ function generateThemeFromPalette$1(palette, overrides = {}) {
   };
 }
 
-const paletteToThemeMapper$1 = {
+const paletteToThemeMapper$2 = {
   assignRoles: assignRoles$1,
   matchTailwindFamily: matchTailwindFamily$1,
   generateThemeFromPalette: generateThemeFromPalette$1,
 };
 
-var paletteToThemeMapper_1 = paletteToThemeMapper$1;
+var paletteToThemeMapper_1 = paletteToThemeMapper$2;
 
 var bufferUtil$1 = {exports: {}};
 
@@ -46080,9 +46080,9 @@ function stats() {
   };
 }
 
-const extractionCacheController$1 = { get, has, clear, invalidate, stats };
+const extractionCacheController$2 = { get, has, clear, invalidate, stats };
 
-var extractionCacheController_1 = extractionCacheController$1;
+var extractionCacheController_1 = extractionCacheController$2;
 
 var mcp = {};
 
@@ -66056,7 +66056,7 @@ const {
   StreamableHTTPServerTransport,
 } = streamableHttp;
 
-const settingsController$1 = settingsController_1;
+const settingsController$2 = settingsController_1;
 
 // --- State ---
 let mcpServer = null;
@@ -66111,7 +66111,7 @@ const registeredResources = [];
  * Register a tool to be exposed via the MCP server.
  * Call this before starting the server (or restart after registering).
  */
-function registerTool$2(toolDef) {
+function registerTool$3(toolDef) {
   registeredTools.push(toolDef);
 }
 
@@ -66141,16 +66141,16 @@ function applyRegistrations(server) {
 
 // --- Settings Helpers ---
 function getMcpServerSettings(win) {
-  const result = settingsController$1.getSettingsForApplication(win);
+  const result = settingsController$2.getSettingsForApplication(win);
   const settings = result?.settings || {};
   return settings.mcpDashServer || {};
 }
 
 function saveMcpServerSettings(win, mcpSettings) {
-  const result = settingsController$1.getSettingsForApplication(win);
+  const result = settingsController$2.getSettingsForApplication(win);
   const settings = result?.settings || {};
   settings.mcpDashServer = mcpSettings;
-  settingsController$1.saveSettingsForApplication(win, settings);
+  settingsController$2.saveSettingsForApplication(win, settings);
 }
 
 // --- App ID Resolution ---
@@ -66434,7 +66434,7 @@ const mcpDashServerController$3 = {
   },
 
   // Expose registration functions for other controllers
-  registerTool: registerTool$2,
+  registerTool: registerTool$3,
   registerResource,
   getServerContext,
 };
@@ -69134,7 +69134,91 @@ const widgetTools$1 = [
   },
 ];
 
-var toolDefinitions = { dashboardTools: dashboardTools$1, widgetTools: widgetTools$1 };
+const themeTools$1 = [
+  {
+    name: "list_themes",
+    description:
+      "List all saved themes with their names and whether they are currently active",
+    inputSchema: {
+      type: "object",
+      properties: {},
+      required: [],
+    },
+  },
+  {
+    name: "get_theme",
+    description:
+      "Get full details of a theme by name, including all color values",
+    inputSchema: {
+      type: "object",
+      properties: {
+        name: {
+          type: "string",
+          description: "Name of the theme to retrieve",
+        },
+      },
+      required: ["name"],
+    },
+  },
+  {
+    name: "create_theme",
+    description:
+      "Create a new theme from a colors object. The colors object should contain color role keys (e.g. primary, secondary, surface, background) mapped to hex values or shade objects.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        name: {
+          type: "string",
+          description: "Display name for the new theme",
+        },
+        colors: {
+          type: "object",
+          description:
+            "Theme colors object with role keys mapped to hex values or shade objects",
+        },
+      },
+      required: ["name", "colors"],
+    },
+  },
+  {
+    name: "create_theme_from_url",
+    description:
+      "Extract brand colors from a website URL and generate a theme. Loads the page, extracts colors from meta tags, CSS variables, computed styles, and favicons, then maps them to theme roles.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        url: {
+          type: "string",
+          description:
+            "Website URL to extract colors from (must start with http:// or https://)",
+        },
+        name: {
+          type: "string",
+          description:
+            "Optional name for the theme. If omitted, a name is derived from the URL hostname.",
+        },
+      },
+      required: ["url"],
+    },
+  },
+  {
+    name: "apply_theme",
+    description:
+      "Apply a saved theme to the active dashboard. The theme must already exist (use list_themes to see available themes).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        name: {
+          type: "string",
+          description: "Name of the theme to apply",
+        },
+      },
+      required: ["name"],
+    },
+  },
+];
+
+var toolDefinitions = { dashboardTools: dashboardTools$1, widgetTools: widgetTools$1, themeTools: themeTools$1 };
 
 /**
  * toolHandlers.js
@@ -69969,6 +70053,507 @@ async function handleSearchWidgets$1({ query }) {
   }
 }
 
+// --- Theme Tool Handlers ---
+
+const settingsController$1 = settingsController_1;
+const themeFromUrlController$1 = themeFromUrlController_1;
+const paletteToThemeMapper$1 = paletteToThemeMapper_1;
+const extractionCacheController$1 = extractionCacheController_1;
+const { THEME_SAVE_COMPLETE, SETTINGS_SAVE_COMPLETE } = events$8;
+
+/**
+ * list_themes — Returns all saved themes with name, active state, and color summary.
+ */
+async function handleListThemes$1() {
+  const { win, appId } = requireContext();
+  const result = themeController$1.listThemesForApplication(win, appId);
+
+  if (result.error) {
+    return {
+      content: [
+        { type: "text", text: JSON.stringify({ error: result.message }) },
+      ],
+      isError: true,
+    };
+  }
+
+  const themes = result.themes || {};
+  const settingsResult = settingsController$1.getSettingsForApplication(win);
+  const activeThemeKey = settingsResult?.settings?.theme || null;
+
+  const themeList = Object.keys(themes).map((name) => ({
+    name,
+    isActive: name === activeThemeKey,
+    colors: themes[name],
+  }));
+
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(
+          { themes: themeList, count: themeList.length },
+          null,
+          2,
+        ),
+      },
+    ],
+  };
+}
+
+/**
+ * get_theme — Returns full details of a theme by name.
+ */
+async function handleGetTheme$1({ name }) {
+  if (!name || typeof name !== "string" || !name.trim()) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            error: "name is required and must be a non-empty string",
+          }),
+        },
+      ],
+      isError: true,
+    };
+  }
+
+  const { win, appId } = requireContext();
+  const result = themeController$1.listThemesForApplication(win, appId);
+
+  if (result.error) {
+    return {
+      content: [
+        { type: "text", text: JSON.stringify({ error: result.message }) },
+      ],
+      isError: true,
+    };
+  }
+
+  const themes = result.themes || {};
+  const themeName = name.trim();
+
+  if (!(themeName in themes)) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({ error: `Theme not found: ${themeName}` }),
+        },
+      ],
+      isError: true,
+    };
+  }
+
+  const settingsResult = settingsController$1.getSettingsForApplication(win);
+  const activeThemeKey = settingsResult?.settings?.theme || null;
+
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(
+          {
+            name: themeName,
+            isActive: themeName === activeThemeKey,
+            colors: themes[themeName],
+          },
+          null,
+          2,
+        ),
+      },
+    ],
+  };
+}
+
+/**
+ * create_theme — Creates a new theme from a colors object.
+ */
+async function handleCreateTheme$1({ name, colors }) {
+  if (!name || typeof name !== "string" || !name.trim()) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            error: "name is required and must be a non-empty string",
+          }),
+        },
+      ],
+      isError: true,
+    };
+  }
+
+  if (!colors || typeof colors !== "object" || Array.isArray(colors)) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            error: "colors is required and must be an object",
+          }),
+        },
+      ],
+      isError: true,
+    };
+  }
+
+  const { win, appId } = requireContext();
+  const themeName = name.trim();
+
+  const result = themeController$1.saveThemeForApplication(
+    win,
+    appId,
+    themeName,
+    colors,
+  );
+
+  if (result.error) {
+    return {
+      content: [
+        { type: "text", text: JSON.stringify({ error: result.message }) },
+      ],
+      isError: true,
+    };
+  }
+
+  // Notify the renderer so the UI updates
+  win.webContents.send(THEME_SAVE_COMPLETE, result);
+
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify({ name: themeName, created: true }, null, 2),
+      },
+    ],
+  };
+}
+
+/**
+ * create_theme_from_url — Extracts colors from a URL and generates a theme.
+ * Uses a hidden BrowserWindow to load the page and extract styles.
+ */
+async function handleCreateThemeFromUrl$1({ url, name }) {
+  if (!url || typeof url !== "string" || !url.trim()) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            error: "url is required and must be a non-empty string",
+          }),
+        },
+      ],
+      isError: true,
+    };
+  }
+
+  const trimmedUrl = url.trim();
+
+  // Validate URL format
+  if (!trimmedUrl.startsWith("http://") && !trimmedUrl.startsWith("https://")) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            error: "url must start with http:// or https://",
+          }),
+        },
+      ],
+      isError: true,
+    };
+  }
+
+  const { win, appId } = requireContext();
+  const { BrowserWindow } = require$$0$2;
+
+  const LOAD_TIMEOUT_MS = 15000;
+
+  try {
+    // Extract colors using a hidden BrowserWindow (same approach as dash-electron IPC handler)
+    const extractionData = await extractionCacheController$1.get(
+      trimmedUrl,
+      async () => {
+        const scanWindow = new BrowserWindow({
+          width: 1280,
+          height: 900,
+          show: false,
+          webPreferences: {
+            nodeIntegration: false,
+            contextIsolation: true,
+          },
+        });
+
+        let destroyed = false;
+        const destroyScanWindow = () => {
+          if (!destroyed) {
+            destroyed = true;
+            scanWindow.destroy();
+          }
+        };
+
+        try {
+          scanWindow.webContents.on("will-navigate", (event) => {
+            event.preventDefault();
+          });
+
+          await new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+              reject(
+                new Error(
+                  `Page load timed out after ${LOAD_TIMEOUT_MS}ms for ${trimmedUrl}`,
+                ),
+              );
+            }, LOAD_TIMEOUT_MS);
+
+            scanWindow.webContents.on(
+              "did-fail-load",
+              (event, errorCode, errorDescription) => {
+                clearTimeout(timeout);
+                const desc = errorDescription || `Error code ${errorCode}`;
+                reject(new Error(`Page load failed: ${desc}`));
+              },
+            );
+
+            scanWindow
+              .loadURL(trimmedUrl)
+              .then(() => {
+                clearTimeout(timeout);
+                resolve();
+              })
+              .catch((err) => {
+                clearTimeout(timeout);
+                reject(
+                  new Error(`Failed to load ${trimmedUrl}: ${err.message}`),
+                );
+              });
+          });
+
+          const extracted = await scanWindow.webContents.executeJavaScript(`
+            (function() {
+              try {
+                const htmlContent = document.documentElement.outerHTML;
+                let cssContent = '';
+                try {
+                  for (const sheet of document.styleSheets) {
+                    try {
+                      for (const rule of sheet.cssRules) {
+                        cssContent += rule.cssText + '\\n';
+                      }
+                    } catch (e) { /* cross-origin stylesheet */ }
+                  }
+                } catch (e) {}
+                const selectors = ['body', 'header', 'nav', 'main', 'footer', 'a', 'button', 'h1', 'h2'];
+                const computedStyles = {};
+                for (const sel of selectors) {
+                  const el = document.querySelector(sel);
+                  if (!el) continue;
+                  const cs = window.getComputedStyle(el);
+                  computedStyles[sel] = {
+                    color: cs.color,
+                    backgroundColor: cs.backgroundColor,
+                    borderColor: cs.borderColor,
+                  };
+                }
+                return { success: true, htmlContent, cssContent, computedStyles };
+              } catch (e) {
+                return { success: false, error: { type: 'EXTRACTION_FAILED', message: e.message } };
+              }
+            })();
+          `);
+
+          if (!extracted || !extracted.success) {
+            const errMsg =
+              extracted?.error?.message || "Script execution failed";
+            throw new Error(`Color extraction failed: ${errMsg}`);
+          }
+
+          return themeFromUrlController$1.extractColorsFromUrl({
+            htmlContent: extracted.htmlContent,
+            cssContent: extracted.cssContent,
+            computedStyles: extracted.computedStyles,
+            baseUrl: trimmedUrl,
+          });
+        } finally {
+          destroyScanWindow();
+        }
+      },
+    );
+
+    // Map palette to theme
+    const palette = extractionData?.palette || [];
+    if (palette.length === 0) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({
+              error: "No colors could be extracted from the URL",
+            }),
+          },
+        ],
+        isError: true,
+      };
+    }
+
+    const { theme: generatedTheme } =
+      paletteToThemeMapper$1.generateThemeFromPalette(palette);
+
+    // Derive theme name from URL hostname if not provided
+    let themeName;
+    if (name && typeof name === "string" && name.trim()) {
+      themeName = name.trim();
+    } else {
+      try {
+        const { URL } = require("url");
+        const parsed = new URL(trimmedUrl);
+        themeName = parsed.hostname.replace(/^www\./, "");
+      } catch {
+        themeName = "url-theme";
+      }
+    }
+
+    // Save the generated theme
+    const saveResult = themeController$1.saveThemeForApplication(
+      win,
+      appId,
+      themeName,
+      generatedTheme,
+    );
+
+    if (saveResult.error) {
+      return {
+        content: [
+          { type: "text", text: JSON.stringify({ error: saveResult.message }) },
+        ],
+        isError: true,
+      };
+    }
+
+    // Notify the renderer
+    win.webContents.send(THEME_SAVE_COMPLETE, saveResult);
+
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(
+            {
+              name: themeName,
+              created: true,
+              colorsExtracted: palette.length,
+              source: trimmedUrl,
+            },
+            null,
+            2,
+          ),
+        },
+      ],
+    };
+  } catch (err) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            error: `Failed to create theme from URL: ${err.message}`,
+          }),
+        },
+      ],
+      isError: true,
+    };
+  }
+}
+
+/**
+ * apply_theme — Applies a saved theme to the active dashboard.
+ * Updates settings to set the active theme key and notifies the renderer.
+ */
+async function handleApplyTheme$1({ name }) {
+  if (!name || typeof name !== "string" || !name.trim()) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            error: "name is required and must be a non-empty string",
+          }),
+        },
+      ],
+      isError: true,
+    };
+  }
+
+  const { win, appId } = requireContext();
+  const themeName = name.trim();
+
+  // Verify the theme exists
+  const themeResult = themeController$1.listThemesForApplication(win, appId);
+  if (themeResult.error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({ error: themeResult.message }),
+        },
+      ],
+      isError: true,
+    };
+  }
+
+  const themes = themeResult.themes || {};
+  if (!(themeName in themes)) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            error: `Theme not found: ${themeName}. Use list_themes to see available themes.`,
+          }),
+        },
+      ],
+      isError: true,
+    };
+  }
+
+  // Update settings to set the active theme
+  const settingsResult = settingsController$1.getSettingsForApplication(win);
+  const settings = settingsResult?.settings || {};
+  settings.theme = themeName;
+
+  const saveResult = settingsController$1.saveSettingsForApplication(
+    win,
+    settings,
+  );
+
+  if (saveResult.error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({ error: saveResult.message }),
+        },
+      ],
+      isError: true,
+    };
+  }
+
+  // Notify the renderer to update the theme
+  win.webContents.send(SETTINGS_SAVE_COMPLETE, { settings });
+
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify({ name: themeName, applied: true }, null, 2),
+      },
+    ],
+  };
+}
+
 var toolHandlers = {
   handleListDashboards: handleListDashboards$1,
   handleGetDashboard: handleGetDashboard$1,
@@ -69980,6 +70565,11 @@ var toolHandlers = {
   handleConfigureWidget: handleConfigureWidget$1,
   handleListWidgets: handleListWidgets$1,
   handleSearchWidgets: handleSearchWidgets$1,
+  handleListThemes: handleListThemes$1,
+  handleGetTheme: handleGetTheme$1,
+  handleCreateTheme: handleCreateTheme$1,
+  handleCreateThemeFromUrl: handleCreateThemeFromUrl$1,
+  handleApplyTheme: handleApplyTheme$1,
 };
 
 /**
@@ -69989,7 +70579,7 @@ var toolHandlers = {
  * Call registerDashboardTools() during app startup (before or after server start).
  */
 
-const { registerTool: registerTool$1 } = mcpDashServerController_1;
+const { registerTool: registerTool$2 } = mcpDashServerController_1;
 const { dashboardTools } = toolDefinitions;
 const {
   handleListDashboards,
@@ -70000,7 +70590,7 @@ const {
 } = toolHandlers;
 
 // Map tool names to handler functions
-const handlerMap$1 = {
+const handlerMap$2 = {
   list_dashboards: handleListDashboards,
   get_dashboard: handleGetDashboard,
   create_dashboard: handleCreateDashboard,
@@ -70013,12 +70603,12 @@ const handlerMap$1 = {
  */
 function registerDashboardTools$1() {
   for (const tool of dashboardTools) {
-    const handler = handlerMap$1[tool.name];
+    const handler = handlerMap$2[tool.name];
     if (!handler) {
       console.warn(`[dashboardTools] No handler found for tool: ${tool.name}`);
       continue;
     }
-    registerTool$1({
+    registerTool$2({
       name: tool.name,
       description: tool.description,
       inputSchema: tool.inputSchema,
@@ -70039,7 +70629,7 @@ var dashboardTools_1 = { registerDashboardTools: registerDashboardTools$1 };
  * Call registerWidgetTools() during app startup (before or after server start).
  */
 
-const { registerTool } = mcpDashServerController_1;
+const { registerTool: registerTool$1 } = mcpDashServerController_1;
 const { widgetTools } = toolDefinitions;
 const {
   handleAddWidget,
@@ -70050,7 +70640,7 @@ const {
 } = toolHandlers;
 
 // Map tool names to handler functions
-const handlerMap = {
+const handlerMap$1 = {
   add_widget: handleAddWidget,
   remove_widget: handleRemoveWidget,
   configure_widget: handleConfigureWidget,
@@ -70063,12 +70653,12 @@ const handlerMap = {
  */
 function registerWidgetTools$1() {
   for (const tool of widgetTools) {
-    const handler = handlerMap[tool.name];
+    const handler = handlerMap$1[tool.name];
     if (!handler) {
       console.warn(`[widgetTools] No handler found for tool: ${tool.name}`);
       continue;
     }
-    registerTool({
+    registerTool$1({
       name: tool.name,
       description: tool.description,
       inputSchema: tool.inputSchema,
@@ -70080,6 +70670,54 @@ function registerWidgetTools$1() {
 
 var widgetTools_1 = { registerWidgetTools: registerWidgetTools$1 };
 
+/**
+ * themeTools.js
+ *
+ * Registers theme MCP tools with the MCP Dash server.
+ * Call registerThemeTools() during app startup (before or after server start).
+ */
+
+const { registerTool } = mcpDashServerController_1;
+const { themeTools } = toolDefinitions;
+const {
+  handleListThemes,
+  handleGetTheme,
+  handleCreateTheme,
+  handleCreateThemeFromUrl,
+  handleApplyTheme,
+} = toolHandlers;
+
+// Map tool names to handler functions
+const handlerMap = {
+  list_themes: handleListThemes,
+  get_theme: handleGetTheme,
+  create_theme: handleCreateTheme,
+  create_theme_from_url: handleCreateThemeFromUrl,
+  apply_theme: handleApplyTheme,
+};
+
+/**
+ * Register all theme tools with the MCP server controller.
+ */
+function registerThemeTools$1() {
+  for (const tool of themeTools) {
+    const handler = handlerMap[tool.name];
+    if (!handler) {
+      console.warn(`[themeTools] No handler found for tool: ${tool.name}`);
+      continue;
+    }
+    registerTool({
+      name: tool.name,
+      description: tool.description,
+      inputSchema: tool.inputSchema,
+      handler,
+    });
+  }
+  console.log(`[themeTools] Registered ${themeTools.length} theme tools`);
+}
+
+var themeTools_1 = { registerThemeTools: registerThemeTools$1 };
+
 /**
  * dashboardRatingsApi.js
  *
@@ -70403,8 +71041,10 @@ const dynamicWidgetLoader = dynamicWidgetLoaderExports;
 // --- MCP Dash Server Tools ---
 const { registerDashboardTools } = dashboardTools_1;
 const { registerWidgetTools } = widgetTools_1;
+const { registerThemeTools } = themeTools_1;
 registerDashboardTools();
 registerWidgetTools();
+registerThemeTools();
 
 // --- Schema ---
 const dashboardConfigValidator = dashboardConfigValidator$1;
@@ -70501,6 +71141,7 @@ var electron = {
   // MCP Dash Server Tools
   registerDashboardTools,
   registerWidgetTools,
+  registerThemeTools,
 };
 
 var index = /*@__PURE__*/getDefaultExportFromCjs(electron);