@trops/dash-core 0.1.85 → 0.1.87

package/dist/electron/index.js

@@ -423,12 +423,14 @@ const REGISTRY_FETCH_INDEX = "registry:fetch-index";
 const REGISTRY_SEARCH = "registry:search";
 const REGISTRY_GET_PACKAGE = "registry:get-package";
 const REGISTRY_CHECK_UPDATES = "registry:check-updates";
+const REGISTRY_SEARCH_DASHBOARDS = "registry:search-dashboards";
 
 var registryEvents$1 = {
   REGISTRY_FETCH_INDEX,
   REGISTRY_SEARCH,
   REGISTRY_GET_PACKAGE,
   REGISTRY_CHECK_UPDATES,
+  REGISTRY_SEARCH_DASHBOARDS,
 };
 
 /**
@@ -586,10 +588,12 @@ var clientCacheEvents$1 = {
 
 const DASHBOARD_CONFIG_EXPORT$1 = "dashboard-config-export";
 const DASHBOARD_CONFIG_IMPORT$1 = "dashboard-config-import";
+const DASHBOARD_CONFIG_INSTALL$1 = "dashboard-config-install";
 
 var dashboardConfigEvents$1 = {
-    DASHBOARD_CONFIG_EXPORT: DASHBOARD_CONFIG_EXPORT$1,
-    DASHBOARD_CONFIG_IMPORT: DASHBOARD_CONFIG_IMPORT$1,
+  DASHBOARD_CONFIG_EXPORT: DASHBOARD_CONFIG_EXPORT$1,
+  DASHBOARD_CONFIG_IMPORT: DASHBOARD_CONFIG_IMPORT$1,
+  DASHBOARD_CONFIG_INSTALL: DASHBOARD_CONFIG_INSTALL$1,
 };
 
 /**
@@ -6009,12 +6013,22 @@ async function fetchRegistryIndex(forceRefresh = false) {
  * @param {string} filters.category - Filter by category
  * @param {string} filters.author - Filter by author
  * @param {string} filters.tag - Filter by tag
+ * @param {string} filters.type - Filter by package type ("widget" or "dashboard")
+ * @param {string[]} filters.compatibleWidgets - Only return dashboards whose required widgets are all in this list
  * @returns {Promise<Object>} { packages: [...], totalWidgets: number }
  */
 async function searchRegistry$1(query = "", filters = {}) {
   const index = await fetchRegistryIndex();
   let packages = index.packages || [];
 
+  // Apply type filter — packages without an explicit type default to "widget"
+  if (filters.type) {
+    const typeLower = filters.type.toLowerCase();
+    packages = packages.filter(
+      (pkg) => (pkg.type || "widget").toLowerCase() === typeLower,
+    );
+  }
+
   // Apply search query
   if (query) {
     const q = query.toLowerCase();
@@ -6063,6 +6077,24 @@ async function searchRegistry$1(query = "", filters = {}) {
     );
   }
 
+  // Apply compatibility filter — only dashboards whose required widgets
+  // are all present in the user's installed widget list
+  if (filters.compatibleWidgets && filters.compatibleWidgets.length) {
+    const installedSet = new Set(
+      filters.compatibleWidgets.map((w) => w.toLowerCase()),
+    );
+    packages = packages.filter((pkg) => {
+      const requiredWidgets = (pkg.widgets || []).filter(
+        (w) => w.required !== false,
+      );
+      return requiredWidgets.every(
+        (w) =>
+          installedSet.has((w.package || "").toLowerCase()) ||
+          installedSet.has((w.name || "").toLowerCase()),
+      );
+    });
+  }
+
   // Count total widgets across matched packages
   const totalWidgets = packages.reduce(
     (sum, pkg) => sum + (pkg.widgets || []).length,
@@ -6110,9 +6142,22 @@ async function checkUpdates(installedWidgets = []) {
   return updates;
 }
 
+/**
+ * Search the registry for dashboard packages only.
+ * Convenience wrapper around searchRegistry with type: "dashboard".
+ *
+ * @param {string} query - Search query string
+ * @param {Object} filters - Optional filters (category, author, tag, compatibleWidgets)
+ * @returns {Promise<Object>} { packages: [...], totalWidgets: number }
+ */
+async function searchDashboards(query = "", filters = {}) {
+  return searchRegistry$1(query, { ...filters, type: "dashboard" });
+}
+
 var registryController$1 = {
   fetchRegistryIndex,
   searchRegistry: searchRegistry$1,
+  searchDashboards,
   getPackage: getPackage$1,
   checkUpdates,
 };
@@ -9931,134 +9976,292 @@ async function importDashboardConfig$1(win, appId, widgetRegistry = null) {
     // Apply defaults to fill in optional fields
     dashboardConfig = applyDefaults(dashboardConfig);
 
-    // 3. Auto-install missing widgets from registry
-    const installSummary = {
-      installed: [],
-      alreadyInstalled: [],
-      failed: [],
+    // Delegate to shared import pipeline
+    return await processDashboardConfig(
+      win,
+      appId,
+      dashboardConfig,
+      widgetRegistry,
+    );
+  } catch (error) {
+    console.error(
+      "[DashboardConfigController] Error importing dashboard:",
+      error,
+    );
+    return {
+      success: false,
+      error: error.message,
     };
+  }
+}
 
-    if (
-      widgetRegistry &&
-      dashboardConfig.widgets &&
-      dashboardConfig.widgets.length
-    ) {
-      const installedWidgets = widgetRegistry.getWidgets();
-      const installedPackages = new Set(installedWidgets.map((w) => w.name));
+/**
+ * Shared import pipeline: install widgets, create workspace, wire events.
+ * Used by both importDashboardConfig (ZIP) and installDashboardFromRegistry.
+ *
+ * @param {BrowserWindow} win - The main window
+ * @param {string} appId - Application identifier
+ * @param {Object} dashboardConfig - Validated dashboard config object
+ * @param {Object} widgetRegistry - WidgetRegistry instance
+ * @param {Object} options - Additional options
+ * @param {string} options.source - Source label ("zip" or "registry")
+ * @returns {Promise<Object>} Result with success, workspace, and summary
+ */
+async function processDashboardConfig(
+  win,
+  appId,
+  dashboardConfig,
+  widgetRegistry = null,
+  options = {},
+) {
+  const source = options.source || "zip";
 
-      for (const widgetDep of dashboardConfig.widgets) {
-        const packageName = widgetDep.package;
+  // 1. Auto-install missing widgets from registry
+  const installSummary = {
+    installed: [],
+    alreadyInstalled: [],
+    failed: [],
+  };
 
-        if (installedPackages.has(packageName)) {
-          installSummary.alreadyInstalled.push(packageName);
-          continue;
-        }
+  if (
+    widgetRegistry &&
+    dashboardConfig.widgets &&
+    dashboardConfig.widgets.length
+  ) {
+    const installedWidgets = widgetRegistry.getWidgets();
+    const installedPackages = new Set(installedWidgets.map((w) => w.name));
 
-        // Try to find the widget in the registry and install it
-        try {
-          const registryPkg = await getPackage(packageName);
-          if (registryPkg && registryPkg.downloadUrl) {
-            await widgetRegistry.downloadWidget(
-              packageName,
-              registryPkg.downloadUrl,
-              registryPkg.dashConfigUrl || null,
-            );
-            installSummary.installed.push(packageName);
-            installedPackages.add(packageName);
-          } else {
-            installSummary.failed.push({
-              package: packageName,
-              reason: "Not found in registry",
-            });
-          }
-        } catch (installError) {
+    for (const widgetDep of dashboardConfig.widgets) {
+      const packageName = widgetDep.package;
+
+      if (installedPackages.has(packageName)) {
+        installSummary.alreadyInstalled.push(packageName);
+        continue;
+      }
+
+      // Try to find the widget in the registry and install it
+      try {
+        const registryPkg = await getPackage(packageName);
+        if (registryPkg && registryPkg.downloadUrl) {
+          await widgetRegistry.downloadWidget(
+            packageName,
+            registryPkg.downloadUrl,
+            registryPkg.dashConfigUrl || null,
+          );
+          installSummary.installed.push(packageName);
+          installedPackages.add(packageName);
+        } else {
           installSummary.failed.push({
             package: packageName,
-            reason: installError.message,
+            reason: "Not found in registry",
           });
         }
+      } catch (installError) {
+        installSummary.failed.push({
+          package: packageName,
+          reason: installError.message,
+        });
       }
     }
+  }
 
-    // 4. Build workspace from config
-    const workspace = dashboardConfig.workspace;
+  // 2. Build workspace from config
+  const workspace = { ...dashboardConfig.workspace };
 
-    if (!workspace) {
+  if (!workspace || !workspace.layout) {
+    return {
+      success: false,
+      error: "Dashboard config has no workspace data",
+    };
+  }
+
+  // Generate a unique ID for the imported workspace
+  workspace.id = Date.now();
+
+  // 3. Apply event wiring to layout
+  const eventWiringSummary = [];
+  if (
+    dashboardConfig.eventWiring &&
+    dashboardConfig.eventWiring.length &&
+    workspace.layout
+  ) {
+    applyEventWiringToLayout(workspace.layout, dashboardConfig.eventWiring);
+    for (const wire of dashboardConfig.eventWiring) {
+      eventWiringSummary.push(
+        `${wire.source?.widget}.${wire.source?.event} → ${wire.target?.widget}.${wire.target?.handler}`,
+      );
+    }
+  }
+
+  // 4. Mark as not shareable (imported dashboards cannot be re-published)
+  workspace._dashboardConfig = {
+    shareable: false,
+    source,
+    importedFrom: dashboardConfig.name,
+    importedAt: new Date().toISOString(),
+    originalAuthor: dashboardConfig.author,
+    schemaVersion: dashboardConfig.schemaVersion,
+  };
+
+  // Save workspace to workspaces.json
+  const workspaceController = workspaceController_1;
+  const saveResult = workspaceController.saveWorkspaceForApplication(
+    win,
+    appId,
+    workspace,
+  );
+
+  if (saveResult.error) {
+    return {
+      success: false,
+      error: `Failed to save workspace: ${saveResult.message}`,
+    };
+  }
+
+  // Build provider requirements summary
+  const providerSummary = (dashboardConfig.providers || []).map((p) => ({
+    type: p.type,
+    providerClass: p.providerClass,
+    required: p.required,
+    usedBy: p.usedBy,
+  }));
+
+  console.log(
+    `[DashboardConfigController] Imported dashboard "${dashboardConfig.name}" (${source}) as workspace ${workspace.id}`,
+  );
+
+  return {
+    success: true,
+    workspace,
+    summary: {
+      name: dashboardConfig.name,
+      description: dashboardConfig.description || "",
+      author: dashboardConfig.author,
+      widgets: installSummary,
+      eventsWired: eventWiringSummary,
+      providersRequired: providerSummary,
+    },
+  };
+}
+
+/**
+ * Install a dashboard from the registry by package name.
+ *
+ * Fetches the dashboard ZIP from the registry, extracts the .dashboard.json,
+ * validates it, and delegates to the shared import pipeline.
+ *
+ * @param {BrowserWindow} win - The main window
+ * @param {string} appId - Application identifier
+ * @param {string} packageName - Registry package name for the dashboard
+ * @param {Object} widgetRegistry - WidgetRegistry instance
+ * @returns {Promise<Object>} Result with success, workspace, and summary
+ */
+async function installDashboardFromRegistry$1(
+  win,
+  appId,
+  packageName,
+  widgetRegistry = null,
+) {
+  try {
+    // 1. Look up the dashboard package in the registry
+    const registryPkg = await getPackage(packageName);
+    if (!registryPkg) {
       return {
         success: false,
-        error: "Dashboard config has no workspace data",
+        error: `Dashboard package not found in registry: ${packageName}`,
       };
     }
 
-    // Generate a unique ID for the imported workspace
-    workspace.id = Date.now();
-
-    // 5. Apply event wiring to layout
-    const eventWiringSummary = [];
-    if (
-      dashboardConfig.eventWiring &&
-      dashboardConfig.eventWiring.length &&
-      workspace.layout
-    ) {
-      applyEventWiringToLayout(workspace.layout, dashboardConfig.eventWiring);
-      for (const wire of dashboardConfig.eventWiring) {
-        eventWiringSummary.push(
-          `${wire.source?.widget}.${wire.source?.event} → ${wire.target?.widget}.${wire.target?.handler}`,
-        );
-      }
+    if (!registryPkg.downloadUrl) {
+      return {
+        success: false,
+        error: `Dashboard package has no download URL: ${packageName}`,
+      };
     }
 
-    // 6. Mark as not shareable (imported dashboards cannot be re-published)
-    workspace._dashboardConfig = {
-      shareable: false,
-      importedFrom: dashboardConfig.name,
-      importedAt: new Date().toISOString(),
-      originalAuthor: dashboardConfig.author,
-      schemaVersion: dashboardConfig.schemaVersion,
-    };
+    // 2. Resolve the download URL and fetch the ZIP
+    const version = registryPkg.version || "1.0.0";
+    let downloadUrl = registryPkg.downloadUrl;
+    downloadUrl = downloadUrl.replace("{version}", version);
+    downloadUrl = downloadUrl.replace("{name}", packageName);
 
-    // Save workspace to workspaces.json
-    const workspaceController = workspaceController_1;
-    const saveResult = workspaceController.saveWorkspaceForApplication(
-      win,
-      appId,
-      workspace,
+    // Enforce HTTPS
+    const parsedUrl = new URL(downloadUrl);
+    if (parsedUrl.protocol !== "https:") {
+      return {
+        success: false,
+        error: `Dashboard downloads must use HTTPS. Refusing: ${downloadUrl}`,
+      };
+    }
+
+    console.log(
+      `[DashboardConfigController] Fetching dashboard from: ${downloadUrl}`,
     );
 
-    if (saveResult.error) {
+    const response = await fetch(downloadUrl);
+    if (!response.ok) {
       return {
         success: false,
-        error: `Failed to save workspace: ${saveResult.message}`,
+        error: `Failed to download dashboard: ${response.status} ${response.statusText}`,
       };
     }
 
-    // Build provider requirements summary
-    const providerSummary = (dashboardConfig.providers || []).map((p) => ({
-      type: p.type,
-      providerClass: p.providerClass,
-      required: p.required,
-      usedBy: p.usedBy,
-    }));
+    const buffer = await response.arrayBuffer();
+    const zip = new AdmZip(Buffer.from(buffer));
 
-    console.log(
-      `[DashboardConfigController] Imported dashboard "${dashboardConfig.name}" as workspace ${workspace.id}`,
+    // 3. Validate ZIP entries
+    const tempDir = path.join(app.getPath("temp"), "dash-registry-import");
+    const { validateZipEntries } = widgetRegistryExports;
+    validateZipEntries(zip, tempDir);
+
+    // 4. Find and parse .dashboard.json
+    const entries = zip.getEntries();
+    const configEntry = entries.find((e) =>
+      e.entryName.endsWith(".dashboard.json"),
     );
 
-    return {
-      success: true,
-      workspace,
-      summary: {
-        name: dashboardConfig.name,
-        description: dashboardConfig.description || "",
-        author: dashboardConfig.author,
-        widgets: installSummary,
-        eventsWired: eventWiringSummary,
-        providersRequired: providerSummary,
+    if (!configEntry) {
+      return {
+        success: false,
+        error: "No .dashboard.json file found in downloaded archive",
+      };
+    }
+
+    const configJson = configEntry.getData().toString("utf-8");
+    let dashboardConfig;
+    try {
+      dashboardConfig = JSON.parse(configJson);
+    } catch (parseError) {
+      return {
+        success: false,
+        error: `Invalid JSON in dashboard config: ${parseError.message}`,
+      };
+    }
+
+    // 5. Validate against schema
+    const validation = validateDashboardConfig(dashboardConfig);
+    if (!validation.valid) {
+      return {
+        success: false,
+        error: `Invalid dashboard config: ${validation.errors.join(", ")}`,
+      };
+    }
+
+    dashboardConfig = applyDefaults(dashboardConfig);
+
+    // 6. Delegate to shared import pipeline
+    return await processDashboardConfig(
+      win,
+      appId,
+      dashboardConfig,
+      widgetRegistry,
+      {
+        source: "registry",
       },
-    };
+    );
   } catch (error) {
     console.error(
-      "[DashboardConfigController] Error importing dashboard:",
+      "[DashboardConfigController] Error installing dashboard from registry:",
       error,
     );
     return {
@@ -10071,6 +10274,7 @@ async function importDashboardConfig$1(win, appId, widgetRegistry = null) {
 var dashboardConfigController$1 = {
   exportDashboardConfig: exportDashboardConfig$1,
   importDashboardConfig: importDashboardConfig$1,
+  installDashboardFromRegistry: installDashboardFromRegistry$1,
 };
 
 /**
@@ -10162,6 +10366,7 @@ const { install: pluginInstall } = pluginController_1;
 const {
   exportDashboardConfig,
   importDashboardConfig,
+  installDashboardFromRegistry,
 } = dashboardConfigController$1;
 
 var controller = {
@@ -10207,6 +10412,7 @@ var controller = {
   searchIndex,
   exportDashboardConfig,
   importDashboardConfig,
+  installDashboardFromRegistry,
 };
 
 const { ipcRenderer: ipcRenderer$i } = require$$0$1;
@@ -11182,6 +11388,25 @@ const registryApi$2 = {
       throw error;
     }
   },
+
+  /**
+   * Search the registry for dashboard packages only
+   * @param {string} query - Search query
+   * @param {Object} filters - Optional filters { category, author, tag, compatibleWidgets }
+   * @returns {Promise<Object>} { packages: [...], totalWidgets: number }
+   */
+  searchDashboards: async (query = "", filters = {}) => {
+    try {
+      return await ipcRenderer$9.invoke(
+        "registry:search-dashboards",
+        query,
+        filters,
+      );
+    } catch (error) {
+      console.error("[RegistryApi] Error searching dashboards:", error);
+      throw error;
+    }
+  },
 };
 
 var registryApi_1 = registryApi$2;
@@ -11564,36 +11789,52 @@ var clientCacheApi_1 = clientCacheApi$2;
 
 const { ipcRenderer: ipcRenderer$1 } = require$$0$1;
 const {
-    DASHBOARD_CONFIG_EXPORT,
-    DASHBOARD_CONFIG_IMPORT,
+  DASHBOARD_CONFIG_EXPORT,
+  DASHBOARD_CONFIG_IMPORT,
+  DASHBOARD_CONFIG_INSTALL,
 } = events$8;
 
 const dashboardConfigApi$2 = {
-    /**
-     * Export a workspace as a dashboard config ZIP file.
-     *
-     * @param {string} appId - Application identifier
-     * @param {number|string} workspaceId - ID of the workspace to export
-     * @param {Object} options - Export options (authorName, authorId, description, tags, icon)
-     * @returns {Promise<Object>} Result with success, filePath, and config
-     */
-    exportDashboardConfig: (appId, workspaceId, options = {}) =>
-        ipcRenderer$1.invoke(DASHBOARD_CONFIG_EXPORT, {
-            appId,
-            workspaceId,
-            options,
-        }),
-
-    /**
-     * Import a dashboard config from a ZIP file.
-     * Shows a file picker, validates the config, installs missing widgets,
-     * creates the workspace, and applies event wiring.
-     *
-     * @param {string} appId - Application identifier
-     * @returns {Promise<Object>} Result with success, workspace, and summary
-     */
-    importDashboardConfig: (appId) =>
-        ipcRenderer$1.invoke(DASHBOARD_CONFIG_IMPORT, { appId }),
+  /**
+   * Export a workspace as a dashboard config ZIP file.
+   *
+   * @param {string} appId - Application identifier
+   * @param {number|string} workspaceId - ID of the workspace to export
+   * @param {Object} options - Export options (authorName, authorId, description, tags, icon)
+   * @returns {Promise<Object>} Result with success, filePath, and config
+   */
+  exportDashboardConfig: (appId, workspaceId, options = {}) =>
+    ipcRenderer$1.invoke(DASHBOARD_CONFIG_EXPORT, {
+      appId,
+      workspaceId,
+      options,
+    }),
+
+  /**
+   * Import a dashboard config from a ZIP file.
+   * Shows a file picker, validates the config, installs missing widgets,
+   * creates the workspace, and applies event wiring.
+   *
+   * @param {string} appId - Application identifier
+   * @returns {Promise<Object>} Result with success, workspace, and summary
+   */
+  importDashboardConfig: (appId) =>
+    ipcRenderer$1.invoke(DASHBOARD_CONFIG_IMPORT, { appId }),
+
+  /**
+   * Install a dashboard from the registry by package name.
+   * Fetches the dashboard ZIP, validates config, installs widgets,
+   * creates workspace, and applies event wiring.
+   *
+   * @param {string} appId - Application identifier
+   * @param {string} packageName - Registry package name
+   * @returns {Promise<Object>} Result with success, workspace, and summary
+   */
+  installDashboardFromRegistry: (appId, packageName) =>
+    ipcRenderer$1.invoke(DASHBOARD_CONFIG_INSTALL, {
+      appId,
+      packageName,
+    }),
 };
 
 var dashboardConfigApi_1 = dashboardConfigApi$2;