@trops/dash-core 0.1.171 → 0.1.172

package/dist/electron/index.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(
@@ -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$2(toolDef) {
   registeredTools.push(toolDef);
 }
 
@@ -66434,7 +66434,7 @@ const mcpDashServerController$3 = {
   },
 
   // Expose registration functions for other controllers
-  registerTool: registerTool$1,
+  registerTool: registerTool$2,
   registerResource,
   getServerContext,
 };
@@ -69042,7 +69042,99 @@ 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"],
+    },
+  },
+];
+
+var toolDefinitions = { dashboardTools: dashboardTools$1, widgetTools: widgetTools$1 };
 
 /**
  * toolHandlers.js
@@ -69392,12 +69484,502 @@ 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,
+    };
+  }
+}
+
 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,
 };
 
 /**
@@ -69407,7 +69989,7 @@ var toolHandlers = {
  * Call registerDashboardTools() during app startup (before or after server start).
  */
 
-const { registerTool } = mcpDashServerController_1;
+const { registerTool: registerTool$1 } = mcpDashServerController_1;
 const { dashboardTools } = toolDefinitions;
 const {
   handleListDashboards,
@@ -69418,7 +70000,7 @@ const {
 } = toolHandlers;
 
 // Map tool names to handler functions
-const handlerMap = {
+const handlerMap$1 = {
   list_dashboards: handleListDashboards,
   get_dashboard: handleGetDashboard,
   create_dashboard: handleCreateDashboard,
@@ -69431,12 +70013,12 @@ const handlerMap = {
  */
 function registerDashboardTools$1() {
   for (const tool of dashboardTools) {
-    const handler = handlerMap[tool.name];
+    const handler = handlerMap$1[tool.name];
     if (!handler) {
       console.warn(`[dashboardTools] No handler found for tool: ${tool.name}`);
       continue;
     }
-    registerTool({
+    registerTool$1({
       name: tool.name,
       description: tool.description,
       inputSchema: tool.inputSchema,
@@ -69450,6 +70032,54 @@ 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 } = 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
  *
@@ -69706,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;
@@ -69772,7 +70402,9 @@ const dynamicWidgetLoader = dynamicWidgetLoaderExports;
 
 // --- MCP Dash Server Tools ---
 const { registerDashboardTools } = dashboardTools_1;
+const { registerWidgetTools } = widgetTools_1;
 registerDashboardTools();
+registerWidgetTools();
 
 // --- Schema ---
 const dashboardConfigValidator = dashboardConfigValidator$1;
@@ -69868,6 +70500,7 @@ var electron = {
 
   // MCP Dash Server Tools
   registerDashboardTools,
+  registerWidgetTools,
 };
 
 var index = /*@__PURE__*/getDefaultExportFromCjs(electron);