Examples of using run configs in IntelliJ API

plugin.kts

import com.intellij.coverage.CoverageExecutor
import com.intellij.execution.ExecutorRegistry
import com.intellij.execution.RunManager
import com.intellij.execution.RunnerAndConfigurationSettings
import com.intellij.execution.application.ApplicationConfiguration
import com.intellij.execution.application.ApplicationConfigurationType
import com.intellij.execution.executors.DefaultDebugExecutor
import com.intellij.execution.executors.DefaultRunExecutor
import com.intellij.execution.junit.JUnitConfiguration
import com.intellij.execution.junit.JUnitConfigurationType
import com.intellij.execution.process.ProcessListener
import com.intellij.execution.runners.ProgramRunner
import com.intellij.psi.JavaPsiFacade
import com.intellij.psi.search.ProjectScope
import liveplugin.show
import org.jetbrains.kotlin.idea.run.KotlinRunConfiguration
import org.jetbrains.kotlin.idea.run.KotlinRunConfigurationType
import org.jetbrains.plugins.gradle.service.execution.GradleExternalTaskConfigurationType
import org.jetbrains.plugins.gradle.service.execution.GradleRunConfiguration

// depends-on-plugin org.jetbrains.kotlin
// depends-on-plugin org.jetbrains.plugins.gradle
// depends-on-plugin JUnit

val runManager = RunManager.getInstance(project!!)
show(runManager.allConfigurationsList.find { it.name.contains("Main") }?.javaClass)

val java = runManager.createJavaSettings(name= "Java main") { javaConfig ->
    javaConfig.mainClassName = "myapp.Main"
    javaConfig.programParameters = "foo bar"
}
java.run()

val kotlin = runManager.createKotlinSettings(name = "Kotlin main") { kotlinConfig ->
    kotlinConfig.runClass = "myapp.MainKt"
    kotlinConfig.programParameters = "foo bar"
    kotlinConfig.setModuleName("mymodule.main")
}
//kotlin.run()

val gradle = runManager.createGradleSettings(name = "Gradle test") { gradleConfig ->
    gradleConfig.rawCommandLine = ":test --tests \"myapp.SomeTest\""
    // gradleConfig.settings.externalProjectPath // Can be used to specify project directory, otherwise, it's the current project
}
//gradle.debug()

val junit = runManager.createJUnitConfig(name = "DbItemsRepositoryTest") { junitConfig ->
    val project = junitConfig.project
    val testClass = JavaPsiFacade.getInstance(project).findClass("myapp.SomeTest", ProjectScope.getAllScope(project))
    junitConfig.setMainClass(testClass)
}
//junit.runWithCoverage()



fun RunManager.createJavaSettings(name: String, f: (junitConfig: ApplicationConfiguration) -> Unit): RunnerAndConfigurationSettings {
    val settings = createConfiguration(name, ApplicationConfigurationType::class.java)
    f(settings.configuration as ApplicationConfiguration)
    return settings
}

fun RunManager.createJUnitConfig(name: String, f: (junitConfig: JUnitConfiguration) -> Unit): RunnerAndConfigurationSettings {
    val settings = createConfiguration(name, JUnitConfigurationType::class.java)
    f(settings.configuration as JUnitConfiguration)
    return settings
}

fun RunManager.createGradleSettings(name: String, f: (gradleConfig: GradleRunConfiguration) -> Unit): RunnerAndConfigurationSettings {
    val settings = createConfiguration(name, GradleExternalTaskConfigurationType::class.java)
    f(settings.configuration as GradleRunConfiguration)
    return settings
}

fun RunManager.createKotlinSettings(name: String, f: (kotlinConfig: KotlinRunConfiguration) -> Unit): RunnerAndConfigurationSettings {
    val settings = createConfiguration(name, KotlinRunConfigurationType::class.java)
    f(settings.configuration as KotlinRunConfiguration)
    return settings
}

fun RunnerAndConfigurationSettings.run(listener: ProcessListener? = null) =
    execute(this, listener, DefaultRunExecutor.getRunExecutorInstance())

fun RunnerAndConfigurationSettings.debug(listener: ProcessListener? = null) =
    execute(this, listener, DefaultDebugExecutor.getDebugExecutorInstance())

fun RunnerAndConfigurationSettings.runWithCoverage(listener: ProcessListener? = null) =
    execute(this, listener, ExecutorRegistry.getInstance().getExecutorById(CoverageExecutor.EXECUTOR_ID)!!)

fun execute(settings: RunnerAndConfigurationSettings, listener: ProcessListener? = null, executor: com.intellij.execution.Executor) {
    val builder = com.intellij.execution.runners.ExecutionEnvironmentBuilder.create(executor, settings)
    val executionEnv = builder.contentToReuse(null).dataContext(null).activeTarget().build()
    executionEnv.assignNewExecutionId()
    executionEnv.callback = ProgramRunner.Callback {
        if (listener != null) it.processHandler?.addProcessListener(listener)
    }
    executionEnv.runner.execute(executionEnv)
}