fyn: avoid logging optional fail if it's due to os/cpu

Author: jchip

packages/fyn/lib/pkg-dep-resolver.ts

@@ -900,6 +900,7 @@ class PkgDepResolver {
 
     const metaJson = meta.versions[resolved];
 
+    const OPT_FAILED_PLATFORM = 3;
     const platformCheck = (): string | true => {
       const sysCheck = checkPkgOsCpu(metaJson);
       if (sysCheck !== true) {
@@ -922,22 +923,23 @@ class PkgDepResolver {
     // - but need to queue them up so when dep resolve queue is drained, need to
     //   wait for them to complete, and then resolve the next dep tree level
     //
+    const sysCheck = platformCheck();
     if (item.dsrc && item.dsrc.includes("opt") && !item.optChecked) {
-      const sysCheck = platformCheck();
-
       if (sysCheck !== true) {
         logger.verbose(`optional dependencies ${sysCheck}`);
+        // Mark as failed due to platform mismatch so lockfile can record it
+        if (!item.optFailed) {
+          item.optFailed = OPT_FAILED_PLATFORM;
+        }
+        item.optChecked = true;
       } else {
         logger.verbose("adding package to opt check:", item.name, item.semver, item.resolved);
-
         this._optResolver.add({ item, meta });
+        return null;
       }
-
-      return null;
     }
 
-    const sysCheck = platformCheck();
-    if (sysCheck !== true) {
+    if (sysCheck !== true && !item.optFailed) {
       logger.error(sysCheck);
       throw new Error(sysCheck);
     }
@@ -983,6 +985,15 @@ class PkgDepResolver {
       }
     }
 
+    if (
+      item.optFailed === OPT_FAILED_PLATFORM &&
+      !pkgV.json &&
+      (metaJson.os || metaJson.cpu)
+    ) {
+      // Store minimal os/cpu info so lockfile can record platform mismatch
+      pkgV.json = { os: metaJson.os, cpu: metaJson.cpu } as PackageVersionMeta;
+    }
+
     const localFromMeta = meta.local || metaJson.local;
     if (localFromMeta) {
       if (!item.localType) {

packages/fyn/lib/pkg-opt-resolver.ts

@@ -195,6 +195,32 @@ class PkgOptResolver {
     };
 
     const logFail = (msg: string): void => {
+      // Skip warning if failure is due to platform/architecture mismatch
+      // Check using os/cpu from lockfile metadata (saved when platform check originally failed)
+      const metaJson = data.meta.versions[version];
+      if (metaJson) {
+        const OPT_FAILED_PLATFORM = 3;
+        if (metaJson.optFailed === OPT_FAILED_PLATFORM) {
+          // Platform mismatch recorded in lockfile
+          return;
+        }
+        // Check if package has os/cpu requirements that don't match current platform
+        // This works even when optFailed is set in lockfile, as os/cpu are saved there
+        const platformCheck = fyntil.checkPkgOsCpu(metaJson);
+        if (platformCheck !== true) {
+          // Platform/arch mismatch - skip warning, already logged as verbose
+          return;
+        }
+        // Also check if error message indicates platform mismatch
+        if (
+          msg.includes("platform") ||
+          msg.includes("architecture") ||
+          msg.includes("cpu/arch") ||
+          msg.includes("doesn't satisfy required")
+        ) {
+          return;
+        }
+      }
       logger.warn(chalk.yellow(`optional dep check failed`), displayId, chalk.yellow(`- ${msg}`));
       logger.info(
         chalk.green(`  you may ignore this since it is optional but some features may be missing`)
@@ -224,6 +250,20 @@ class PkgOptResolver {
     }
 
     if (!this._fyn.refreshOptionals && _.get(data, ["meta", "versions", version, "optFailed"])) {
+      // Check if this is a platform mismatch before logging warning
+      const metaJson = data.meta.versions[version];
+      if (metaJson) {
+        const platformCheck = fyntil.checkPkgOsCpu(metaJson);
+        if (platformCheck !== true) {
+          // Platform/arch mismatch - skip warning, already logged as verbose
+          const rx = {
+            passed: false,
+            err: new Error("optional dep fail by flag optFailed in lockfile - platform mismatch")
+          };
+          addChecked(rx);
+          return processCheckResult(Promise.resolve(rx));
+        }
+      }
       logFail("by flag optFailed in lockfile");
       const rx = {
         passed: false,