@trops/dash-core 0.1.105 → 0.1.106

package/dist/electron/index.js

@@ -6077,6 +6077,7 @@ async function fetchRegistryIndex(forceRefresh = false) {
  * @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
+ * @param {string[]} filters.appCapabilities - Only return packages whose required API providers are all in this list
  * @returns {Promise<Object>} { packages: [...], totalWidgets: number }
  */
 async function searchRegistry$1(query = "", filters = {}) {
@@ -6157,6 +6158,37 @@ async function searchRegistry$1(query = "", filters = {}) {
     });
   }
 
+  // Apply API capability filter — only return packages whose required
+  // "api" providers are all present in the app's capability set
+  if (filters.appCapabilities && filters.appCapabilities.length) {
+    const capSet = new Set(
+      filters.appCapabilities.map((c) => c.toLowerCase()),
+    );
+    packages = packages.filter((pkg) => {
+      // Collect all "api" provider requirements from package-level and widget-level providers
+      const apiProviders = [];
+
+      // Package-level providers
+      for (const p of pkg.providers || []) {
+        if (p.providerClass === "api" && p.required !== false) {
+          apiProviders.push(p.type);
+        }
+      }
+
+      // Widget-level providers
+      for (const w of pkg.widgets || []) {
+        for (const p of w.providers || []) {
+          if (p.providerClass === "api" && p.required !== false) {
+            apiProviders.push(p.type);
+          }
+        }
+      }
+
+      // Package is compatible if all required API namespaces are present
+      return apiProviders.every((api) => capSet.has(api.toLowerCase()));
+    });
+  }
+
   // Count total widgets across matched packages
   const totalWidgets = packages.reduce(
     (sum, pkg) => sum + (pkg.widgets || []).length,
@@ -7828,10 +7860,11 @@ var properties = {
 				},
 				providerClass: {
 					type: "string",
-					description: "Provider class: credential or mcp",
+					description: "Provider class: credential, mcp, or api",
 					"enum": [
 						"credential",
-						"mcp"
+						"mcp",
+						"api"
 					]
 				},
 				required: {
@@ -7853,6 +7886,11 @@ var properties = {
 		"default": [
 		]
 	},
+	appOrigin: {
+		type: "string",
+		description: "Originating app package name (from package.json). Informational — indicates which app this dashboard was built for.",
+		maxLength: 200
+	},
 	eventWiring: {
 		type: "array",
 		description: "Pre-configured event connections between widgets",
@@ -8053,7 +8091,7 @@ function validateDashboardConfig$1(config) {
     if (!Array.isArray(config.providers)) {
       errors.push(`"providers" must be an array`);
     } else {
-      const validClasses = ["credential", "mcp"];
+      const validClasses = ["credential", "mcp", "api"];
       for (let i = 0; i < config.providers.length; i++) {
         const p = config.providers[i];
         if (typeof p !== "object" || p === null) {
@@ -8065,7 +8103,7 @@ function validateDashboardConfig$1(config) {
         }
         if (!validClasses.includes(p.providerClass)) {
           errors.push(
-            `"providers[${i}].providerClass" must be "credential" or "mcp", got "${p.providerClass}"`,
+            `"providers[${i}].providerClass" must be "credential", "mcp", or "api", got "${p.providerClass}"`,
           );
         }
         if ("usedBy" in p && !Array.isArray(p.usedBy)) {
@@ -8075,6 +8113,15 @@ function validateDashboardConfig$1(config) {
     }
   }
 
+  // appOrigin (optional)
+  if ("appOrigin" in config) {
+    if (typeof config.appOrigin !== "string") {
+      errors.push(`"appOrigin" must be a string`);
+    } else if (config.appOrigin.length > 200) {
+      errors.push(`"appOrigin" must be 200 characters or fewer`);
+    }
+  }
+
   // eventWiring (optional)
   if ("eventWiring" in config) {
     if (!Array.isArray(config.eventWiring)) {
@@ -8511,6 +8558,7 @@ function checkDashboardCompatibility(
  * @param {string} options.githubUser - GitHub username / org for the package scope
  * @param {string} options.category - Registry category (default: "general")
  * @param {string} options.repository - Repository URL (optional)
+ * @param {string} options.appOrigin - Originating app package name (optional)
  * @returns {Object} Registry manifest object
  */
 function generateRegistryManifest(dashboardConfig, options = {}) {
@@ -8550,6 +8598,10 @@ function generateRegistryManifest(dashboardConfig, options = {}) {
     eventWiring: dashboardConfig.eventWiring || [],
   };
 
+  if (options.appOrigin || dashboardConfig.appOrigin) {
+    manifest.appOrigin = options.appOrigin || dashboardConfig.appOrigin;
+  }
+
   return manifest;
 }
 
@@ -8592,6 +8644,7 @@ function buildDashboardPreview(source) {
       required: p.required !== false,
       usedBy: p.usedBy || [],
     })),
+    appOrigin: source.appOrigin || null,
     summary: {
       widgetCount: (source.widgets || []).length,
       eventCount: (source.eventWiring || []).length,
@@ -8706,6 +8759,38 @@ function buildProviderSetupManifest(
   };
 }
 
+/**
+ * Check API compatibility of a package against the app's capabilities.
+ * Extracts providers with providerClass "api" and checks whether
+ * each required API namespace is present in the app's capability set.
+ *
+ * @param {Array} providers - Provider requirements (from widget config or package manifest)
+ * @param {string[]} appCapabilities - API namespaces the app exposes (e.g., Object.keys(window.mainApi))
+ * @returns {Object} Compatibility report
+ */
+function checkApiCompatibility(providers = [], appCapabilities = []) {
+  const capSet = new Set(appCapabilities.map((c) => c.toLowerCase()));
+
+  const apiProviders = providers.filter((p) => p.providerClass === "api");
+
+  if (apiProviders.length === 0) {
+    return { compatible: true, missingApis: [], requiredApis: [] };
+  }
+
+  const requiredApis = apiProviders
+    .filter((p) => p.required !== false)
+    .map((p) => p.type);
+  const missingApis = requiredApis.filter(
+    (api) => !capSet.has(api.toLowerCase()),
+  );
+
+  return {
+    compatible: missingApis.length === 0,
+    missingApis,
+    requiredApis,
+  };
+}
+
 var dashboardConfigUtils$1 = {
   collectComponentNames: collectComponentNames$1,
   extractEventWiring: extractEventWiring$1,
@@ -8717,6 +8802,7 @@ var dashboardConfigUtils$1 = {
   buildDashboardPreview,
   checkDashboardUpdates,
   buildProviderSetupManifest,
+  checkApiCompatibility,
 };
 
 var widgetRegistry$1 = {exports: {}};