@trops/dash-core 0.1.86 → 0.1.88

package/dist/electron/index.js

@@ -588,10 +588,14 @@ 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";
+const DASHBOARD_CONFIG_COMPATIBILITY$1 = "dashboard-config-compatibility";
 
 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,
+  DASHBOARD_CONFIG_COMPATIBILITY: DASHBOARD_CONFIG_COMPATIBILITY$1,
 };
 
 /**
@@ -8354,12 +8358,98 @@ function applyEventWiringToLayout$1(layout, eventWiring) {
   return layout;
 }
 
+/**
+ * Check compatibility of a dashboard config against installed widgets.
+ * Returns a per-widget status report indicating what's installed,
+ * what needs to be installed, and what's unavailable.
+ *
+ * @param {Array} dashboardWidgets - Widget deps from dashboard config (widgets array)
+ * @param {Array} installedWidgets - Currently installed widget metadata (from widgetRegistry.getWidgets())
+ * @param {Array} registryPackages - Available packages from registry index (optional)
+ * @returns {Object} Compatibility report
+ */
+function checkDashboardCompatibility(
+  dashboardWidgets = [],
+  installedWidgets = [],
+  registryPackages = [],
+) {
+  const installedByName = new Map();
+  for (const w of installedWidgets) {
+    if (w.name) {
+      installedByName.set(w.name, w);
+    }
+  }
+
+  const registryByName = new Map();
+  for (const p of registryPackages) {
+    if (p.name) {
+      registryByName.set(p.name, p);
+    }
+  }
+
+  const widgets = [];
+  let installedCount = 0;
+  let toInstallCount = 0;
+  let unavailableCount = 0;
+
+  for (const dep of dashboardWidgets) {
+    const packageName = dep.package;
+    const required = dep.required !== false;
+    const installed = installedByName.get(packageName);
+
+    if (installed) {
+      installedCount++;
+      widgets.push({
+        package: packageName,
+        required,
+        status: "installed",
+        installedVersion: installed.version || null,
+        requiredVersion: dep.version || "*",
+      });
+    } else if (registryByName.has(packageName)) {
+      toInstallCount++;
+      const registryPkg = registryByName.get(packageName);
+      widgets.push({
+        package: packageName,
+        required,
+        status: "to-install",
+        availableVersion: registryPkg.version || null,
+        requiredVersion: dep.version || "*",
+      });
+    } else {
+      unavailableCount++;
+      widgets.push({
+        package: packageName,
+        required,
+        status: "unavailable",
+        requiredVersion: dep.version || "*",
+      });
+    }
+  }
+
+  const hasUnavailableRequired = widgets.some(
+    (w) => w.status === "unavailable" && w.required,
+  );
+
+  return {
+    compatible: !hasUnavailableRequired,
+    summary: {
+      total: dashboardWidgets.length,
+      installed: installedCount,
+      toInstall: toInstallCount,
+      unavailable: unavailableCount,
+    },
+    widgets,
+  };
+}
+
 var dashboardConfigUtils$1 = {
   collectComponentNames: collectComponentNames$1,
   extractEventWiring: extractEventWiring$1,
   buildWidgetDependencies: buildWidgetDependencies$1,
   buildProviderRequirements: buildProviderRequirements$1,
   applyEventWiringToLayout: applyEventWiringToLayout$1,
+  checkDashboardCompatibility,
 };
 
 var widgetRegistry$1 = {exports: {}};
@@ -9974,134 +10064,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 {
@@ -10111,9 +10359,43 @@ async function importDashboardConfig$1(win, appId, widgetRegistry = null) {
   }
 }
 
+/**
+ * Check compatibility of a dashboard's widget dependencies against
+ * installed widgets and registry availability.
+ *
+ * @param {Array} dashboardWidgets - Widget deps from dashboard config
+ * @param {Object} widgetRegistry - WidgetRegistry instance (needs getWidgets())
+ * @returns {Promise<Object>} Compatibility report
+ */
+async function checkCompatibility$1(dashboardWidgets, widgetRegistry = null) {
+  const { checkDashboardCompatibility } = dashboardConfigUtils$1;
+  const { fetchRegistryIndex } = registryController$1;
+
+  const installedWidgets = widgetRegistry ? widgetRegistry.getWidgets() : [];
+
+  let registryPackages = [];
+  try {
+    const index = await fetchRegistryIndex();
+    registryPackages = index.packages || [];
+  } catch (err) {
+    console.warn(
+      "[DashboardConfigController] Could not fetch registry index for compatibility check:",
+      err.message,
+    );
+  }
+
+  return checkDashboardCompatibility(
+    dashboardWidgets,
+    installedWidgets,
+    registryPackages,
+  );
+}
+
 var dashboardConfigController$1 = {
   exportDashboardConfig: exportDashboardConfig$1,
   importDashboardConfig: importDashboardConfig$1,
+  installDashboardFromRegistry: installDashboardFromRegistry$1,
+  checkCompatibility: checkCompatibility$1,
 };
 
 /**
@@ -10205,6 +10487,8 @@ const { install: pluginInstall } = pluginController_1;
 const {
   exportDashboardConfig,
   importDashboardConfig,
+  installDashboardFromRegistry,
+  checkCompatibility,
 } = dashboardConfigController$1;
 
 var controller = {
@@ -10250,6 +10534,8 @@ var controller = {
   searchIndex,
   exportDashboardConfig,
   importDashboardConfig,
+  installDashboardFromRegistry,
+  checkCompatibility,
 };
 
 const { ipcRenderer: ipcRenderer$i } = require$$0$1;
@@ -11626,36 +11912,66 @@ 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,
+  DASHBOARD_CONFIG_COMPATIBILITY,
 } = 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,
+    }),
+
+  /**
+   * Check compatibility of a dashboard config against installed widgets.
+   *
+   * @param {string} appId - Application identifier
+   * @param {Array} dashboardWidgets - Widget dependencies from dashboard config
+   * @returns {Promise<Object>} Compatibility report with per-widget status
+   */
+  checkDashboardCompatibility: (appId, dashboardWidgets) =>
+    ipcRenderer$1.invoke(DASHBOARD_CONFIG_COMPATIBILITY, {
+      appId,
+      dashboardWidgets,
+    }),
 };
 
 var dashboardConfigApi_1 = dashboardConfigApi$2;