@trops/dash-core 0.1.171 → 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
@@ -26872,7 +26872,7 @@ async function searchThemes(query = "", filters = {}) {
   return searchRegistry$1(query, { ...filters, type: "theme" });
 }
 
-var registryController$2 = {
+var registryController$3 = {
   fetchRegistryIndex,
   searchRegistry: searchRegistry$1,
   searchDashboards,
@@ -31852,7 +31852,7 @@ const { app: app$2, dialog: dialog$1 } = require$$0$2;
 const AdmZip$1 = require$$3$4;
 
 const themeController$3 = themeController_1;
-const registryController$1 = registryController$2;
+const registryController$2 = registryController$3;
 const registryApiController$1 = registryApiController$2;
 const {
   getAuthStatus,
@@ -32082,7 +32082,7 @@ async function prepareThemeForPublish$1(win, appId, themeKey, options = {}) {
 async function installThemeFromRegistry$1(win, appId, packageName) {
   try {
     // Look up the package
-    const pkg = await registryController$1.getPackage(packageName);
+    const pkg = await registryController$2.getPackage(packageName);
     if (!pkg) {
       return {
         success: false,
@@ -32272,7 +32272,7 @@ const {
   buildProviderRequirements,
   applyEventWiringToLayout,
 } = dashboardConfigUtils$1;
-const { searchRegistry, getPackage } = registryController$2;
+const { searchRegistry, getPackage } = registryController$3;
 const themeController$2 = themeController_1;
 
 const configFilename = "workspaces.json";
@@ -32998,7 +32998,7 @@ async function checkCompatibility$1(dashboardWidgets, widgetRegistry = null) {
   const {
     checkDashboardCompatibility,
   } = dashboardConfigUtils$1;
-  const { fetchRegistryIndex } = registryController$2;
+  const { fetchRegistryIndex } = registryController$3;
 
   const installedWidgets = widgetRegistry ? widgetRegistry.getWidgets() : [];
 
@@ -33153,7 +33153,7 @@ async function prepareDashboardForPublish$1(
     }
 
     // 6. Check which widgets exist in the registry (soft warning, not blocking)
-    const { fetchRegistryIndex } = registryController$2;
+    const { fetchRegistryIndex } = registryController$3;
     let registryPackages = [];
     let registryCheckFailed = false;
     try {
@@ -33300,7 +33300,7 @@ async function getDashboardPreview$1(packageName, widgetRegistry = null) {
     buildDashboardPreview,
     checkDashboardCompatibility,
   } = dashboardConfigUtils$1;
-  const { getPackage, fetchRegistryIndex } = registryController$2;
+  const { getPackage, fetchRegistryIndex } = registryController$3;
 
   const pkg = await getPackage(packageName);
   if (!pkg) {
@@ -33345,7 +33345,7 @@ async function getDashboardPreview$1(packageName, widgetRegistry = null) {
  */
 async function checkDashboardUpdatesForApp$1(appId) {
   const { checkDashboardUpdates } = dashboardConfigUtils$1;
-  const { fetchRegistryIndex } = registryController$2;
+  const { fetchRegistryIndex } = registryController$3;
 
   try {
     const filename = path$1.join(
@@ -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$1(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$1,
+  registerTool: registerTool$3,
   registerResource,
   getServerContext,
 };
@@ -69042,7 +69042,183 @@ const dashboardTools$1 = [
   },
 ];
 
-var toolDefinitions = { dashboardTools: dashboardTools$1 };
+const widgetTools$1 = [
+  {
+    name: "add_widget",
+    description:
+      "Add a widget to a dashboard by component name. Use list_widgets or search_widgets to find available widget names.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        dashboardId: {
+          type: "string",
+          description:
+            "Dashboard ID to add the widget to. Omit to use the active dashboard.",
+        },
+        widgetName: {
+          type: "string",
+          description:
+            "Component name of the widget to add (e.g. 'Clock', 'WeatherWidget')",
+        },
+      },
+      required: ["widgetName"],
+    },
+  },
+  {
+    name: "remove_widget",
+    description: "Remove a widget instance from a dashboard by its ID",
+    inputSchema: {
+      type: "object",
+      properties: {
+        dashboardId: {
+          type: "string",
+          description: "Dashboard ID. Omit to use the active dashboard.",
+        },
+        widgetId: {
+          type: "string",
+          description: "ID of the widget instance to remove",
+        },
+      },
+      required: ["widgetId"],
+    },
+  },
+  {
+    name: "configure_widget",
+    description:
+      "Update a widget's configuration. The config object is merged into the existing config.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        dashboardId: {
+          type: "string",
+          description: "Dashboard ID. Omit to use the active dashboard.",
+        },
+        widgetId: {
+          type: "string",
+          description: "ID of the widget instance to configure",
+        },
+        config: {
+          type: "object",
+          description:
+            "Configuration object to merge into existing widget config",
+        },
+      },
+      required: ["widgetId", "config"],
+    },
+  },
+  {
+    name: "list_widgets",
+    description:
+      "List available widgets from the registry, including name, description, and provider info",
+    inputSchema: {
+      type: "object",
+      properties: {},
+      required: [],
+    },
+  },
+  {
+    name: "search_widgets",
+    description:
+      "Search the widget registry by keyword. Returns matching widgets with name, description, and provider info.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        query: {
+          type: "string",
+          description:
+            "Search keyword to match against widget names, descriptions, and tags",
+        },
+      },
+      required: ["query"],
+    },
+  },
+];
+
+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
@@ -69392,12 +69568,1008 @@ async function handleGetAppStats$1() {
   };
 }
 
+// --- Widget Tool Handlers ---
+
+const registryController$1 = registryController$3;
+
+/**
+ * Helper: find a workspace by ID or return the first (active) one.
+ */
+function findWorkspace(workspaces, dashboardId) {
+  if (dashboardId) {
+    const ws = workspaces.find((w) => String(w.id) === dashboardId);
+    if (!ws) {
+      return {
+        error: true,
+        response: {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                error: `Dashboard not found: ${dashboardId}`,
+              }),
+            },
+          ],
+          isError: true,
+        },
+      };
+    }
+    return { workspace: ws };
+  }
+  if (!workspaces.length) {
+    return {
+      error: true,
+      response: {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({ error: "No dashboards exist" }),
+          },
+        ],
+        isError: true,
+      },
+    };
+  }
+  return { workspace: workspaces[0] };
+}
+
+/**
+ * Helper: generate the next unique layout item ID within a workspace.
+ */
+function nextLayoutId(layout) {
+  if (!Array.isArray(layout) || layout.length === 0) return 1;
+  const maxId = layout.reduce(
+    (max, item) => Math.max(max, Number(item.id) || 0),
+    0,
+  );
+  return maxId + 1;
+}
+
+/**
+ * add_widget — Add a widget to a dashboard by component name.
+ */
+async function handleAddWidget$1({ dashboardId, widgetName }) {
+  if (!widgetName || typeof widgetName !== "string" || !widgetName.trim()) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            error: "widgetName is required and must be a non-empty string",
+          }),
+        },
+      ],
+      isError: true,
+    };
+  }
+
+  const { win, appId } = requireContext();
+  const result = workspaceController$1.listWorkspacesForApplication(win, appId);
+  if (result.error) {
+    return {
+      content: [
+        { type: "text", text: JSON.stringify({ error: result.message }) },
+      ],
+      isError: true,
+    };
+  }
+
+  const found = findWorkspace(result.workspaces || [], dashboardId);
+  if (found.error) return found.response;
+
+  const workspace = found.workspace;
+  const layout = workspace.layout || [];
+
+  // Find the first container to add the widget into
+  const container = layout.find(
+    (item) =>
+      item.component === "Container" ||
+      item.component === "LayoutContainer" ||
+      item.component === "LayoutGridContainer",
+  );
+  const parentId = container ? container.id : 0;
+
+  const newId = nextLayoutId(layout);
+  const maxOrder = layout.reduce(
+    (max, item) => Math.max(max, Number(item.order) || 0),
+    0,
+  );
+
+  const newItem = {
+    id: newId,
+    order: maxOrder + 1,
+    component: widgetName.trim(),
+    parentId,
+    config: {},
+  };
+
+  workspace.layout = [...layout, newItem];
+
+  const saveResult = workspaceController$1.saveWorkspaceForApplication(
+    win,
+    appId,
+    workspace,
+  );
+  if (saveResult.error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({ error: saveResult.message }),
+        },
+      ],
+      isError: true,
+    };
+  }
+
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(
+          {
+            widgetId: String(newId),
+            name: widgetName.trim(),
+            dashboardId: String(workspace.id),
+          },
+          null,
+          2,
+        ),
+      },
+    ],
+  };
+}
+
+/**
+ * remove_widget — Remove a widget instance from a dashboard.
+ */
+async function handleRemoveWidget$1({ dashboardId, widgetId }) {
+  if (!widgetId || typeof widgetId !== "string") {
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({ error: "widgetId is required" }),
+        },
+      ],
+      isError: true,
+    };
+  }
+
+  const { win, appId } = requireContext();
+  const result = workspaceController$1.listWorkspacesForApplication(win, appId);
+  if (result.error) {
+    return {
+      content: [
+        { type: "text", text: JSON.stringify({ error: result.message }) },
+      ],
+      isError: true,
+    };
+  }
+
+  const found = findWorkspace(result.workspaces || [], dashboardId);
+  if (found.error) return found.response;
+
+  const workspace = found.workspace;
+  const layout = workspace.layout || [];
+
+  const exists = layout.some((item) => String(item.id) === widgetId);
+  if (!exists) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            error: `Widget not found: ${widgetId}`,
+          }),
+        },
+      ],
+      isError: true,
+    };
+  }
+
+  workspace.layout = layout.filter((item) => String(item.id) !== widgetId);
+
+  const saveResult = workspaceController$1.saveWorkspaceForApplication(
+    win,
+    appId,
+    workspace,
+  );
+  if (saveResult.error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({ error: saveResult.message }),
+        },
+      ],
+      isError: true,
+    };
+  }
+
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify({
+          success: true,
+          removed: widgetId,
+          remainingWidgets: countWidgets(workspace.layout),
+        }),
+      },
+    ],
+  };
+}
+
+/**
+ * configure_widget — Update widget settings (partial merge).
+ */
+async function handleConfigureWidget$1({ dashboardId, widgetId, config }) {
+  if (!widgetId || typeof widgetId !== "string") {
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({ error: "widgetId is required" }),
+        },
+      ],
+      isError: true,
+    };
+  }
+
+  if (!config || typeof config !== "object" || Array.isArray(config)) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            error: "config is required and must be an object",
+          }),
+        },
+      ],
+      isError: true,
+    };
+  }
+
+  const { win, appId } = requireContext();
+  const result = workspaceController$1.listWorkspacesForApplication(win, appId);
+  if (result.error) {
+    return {
+      content: [
+        { type: "text", text: JSON.stringify({ error: result.message }) },
+      ],
+      isError: true,
+    };
+  }
+
+  const found = findWorkspace(result.workspaces || [], dashboardId);
+  if (found.error) return found.response;
+
+  const workspace = found.workspace;
+  const layout = workspace.layout || [];
+  const item = layout.find((i) => String(i.id) === widgetId);
+
+  if (!item) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            error: `Widget not found: ${widgetId}`,
+          }),
+        },
+      ],
+      isError: true,
+    };
+  }
+
+  // Merge config
+  item.config = { ...(item.config || {}), ...config };
+
+  const saveResult = workspaceController$1.saveWorkspaceForApplication(
+    win,
+    appId,
+    workspace,
+  );
+  if (saveResult.error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({ error: saveResult.message }),
+        },
+      ],
+      isError: true,
+    };
+  }
+
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(
+          {
+            widgetId,
+            component: item.component,
+            config: item.config,
+          },
+          null,
+          2,
+        ),
+      },
+    ],
+  };
+}
+
+/**
+ * list_widgets — List available widgets from the registry.
+ */
+async function handleListWidgets$1() {
+  try {
+    const index = await registryController$1.fetchRegistryIndex();
+    const packages = index.packages || [];
+
+    const widgets = [];
+    for (const pkg of packages) {
+      // Skip non-widget packages
+      if (pkg.type && pkg.type !== "widget") continue;
+
+      for (const w of pkg.widgets || []) {
+        widgets.push({
+          name: w.name || pkg.name,
+          displayName: w.displayName || w.name || pkg.displayName || pkg.name,
+          description: w.description || pkg.description || "",
+          icon: w.icon || pkg.icon || null,
+          package: pkg.name,
+          providers: (w.providers || pkg.providers || []).map((p) => ({
+            type: p.type,
+            providerClass: p.providerClass || "api",
+            required: p.required !== false,
+          })),
+        });
+      }
+
+      // If a package has no widgets array, treat the package itself as a widget
+      if (!pkg.widgets || pkg.widgets.length === 0) {
+        widgets.push({
+          name: pkg.name,
+          displayName: pkg.displayName || pkg.name,
+          description: pkg.description || "",
+          icon: pkg.icon || null,
+          package: pkg.name,
+          providers: (pkg.providers || []).map((p) => ({
+            type: p.type,
+            providerClass: p.providerClass || "api",
+            required: p.required !== false,
+          })),
+        });
+      }
+    }
+
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({ widgets, count: widgets.length }, null, 2),
+        },
+      ],
+    };
+  } catch (err) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            error: `Failed to fetch widget registry: ${err.message}`,
+          }),
+        },
+      ],
+      isError: true,
+    };
+  }
+}
+
+/**
+ * search_widgets — Search the registry by keyword.
+ */
+async function handleSearchWidgets$1({ query }) {
+  if (!query || typeof query !== "string" || !query.trim()) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            error: "query is required and must be a non-empty string",
+          }),
+        },
+      ],
+      isError: true,
+    };
+  }
+
+  try {
+    const result = await registryController$1.searchRegistry(query.trim());
+    const packages = result.packages || [];
+
+    const widgets = [];
+    for (const pkg of packages) {
+      if (pkg.type && pkg.type !== "widget") continue;
+
+      for (const w of pkg.widgets || []) {
+        widgets.push({
+          name: w.name || pkg.name,
+          displayName: w.displayName || w.name || pkg.displayName || pkg.name,
+          description: w.description || pkg.description || "",
+          icon: w.icon || pkg.icon || null,
+          package: pkg.name,
+          providers: (w.providers || pkg.providers || []).map((p) => ({
+            type: p.type,
+            providerClass: p.providerClass || "api",
+            required: p.required !== false,
+          })),
+        });
+      }
+
+      if (!pkg.widgets || pkg.widgets.length === 0) {
+        widgets.push({
+          name: pkg.name,
+          displayName: pkg.displayName || pkg.name,
+          description: pkg.description || "",
+          icon: pkg.icon || null,
+          package: pkg.name,
+          providers: (pkg.providers || []).map((p) => ({
+            type: p.type,
+            providerClass: p.providerClass || "api",
+            required: p.required !== false,
+          })),
+        });
+      }
+    }
+
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(
+            { query: query.trim(), widgets, count: widgets.length },
+            null,
+            2,
+          ),
+        },
+      ],
+    };
+  } catch (err) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            error: `Failed to search widget registry: ${err.message}`,
+          }),
+        },
+      ],
+      isError: true,
+    };
+  }
+}
+
+// --- 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,
   handleCreateDashboard: handleCreateDashboard$1,
   handleDeleteDashboard: handleDeleteDashboard$1,
   handleGetAppStats: handleGetAppStats$1,
+  handleAddWidget: handleAddWidget$1,
+  handleRemoveWidget: handleRemoveWidget$1,
+  handleConfigureWidget: handleConfigureWidget$1,
+  handleListWidgets: handleListWidgets$1,
+  handleSearchWidgets: handleSearchWidgets$1,
+  handleListThemes: handleListThemes$1,
+  handleGetTheme: handleGetTheme$1,
+  handleCreateTheme: handleCreateTheme$1,
+  handleCreateThemeFromUrl: handleCreateThemeFromUrl$1,
+  handleApplyTheme: handleApplyTheme$1,
 };
 
 /**
@@ -69407,7 +70579,7 @@ var toolHandlers = {
  * Call registerDashboardTools() during app startup (before or after server start).
  */
 
-const { registerTool } = mcpDashServerController_1;
+const { registerTool: registerTool$2 } = mcpDashServerController_1;
 const { dashboardTools } = toolDefinitions;
 const {
   handleListDashboards,
@@ -69418,7 +70590,7 @@ const {
 } = toolHandlers;
 
 // Map tool names to handler functions
-const handlerMap = {
+const handlerMap$2 = {
   list_dashboards: handleListDashboards,
   get_dashboard: handleGetDashboard,
   create_dashboard: handleCreateDashboard,
@@ -69431,12 +70603,12 @@ const handlerMap = {
  */
 function registerDashboardTools$1() {
   for (const tool of dashboardTools) {
-    const handler = handlerMap[tool.name];
+    const handler = handlerMap$2[tool.name];
     if (!handler) {
       console.warn(`[dashboardTools] No handler found for tool: ${tool.name}`);
       continue;
     }
-    registerTool({
+    registerTool$2({
       name: tool.name,
       description: tool.description,
       inputSchema: tool.inputSchema,
@@ -69450,6 +70622,102 @@ function registerDashboardTools$1() {
 
 var dashboardTools_1 = { registerDashboardTools: registerDashboardTools$1 };
 
+/**
+ * widgetTools.js
+ *
+ * Registers widget MCP tools with the MCP Dash server.
+ * Call registerWidgetTools() during app startup (before or after server start).
+ */
+
+const { registerTool: registerTool$1 } = mcpDashServerController_1;
+const { widgetTools } = toolDefinitions;
+const {
+  handleAddWidget,
+  handleRemoveWidget,
+  handleConfigureWidget,
+  handleListWidgets,
+  handleSearchWidgets,
+} = toolHandlers;
+
+// Map tool names to handler functions
+const handlerMap$1 = {
+  add_widget: handleAddWidget,
+  remove_widget: handleRemoveWidget,
+  configure_widget: handleConfigureWidget,
+  list_widgets: handleListWidgets,
+  search_widgets: handleSearchWidgets,
+};
+
+/**
+ * Register all widget tools with the MCP server controller.
+ */
+function registerWidgetTools$1() {
+  for (const tool of widgetTools) {
+    const handler = handlerMap$1[tool.name];
+    if (!handler) {
+      console.warn(`[widgetTools] No handler found for tool: ${tool.name}`);
+      continue;
+    }
+    registerTool$1({
+      name: tool.name,
+      description: tool.description,
+      inputSchema: tool.inputSchema,
+      handler,
+    });
+  }
+  console.log(`[widgetTools] Registered ${widgetTools.length} widget tools`);
+}
+
+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
  *
@@ -69706,7 +70974,7 @@ const settingsController = settingsController_1;
 const providerController = requireProviderController();
 const layoutController = layoutController_1;
 const mcpController = mcpControllerExports;
-const registryController = registryController$2;
+const registryController = registryController$3;
 const algoliaController = algoliaController_1;
 const openaiController = openaiController_1;
 const menuItemsController = menuItemsController_1;
@@ -69772,7 +71040,11 @@ 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;
@@ -69868,6 +71140,8 @@ var electron = {
 
   // MCP Dash Server Tools
   registerDashboardTools,
+  registerWidgetTools,
+  registerThemeTools,
 };
 
 var index = /*@__PURE__*/getDefaultExportFromCjs(electron);