remote.invalid.remote.text=Invalid remote server {0}...
command.execute.text=Executing command in terminal...

remote.invalid.remote.text=Invalid remote server {0}...

settings.title=Dracon (Pijul)
settings.pijul.path.text=Pijul path:
settings.pijul.path.detect.text=Detect
settings.pijul.path.select.text=Select Pijul Binary
settings.dracon.index.all.text=Index all revisions
settings.dracon.index.all.tooltip.text=Enable caching of all revisions, it does speed up revision loading however \
  caching uses a bunch of storage space and takes a bit of more time at first loading.

        <applicationConfigurable parentId="tools" instance="com.github.jonathanxd.dracon.component.PijulSettingsConfigurable"
                                 id="com.github.jonathanxd.dracon.component.PijulSettingsConfigurable"
                                 displayName="Dracon (Pijul)"/>

        <applicationService serviceImplementation="com.github.jonathanxd.dracon.config.PijulSettings"/>

            val push = pijul(project).push(

            val push = pijul(project).pushInTerminal(

        val r = pijul(project).push(project, ctx.root, fromChannel, toChannel, toRemote) {

        val r = pijul(project).pushInTerminal(project, ctx.root, fromChannel, toChannel, toRemote) {

    fun pushInTerminal(project: Project, root: Path,
             fromChannel: String? = null,
             toChannel: String? = null,
             repository: String? = null,
             editorServerConsumer: (EditorServer) -> Unit): PijulOperationResult<String>
    @RequiresBackgroundThread

package com.github.jonathanxd.dracon.exec
import com.github.jonathanxd.dracon.i18n.BUNDLE
import com.github.jonathanxd.dracon.i18n.DraconBundle
import com.intellij.execution.configurations.GeneralCommandLine
import com.intellij.execution.process.ProcessOutput
import com.intellij.execution.util.ExecUtil
import org.jetbrains.annotations.PropertyKey
import java.nio.file.Path
fun execInTerminal(
    @PropertyKey(resourceBundle = BUNDLE) name: String,
    command: String
) {
    ExecUtil.execAndGetOutput(GeneralCommandLine(ExecUtil.getTerminalCommand(DraconBundle.message(name), command)))
}
fun execInTerminal(
    @PropertyKey(resourceBundle = BUNDLE) name: String,
    vars: Map<String, String>,
    workDir: Path,
    command: String
): ProcessOutput {
    val cmd = GeneralCommandLine(ExecUtil.getTerminalCommand(DraconBundle.message(name), command))
    cmd.environment.putAll(vars)
    cmd.workDirectory = workDir.toFile()
    return ExecUtil.execAndGetOutput(cmd)
}
fun terminalCommand(
    @PropertyKey(resourceBundle = BUNDLE) name: String,
    command: String
): List<String> {
    return ExecUtil.getTerminalCommand(DraconBundle.message(name), command)
}

import com.github.jonathanxd.dracon.util.findBinary
import com.github.jonathanxd.dracon.util.findBinaryOrNull

@State(name = "Pijul.Settings", storages = [Storage(StoragePathMacros.WORKSPACE_FILE)])

@State(name = "Pijul.Settings", storages = [Storage("DraconSettings.xml")])

    companion object {
        val instance get() = service<PijulSettings>()
    }

    fun saveToCacheAllRevisions(cacheAllRevisions: Boolean) {
        this.state.cacheAllRevisions = cacheAllRevisions
    }
    fun savePathToPijul(pathToPijul: String?) {
        this.state.pathToPijul = pathToPijul
    }
    fun getPathToPijul() =
        this.state.pathToPijul

    var pathToGit by string()

    var pathToPijul by string(defaultValue = findBinaryOrNull("pijul"))

    var cacheAllRevisions by property(defaultValue = true)

    var cacheAllRevisions by property(defaultValue = false)

package com.github.jonathanxd.dracon.component
import com.github.jonathanxd.dracon.config.PijulSettings
import com.github.jonathanxd.dracon.i18n.DraconBundle
import com.intellij.openapi.options.Configurable
import javax.swing.JComponent
class PijulSettingsConfigurable: Configurable {
    private var pijulSettingsComponent: PijulSettingsComponent? = null
    override fun createComponent(): JComponent =
        PijulSettingsComponent().let {
            this.pijulSettingsComponent = it
            it
        }.mainPanel
    override fun getPreferredFocusedComponent(): JComponent? =
        this.pijulSettingsComponent?.preferredFocusedComponent
    override fun isModified(): Boolean {
        val settings = PijulSettings.instance
        val pathToPijul = settings.getPathToPijul()
        val cacheAllRevisions = settings.isToCacheAllRevisions()
        var modified = this.pijulSettingsComponent?.pijulPath?.text != pathToPijul
        modified = modified || (this.pijulSettingsComponent?.indexAllRevisions?.isSelected == cacheAllRevisions)
        return modified
    }
    override fun apply() {
        val settings = PijulSettings.instance
        settings.savePathToPijul(this.pijulSettingsComponent?.pijulPath?.text)
        settings.saveToCacheAllRevisions(this.pijulSettingsComponent?.indexAllRevisions?.isSelected ?: false)
    }
    override fun getDisplayName(): String =
        DraconBundle.message("settings.title")
    override fun reset() {
        val settings = PijulSettings.instance
        this.pijulSettingsComponent?.pijulPath?.text = settings.getPathToPijul() ?: ""
        this.pijulSettingsComponent?.indexAllRevisions?.isSelected = settings.isToCacheAllRevisions()
    }
    override fun disposeUIResources() {
        this.pijulSettingsComponent = null
    }
}

package com.github.jonathanxd.dracon.component
import com.github.jonathanxd.dracon.i18n.DraconBundle
import com.github.jonathanxd.dracon.util.findBinaryOrNull
import com.intellij.openapi.fileChooser.FileChooserDescriptor
import com.intellij.openapi.fileTypes.FileTypeRegistry
import com.intellij.openapi.ui.FixedSizeButton
import com.intellij.openapi.ui.TextFieldWithBrowseButton
import com.intellij.openapi.vfs.VirtualFile
import com.intellij.ui.components.JBCheckBox
import com.intellij.ui.components.JBLabel
import com.intellij.uiDesigner.core.Spacer
import com.intellij.util.ui.FormBuilder
import com.intellij.util.ui.UIUtil
import java.awt.BorderLayout
import java.awt.event.MouseAdapter
import java.awt.event.MouseEvent
import javax.swing.JButton
import javax.swing.JComponent
import javax.swing.JPanel
class PijulSettingsComponent {
    val indexAllRevisions = JBCheckBox(DraconBundle.message("settings.dracon.index.all.text")).also {
        it.toolTipText = DraconBundle.message("settings.dracon.index.all.tooltip.text")
    }
    val pijulPath = TextFieldWithBrowseButton().also {
        it.addBrowseFolderListener(
            DraconBundle.message("settings.pijul.path.select.text"),
            "",
            null,
            FileChooserDescriptor(true, false, false, false, false, false)
                .withFileFilter { file: VirtualFile? ->
                    file?.name == "pijul"
                }
        )
    }
    val detectPijul = JButton(DraconBundle.message("settings.pijul.path.detect.text")).also {
        it.addMouseListener(object : MouseAdapter() {
            override fun mouseClicked(e: MouseEvent) {
                pijulPath.text = findBinaryOrNull("pijul") ?: ""
            }
        })
        it.updateUI()
    }
    var mainPanel: JPanel =
        FormBuilder.createFormBuilder()
            .addLabeledComponent(
                JBLabel(DraconBundle.message("settings.pijul.path.text")), pijulPath, 1, false
            )
            .addComponent(JPanel(BorderLayout()).also {
                it.add(indexAllRevisions, BorderLayout.WEST)
                it.add(detectPijul, BorderLayout.EAST)
            }, 0)
            .addComponentFillVertically(JPanel(), 0)
            .panel
    val preferredFocusedComponent: JComponent
        get() = this.pijulPath
}

import com.github.jonathanxd.dracon.config.PijulSettings

import com.github.jonathanxd.dracon.exec.execInTerminal
import com.github.jonathanxd.dracon.exec.terminalCommand

import java.util.concurrent.CompletableFuture

            this.project,
            root,
            arguments,
            editorServerConsumer
        )
        return this.doExecutionWithMapper("push", operation) {
            it
        }
    }
    override fun pushInTerminal(
        project: Project,
        root: Path,
        fromChannel: String?,
        toChannel: String?,
        repository: String?,
        editorServerConsumer: (EditorServer) -> Unit
    ): PijulOperationResult<String> {
        val arguments = mutableListOf("push")
        if (fromChannel != null) {
            arguments.add("--from-channel")
            arguments.add(fromChannel)
        }
        if (toChannel != null) {
            arguments.add("--to-channel")
            arguments.add(toChannel)
        }
        if (repository != null) {
            arguments.add(repository)
        }
        val operation = this.createPainlessExecPijulWithEditorServerInTerminal(

            .directory(dir.toFile())
            .start()
        editorServerConsumer(EditorServer(freePort) {
            !process.isAlive
        })
        val input = String(process.inputStream.readAllBytes(), Charsets.UTF_8)
        val error = String(process.errorStream.readAllBytes(), Charsets.UTF_8)
        input.split("\n").forEach {
            draconConsoleWriter(project).logCommand("pijul", args, it)
        }
        error.split("\n").forEach {
            draconConsoleWriter(project).logCommandError("pijul", args, it)
        }
        val exit = process.waitFor()
        if (exit == 0) {
            draconConsoleWriter(project).logCommand("pijul", args, "<Exit status> $exit")
        } else {
            draconConsoleWriter(project).logCommandError("pijul", args, "<Exit status> $exit")
        }
        return PijulExecution(
            input,
            error,
            exit
        )
    }
    /**
     * Creates a [PijulExecution] operation that could be executed at any time. This operation uses Kotlin Coroutines
     * and can be executed immediately through [doExecution] or through [doExecutionWithMapper].
     *
     * This implementation does not requires a delay value to be provided, like [createExecPijulOperation] does, instead
     * it uses the kotlin conversion from `CompletionStage` to `Coroutines` and awaits the process through [Process.onExit].
     *
     * [doExecution] and [doExecutionWithMapper] does execution by scheduling task to [Dispatchers.IO], instead of Main Thread,
     * offloading the Process execution handling to a different scheduler. However, mapping operation of [doExecutionWithMapper]
     * is not offloaded from the caller context.
     *
     */
    @RequiresBackgroundThread
    private fun createPainlessExecPijulWithEditorServerInTerminal(
        project: Project,
        dir: Path,
        args: List<String>,
        editorServerConsumer: (EditorServer) -> Unit
    ): PijulExecution {
        val freePort = freePort()
        val cmd = listOf(this.findPijul()) + args
        val terminalCmd = terminalCommand("command.execute.text", cmd.joinToString(" "))
        val process = ProcessBuilder()
            .apply {
                environment()["EDITOR_SERVER_PORT"] = freePort.toString()
                environment()["VISUAL"] = editorServerPath()
                environment()["EDITOR"] = editorServerPath()
            }
            .command(terminalCmd)

    private fun findPijul(): String = findBinary("pijul")

    private fun findPijul(): String =
        service<PijulSettings>().getPathToPijul() ?: findBinary("pijul")

        private val settings = project.service<PijulSettings>()

        private val settings = PijulSettings.instance

                        project.service<PijulSettings>().isToCacheAllRevisions()

                        PijulSettings.instance.isToCacheAllRevisions()

import com.github.jonathanxd.dracon.exec.execInTerminal

                            this.execInTerminal("install.cargo.title", file.toString())

                            execInTerminal("install.cargo.title", file.toString())

                            this.execInTerminal("install.cargo.title", "sh $file")

                            execInTerminal("install.cargo.title", "sh $file")

    fun execInTerminal(
        @PropertyKey(resourceBundle = BUNDLE) name: String,
        command: String
    ) {
        ExecUtil.execAndGetOutput(GeneralCommandLine(ExecUtil.getTerminalCommand(DraconBundle.message(name), command)))
    }

        val record = pijul(project).push(project, root) {

        val record = pijul(project).pushInTerminal(project, root) {