@trops/dash-core 0.1.428 → 0.1.431

package/dist/electron/index.js

@@ -472,6 +472,7 @@ const REGISTRY_SEARCH_DASHBOARDS = "registry:search-dashboards";
 const REGISTRY_SEARCH_THEMES = "registry:search-themes";
 const REGISTRY_PUBLISH_WIDGET = "registry:publish-widget";
 const REGISTRY_INSPECT_WIDGET_PACKAGE = "registry:inspect-widget-package";
+const REGISTRY_SCAN_WIDGET_DEFAULTS = "registry:scan-widget-defaults";
 const REGISTRY_PREVIEW_FETCH = "registry:preview-fetch";
 
 var registryEvents$1 = {
@@ -483,6 +484,7 @@ var registryEvents$1 = {
   REGISTRY_SEARCH_THEMES,
   REGISTRY_PUBLISH_WIDGET,
   REGISTRY_INSPECT_WIDGET_PACKAGE,
+  REGISTRY_SCAN_WIDGET_DEFAULTS,
   REGISTRY_PREVIEW_FETCH,
 };
 
@@ -27268,7 +27270,7 @@ function findWidgetsDir$2(widgetPath) {
  * @param {string} widgetPath - Absolute path to the widget directory
  * @returns {Promise<string|null>} Path to the compiled bundle, or null if nothing to compile
  */
-async function compileWidget(widgetPath) {
+async function compileWidget$1(widgetPath) {
   const widgetsDir = findWidgetsDir$2(widgetPath);
 
   if (!widgetsDir) {
@@ -27400,7 +27402,7 @@ async function compileWidget(widgetPath) {
   }
 }
 
-var widgetCompiler$1 = { compileWidget, findWidgetsDir: findWidgetsDir$2 };
+var widgetCompiler$1 = { compileWidget: compileWidget$1, findWidgetsDir: findWidgetsDir$2 };
 
 /**
  * Dynamic Widget Loader
@@ -29416,25 +29418,31 @@ var schedulerController_1 = schedulerController$2;
 
 	      let bundlePath = findBundlePath(widget.path);
 
-	      // Auto-compile if no bundle exists (same as read-all-bundles)
+	      // Auto-compile if no bundle exists (registry installs ship the
+	      // bundle pre-compiled, so this fallback only fires for older
+	      // packages or local installs).
+	      let compileError = null;
 	      if (!bundlePath) {
 	        try {
 	          const compiled = await compileWidget(widget.path);
 	          if (compiled) {
 	            bundlePath = compiled;
 	          }
-	        } catch (compileError) {
-	          console.warn(
-	            `[WidgetRegistry] Could not compile ${widgetName}:`,
-	            compileError,
-	          );
+	        } catch (err) {
+	          compileError = err;
+	          // dash-core's electron build strips console.* — surface
+	          // the actual cause through the IPC return so the renderer
+	          // can show it to the user.
 	        }
 	      }
 
 	      if (!bundlePath) {
+	        const detail = compileError
+	          ? ` (auto-compile failed: ${compileError.message})`
+	          : "";
 	        return {
 	          success: false,
-	          error: `No bundle found in: ${widget.path}`,
+	          error: `No bundle found in: ${widget.path}${detail}`,
 	        };
 	      }
 
@@ -64502,6 +64510,74 @@ function stripPersonalizationFromWorkspace$1(workspace) {
   return cleaned;
 }
 
+/**
+ * Remap each layout item's `packageId` from a local-only scope (e.g.
+ * `@ai-built/foo`) to the caller's published scope (`@<callerScope>/foo`)
+ * so the installer's ComponentManager — which registers widgets under
+ * the published scope — can look them up.
+ *
+ * Mirrors the scope-remap that `generateRegistryManifest` already does
+ * for the dashboard's widget DEPENDENCIES list. Without this, the deps
+ * list is correct (`@callerScope/foo`) but the per-instance layout
+ * items still say `packageId: "@ai-built/foo"` — every Dependencies
+ * tab + publish-flow attribution on the installer's machine misses.
+ *
+ * Returns a deep copy. Idempotent: items already under the caller
+ * scope (or any non-local scope) pass through untouched.
+ *
+ * @param {Object} workspace
+ * @param {string} callerScope - Publisher's registry username (e.g. "trops")
+ * @param {string[]} [localOnlyScopes=["ai-built"]] - Scopes that must be remapped
+ */
+function remapLayoutPackageScopes$1(
+  workspace,
+  callerScope,
+  localOnlyScopes = ["ai-built"],
+) {
+  if (!workspace || !callerScope) return workspace;
+  const localScopeSet = new Set(
+    localOnlyScopes.map((s) => String(s).replace(/^@/, "")),
+  );
+  const remapPackageId = (pkgId) => {
+    if (typeof pkgId !== "string" || pkgId.length === 0) return pkgId;
+    // Match `@<scope>/<rest>` or `<scope>/<rest>`. Tolerant of either form.
+    const m = pkgId.match(/^@?([^/]+)\/(.+)$/);
+    if (!m) return pkgId;
+    const scope = m[1];
+    const rest = m[2];
+    if (!localScopeSet.has(scope)) return pkgId;
+    return `@${callerScope.replace(/^@/, "")}/${rest}`;
+  };
+  const remapItem = (item) => {
+    if (!item || typeof item !== "object") return item;
+    const next = { ...item };
+    if (item.packageId) {
+      const remapped = remapPackageId(item.packageId);
+      if (remapped !== item.packageId) next.packageId = remapped;
+    }
+    if (item._sourcePackage) {
+      const remapped = remapPackageId(item._sourcePackage);
+      if (remapped !== item._sourcePackage) next._sourcePackage = remapped;
+    }
+    if (Array.isArray(item.items)) next.items = item.items.map(remapItem);
+    if (Array.isArray(item.layout)) next.layout = item.layout.map(remapItem);
+    return next;
+  };
+  const next = { ...workspace };
+  if (Array.isArray(next.layout)) next.layout = next.layout.map(remapItem);
+  if (Array.isArray(next.sidebarLayout)) {
+    next.sidebarLayout = next.sidebarLayout.map(remapItem);
+  }
+  if (Array.isArray(next.pages)) {
+    next.pages = next.pages.map((page) =>
+      page && Array.isArray(page.layout)
+        ? { ...page, layout: page.layout.map(remapItem) }
+        : page,
+    );
+  }
+  return next;
+}
+
 var dashboardConfigUtils$1 = {
   collectComponentNames: collectComponentNames$1,
   collectComponentNamesFromWorkspace: collectComponentNamesFromWorkspace$1,
@@ -64518,6 +64594,7 @@ var dashboardConfigUtils$1 = {
   buildProviderSetupManifest,
   checkApiCompatibility,
   stripPersonalizationFromWorkspace: stripPersonalizationFromWorkspace$1,
+  remapLayoutPackageScopes: remapLayoutPackageScopes$1,
 };
 
 /**
@@ -65559,6 +65636,7 @@ const {
   buildProviderRequirements,
   applyEventWiringToLayout,
   stripPersonalizationFromWorkspace,
+  remapLayoutPackageScopes,
 } = dashboardConfigUtils$1;
 const { searchRegistry, getPackage } = registryController$3;
 const { getStoredToken, clearToken } = registryAuthController$2;
@@ -66978,7 +67056,33 @@ async function prepareDashboardForPublish$1(
     // widget's own `defaultValue` on each field never gets a chance.
     // Layout position, ordering, nested containers, and any title text
     // are preserved (they're part of the template, not personal).
-    const sharedWorkspace = stripPersonalizationFromWorkspace(workspace);
+    let sharedWorkspace = stripPersonalizationFromWorkspace(workspace);
+
+    // Remap layout-item `packageId` from any local-only scope (e.g.
+    // `@ai-built/foo`) to the publisher's scope (`@<callerScope>/foo`).
+    // The widget-deps array in the dashboard manifest already gets
+    // remapped (see generateRegistryManifest), but the per-instance
+    // `packageId` on the layout items themselves was being shipped
+    // as-is — so installers' ComponentManager (which registers
+    // widgets under the published scope) couldn't reverse-look-up by
+    // `packageId` on a layout item, breaking the Dependencies tab and
+    // the publish-flow attribution on chained republishes.
+    let resolvedCallerScope = options.callerScope || options.githubUser || "";
+    if (!resolvedCallerScope) {
+      try {
+        const { getRegistryProfile } = registryAuthController$2;
+        const profile = await getRegistryProfile();
+        resolvedCallerScope = profile?.username || options.authorId || "";
+      } catch {
+        resolvedCallerScope = options.authorId || "";
+      }
+    }
+    if (resolvedCallerScope) {
+      sharedWorkspace = remapLayoutPackageScopes(
+        sharedWorkspace,
+        resolvedCallerScope,
+      );
+    }
     const layout = sharedWorkspace.layout || [];
 
     // 3. Build the dashboard config — walk main + pages + sidebar
@@ -73729,7 +73833,7 @@ const {
 } = registryAuthController$2;
 const widgetRegistryModule = widgetRegistryExports;
 const { dynamicWidgetLoader: dynamicWidgetLoader$1 } = dynamicWidgetLoaderExports;
-const { findWidgetsDir } = widgetCompiler$1;
+const { findWidgetsDir, compileWidget } = widgetCompiler$1;
 const {
   resolveNextVersion,
   parsePackageName,
@@ -73790,11 +73894,160 @@ async function scanWidgetConfigs(widgetPath) {
   }
 }
 
+// ─── Publish-time defaults scan + staged rewrite ─────────────────────────────
+
+/**
+ * Scan a widget package's `.dash.js` files and return every non-empty
+ * `userConfig[field].defaultValue` as a structured ref. Powers the
+ * publish modal's "Verify defaults" step — surfaces values the
+ * developer set during testing (regional paths, test tokens, etc.)
+ * so the publisher can keep, blank, or edit each one before the ZIP
+ * ships.
+ *
+ * @param {string} packageId e.g. "@ai-built/pipeline"
+ * @returns {Promise<{success: boolean, defaults: Array, error?: string}>}
+ */
+async function scanWidgetDefaults$1(packageId) {
+  try {
+    const registry = widgetRegistryModule.getWidgetRegistry();
+    const widget = findWidget(registry, packageId);
+    if (!widget || !widget.path) {
+      return {
+        success: false,
+        error: `Widget package not found locally: ${packageId}`,
+      };
+    }
+
+    const configs = await scanWidgetConfigs(widget.path);
+    const defaults = [];
+    for (const cfg of configs) {
+      const widgetName = cfg.component || cfg.name;
+      if (!widgetName) continue;
+      const userConfig = cfg.userConfig;
+      if (!userConfig || typeof userConfig !== "object") continue;
+      for (const [field, spec] of Object.entries(userConfig)) {
+        if (!spec || typeof spec !== "object") continue;
+        const value = spec.defaultValue;
+        // "non-empty" = not nullish, not empty-string. `false` and `0`
+        // are legitimate defaults (checkbox-off, numeric zero) so we
+        // keep them. Arrays/objects only surface if non-empty.
+        const isEmpty =
+          value === null ||
+          value === undefined ||
+          value === "" ||
+          (Array.isArray(value) && value.length === 0) ||
+          (typeof value === "object" &&
+            !Array.isArray(value) &&
+            Object.keys(value).length === 0);
+        if (isEmpty) continue;
+        defaults.push({
+          widgetName,
+          field,
+          currentDefault: value,
+          displayName: spec.displayName || field,
+          type: spec.type || "text",
+          instructions: spec.instructions || "",
+        });
+      }
+    }
+    return { success: true, defaults };
+  } catch (error) {
+    console.error("[widgetRegistry] scanWidgetDefaults failed:", error);
+    return { success: false, error: error.message };
+  }
+}
+
+/**
+ * Return the exported-default object from a `.dash.js` serialized as
+ * pretty-printed JS. We use JSON.stringify (plus a couple of minor
+ * touch-ups) because dash configs are pure data — no functions, no
+ * imports, no regex literals. The source file shape we emit matches
+ * the scaffolded template so dynamicWidgetLoader reads it back
+ * unchanged.
+ */
+function serializeDashConfig(config) {
+  const json = JSON.stringify(config, null, 4);
+  return `export default ${json};\n`;
+}
+
+/**
+ * Copy a source widget directory into `dstDir`, then rewrite the
+ * `userConfig[field].defaultValue` for every entry in `overrides`.
+ * `overrides` shape: `{ [widgetName]: { [field]: newValue } }`.
+ *
+ * Returns the list of files that were actually rewritten (useful for
+ * the UI / logs). Pure file-system side effect; does NOT touch the
+ * original source directory.
+ */
+async function stageOverrides(srcDir, dstDir, overrides) {
+  // Copy the whole package tree into dstDir.
+  fs.cpSync(srcDir, dstDir, {
+    recursive: true,
+    filter: (src) => {
+      const base = path.basename(src);
+      if (ZIP_EXCLUDE_DIRS.has(base)) return false;
+      if (base.startsWith(".")) return false;
+      return true;
+    },
+  });
+
+  if (!overrides || Object.keys(overrides).length === 0) return [];
+
+  const widgetsDir = findWidgetsDir(dstDir) || path.join(dstDir, "widgets");
+  if (!fs.existsSync(widgetsDir)) return [];
+
+  const rewritten = [];
+  const files = fs.readdirSync(widgetsDir);
+  for (const file of files) {
+    if (!file.endsWith(".dash.js")) continue;
+    const filePath = path.join(widgetsDir, file);
+    let cfg;
+    try {
+      // eslint-disable-next-line no-await-in-loop
+      cfg = await dynamicWidgetLoader$1.loadConfigFile(filePath);
+    } catch (err) {
+      console.warn(
+        `[widgetRegistry] Could not load ${file} for override: ${err.message}`,
+      );
+      continue;
+    }
+    if (!cfg || typeof cfg !== "object") continue;
+    const widgetName = cfg.component || cfg.name;
+    if (!widgetName || !overrides[widgetName]) continue;
+    const fieldOverrides = overrides[widgetName];
+
+    if (!cfg.userConfig || typeof cfg.userConfig !== "object") continue;
+    let changed = false;
+    for (const [field, newValue] of Object.entries(fieldOverrides)) {
+      if (!cfg.userConfig[field] || typeof cfg.userConfig[field] !== "object") {
+        continue;
+      }
+      // Undefined = "no change" from the UI side. Explicit null / ""
+      // = user wants to blank it out.
+      if (newValue === undefined) continue;
+      cfg.userConfig[field] = {
+        ...cfg.userConfig[field],
+        defaultValue: newValue,
+      };
+      changed = true;
+    }
+    if (!changed) continue;
+
+    fs.writeFileSync(filePath, serializeDashConfig(cfg));
+    rewritten.push(file);
+  }
+  return rewritten;
+}
+
 // ─── ZIP builder ─────────────────────────────────────────────────────────────
 
+// `dist` is intentionally NOT excluded — the publish flow runs
+// `compileWidget` against the staged package right before zipping so
+// the installer doesn't have to recompile (and fail silently because
+// `console.*` is stripped from dash-core's electron build, masking
+// any esbuild error). Shipping the bundle makes install zero-config.
 const ZIP_EXCLUDE_DIRS = new Set([
   "node_modules",
-  "dist",
   ".git",
   ".DS_Store",
   ".next",
@@ -73983,45 +74236,92 @@ async function prepareWidgetForPublish$1(appId, packageId, options = {}) {
       appOrigin: appId,
     });
 
-    // 7. Zip the widget directory to a temp file
+    // 7. Zip the widget directory to a temp file. When the caller
+    //    supplied `defaultsOverride`, stage a copy of the package
+    //    under os.tmpdir() and rewrite the targeted
+    //    `userConfig[field].defaultValue` entries there before
+    //    zipping — source files on the publisher's machine stay
+    //    untouched.
     const zipName = `widget-${manifest.scope}-${manifest.name}-v${manifest.version}.zip`;
     const zipPath = path.join(app.getPath("temp"), zipName);
-    const zip = new AdmZip();
-    addDirToZip(zip, widget.path);
-    zip.writeZip(zipPath);
+    const hasOverrides =
+      options.defaultsOverride &&
+      typeof options.defaultsOverride === "object" &&
+      Object.keys(options.defaultsOverride).length > 0;
+    const stagedDir = hasOverrides
+      ? fs.mkdtempSync(path.join(app.getPath("temp"), `dash-publish-stage-`))
+      : null;
+    let registryResult;
+    try {
+      let sourceDir = widget.path;
+      if (stagedDir) {
+        await stageOverrides(widget.path, stagedDir, options.defaultsOverride);
+        sourceDir = stagedDir;
+      }
 
-    // 8. Publish to registry
-    const registryResult = await registryApiController$1.publishToRegistry(
-      zipPath,
-      manifest,
-    );
+      // Compile the widget into `dist/index.cjs.js` before zipping.
+      // The installer also runs compileWidget at first-load, but
+      // dash-core strips `console.*` from its electron bundle, so any
+      // esbuild error during install-time compile vanishes silently
+      // and the user just sees `No bundle found`. Compiling at
+      // publish time (where errors WILL surface to the publisher who
+      // can fix them) and shipping the bundle in the ZIP makes
+      // install zero-config.
+      try {
+        await compileWidget(sourceDir);
+      } catch (compileErr) {
+        return {
+          success: false,
+          error: `Widget compilation failed: ${compileErr.message}. Fix the source error and republish; otherwise installers won't be able to load the widget.`,
+          manifest,
+        };
+      }
+
+      const zip = new AdmZip();
+      addDirToZip(zip, sourceDir);
+      zip.writeZip(zipPath);
+
+      // 8. Publish to registry
+      registryResult = await registryApiController$1.publishToRegistry(
+        zipPath,
+        manifest,
+      );
+
+      // 9. On failure: revert package.json (if we bumped) and surface details
+      if (!registryResult.success) {
+        if (newVersion !== previousVersion) {
+          try {
+            pkgJson.version = previousVersion;
+            fs.writeFileSync(
+              pkgJsonPath,
+              JSON.stringify(pkgJson, null, 2) + "\n",
+            );
+          } catch {
+            /* best effort */
+          }
+        }
+        return {
+          success: false,
+          error: registryResult.error,
+          details: registryResult.details,
+          manifest,
+        };
+      }
 
-    // 9. On failure: revert package.json (if we bumped) and surface details
-    if (!registryResult.success) {
-      if (newVersion !== previousVersion) {
+      // Clean up the temp zip on success.
+      try {
+        fs.unlinkSync(zipPath);
+      } catch {
+        /* ignore */
+      }
+    } finally {
+      if (stagedDir) {
         try {
-          pkgJson.version = previousVersion;
-          fs.writeFileSync(
-            pkgJsonPath,
-            JSON.stringify(pkgJson, null, 2) + "\n",
-          );
+          fs.rmSync(stagedDir, { recursive: true, force: true });
         } catch {
           /* best effort */
         }
       }
-      return {
-        success: false,
-        error: registryResult.error,
-        details: registryResult.details,
-        manifest,
-      };
-    }
-
-    // Clean up the temp zip
-    try {
-      fs.unlinkSync(zipPath);
-    } catch {
-      /* ignore */
     }
 
     return {
@@ -74098,6 +74398,7 @@ async function inspectWidgetPackage$1(packageId) {
 var widgetRegistryController = {
   prepareWidgetForPublish: prepareWidgetForPublish$1,
   inspectWidgetPackage: inspectWidgetPackage$1,
+  scanWidgetDefaults: scanWidgetDefaults$1,
 };
 
 /**
@@ -74215,6 +74516,7 @@ const {
 const {
   prepareWidgetForPublish,
   inspectWidgetPackage,
+  scanWidgetDefaults,
 } = widgetRegistryController;
 const {
   assignRoles,
@@ -74307,6 +74609,7 @@ var controller = {
   checkThemeUpdatesForApp,
   prepareWidgetForPublish,
   inspectWidgetPackage,
+  scanWidgetDefaults,
   assignRoles,
   matchTailwindFamily,
   generateThemeFromPalette,
@@ -75456,6 +75759,27 @@ const registryApi$2 = {
     }
   },
 
+  /**
+   * Scan a widget package's `.dash.js` configs and return the list of
+   * non-empty `userConfig[field].defaultValue` entries. Powers the
+   * publish modal's "Verify defaults" step — lets the publisher
+   * review (and optionally blank / edit) values set during
+   * development before the ZIP ships.
+   *
+   * @param {string} packageId - Widget packageId (e.g. "@scope/name")
+   * @returns {Promise<Object>} { success, defaults: [{widgetName, field, currentDefault, displayName, type, instructions}], error? }
+   */
+  scanWidgetDefaults: async (packageId) => {
+    try {
+      return await ipcRenderer$h.invoke("registry:scan-widget-defaults", {
+        packageId,
+      });
+    } catch (error) {
+      console.error("[RegistryApi] Error scanning widget defaults:", error);
+      throw error;
+    }
+  },
+
   /**
    * Fetch a registry package's source (component + config + bundle) into a
    * temp directory and return the source strings without installing the