finally!!!

Author: Mr3zee

.puppeteerrc.cjs

@@ -1,8 +1,13 @@
+/*
+ * Copyright 2023-2025 JetBrains s.r.o and contributors. Use of this source code is governed by the Apache 2.0 license.
+ */
+
 const {join} = require('path');
 
-const isCI = process.env.TEAMCITY_VERSION || process.env.GITHUB_ACTIONS;
+const isTC = process.env.TEAMCITY_VERSION;
+const isGA = process.env.GITHUB_ACTIONS;
 
-if (isCI) {
+if (isTC !== undefined || isGA !== undefined) {
     /**
      * @type {import("puppeteer").Configuration}
      */

docs/environment.md

@@ -366,24 +366,71 @@ Here is a 'simple' guide for solving problems:
 - Kotlin/Js or Kotlin/Wasm
   - `kotlinUpgradePackageLock` or `kotlinWasmUpgradePackageLock` (and also `kotlinNpmInstall` or `kotlinWasmNpmInstall`)
 have a funny tendency to fail sometimes, and you don't know why. 
+<br/>
 I'll tell you! 
+<br/>
 We use proxy repos, and sometimes dependencies get downloaded from the wrong source.
 Make sure ALL urls in `package-lock.json` files start with `https://packages.jetbrains.team/npm/p/krpc/build-deps/`.
+<br/>
 If something doesn't work, your steps are:
     - Delete `package-lock.json` file
     - Delete `<REPO_ROOT>/build/js` / `<REPO_ROOT>/build/wasm`
     - Run `kotlinUpgradePackageLock` / `kotlinWasmUpgradePackageLock`
-  - If the problem persists:
-    - Check that `<REPO_ROOT>/build/<target>/.npmrc` AND `<REPO_ROOT>/build/<target>/.yarnrc` are present
-    - Check that `.yarnrc` contains one line: `registry: "https://packages.jetbrains.team/npm/p/krpc/build-deps/"`
-    - Check that `.npmrc` contains the following lines:
-      - `registry="https://packages.jetbrains.team/npm/p/krpc/build-deps/"`
-      - `always-auth=true`
-      - `save-exact=true`
-      - `//packages.jetbrains.team/npm/p/krpc/build-deps/:_authToken=<your_auth_token>`, 
+    - If the problem persists:
+      - Check that `<REPO_ROOT>/build/<target>/.npmrc` AND `<REPO_ROOT>/build/<target>/.yarnrc` are present
+      - Check that `.yarnrc` contains one line: `registry: "https://packages.jetbrains.team/npm/p/krpc/build-deps/"`
+      - Check that `.npmrc` contains the following lines:
+        - `registry="https://packages.jetbrains.team/npm/p/krpc/build-deps/"`
+        - `always-auth=true`
+        - `save-exact=true`
+        - `//packages.jetbrains.team/npm/p/krpc/build-deps/:_authToken=<your_auth_token>`, 
 where `<your_auth_token>` is from the [proxy-repositories.md](proxy-repositories.md) guide.
-    - Check that `<USER_HOME>/.npmrc` / `<USER_HOME>/.yarnrc` don't interfere
+      - Check that `<USER_HOME>/.npmrc` / `<USER_HOME>/.yarnrc` don't interfere
 command to debug. Replace versions of tools if needed.
+  - When you get the following error — `puppeteer` failed to run the installation script. 
+Reasons vary, try updating the version to a newer one, 
+check the [.puppeteerrc.cjs](../.puppeteerrc.cjs) and [chrome_bin.js](../karma/chrome_bin.js) files if they are valid js.
+
+        For (2), check out our guide on configuring puppeteer at https://pptr.dev/guides/configuration.
+        at ChromeLauncher.resolveExecutablePath (/rpc/build/js/packages/kotlinx-rpc-utils-test/node_modules/puppeteer-core/lib/cjs/puppeteer/node/ProductLauncher.js:295:27)
+
+  - When the previous error is gone, you may get the next one.
+         
+        Errors occurred during launch of browser for testing.
+            - ChromeHeadless
+            Please make sure that you have installed browsers.
+            Or change it via
+            browser {
+                testTask {
+                    useKarma {
+                        useFirefox()
+                        useChrome()
+                        useSafari()
+                    }
+                }
+            }
+    This means the `puppeteer` failed to locate Chrome.
+Either the cache dir is wrong (check [.puppeteerrc.cjs](../.puppeteerrc.cjs) file) or it really isn't there.
+<br/>
+Reasons again vary.
+When `npm` installs `puppeteer`, it should execute script to install the browser too
+(On CI to the `<ROOT_DIR>/.puppeteer/browsers` directory).
+This absence may be caused by the `--ignore-scripts` flag. 
+Check the clean installation (`rm -rf build && ./gradlew clean cleanJsBrowserTest`) with `--debug` flag.
+(Something like `./gradlew jsBrowserTest --debug`).
+**IMPORTANT: run in docker with `TEAMCITY_VERSION` env var set, if you are chasing a CI fail**.
+<br/>
+The property is set in [npm.kt](../gradle-conventions/src/main/kotlin/util/tasks/npm.kt), see `ignoreScripts`, 
+it should be `false`. 
+<br/>
+If this is not the case, check the debug log for other `node`-related issues.
+Try installing browsers manually: `~/.gradle/nodejs/node-v22.0.0-linux-x64/bin/node build/js/node_modules/puppeteer/install.mjs`
+If this works — problem is somewhere in KGP and probably your configs. 
+Check that your config (like ones with `ignoreScript`) are actually applied, 
+as they use on demand execution and may target wrong plugin or extension and never be executed.
+<br/>
+**Bonus**: it may not be installed, because npm install doesn't do this. 
+See the long comment in [npm.kt](../gradle-conventions/src/main/kotlin/util/tasks/npm.kt).
 
 Something doesn't work, and you are sure it's not your fault? Report it appropriately! Don't be lazy.
 

gradle-conventions/src/main/kotlin/util/tasks/npm.kt

@@ -6,31 +6,41 @@ package util.tasks
 
 import org.gradle.api.GradleException
 import org.gradle.api.Project
+import org.gradle.api.Task
+import org.gradle.api.tasks.Delete
+import org.gradle.api.tasks.Exec
+import org.gradle.api.tasks.TaskProvider
 import org.gradle.kotlin.dsl.*
 import org.jetbrains.kotlin.gradle.targets.js.nodejs.NodeJsEnvSpec
+import org.jetbrains.kotlin.gradle.targets.js.nodejs.NodeJsRootExtension
 import org.jetbrains.kotlin.gradle.targets.js.nodejs.NodeJsRootPlugin
 import org.jetbrains.kotlin.gradle.targets.js.npm.BaseNpmExtension
 import org.jetbrains.kotlin.gradle.targets.js.npm.LockFileMismatchReport
+import org.jetbrains.kotlin.gradle.targets.js.npm.NpmExtension
 import org.jetbrains.kotlin.gradle.targets.wasm.nodejs.WasmNodeJsEnvSpec
+import org.jetbrains.kotlin.gradle.targets.wasm.nodejs.WasmNodeJsRootExtension
 import org.jetbrains.kotlin.gradle.targets.wasm.nodejs.WasmNodeJsRootPlugin
+import org.jetbrains.kotlin.gradle.targets.wasm.npm.WasmNpmExtension
 import org.jetbrains.kotlin.gradle.targets.web.nodejs.BaseNodeJsEnvSpec
+import org.jetbrains.kotlin.gradle.targets.web.nodejs.BaseNodeJsRootExtension
 import org.jetbrains.kotlin.gradle.targets.web.nodejs.CommonNodeJsRootPlugin
-import org.jetbrains.kotlin.gradle.targets.web.npm.CommonNpmResolverPlugin
 import util.other.optionalProperty
 import util.other.spacePassword
 import util.other.useProxyRepositories
 import java.io.File
 
+const val PUPPETEER_BROWSERS_DIR = ".puppeteer"
+
 private inline fun <
     reified Plugin : CommonNodeJsRootPlugin,
-    reified Spec : BaseNodeJsEnvSpec
-> Project.registerExecuteNpmLoginTask(
+    reified Spec : BaseNodeJsEnvSpec,
+    reified RootExtension : BaseNodeJsRootExtension,
+> Project.registerCustomNpmTasks(
     target: String,
-    npmInstallTaskName: String,
     useProxy: Boolean,
 ) {
     val capitalizedTarget = target.replaceFirstChar { it.titlecase() }
-    val task = tasks.register("execute${capitalizedTarget}NpmLogin") {
+    val login = tasks.register("execute${capitalizedTarget}NpmLogin") {
         if (!useProxyRepositories) {
             return@register
         }
@@ -75,46 +85,106 @@ private inline fun <
     }
 
     plugins.withType<Plugin>().configureEach {
-        rootProject.extensions.configure<Spec> {
+        extensions.configure<Spec> {
             download = true
 
             if (useProxy) {
                 downloadBaseUrl = "https://packages.jetbrains.team/files/p/krpc/build-deps/"
             }
-        }
 
-        tasks.named(npmInstallTaskName).configure {
-            dependsOn(task)
+            val nodeExecutable = executable
+
+            extensions.configure<RootExtension> {
+                /**
+                 * Long story short:
+                 * We can use Yarn because of this: https://youtrack.jetbrains.com/issue/KT-78504
+                 * So: `kotlin.js.yarn=false`
+                 *
+                 * When we use `npm` instead, it runs `npm install` task.
+                 * That should install `puppeteer` package, which should run its script `install.mjs`.
+                 * That script installs browsers for tests.
+                 *
+                 * If we pass `--ignore-scripts` to npm, the script won't be executed.
+                 * KGP does it by default.
+                 * So we set `ignoreScripts = false`.
+                 * We set it for `NpmExtension` and `WasmNpmExtension` in `NodeJsRootPlugin` and `WasmNodeJsRootPlugin`
+                 * respectively (and not their common supertype because it will not work)
+                 *
+                 * And this approach worked for Yarn.
+                 * Script was executed, browsers were installed.
+                 *
+                 * For some reason, for `npm` it didn't work.
+                 * Even with a proper flag (which I checked with a --debug flag).
+                 *
+                 * So we need to run the script manually AFTER `kotlinNpmInstall` (or `kotlinWasmNpmInstall`).
+                 * But also, BEFORE every other action that comes after `kotlinNpmInstall` (or `kotlinWasmNpmInstall`),
+                 * as otherwise there will be race in parallel tasks execution.
+                 *
+                 * Hence, all shenanigans.
+                 */
+                val puppeteerInstall = tasks.register<Exec>("puppeteerInstall$capitalizedTarget") {
+                    commandLine(nodeExecutable.get(), "build/$target/node_modules/puppeteer/install.mjs")
+                    workingDir = rootProject.projectDir
+
+                    // keep in sync with <ROOT>/.puppeteer.cjs
+                    outputs.dir(rootProject.projectDir.resolve(PUPPETEER_BROWSERS_DIR).resolve("browsers"))
+                }
+
+                npmInstallTaskProvider.configure {
+                    dependsOn(login)
+                    finalizedBy(puppeteerInstall)
+                }
+
+                tasks.matching { task ->
+                    task.dependsOn.any { dependency ->
+                        when (dependency) {
+                            is Task -> dependency == npmInstallTaskProvider.get()
+                            is TaskProvider<*> -> dependency == npmInstallTaskProvider
+                            is String -> dependency == npmInstallTaskProvider.name
+                            else -> false
+                        }
+                    }
+                }.configureEach {
+                    dependsOn(puppeteerInstall)
+                }
+            }
         }
     }
 }
 
+@Suppress("UnusedReceiverParameter")
+fun BaseNpmExtension.configureNpmExtension(useProxy: Boolean, kotlinMasterBuild: Boolean) {
+    // todo it still doesn't work for an unknown reason, see 'puppeteerInstall*' tasks above
+    ignoreScripts = false // if true - puppeteer won't install browsers
+
+    packageLockMismatchReport = if (useProxy && !kotlinMasterBuild) {
+        LockFileMismatchReport.FAIL
+    } else {
+        LockFileMismatchReport.WARNING
+    }
+}
+
 fun Project.configureNpm() {
     val kotlinMasterBuild by optionalProperty()
     val useProxy = useProxyRepositories
 
-    registerExecuteNpmLoginTask<NodeJsRootPlugin, NodeJsEnvSpec>(
-        target = "js",
-        npmInstallTaskName = "kotlinNpmInstall",
-        useProxy = useProxy,
-    )
-
-    registerExecuteNpmLoginTask<WasmNodeJsRootPlugin, WasmNodeJsEnvSpec>(
-        target = "wasm",
-        npmInstallTaskName = "kotlinWasmNpmInstall",
-        useProxy = useProxy,
-    )
+    registerCustomNpmTasks<NodeJsRootPlugin, NodeJsEnvSpec, NodeJsRootExtension>("js", useProxy)
+    registerCustomNpmTasks<WasmNodeJsRootPlugin, WasmNodeJsEnvSpec, WasmNodeJsRootExtension>("wasm", useProxy)
 
     // necessary for CI js tests
-    rootProject.plugins.withType<CommonNpmResolverPlugin> {
-        rootProject.extensions.configure<BaseNpmExtension> {
-            ignoreScripts = false
-
-            packageLockMismatchReport = if (useProxy && !kotlinMasterBuild) {
-                LockFileMismatchReport.FAIL
-            } else {
-                LockFileMismatchReport.WARNING
-            }
+    rootProject.plugins.withType<NodeJsRootPlugin> {
+        rootProject.extensions.configure<NpmExtension> {
+            configureNpmExtension(useProxy, kotlinMasterBuild)
         }
     }
+
+    rootProject.plugins.withType<WasmNodeJsRootPlugin> {
+        rootProject.extensions.configure<WasmNpmExtension> {
+            configureNpmExtension(useProxy, kotlinMasterBuild)
+        }
+    }
+
+    tasks.named<Delete>("clean") {
+        delete(project.layout.projectDirectory.dir(PUPPETEER_BROWSERS_DIR))
+    }
 }

karma/chrome_bin.js

@@ -1,5 +1,5 @@
 /*
- * Copyright 2023-2024 JetBrains s.r.o and contributors. Use of this source code is governed by the Apache 2.0 license.
+ * Copyright 2023-2025 JetBrains s.r.o and contributors. Use of this source code is governed by the Apache 2.0 license.
  */
 
 config.set({