@trops/dash-core 0.1.534 → 0.1.536

package/dist/electron/index.js

@@ -3827,6 +3827,110 @@ var manifestScanner = {
   SCAN_FILE_LIMIT,
 };
 
+/**
+ * dedupeWidgetFolders
+ *
+ * Boot-time pass over the widgets cache directory. Looks for
+ * top-level folders that don't follow the canonical `@scope/name`
+ * shape but whose `package.json` declares a scoped name (e.g.
+ * `widgets/pipeline/` containing `{ "name": "@ai-built/pipeline" }`).
+ * These are stale artifacts from older install paths — they coexist
+ * with the canonical `widgets/@scope/name/` folder and crash
+ * ComponentManager with "missing origin metadata" because the
+ * bare-name registry entry has no scope to derive a 3-segment
+ * `<scope>.<package>.<component>` id from.
+ *
+ * Two outcomes per malformed folder:
+ *   - Scoped twin already exists → remove the bare copy (redundant)
+ *   - Scoped twin missing       → move the folder to the canonical
+ *     scoped path
+ *
+ * Pure boundary effects (fs read/write/move/remove). The only
+ * registry-side fixup is left to the caller — once this returns,
+ * `widgetRegistry.reconcileWithDisk` re-walks the directory and
+ * picks up the (now canonical) layout cleanly.
+ *
+ * @param {string} widgetsDir
+ * @returns {{removed: string[], migrated: Array<{from: string, to: string}>, errors: Array<{path: string, error: string}>}}
+ */
+
+var dedupeWidgetFolders_1;
+var hasRequiredDedupeWidgetFolders;
+
+function requireDedupeWidgetFolders () {
+	if (hasRequiredDedupeWidgetFolders) return dedupeWidgetFolders_1;
+	hasRequiredDedupeWidgetFolders = 1;
+
+	const fs = require$$0$2;
+	const path = require$$1$1;
+
+	const RESERVED_TOP_LEVEL = new Set(["registry.json"]);
+
+	function dedupeWidgetFolders(widgetsDir) {
+	  const summary = { removed: [], migrated: [], errors: [] };
+	  if (typeof widgetsDir !== "string" || !fs.existsSync(widgetsDir)) {
+	    return summary;
+	  }
+
+	  let entries;
+	  try {
+	    entries = fs.readdirSync(widgetsDir, { withFileTypes: true });
+	  } catch (e) {
+	    summary.errors.push({ path: widgetsDir, error: e.message });
+	    return summary;
+	  }
+
+	  for (const entry of entries) {
+	    if (!entry.isDirectory()) continue;
+	    if (RESERVED_TOP_LEVEL.has(entry.name)) continue;
+	    // Canonical scoped folders are handled by reconcileWithDisk;
+	    // skip them here.
+	    if (entry.name.startsWith("@")) continue;
+
+	    const bareDir = path.join(widgetsDir, entry.name);
+	    const pkgJsonPath = path.join(bareDir, "package.json");
+	    if (!fs.existsSync(pkgJsonPath)) continue;
+
+	    let pkgName;
+	    try {
+	      const pkg = JSON.parse(fs.readFileSync(pkgJsonPath, "utf8"));
+	      pkgName = typeof pkg?.name === "string" ? pkg.name : null;
+	    } catch (e) {
+	      summary.errors.push({ path: bareDir, error: e.message });
+	      continue;
+	    }
+
+	    // Truly unscoped package — leave alone.
+	    if (!pkgName || !pkgName.startsWith("@")) continue;
+
+	    const parts = pkgName.split("/");
+	    if (parts.length !== 2) continue; // malformed scoped name; ignore
+	    const scope = parts[0]; // e.g. "@ai-built"
+	    const name = parts[1];
+	    const scopedDir = path.join(widgetsDir, scope, name);
+
+	    try {
+	      if (fs.existsSync(scopedDir)) {
+	        // Redundant bare copy — remove it.
+	        fs.rmSync(bareDir, { recursive: true, force: true });
+	        summary.removed.push(bareDir);
+	      } else {
+	        // Migrate the bare folder to the canonical scoped path.
+	        fs.mkdirSync(path.dirname(scopedDir), { recursive: true });
+	        fs.renameSync(bareDir, scopedDir);
+	        summary.migrated.push({ from: bareDir, to: scopedDir });
+	      }
+	    } catch (e) {
+	      summary.errors.push({ path: bareDir, error: e.message });
+	    }
+	  }
+	  return summary;
+	}
+
+	dedupeWidgetFolders_1 = { dedupeWidgetFolders };
+	return dedupeWidgetFolders_1;
+}
+
 /**
  * scanWidgetPackagePermissions
  *
@@ -4847,6 +4951,37 @@ var schedulerController_1 = schedulerController$2;
 	      console.error("[WidgetRegistry] Error loading registry:", error);
 	    }
 
+	    // Slice 13f: clean up bare-name folders whose package.json declares
+	    // a scoped name (legacy install artifact). Without this, the
+	    // `reconcileWithDisk` orphan loop below re-registers them under
+	    // the bare folder name and ComponentManager later crashes with
+	    // "missing origin metadata" trying to derive a 3-segment id from
+	    // a scope-less entry. Runs BEFORE reconcile so the registry's
+	    // re-register pass sees a canonical layout.
+	    try {
+	      const { dedupeWidgetFolders } = requireDedupeWidgetFolders();
+	      const dedup = dedupeWidgetFolders(WIDGETS_CACHE_DIR);
+	      if (dedup.removed.length > 0 || dedup.migrated.length > 0) {
+	        console.log(
+	          `[WidgetRegistry] Folder dedupe: removed ${dedup.removed.length}, migrated ${dedup.migrated.length}`,
+	        );
+	        // Drop any registry entry that pointed at a now-removed bare
+	        // folder, so reconcileWithDisk re-registers from the canonical
+	        // scoped path on its next pass.
+	        const removedSet = new Set(dedup.removed);
+	        for (const [key, entry] of Array.from(this.widgets.entries())) {
+	          if (entry?.path && removedSet.has(entry.path)) {
+	            this.widgets.delete(key);
+	          }
+	        }
+	      }
+	      if (dedup.errors.length > 0) {
+	        console.warn(`[WidgetRegistry] Folder dedupe errors:`, dedup.errors);
+	      }
+	    } catch (e) {
+	      console.warn("[WidgetRegistry] Folder dedupe failed:", e.message);
+	    }
+
 	    // Reconcile: re-register orphaned widget packages found on disk
 	    this.reconcileWithDisk();