@trops/dash-core 0.1.90 → 0.1.92

package/dist/electron/index.js

@@ -592,6 +592,8 @@ const DASHBOARD_CONFIG_INSTALL$1 = "dashboard-config-install";
 const DASHBOARD_CONFIG_COMPATIBILITY$1 = "dashboard-config-compatibility";
 const DASHBOARD_CONFIG_PUBLISH$1 = "dashboard-config-publish";
 const DASHBOARD_CONFIG_PREVIEW$1 = "dashboard-config-preview";
+const DASHBOARD_CONFIG_CHECK_UPDATES$1 = "dashboard-config-check-updates";
+const DASHBOARD_CONFIG_PROVIDER_SETUP$1 = "dashboard-config-provider-setup";
 
 var dashboardConfigEvents$1 = {
   DASHBOARD_CONFIG_EXPORT: DASHBOARD_CONFIG_EXPORT$1,
@@ -600,6 +602,8 @@ var dashboardConfigEvents$1 = {
   DASHBOARD_CONFIG_COMPATIBILITY: DASHBOARD_CONFIG_COMPATIBILITY$1,
   DASHBOARD_CONFIG_PUBLISH: DASHBOARD_CONFIG_PUBLISH$1,
   DASHBOARD_CONFIG_PREVIEW: DASHBOARD_CONFIG_PREVIEW$1,
+  DASHBOARD_CONFIG_CHECK_UPDATES: DASHBOARD_CONFIG_CHECK_UPDATES$1,
+  DASHBOARD_CONFIG_PROVIDER_SETUP: DASHBOARD_CONFIG_PROVIDER_SETUP$1,
 };
 
 /**
@@ -8551,6 +8555,104 @@ function buildDashboardPreview(source) {
   return preview;
 }
 
+/**
+ * Check installed dashboards for available updates in the registry.
+ *
+ * Compares the `_dashboardConfig.installedVersion` of each workspace
+ * against the current version in the registry.
+ *
+ * @param {Array} workspaces - All workspaces from workspaces.json
+ * @param {Array} registryPackages - Packages from registry index
+ * @returns {Array} Update records with workspace info and version comparison
+ */
+function checkDashboardUpdates(workspaces = [], registryPackages = []) {
+  const registryByName = new Map();
+  for (const pkg of registryPackages) {
+    if (pkg.name && (pkg.type || "widget") === "dashboard") {
+      registryByName.set(pkg.name, pkg);
+    }
+  }
+
+  const updates = [];
+
+  for (const ws of workspaces) {
+    const config = ws._dashboardConfig;
+    if (!config || !config.registryPackage) continue;
+
+    const registryPkg = registryByName.get(config.registryPackage);
+    if (!registryPkg) continue;
+
+    const installedVersion = config.installedVersion || "0.0.0";
+    const latestVersion = registryPkg.version || "0.0.0";
+
+    if (installedVersion !== latestVersion) {
+      updates.push({
+        workspaceId: ws.id,
+        workspaceName: ws.name || ws.label || "",
+        registryPackage: config.registryPackage,
+        installedVersion,
+        latestVersion,
+        importedAt: config.importedAt || null,
+      });
+    }
+  }
+
+  return updates;
+}
+
+/**
+ * Build a provider setup manifest for a dashboard's requirements.
+ * Compares required providers against configured providers,
+ * returning status (configured/needs-setup) for each.
+ *
+ * @param {Array} requiredProviders - Provider requirements from dashboard config
+ * @param {Array} configuredProviders - User's configured providers (from providerController)
+ * @returns {Object} Setup manifest with per-provider status
+ */
+function buildProviderSetupManifest(
+  requiredProviders = [],
+  configuredProviders = [],
+) {
+  const configuredByType = new Map();
+  for (const p of configuredProviders) {
+    const key = p.type || p.name || "";
+    if (key) {
+      configuredByType.set(key.toLowerCase(), p);
+    }
+  }
+
+  const providers = requiredProviders.map((req) => {
+    const typeKey = (req.type || "").toLowerCase();
+    const configured = configuredByType.get(typeKey);
+
+    return {
+      type: req.type || "",
+      providerClass: req.providerClass || "",
+      required: req.required !== false,
+      usedBy: req.usedBy || [],
+      status: configured ? "configured" : "needs-setup",
+      configuredProvider: configured || null,
+    };
+  });
+
+  const configuredCount = providers.filter(
+    (p) => p.status === "configured",
+  ).length;
+  const needsSetupCount = providers.filter(
+    (p) => p.status === "needs-setup",
+  ).length;
+
+  return {
+    allConfigured: needsSetupCount === 0,
+    summary: {
+      total: providers.length,
+      configured: configuredCount,
+      needsSetup: needsSetupCount,
+    },
+    providers,
+  };
+}
+
 var dashboardConfigUtils$1 = {
   collectComponentNames: collectComponentNames$1,
   extractEventWiring: extractEventWiring$1,
@@ -8560,6 +8662,8 @@ var dashboardConfigUtils$1 = {
   checkDashboardCompatibility,
   generateRegistryManifest,
   buildDashboardPreview,
+  checkDashboardUpdates,
+  buildProviderSetupManifest,
 };
 
 var widgetRegistry$1 = {exports: {}};
@@ -10299,6 +10403,8 @@ async function processDashboardConfig(
     importedAt: new Date().toISOString(),
     originalAuthor: dashboardConfig.author,
     schemaVersion: dashboardConfig.schemaVersion,
+    registryPackage: options.registryPackage || null,
+    installedVersion: options.installedVersion || null,
   };
 
   // Save workspace to workspaces.json
@@ -10455,6 +10561,8 @@ async function installDashboardFromRegistry$1(
       widgetRegistry,
       {
         source: "registry",
+        registryPackage: packageName,
+        installedVersion: registryPkg.version || null,
       },
     );
   } catch (error) {
@@ -10726,6 +10834,75 @@ async function getDashboardPreview$1(packageName, widgetRegistry = null) {
   };
 }
 
+/**
+ * Check installed dashboards for available updates.
+ * Reads workspaces, finds those installed from the registry,
+ * and compares versions against the current registry index.
+ *
+ * @param {string} appId - Application identifier
+ * @returns {Promise<Object>} Result with updates array
+ */
+async function checkDashboardUpdatesForApp$1(appId) {
+  const { checkDashboardUpdates } = dashboardConfigUtils$1;
+  const { fetchRegistryIndex } = registryController$1;
+
+  try {
+    const filename = path.join(
+      app.getPath("userData"),
+      appName,
+      appId,
+      configFilename,
+    );
+    const workspaces = getFileContents(filename) || [];
+
+    const index = await fetchRegistryIndex();
+    const registryPackages = index.packages || [];
+
+    const updates = checkDashboardUpdates(workspaces, registryPackages);
+
+    return {
+      success: true,
+      updates,
+      totalInstalled: workspaces.filter((w) => w._dashboardConfig?.registryPackage).length,
+    };
+  } catch (error) {
+    console.error(
+      "[DashboardConfigController] Error checking dashboard updates:",
+      error,
+    );
+    return {
+      success: false,
+      error: error.message,
+      updates: [],
+    };
+  }
+}
+
+/**
+ * Get a provider setup manifest for a dashboard's requirements.
+ * Compares required providers against the user's configured providers.
+ *
+ * @param {string} appId - Application identifier
+ * @param {Array} requiredProviders - Provider requirements from dashboard config
+ * @returns {Object} Setup manifest with per-provider status
+ */
+function getProviderSetupManifest$1(appId, requiredProviders = []) {
+  const { buildProviderSetupManifest } = dashboardConfigUtils$1;
+  const { listProviders } = requireProviderController();
+
+  let configuredProviders = [];
+  try {
+    configuredProviders = listProviders(null, appId) || [];
+  } catch (err) {
+    console.warn(
+      "[DashboardConfigController] Could not list providers:",
+      err.message,
+    );
+  }
+
+  return buildProviderSetupManifest(requiredProviders, configuredProviders);
+}
+
 var dashboardConfigController$1 = {
   exportDashboardConfig: exportDashboardConfig$1,
   importDashboardConfig: importDashboardConfig$1,
@@ -10733,6 +10910,8 @@ var dashboardConfigController$1 = {
   checkCompatibility: checkCompatibility$1,
   prepareDashboardForPublish: prepareDashboardForPublish$1,
   getDashboardPreview: getDashboardPreview$1,
+  checkDashboardUpdatesForApp: checkDashboardUpdatesForApp$1,
+  getProviderSetupManifest: getProviderSetupManifest$1,
 };
 
 /**
@@ -10828,6 +11007,8 @@ const {
   checkCompatibility,
   prepareDashboardForPublish,
   getDashboardPreview,
+  checkDashboardUpdatesForApp,
+  getProviderSetupManifest,
 } = dashboardConfigController$1;
 
 var controller = {
@@ -10877,6 +11058,8 @@ var controller = {
   checkCompatibility,
   prepareDashboardForPublish,
   getDashboardPreview,
+  checkDashboardUpdatesForApp,
+  getProviderSetupManifest,
 };
 
 const { ipcRenderer: ipcRenderer$i } = require$$0$1;
@@ -12259,6 +12442,8 @@ const {
   DASHBOARD_CONFIG_COMPATIBILITY,
   DASHBOARD_CONFIG_PUBLISH,
   DASHBOARD_CONFIG_PREVIEW,
+  DASHBOARD_CONFIG_CHECK_UPDATES,
+  DASHBOARD_CONFIG_PROVIDER_SETUP,
 } = events$8;
 
 const dashboardConfigApi$2 = {
@@ -12342,6 +12527,28 @@ const dashboardConfigApi$2 = {
    */
   getDashboardPreview: (packageName) =>
     ipcRenderer$1.invoke(DASHBOARD_CONFIG_PREVIEW, { packageName }),
+
+  /**
+   * Check installed dashboards for available updates.
+   *
+   * @param {string} appId - Application identifier
+   * @returns {Promise<Object>} Result with updates array
+   */
+  checkDashboardUpdates: (appId) =>
+    ipcRenderer$1.invoke(DASHBOARD_CONFIG_CHECK_UPDATES, { appId }),
+
+  /**
+   * Get provider setup manifest for a dashboard's requirements.
+   *
+   * @param {string} appId - Application identifier
+   * @param {Array} requiredProviders - Provider requirements from dashboard config
+   * @returns {Promise<Object>} Setup manifest with per-provider status
+   */
+  getProviderSetupManifest: (appId, requiredProviders) =>
+    ipcRenderer$1.invoke(DASHBOARD_CONFIG_PROVIDER_SETUP, {
+      appId,
+      requiredProviders,
+    }),
 };
 
 var dashboardConfigApi_1 = dashboardConfigApi$2;