@trops/dash-core 0.1.170 → 0.1.172

package/dist/electron/index.js

@@ -828,49 +828,57 @@ var themeFromUrlEvents$1 = {
  * IPC communication between main and renderer processes.
  */
 
-const WS_CONNECT$1 = "ws-connect";
-const WS_CONNECT_COMPLETE = "ws-connect-complete";
-const WS_CONNECT_ERROR = "ws-connect-error";
-
-const WS_DISCONNECT$1 = "ws-disconnect";
-const WS_DISCONNECT_COMPLETE = "ws-disconnect-complete";
-const WS_DISCONNECT_ERROR = "ws-disconnect-error";
-
-const WS_SEND$1 = "ws-send";
-const WS_SEND_COMPLETE = "ws-send-complete";
-const WS_SEND_ERROR = "ws-send-error";
-
-const WS_STATUS$1 = "ws-status";
-const WS_STATUS_COMPLETE = "ws-status-complete";
-const WS_STATUS_ERROR = "ws-status-error";
-
-const WS_MESSAGE$1 = "ws-message";
-
-const WS_STATUS_CHANGE$1 = "ws-status-change";
-
-const WS_GET_ALL$1 = "ws-get-all";
-const WS_GET_ALL_COMPLETE = "ws-get-all-complete";
-const WS_GET_ALL_ERROR = "ws-get-all-error";
-
-var webSocketEvents$1 = {
-  WS_CONNECT: WS_CONNECT$1,
-  WS_CONNECT_COMPLETE,
-  WS_CONNECT_ERROR,
-  WS_DISCONNECT: WS_DISCONNECT$1,
-  WS_DISCONNECT_COMPLETE,
-  WS_DISCONNECT_ERROR,
-  WS_SEND: WS_SEND$1,
-  WS_SEND_COMPLETE,
-  WS_SEND_ERROR,
-  WS_STATUS: WS_STATUS$1,
-  WS_STATUS_COMPLETE,
-  WS_STATUS_ERROR,
-  WS_MESSAGE: WS_MESSAGE$1,
-  WS_STATUS_CHANGE: WS_STATUS_CHANGE$1,
-  WS_GET_ALL: WS_GET_ALL$1,
-  WS_GET_ALL_COMPLETE,
-  WS_GET_ALL_ERROR,
-};
+var webSocketEvents$1;
+var hasRequiredWebSocketEvents;
+
+function requireWebSocketEvents () {
+	if (hasRequiredWebSocketEvents) return webSocketEvents$1;
+	hasRequiredWebSocketEvents = 1;
+	const WS_CONNECT = "ws-connect";
+	const WS_CONNECT_COMPLETE = "ws-connect-complete";
+	const WS_CONNECT_ERROR = "ws-connect-error";
+
+	const WS_DISCONNECT = "ws-disconnect";
+	const WS_DISCONNECT_COMPLETE = "ws-disconnect-complete";
+	const WS_DISCONNECT_ERROR = "ws-disconnect-error";
+
+	const WS_SEND = "ws-send";
+	const WS_SEND_COMPLETE = "ws-send-complete";
+	const WS_SEND_ERROR = "ws-send-error";
+
+	const WS_STATUS = "ws-status";
+	const WS_STATUS_COMPLETE = "ws-status-complete";
+	const WS_STATUS_ERROR = "ws-status-error";
+
+	const WS_MESSAGE = "ws-message";
+
+	const WS_STATUS_CHANGE = "ws-status-change";
+
+	const WS_GET_ALL = "ws-get-all";
+	const WS_GET_ALL_COMPLETE = "ws-get-all-complete";
+	const WS_GET_ALL_ERROR = "ws-get-all-error";
+
+	webSocketEvents$1 = {
+	  WS_CONNECT,
+	  WS_CONNECT_COMPLETE,
+	  WS_CONNECT_ERROR,
+	  WS_DISCONNECT,
+	  WS_DISCONNECT_COMPLETE,
+	  WS_DISCONNECT_ERROR,
+	  WS_SEND,
+	  WS_SEND_COMPLETE,
+	  WS_SEND_ERROR,
+	  WS_STATUS,
+	  WS_STATUS_COMPLETE,
+	  WS_STATUS_ERROR,
+	  WS_MESSAGE,
+	  WS_STATUS_CHANGE,
+	  WS_GET_ALL,
+	  WS_GET_ALL_COMPLETE,
+	  WS_GET_ALL_ERROR,
+	};
+	return webSocketEvents$1;
+}
 
 /**
  * Event Constants File - MCP Dash Server Events
@@ -923,7 +931,7 @@ const sessionEvents = sessionEvents$1;
 const notificationEvents = notificationEvents$1;
 const schedulerEvents = schedulerEvents$1;
 const themeFromUrlEvents = themeFromUrlEvents$1;
-const webSocketEvents = webSocketEvents$1;
+const webSocketEvents = requireWebSocketEvents();
 const mcpDashServerEvents = mcpDashServerEvents$1;
 
 const publicEvents = {
@@ -1207,7 +1215,7 @@ const { getFileContents: getFileContents$7 } = file;
 const configFilename$5 = "workspaces.json";
 const appName$7 = "Dashboard";
 
-const workspaceController$1 = {
+const workspaceController$2 = {
   /**
    * createWorkspace
    *
@@ -1449,7 +1457,7 @@ const workspaceController$1 = {
   },
 };
 
-var workspaceController_1 = workspaceController$1;
+var workspaceController_1 = workspaceController$2;
 
 const { app: app$9 } = require$$0$2;
 const path$f = require$$1$2;
@@ -1459,7 +1467,7 @@ const { getFileContents: getFileContents$6 } = file;
 const configFilename$4 = "themes.json";
 const appName$6 = "Dashboard";
 
-const themeController$3 = {
+const themeController$4 = {
   /**
    * saveTheme
    * Create a new Theme that can be used in the application
@@ -1590,7 +1598,7 @@ const themeController$3 = {
   },
 };
 
-var themeController_1 = themeController$3;
+var themeController_1 = themeController$4;
 
 /**
  * Utils/tranaform
@@ -26864,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,
@@ -31843,8 +31851,8 @@ const path$2 = require$$1$2;
 const { app: app$2, dialog: dialog$1 } = require$$0$2;
 const AdmZip$1 = require$$3$4;
 
-const themeController$2 = themeController_1;
-const registryController$1 = registryController$2;
+const themeController$3 = themeController_1;
+const registryController$2 = registryController$3;
 const registryApiController$1 = registryApiController$2;
 const {
   getAuthStatus,
@@ -31950,7 +31958,7 @@ function extractColors(themeData) {
 async function prepareThemeForPublish$1(win, appId, themeKey, options = {}) {
   try {
     // Read the theme data
-    const themesResult = themeController$2.listThemesForApplication(win, appId);
+    const themesResult = themeController$3.listThemesForApplication(win, appId);
     if (themesResult.error) {
       return {
         success: false,
@@ -32074,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,
@@ -32161,7 +32169,7 @@ async function installThemeFromRegistry$1(win, appId, packageName) {
     const themeKey = pkg.displayName || pkg.name;
 
     // Save via themeController
-    const saveResult = themeController$2.saveThemeForApplication(
+    const saveResult = themeController$3.saveThemeForApplication(
       win,
       appId,
       themeKey,
@@ -32198,7 +32206,7 @@ async function installThemeFromRegistry$1(win, appId, packageName) {
  */
 function getThemePublishPreview$1(appId, themeKey) {
   try {
-    const themesResult = themeController$2.listThemesForApplication(null, appId);
+    const themesResult = themeController$3.listThemesForApplication(null, appId);
     if (themesResult.error) {
       return {
         success: false,
@@ -32264,8 +32272,8 @@ const {
   buildProviderRequirements,
   applyEventWiringToLayout,
 } = dashboardConfigUtils$1;
-const { searchRegistry, getPackage } = registryController$2;
-const themeController$1 = themeController_1;
+const { searchRegistry, getPackage } = registryController$3;
+const themeController$2 = themeController_1;
 
 const configFilename = "workspaces.json";
 const appName$1 = "Dashboard";
@@ -32345,7 +32353,7 @@ async function exportDashboardConfig$1(
     // 4. Bundle theme if workspace has a themeKey
     if (workspace.themeKey) {
       try {
-        const themeResult = themeController$1.listThemesForApplication(
+        const themeResult = themeController$2.listThemesForApplication(
           win,
           appId,
         );
@@ -32700,7 +32708,7 @@ async function processDashboardConfig(
   if (dashboardConfig.theme) {
     const bundledTheme = dashboardConfig.theme;
     try {
-      const themeResult = themeController$1.listThemesForApplication(win, appId);
+      const themeResult = themeController$2.listThemesForApplication(win, appId);
       const existingThemes = themeResult.themes || {};
       const themeKey = bundledTheme.key;
 
@@ -32714,7 +32722,7 @@ async function processDashboardConfig(
             installedAt: new Date().toISOString(),
           };
         }
-        themeController$1.saveThemeForApplication(
+        themeController$2.saveThemeForApplication(
           win,
           appId,
           themeKey,
@@ -32990,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() : [];
 
@@ -33112,7 +33120,7 @@ async function prepareDashboardForPublish$1(
     // 4. Bundle theme if workspace has a themeKey
     if (workspace.themeKey) {
       try {
-        const themeResult = themeController$1.listThemesForApplication(
+        const themeResult = themeController$2.listThemesForApplication(
           win,
           appId,
         );
@@ -33145,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 {
@@ -33292,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) {
@@ -33337,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(
@@ -45243,7 +45251,7 @@ function interpolate(template, credentials) {
  * @param {object} extra - Additional fields (error, retryCount, retryIn, etc.)
  */
 function broadcastStatusChange(providerName, status, extra = {}) {
-  const { WS_STATUS_CHANGE } = webSocketEvents$1;
+  const { WS_STATUS_CHANGE } = requireWebSocketEvents();
   const { BrowserWindow } = require$$0$2;
 
   const payload = { provider: providerName, status, ...extra };
@@ -45261,7 +45269,7 @@ function broadcastStatusChange(providerName, status, extra = {}) {
  * @param {*} data - The message data
  */
 function broadcastMessage(providerName, data) {
-  const { WS_MESSAGE } = webSocketEvents$1;
+  const { WS_MESSAGE } = requireWebSocketEvents();
   const { BrowserWindow } = require$$0$2;
 
   const payload = {
@@ -66056,6 +66064,7 @@ let httpServer = null;
 let transport = null;
 let startTime = null;
 let connectionCount = 0;
+let activeWin = null;
 
 // --- Rate Limiting ---
 const RATE_LIMIT = 60; // requests per minute
@@ -66102,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(toolDef) {
+function registerTool$2(toolDef) {
   registeredTools.push(toolDef);
 }
 
@@ -66144,8 +66153,43 @@ function saveMcpServerSettings(win, mcpSettings) {
   settingsController$1.saveSettingsForApplication(win, settings);
 }
 
+// --- App ID Resolution ---
+/**
+ * Resolve the appId by scanning the userData/Dashboard directory for
+ * subdirectories containing workspaces.json. Falls back to the default.
+ */
+function resolveAppId() {
+  const { app } = require$$0$2;
+  const fs = require$$0$3;
+  const path = require$$1$2;
+  const dashboardDir = path.join(app.getPath("userData"), "Dashboard");
+  try {
+    const entries = fs.readdirSync(dashboardDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        const wsFile = path.join(dashboardDir, entry.name, "workspaces.json");
+        if (fs.existsSync(wsFile)) {
+          return entry.name;
+        }
+      }
+    }
+  } catch (e) {
+    // Directory may not exist yet
+  }
+  return "@trops/dash-electron";
+}
+
+/**
+ * Get the current server context (win + appId) for tool handlers.
+ * Returns null if the server is not running.
+ */
+function getServerContext() {
+  if (!activeWin) return null;
+  return { win: activeWin, appId: resolveAppId() };
+}
+
 // --- Controller ---
-const mcpDashServerController$2 = {
+const mcpDashServerController$3 = {
   /**
    * Start the MCP Dash server.
    * @param {BrowserWindow} win
@@ -66163,7 +66207,7 @@ const mcpDashServerController$2 = {
       const serverSettings = getMcpServerSettings(win);
       const port = options.port || serverSettings.port || 3141;
       const token =
-        serverSettings.token || mcpDashServerController$2.getOrCreateToken(win);
+        serverSettings.token || mcpDashServerController$3.getOrCreateToken(win);
 
       // Create McpServer
       mcpServer = new McpServer({
@@ -66257,6 +66301,7 @@ const mcpDashServerController$2 = {
 
       startTime = Date.now();
       connectionCount = 0;
+      activeWin = win;
       startCleanup();
 
       // Save enabled state
@@ -66317,6 +66362,7 @@ const mcpDashServerController$2 = {
       transport = null;
       startTime = null;
       connectionCount = 0;
+      activeWin = null;
 
       // Update settings
       if (win) {
@@ -66339,8 +66385,8 @@ const mcpDashServerController$2 = {
    * Restart the server (stop + start).
    */
   restartServer: async (win, options = {}) => {
-    await mcpDashServerController$2.stopServer(win);
-    return mcpDashServerController$2.startServer(win, options);
+    await mcpDashServerController$3.stopServer(win);
+    return mcpDashServerController$3.startServer(win, options);
   },
 
   /**
@@ -66380,7 +66426,7 @@ const mcpDashServerController$2 = {
     const serverSettings = getMcpServerSettings(win);
     if (serverSettings.enabled) {
       console.log("[mcpDashServer] Auto-starting server...");
-      return mcpDashServerController$2.startServer(win, {
+      return mcpDashServerController$3.startServer(win, {
         port: serverSettings.port,
       });
     }
@@ -66388,11 +66434,12 @@ const mcpDashServerController$2 = {
   },
 
   // Expose registration functions for other controllers
-  registerTool,
+  registerTool: registerTool$2,
   registerResource,
+  getServerContext,
 };
 
-var mcpDashServerController_1 = mcpDashServerController$2;
+var mcpDashServerController_1 = mcpDashServerController$3;
 
 /**
  * clientFactories.js
@@ -66825,7 +66872,7 @@ const {
   matchTailwindFamily,
   generateThemeFromPalette,
 } = paletteToThemeMapper_1;
-const mcpDashServerController$1 = mcpDashServerController_1;
+const mcpDashServerController$2 = mcpDashServerController_1;
 
 var controller = {
   showDialog,
@@ -66908,7 +66955,7 @@ var controller = {
   assignRoles,
   matchTailwindFamily,
   generateThemeFromPalette,
-  mcpDashServerController: mcpDashServerController$1,
+  mcpDashServerController: mcpDashServerController$2,
 };
 
 const { ipcRenderer: ipcRenderer$q } = require$$0$2;
@@ -68921,6 +68968,1118 @@ const mcpDashServerApi$2 = {
 
 var mcpDashServerApi_1 = mcpDashServerApi$2;
 
+/**
+ * toolDefinitions.js
+ *
+ * MCP tool schemas for dashboard/workspace operations and app stats.
+ * Each definition includes name, description, and JSON Schema inputSchema.
+ */
+
+const dashboardTools$1 = [
+  {
+    name: "list_dashboards",
+    description: "List all dashboards with their IDs, names, and widget counts",
+    inputSchema: {
+      type: "object",
+      properties: {},
+      required: [],
+    },
+  },
+  {
+    name: "get_dashboard",
+    description:
+      "Get full details of a dashboard including layout and widgets. Omit dashboardId to get the active dashboard.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        dashboardId: {
+          type: "string",
+          description:
+            "Dashboard ID. Omit to get the currently active dashboard.",
+        },
+      },
+      required: [],
+    },
+  },
+  {
+    name: "create_dashboard",
+    description: "Create a new dashboard with the given name",
+    inputSchema: {
+      type: "object",
+      properties: {
+        name: {
+          type: "string",
+          description: "Display name for the new dashboard",
+        },
+      },
+      required: ["name"],
+    },
+  },
+  {
+    name: "delete_dashboard",
+    description:
+      "Delete a dashboard by ID. Cannot delete the last remaining dashboard.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        dashboardId: {
+          type: "string",
+          description: "ID of the dashboard to delete",
+        },
+      },
+      required: ["dashboardId"],
+    },
+  },
+  {
+    name: "get_app_stats",
+    description:
+      "Get application statistics: counts of dashboards, widgets, themes, and providers",
+    inputSchema: {
+      type: "object",
+      properties: {},
+      required: [],
+    },
+  },
+];
+
+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"],
+    },
+  },
+];
+
+var toolDefinitions = { dashboardTools: dashboardTools$1, widgetTools: widgetTools$1 };
+
+/**
+ * toolHandlers.js
+ *
+ * MCP tool handlers for dashboard/workspace CRUD and app statistics.
+ * Each handler delegates to existing controllers via getServerContext().
+ */
+const mcpDashServerController$1 = mcpDashServerController_1;
+const workspaceController$1 = workspaceController_1;
+const themeController$1 = themeController_1;
+const providerController$1 = requireProviderController();
+
+/**
+ * Helper: get win + appId or throw a descriptive error.
+ */
+function requireContext() {
+  const ctx = mcpDashServerController$1.getServerContext();
+  if (!ctx) {
+    throw new Error("MCP server is not running or has no active window");
+  }
+  return ctx;
+}
+
+/**
+ * Helper: count widgets in a workspace's layout array.
+ * Widgets are layout items whose component is registered and is not a container.
+ */
+function countWidgets(layout) {
+  if (!Array.isArray(layout)) return 0;
+  return layout.filter(
+    (item) =>
+      item.component &&
+      item.component !== "Container" &&
+      item.component !== "LayoutContainer" &&
+      item.component !== "LayoutGridContainer",
+  ).length;
+}
+
+/**
+ * list_dashboards — Returns all workspaces with id, name, widget count, active state.
+ */
+async function handleListDashboards$1() {
+  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 dashboards = (result.workspaces || []).map((ws, index) => ({
+    id: String(ws.id),
+    name: ws.name || ws.label || `Dashboard ${index + 1}`,
+    widgetCount: countWidgets(ws.layout),
+    isActive: index === 0,
+  }));
+
+  return {
+    content: [{ type: "text", text: JSON.stringify(dashboards, null, 2) }],
+  };
+}
+
+/**
+ * get_dashboard — Returns full details for a dashboard by ID (or the active one).
+ */
+async function handleGetDashboard$1({ dashboardId }) {
+  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 workspaces = result.workspaces || [];
+  let workspace;
+
+  if (dashboardId) {
+    workspace = workspaces.find((ws) => String(ws.id) === dashboardId);
+    if (!workspace) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({
+              error: `Dashboard not found: ${dashboardId}`,
+            }),
+          },
+        ],
+        isError: true,
+      };
+    }
+  } else {
+    // Return first workspace as the "active" one
+    workspace = workspaces[0];
+    if (!workspace) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({
+              error: "No dashboards exist",
+            }),
+          },
+        ],
+        isError: true,
+      };
+    }
+  }
+
+  const widgets = (workspace.layout || [])
+    .filter(
+      (item) =>
+        item.component &&
+        item.component !== "Container" &&
+        item.component !== "LayoutContainer" &&
+        item.component !== "LayoutGridContainer",
+    )
+    .map((item) => ({
+      id: String(item.id),
+      type: item.component,
+      config: item.config || {},
+    }));
+
+  const detail = {
+    id: String(workspace.id),
+    name: workspace.name || workspace.label || "Dashboard",
+    layout: workspace.layout || [],
+    widgets,
+    theme: workspace.theme || null,
+  };
+
+  return {
+    content: [{ type: "text", text: JSON.stringify(detail, null, 2) }],
+  };
+}
+
+/**
+ * create_dashboard — Creates a new workspace with the given name.
+ */
+async function handleCreateDashboard$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 newWorkspace = {
+    id: Date.now(),
+    name: name.trim(),
+    label: name.trim(),
+    type: "workspace",
+    version: 1,
+    menuId: 1,
+    layout: [
+      {
+        id: 1,
+        order: 1,
+        component: "Container",
+        parentId: 0,
+        items: [],
+      },
+    ],
+  };
+
+  const result = workspaceController$1.saveWorkspaceForApplication(
+    win,
+    appId,
+    newWorkspace,
+  );
+
+  if (result.error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({ error: result.message }),
+        },
+      ],
+      isError: true,
+    };
+  }
+
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(
+          { id: String(newWorkspace.id), name: newWorkspace.name },
+          null,
+          2,
+        ),
+      },
+    ],
+  };
+}
+
+/**
+ * delete_dashboard — Deletes a workspace by ID. Rejects if it's the last one.
+ */
+async function handleDeleteDashboard$1({ dashboardId }) {
+  if (!dashboardId || typeof dashboardId !== "string") {
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            error: "dashboardId is required",
+          }),
+        },
+      ],
+      isError: true,
+    };
+  }
+
+  const { win, appId } = requireContext();
+
+  // Check how many dashboards exist
+  const listResult = workspaceController$1.listWorkspacesForApplication(
+    win,
+    appId,
+  );
+  const workspaces = listResult.workspaces || [];
+
+  if (workspaces.length <= 1) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            error: "Cannot delete the last remaining dashboard",
+          }),
+        },
+      ],
+      isError: true,
+    };
+  }
+
+  // Verify the dashboard exists
+  const exists = workspaces.some((ws) => String(ws.id) === dashboardId);
+  if (!exists) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            error: `Dashboard not found: ${dashboardId}`,
+          }),
+        },
+      ],
+      isError: true,
+    };
+  }
+
+  // Use numeric ID if stored as number
+  const targetWs = workspaces.find((ws) => String(ws.id) === dashboardId);
+  const result = workspaceController$1.deleteWorkspaceForApplication(
+    win,
+    appId,
+    targetWs.id,
+  );
+
+  if (result.error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({ error: result.message }),
+        },
+      ],
+      isError: true,
+    };
+  }
+
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify({
+          success: true,
+          deleted: dashboardId,
+          remaining: (result.workspaces || []).length,
+        }),
+      },
+    ],
+  };
+}
+
+/**
+ * get_app_stats — Returns counts of dashboards, widgets, themes, and providers.
+ */
+async function handleGetAppStats$1() {
+  const { win, appId } = requireContext();
+
+  // Dashboards + widget count
+  const wsResult = workspaceController$1.listWorkspacesForApplication(win, appId);
+  const workspaces = wsResult.workspaces || [];
+  const dashboardCount = workspaces.length;
+  const widgetCount = workspaces.reduce(
+    (sum, ws) => sum + countWidgets(ws.layout),
+    0,
+  );
+
+  // Themes
+  const themeResult = themeController$1.listThemesForApplication(win, appId);
+  const themes = themeResult.themes || {};
+  const themeCount = Object.keys(themes).length;
+
+  // Providers
+  const providerResult = providerController$1.listProviders(win, appId);
+  const providers = providerResult.providers || {};
+  const providerCount = Object.keys(providers).length;
+
+  const stats = {
+    dashboardCount,
+    widgetCount,
+    themeCount,
+    providerCount,
+  };
+
+  return {
+    content: [{ type: "text", text: JSON.stringify(stats, null, 2) }],
+  };
+}
+
+// --- 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,
+    };
+  }
+}
+
+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,
+};
+
+/**
+ * dashboardTools.js
+ *
+ * Registers dashboard/workspace MCP tools with the MCP Dash server.
+ * Call registerDashboardTools() during app startup (before or after server start).
+ */
+
+const { registerTool: registerTool$1 } = mcpDashServerController_1;
+const { dashboardTools } = toolDefinitions;
+const {
+  handleListDashboards,
+  handleGetDashboard,
+  handleCreateDashboard,
+  handleDeleteDashboard,
+  handleGetAppStats,
+} = toolHandlers;
+
+// Map tool names to handler functions
+const handlerMap$1 = {
+  list_dashboards: handleListDashboards,
+  get_dashboard: handleGetDashboard,
+  create_dashboard: handleCreateDashboard,
+  delete_dashboard: handleDeleteDashboard,
+  get_app_stats: handleGetAppStats,
+};
+
+/**
+ * Register all dashboard tools with the MCP server controller.
+ */
+function registerDashboardTools$1() {
+  for (const tool of dashboardTools) {
+    const handler = handlerMap$1[tool.name];
+    if (!handler) {
+      console.warn(`[dashboardTools] No handler found for tool: ${tool.name}`);
+      continue;
+    }
+    registerTool$1({
+      name: tool.name,
+      description: tool.description,
+      inputSchema: tool.inputSchema,
+      handler,
+    });
+  }
+  console.log(
+    `[dashboardTools] Registered ${dashboardTools.length} dashboard tools`,
+  );
+}
+
+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 } = mcpDashServerController_1;
+const { widgetTools } = toolDefinitions;
+const {
+  handleAddWidget,
+  handleRemoveWidget,
+  handleConfigureWidget,
+  handleListWidgets,
+  handleSearchWidgets,
+} = toolHandlers;
+
+// Map tool names to handler functions
+const handlerMap = {
+  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[tool.name];
+    if (!handler) {
+      console.warn(`[widgetTools] No handler found for tool: ${tool.name}`);
+      continue;
+    }
+    registerTool({
+      name: tool.name,
+      description: tool.description,
+      inputSchema: tool.inputSchema,
+      handler,
+    });
+  }
+  console.log(`[widgetTools] Registered ${widgetTools.length} widget tools`);
+}
+
+var widgetTools_1 = { registerWidgetTools: registerWidgetTools$1 };
+
 /**
  * dashboardRatingsApi.js
  *
@@ -69177,7 +70336,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;
@@ -69241,6 +70400,12 @@ const widgetRegistry = widgetRegistryExports;
 const widgetCompiler = widgetCompiler$1;
 const dynamicWidgetLoader = dynamicWidgetLoaderExports;
 
+// --- MCP Dash Server Tools ---
+const { registerDashboardTools } = dashboardTools_1;
+const { registerWidgetTools } = widgetTools_1;
+registerDashboardTools();
+registerWidgetTools();
+
 // --- Schema ---
 const dashboardConfigValidator = dashboardConfigValidator$1;
 const dashboardConfigUtils = dashboardConfigUtils$1;
@@ -69332,6 +70497,10 @@ var electron = {
 
   // Setup helpers
   setupCacheHandlers: clientCache.setupCacheHandlers.bind(clientCache),
+
+  // MCP Dash Server Tools
+  registerDashboardTools,
+  registerWidgetTools,
 };
 
 var index = /*@__PURE__*/getDefaultExportFromCjs(electron);