;;; GNU Guix --- Functional package management for GNU
;;; Copyright © 2015 Eric Bavier <bavier@member.fsf.org>
;;; Copyright © 2016 Jan Nieuwenhuizen <janneke@gnu.org>
;;; Copyright © 2016, 2017 Mathieu Lirzin <mthl@gnu.org>
;;; Copyright © 2017, 2020, 2021 Mathieu Othacehe <m.othacehe@gmail.com>
;;; Copyright © 2017, 2019, 2020 Ricardo Wurmus <rekado@elephly.net>
;;; Copyright © 2018 Clément Lassieur <clement@lassieur.org>
;;; Copyright © 2022, 2024 Arun Isaac <arunisaac@systemreboot.net>
;;; Copyright © 2023 David Pflug <david@pflug.io>
;;; Copyright © 2025 David Thompson <davet@gnu.org>
;;; Copyright © 2025 Ludovic Courtès <ludo@gnu.org>
;;;
;;; This file is part of GNU Guix.
;;;
;;; GNU Guix is free software; you can redistribute it and/or modify it
;;; under the terms of the GNU General Public License as published by
;;; the Free Software Foundation; either version 3 of the License, or (at
;;; your option) any later version.
;;;
;;; GNU Guix is distributed in the hope that it will be useful, but
;;; WITHOUT ANY WARRANTY; without even the implied warranty of
;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
;;; GNU General Public License for more details.
;;;
;;; You should have received a copy of the GNU General Public License
;;; along with GNU Guix.  If not, see <http://www.gnu.org/licenses/>.

(define-module (gnu packages ci)
  #:use-module ((guix licenses) #:prefix l:)
  #:use-module (gnu packages)
  #:use-module (guix packages)
  #:use-module (guix download)
  #:use-module (guix git-download)
  #:use-module (guix download)
  #:use-module (guix gexp)
  #:use-module ((guix search-paths) #:select ($SSL_CERT_DIR))
  #:use-module (gnu packages autotools)
  #:use-module (gnu packages base)
  #:use-module (gnu packages bash)
  #:use-module (gnu packages boost)
  #:use-module (gnu packages check)
  #:use-module (gnu packages docbook)
  #:use-module (gnu packages compression)
  #:use-module (gnu packages databases)
  #:use-module (gnu packages golang)
  #:use-module (gnu packages golang-build)
  #:use-module (gnu packages golang-check)
  #:use-module (gnu packages golang-vcs)
  #:use-module (gnu packages golang-web)
  #:use-module (gnu packages golang-xyz)
  #:use-module (gnu packages guile)
  #:use-module (gnu packages guile-xyz)
  #:use-module (gnu packages gnupg)
  #:use-module (gnu packages mail)
  #:use-module (gnu packages package-management)
  #:use-module (gnu packages perl)
  #:use-module (gnu packages perl-compression)
  #:use-module (gnu packages pkg-config)
  #:use-module (gnu packages serialization)
  #:use-module (gnu packages sqlite)
  #:use-module (gnu packages tls)
  #:use-module (gnu packages texinfo)
  #:use-module (gnu packages uglifyjs)
  #:use-module (gnu packages version-control)
  #:use-module (gnu packages web)
  #:use-module (gnu packages xml)
  #:use-module (guix build-system cmake)
  #:use-module (guix build-system gnu)
  #:use-module (guix build-system go)
  #:use-module ((guix search-paths) #:select ($SSL_CERT_DIR)))

(define-public cuirass
  (package
    (name "cuirass")
    (version "1.3.0")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
              (url "https://git.guix.gnu.org/cuirass.git")
              (commit (string-append "v" version))))
       (file-name (git-file-name name version))
       (sha256
        (base32
         "15jrl0rx6i5ibiw7svrdgcy13v8iwi5z30jp49gfxrapp6m6lsrw"))))
    (build-system gnu-build-system)
    (arguments
     (list #:modules `((guix build utils)
                       (guix build gnu-build-system)
                       (ice-9 match)
                       (ice-9 rdelim)
                       (ice-9 popen)
                       (srfi srfi-1))
           #:configure-flags #~'("--localstatedir=/var" ;for /var/log/cuirass
                                 "--sysconfdir=/etc") ;for /etc/cuirass/forge-tokens
           ;; XXX: HTTP tests fail on aarch64 due to Fibers errors, disable them
           ;; on that architecture for now.
           #:tests? (let ((s (or (%current-target-system)
                                 (%current-system))))
                      (not (string-prefix? "aarch64" s)))
           #:parallel-tests? #f
           #:phases
           #~(modify-phases %standard-phases
               (add-after 'build 'install-minified-javascript
                 (lambda _
                   ;; Work around guix/cuirass#34.  Remove when 1.3.1 is out.
                   (define files
                     '("src/static/js/choices.min.js"
                       "src/static/js/d3.v6.min.js"
                       "src/static/js/list.min.js"))
                   (apply invoke "make" files)
                   (for-each (lambda (file)
                               (install-file
                                file
                                (in-vicinity #$output
                                             "share/cuirass/static/js")))
                             files)))
               (add-after 'install 'wrap-program
                 (lambda* (#:key inputs outputs #:allow-other-keys)
                   ;; Wrap the 'cuirass' command to refer to the right modules.
                   ;; Do so by collecting the subset of INPUTS that provides Guile
                   ;; modules.  This includes direct inputs as well as their
                   ;; propagated inputs--e.g., 'guix' propagates 'guile-zstd'.
                   (define (sub-directory suffix)
                     (match-lambda
                       ((label . directory)
                        (let ((directory (string-append directory suffix)))
                          (and (directory-exists? directory)
                               directory)))))

                   (let* ((out (assoc-ref outputs "out"))
                          (effective
                           (read-line
                            (open-pipe* OPEN_READ (which "guile") "-c"
                                        "(display (effective-version))")))
                          (mods (filter-map (sub-directory
                                             (string-append
                                              "/share/guile/site/"
                                              effective))
                                            inputs))
                          (objs (filter-map (sub-directory
                                             (string-append
                                              "/lib/guile/" effective
                                              "/site-ccache"))
                                            inputs)))
                     (wrap-program (string-append out "/bin/cuirass")
                       `("PATH" ":" prefix
                         (,(string-append out "/bin")))
                       `("GUILE_LOAD_PATH" ":" prefix
                         ,mods)
                       `("GUILE_LOAD_COMPILED_PATH" ":" prefix
                         ,objs))))))))
    (inputs
     (list bash-minimal
           guile-3.0-latest
           guile-avahi
           guile-fibers
           guile-gcrypt
           guile-json-4
           guile-simple-zmq
           guile-squee
           guile-git
           guile-zlib
           guile-mastodon
           guile-gnutls
           mailutils
           ;; FIXME: this is propagated by "guile-git", but it needs to be among
           ;; the inputs to add it to GUILE_LOAD_PATH.
           guile-bytestructures

           guix))
    (native-inputs
     (list autoconf-2.71
           automake
           pkg-config
           texinfo
           ephemeralpg
           esbuild))
    (native-search-paths
     ;; For HTTPS access, Cuirass itself honors these variables, with the
     ;; same semantics as Git and OpenSSL (respectively).
     (list (search-path-specification
             (variable "GIT_SSL_CAINFO")
             (file-type 'regular)
             (separator #f)                      ;single entry
             (files '("etc/ssl/certs/ca-certificates.crt")))
           $SSL_CERT_DIR))
    (synopsis "Continuous integration system")
    (description
     "Cuirass is a continuous integration tool using GNU Guix.  It is
intended as a replacement for Hydra.")
    (home-page "https://guix.gnu.org/cuirass/")
    (license l:gpl3+)))

(define-public laminar
  (package
    (name "laminar")
    (version "1.3")
    (source
     (origin (method git-fetch)
             (uri (git-reference
                   (url "https://github.com/ohwgiles/laminar")
                   (commit version)))
             (file-name (git-file-name name version))
             (sha256
              (base32
               "0ya5nzl1qf11if564xd49l8ajxyish7pbn875js4f153z775d3ks"))))
    (build-system cmake-build-system)
    (arguments
     `(#:tests? #f                      ; TODO Can't build tests
       #:configure-flags
       (list "-DCMAKE_CXX_STANDARD=17"
             ;; "-DBUILD_TESTS=true" TODO: objcopy: js/stPskyUS: can't add
             ;; section '.note.GNU-stack': file format not recognized
             (string-append "-DLAMINAR_VERSION=" ,version))
       #:phases
       (modify-phases %standard-phases
         (add-after 'unpack 'patch-CMakeLists.txt
           (lambda _
             (substitute* "CMakeLists.txt"
               (("file\\(DOWNLOAD.*\n$")
                "# file download removed by Guix --")
               (("install\\(FILES etc/laminar.service DESTINATION \\$\\{SYSTEMD\\_UNITDIR\\}\\)")
                "")
               (("install\\(FILES \\$\\{CMAKE\\_CURRENT\\_BINARY\\_DIR\\}\\/laminar\\.service DESTINATION \\$\\{SYSTEMD\\_UNITDIR\\}\\)")
                "")
               (("install\\(FILES etc/laminar\\.conf DESTINATION \\/etc\\)") "")
               (("\\/usr\\/") ""))))
         (add-after 'configure 'copy-in-javascript-and-css
           (lambda* (#:key inputs outputs #:allow-other-keys)
             (use-modules (ice-9 popen))

             (mkdir-p "../build/js")
             (invoke "tar" "-xf" (assoc-ref inputs "chart.js.tgz")
                     "--strip-components" "2"
                     "package/dist/chart.js")
             (for-each (lambda (file minified-file)
                         (let* ((port
                                 (open-pipe* OPEN_READ "uglifyjs" file))
                                (destination
                                 (string-append
                                  "../build/js/" minified-file)))

                           (call-with-output-file destination
                             (lambda (output-port)
                               (dump-port port output-port)))

                           (let ((exit (close-pipe port)))
                             (unless (zero? exit)
                               (error "uglifyjs failed" exit)))))

                       (list (assoc-ref inputs "vue.js")
                             (assoc-ref inputs "vue-router.js")
                             "chart.js")
                       (list "vue.min.js"
                             "vue-router.min.js"
                             "Chart.min.js"))

             ;; ansi_up.js isn't minified
             (copy-file (assoc-ref inputs "ansi_up.js")
                        "../build/js/ansi_up.js"))))))
    (inputs
     (list capnproto rapidjson sqlite boost zlib))
    (native-inputs
     `(("googletest" ,googletest)
       ("uglifyjs" ,node-uglify-js)

       ("vue.js"
        ,(origin (method url-fetch)
                 (uri (string-append "https://raw.githubusercontent.com/"
                                     "vuejs/vue/v2.6.12/dist/vue.js"))
                 (sha256
                  (base32
                   "1mq2dn6yqbmzar77xf4x2bvvanf9xc9nwfq06sksl5zmr300m7qm"))))
       ("vue-router.js"
        ,(origin (method url-fetch)
                 (uri (string-append "https://raw.githubusercontent.com/"
                                     "vuejs/vue-router/v3.4.8/dist/vue-router.js"))
                 (sha256
                  (base32
                   "1hkrbgzhpnrsb4zdafslqagy1vkac6bkdj7kh49js2lhkp9z4nj5"))))
       ("ansi_up.js"
        ,(origin (method url-fetch)
                 (uri (string-append "https://raw.githubusercontent.com/"
                                     "drudru/ansi_up/v4.0.4/ansi_up.js"))
                 (sha256
                  (base32
                   "1dx8wn38ds8d01kkih26fx1yrisg3kpz61qynjr4zil03ap0hrlr"))))
       ("chart.js.tgz"
        ,(origin (method url-fetch)
                 (uri (string-append "https://github.com/chartjs/Chart.js/"
                                     "releases/download/v3.9.1/chart.js-3.9.1.tgz"))
                 (sha256
                  (base32
                   "1ikjgspaknqlhpjad17563yph4pvrh8dkzjdx58pl23gg58hf7hi"))))))
    (synopsis "Lightweight continuous integration service")
    (description
     "Laminar is a lightweight and modular continuous integration service.  It
doesn't have a configuration web UI instead uses version-controllable
configuration files and scripts.

Laminar encourages the use of existing tools such as bash and cron instead of
reinventing them.")
    (home-page "https://laminar.ohwg.net/")
    (license l:gpl3+)))

(define-public forgejo-runner
  (package
    (name "forgejo-runner")
    (version "6.2.2")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://code.forgejo.org/forgejo/runner.git")
             (commit (string-append "v" version))))
       (file-name (git-file-name name version))
       (sha256
        (base32 "0bdn1pk9ghbyd4i9hmk7rfhqdkz9l5w4wgrwiryg8qpwplb7j8mz"))))
    (build-system go-build-system)
    (arguments
     (list
      #:install-source? #f
      #:import-path "gitea.com/gitea/act_runner"
      #:embed-files #~(list ".*\\.json" ".*\\.js" ".*\\.sh")
      #:test-flags
      #~(list "-skip" (string-join
                       (list
                       ;; Should be true.
                       "Test_ping"
	               ;; panic: runtime error: invalid memory address or nil
	               ;; pointer dereference.
                        "Test_runCreateRunnerFile")
                       "|"))
      #:phases #~(modify-phases %standard-phases
                   (add-after 'install 'rename-binary
                     (lambda _
                       (rename-file (string-append #$output "/bin/act_runner")
                                    (string-append #$output "/bin/forgejo-runner")))))))
    (native-inputs
     (list go-code-gitea-io-actions-proto-go-ping
           go-code-gitea-io-actions-proto-go-runner
           go-connectrpc-com-connect
           go-github-com-avast-retry-go
           go-github-com-avast-retry-go-v4
           go-github-com-google-uuid
           go-github-com-joho-godotenv
           go-github-com-mattn-go-isatty
           go-github-com-nektos-act
           go-github-com-sirupsen-logrus
           go-github-com-spf13-cobra
           go-golang-org-x-term
           go-golang-org-x-time
           go-google-golang-org-protobuf
           go-gopkg-in-yaml-v3
           go-gotest-tools-v3))
    (home-page "https://code.forgejo.org/forgejo/runner")
    (synopsis "Run continuous integration jobs for Forgejo")
    (description
     "Forgejo Runner is a daemon that connects to a Forgejo instance and runs
jobs for continuous integration.")
    (license l:expat)))

