Merge pull request 'default GITHUB_SERVER_URL with registration address' (#24 ) from earl-warren/runner:wip-sync into main

Reviewed-on: https://code.forgejo.org/forgejo/runner/pulls/24 Reviewed-by: dachary <dachary@noreply.code.forgejo.org>
default GITHUB_SERVER_URL with registration address
2023-04-05 15:08:01 +00:00 · 2023-04-05 16:39:09 +02:00 · 2023-04-04 23:07:29 +00:00 · 2023-04-05 00:53:35 +02:00 · 2023-04-05 00:53:35 +02:00 · 2023-04-05 00:53:35 +02:00
39 changed files with 2547 additions and 1231 deletions
--- a/.dockerignore
+++ b/.dockerignore
@ -0,0 +1,2 @@
+Dockerfile
+forgejo-runner
--- a/.forgejo/workflows/integration.yml
+++ b/.forgejo/workflows/integration.yml
@ -0,0 +1,55 @@
+name: Integration tests for the release process
+
+on: 
+  push:
+    paths:
+      - go.mod
+      - .forgejo/workflows/release.yml
+      - .forgejo/workflows/integration.yml
+
+jobs:
+  release-simulation:
+    runs-on: self-hosted
+    steps:
+      - uses: actions/checkout@v3
+
+      - id: forgejo
+        uses: https://code.forgejo.org/actions/setup-forgejo@v1
+        with:
+          user: root
+          password: admin1234
+          image-version: 1.19
+          lxc-ip-prefix: 10.0.9
+
+      - name: publish the runner release
+        run: |
+          set -x
+
+          dir=$(mktemp -d)
+          trap "rm -fr $dir" EXIT
+
+          url=http://root:admin1234@${{ steps.forgejo.outputs.host-port }}
+          export FORGEJO_RUNNER_LOGS="${{ steps.forgejo.outputs.runner-logs }}"
+
+          #
+          # Create a new project with the runner and the release workflow only
+          #
+          rsync -a --exclude .git ./ $dir/
+          rm $(find $dir/.forgejo/workflows/*.yml | grep -v release.yml)
+          forgejo-test-helper.sh push $dir $url root runner |& tee $dir/pushed
+          eval $(grep '^sha=' < $dir/pushed)
+
+          #
+          # Push a tag to trigger the release workflow and wait for it to complete
+          #
+          forgejo-test-helper.sh api POST $url repos/root/runner/tags ${{ steps.forgejo.outputs.token }} --data-raw '{"tag_name": "v1.2.3", "target": "'$sha'"}'
+          LOOPS=180 forgejo-test-helper.sh wait_success "$url" root/runner $sha
+
+          #
+          # Minimal sanity checks. e2e test is for the setup-forgejo action
+          # and the infrastructure playbook.
+          #
+          curl -L -sS $url/root/runner/releases/download/v1.2.3/forgejo-runner-amd64 > forgejo-runner
+          chmod +x forgejo-runner
+          ./forgejo-runner --version | grep 1.2.3
+
--- a/.forgejo/workflows/release.yml
+++ b/.forgejo/workflows/release.yml
@ -0,0 +1,114 @@
+name: Publish release
+
+on: 
+  push:
+    tags: 'v*'
+
+jobs:
+  release:
+    runs-on: self-hosted
+    steps:
+      - uses: actions/checkout@v3
+
+      - id: verbose
+        run: |
+          # if there are no secrets, be verbose
+          if test -z "${{ secrets.TOKEN }}"; then
+            value=true
+          else
+            value=false
+          fi
+          echo "value=$value" >> "$GITHUB_OUTPUT"
+          echo "shell=set -x" >> "$GITHUB_OUTPUT"
+          
+      - id: registry
+        run: |
+          ${{ steps.verbose.outputs.shell }}
+          url="${{ env.GITHUB_SERVER_URL }}"
+          hostport=${url##http*://}
+          hostport=${hostport%%/}
+          echo "host-port=${hostport}" >> "$GITHUB_OUTPUT"
+          if ! [[ $url =~ ^http:// ]] ; then
+             exit 0
+          fi
+          cat >> "$GITHUB_OUTPUT" <<EOF
+          insecure=true
+          buildx-config<<ENDVAR
+          [registry."${hostport}"]
+            http = true
+          ENDVAR
+          EOF
+        
+      - id: secrets
+        run: |
+          token="${{ secrets.TOKEN }}"
+          doer="${{ secrets.DOER }}"
+          if test -z "$token"; then
+             apt-get -qq install -y jq
+             doer=root
+             api=http://$doer:admin1234@${{ steps.registry.outputs.host-port }}/api/v1/users/$doer/tokens
+             curl -sS -X DELETE $api/release
+             token=$(curl -sS -X POST -H 'Content-Type: application/json' --data-raw '{"name": "release", "scopes": ["all"]}' $api | jq --raw-output .sha1)
+          fi
+          echo "token=${token}" >> "$GITHUB_OUTPUT"
+          echo "doer=${doer}" >> "$GITHUB_OUTPUT"
+
+      - name: allow docker pull/push to forgejo
+        if: ${{ steps.registry.outputs.insecure }}
+        run: |-
+          mkdir /etc/docker
+          cat > /etc/docker/daemon.json <<EOF
+            {
+              "insecure-registries" : ["${{ steps.registry.outputs.host-port }}"],
+              "bip": "172.26.0.1/16"
+            }
+          EOF
+
+      - run: |
+          echo deb http://deb.debian.org/debian bullseye-backports main | tee /etc/apt/sources.list.d/backports.list && apt-get -qq update
+          DEBIAN_FRONTEND=noninteractive apt-get install --no-install-recommends -qq -y -t bullseye-backports docker.io
+          
+      - uses: https://github.com/docker/setup-buildx-action@v2
+        with:
+          config-inline: |
+           ${{ steps.registry.outputs.buildx-config }}
+
+      - run: |
+          BASE64_AUTH=`echo -n "${{ steps.secrets.outputs.doer }}:${{ steps.secrets.outputs.token }}" | base64`
+          mkdir -p ~/.docker
+          echo "{\"auths\": {\"$CI_REGISTRY\": {\"auth\": \"$BASE64_AUTH\"}}}" > ~/.docker/config.json
+        env:
+          CI_REGISTRY: "${{ env.GITHUB_SERVER_URL }}${{ env.GITHUB_REPOSITORY_OWNER }}"
+
+      - id: build
+        run: |
+          ${{ steps.verbose.outputs.shell }}
+          tag="${{ github.ref_name }}"
+          tag=${tag##*v}
+          echo "tag=$tag" >> "$GITHUB_OUTPUT"
+          echo "image=${{ steps.registry.outputs.host-port }}/${{ github.repository }}:${tag}" >> "$GITHUB_OUTPUT"
+          
+      - uses: https://github.com/docker/build-push-action@v4
+        with:
+          context: .
+          push: true
+          platforms: linux/amd64,linux/arm64
+          tags: ${{ steps.build.outputs.image }}
+
+      - run: |
+          ${{ steps.verbose.outputs.shell }}
+          mkdir -p release
+          for arch in amd64 arm64; do
+            docker create --platform linux/$arch --name runner ${{ steps.build.outputs.image }}
+            docker cp runner:/bin/forgejo-runner release/forgejo-runner-$arch
+            shasum -a 256 < release/forgejo-runner-$arch > release/forgejo-runner-$arch.sha256
+            docker rm runner
+          done
+
+      - uses: https://code.forgejo.org/actions/forgejo-release@v1
+        with:
+          direction: upload
+          release-dir: release
+          release-notes: "RELEASE-NOTES#${{ steps.build.outputs.tag }}"
+          token: ${{ steps.secrets.outputs.token }}
+          verbose: ${{ steps.verbose.outputs.value }}
--- a/.forgejo/workflows/test.yml
+++ b/.forgejo/workflows/test.yml
@ -0,0 +1,23 @@
+name: checks
+on: 
+  - pull_request
+  - push
+
+env:
+  GOPROXY: https://goproxy.io,direct
+
+jobs:
+  lint:
+    name: check and test
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/setup-go@v3
+        with:
+          go-version: 1.19
+      - uses: actions/checkout@v3
+      - name: vet checks
+        run: make vet
+      - name: build
+        run: make build
+      - name: test
+        run: make test
--- a/.gitea/workflows/lint.yml
+++ b/.gitea/workflows/lint.yml
@ -1,21 +0,0 @@
-name: checks
-on: [push]
-
-env:
-  GOPROXY: https://goproxy.io,direct
-
-jobs:
-  lint:
-    name: lint
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/setup-go@v3
-        with:
-          go-version: 1.17
-      - uses: actions/checkout@v3
-      - uses: Jerome1337/golint-action@v1.0.2
-      #- name: golangci-lint
-      #  uses: golangci/golangci-lint-action@v3
-      #  with:
-          # Optional: version of golangci-lint to use in form of v1.2 or v1.2.3 or `latest` to use the latest version
-      #    version: v1.29
--- a/.gitea/workflows/test.yml
+++ b/.gitea/workflows/test.yml
@ -0,0 +1,43 @@
+name: checks
+on: 
+  - push
+  - pull_request
+
+env:
+  GOPROXY: https://goproxy.io,direct
+  GOPATH: /go_path
+  GOCACHE: /go_cache
+
+jobs:
+  lint:
+    name: check and test
+    runs-on: ubuntu-latest
+    steps:
+      - name: cache go path
+        id: cache-go-path
+        uses: https://github.com/actions/cache@v3
+        with:
+          path: /go_path
+          key: go_path-${{ github.repository }}-${{ github.ref_name }}
+          restore-keys: |
+            go_path-${{ github.repository }}-
+            go_path-            
+      - name: cache go cache
+        id: cache-go-cache
+        uses: https://github.com/actions/cache@v3
+        with:
+          path: /go_cache
+          key: go_cache-${{ github.repository }}-${{ github.ref_name }}
+          restore-keys: |
+            go_cache-${{ github.repository }}-
+            go_cache-    
+      - uses: actions/setup-go@v3
+        with:
+          go-version: 1.20
+      - uses: actions/checkout@v3
+      - name: vet checks
+        run: make vet
+      - name: build
+        run: make build
+      - name: test
+        run: make test
--- a/.gitignore
+++ b/.gitignore
@ -1,3 +1,11 @@
-act_runner
+*~
+forgejo-runner
 .env
 .runner
+coverage.txt
+/gitea-vet
+/config.yaml
+
+# MS VSCode
+.vscode
+__debug_bin
--- a/15
+++ b/15
@ -0,0 +1,15 @@
+#Build stage
+FROM golang:1.20-alpine3.17 AS build-env
+
+RUN apk --no-cache add build-base git
+
+COPY . /srv
+WORKDIR /srv
+RUN make build
+
+FROM alpine:3.17
+LABEL maintainer="contact@forgejo.org"
+
+COPY --from=build-env /srv/forgejo-runner /bin/forgejo-runner
+
+ENTRYPOINT ["/bin/forgejo-runner"]
--- a/38
+++ b/38
@ -1,5 +1,5 @@
 DIST := dist
-EXECUTABLE := act_runner
+EXECUTABLE := forgejo-runner
 GOFMT ?= gofumpt -l
 DIST := dist
 DIST_DIRS := $(DIST)/binaries $(DIST)/release
@ -9,17 +9,15 @@ HAS_GO = $(shell hash $(GO) > /dev/null 2>&1 && echo "GO" || echo "NOGO" )
 XGO_PACKAGE ?= src.techknowlogick.com/xgo@latest
 XGO_VERSION := go-1.18.x
 GXZ_PAGAGE ?= github.com/ulikunitz/xz/cmd/gxz@v0.5.10
+RUNNER_CMD_PACKAGE_PATH := codeberg.org/forgejo/runner/cmd

 LINUX_ARCHS ?= linux/amd64,linux/arm64
 DARWIN_ARCHS ?= darwin-12/amd64,darwin-12/arm64
 WINDOWS_ARCHS ?= windows/amd64
-GOFILES := $(shell find . -type f -name "*.go" ! -name "generated.*")
+GO_FMT_FILES := $(shell find . -type f -name "*.go" ! -name "generated.*")
+GOFILES := $(shell find . -type f -name "*.go" -o -name "go.mod" ! -name "generated.*")

-ifneq ($(shell uname), Darwin)
-	EXTLDFLAGS = -extldflags "-static" $(null)
-else
-	EXTLDFLAGS =
-endif
+EXTLDFLAGS = -extldflags "-static" $(null)

 ifeq ($(HAS_GO), GO)
 	GOPATH ?= $(shell $(GO) env GOPATH)
@ -49,7 +47,7 @@ else
 	ifneq ($(DRONE_BRANCH),)
 		VERSION ?= $(subst release/v,,$(DRONE_BRANCH))
 	else
-		VERSION ?= master
+		VERSION ?= main
 	endif

 	STORED_VERSION=$(shell cat $(STORED_VERSION_FILE) 2>/dev/null)
@ -61,25 +59,35 @@ else
 endif

 TAGS ?=
-LDFLAGS ?= -X 'main.Version=$(VERSION)'
+LDFLAGS ?= -X "$(RUNNER_CMD_PACKAGE_PATH).version=$(RELASE_VERSION)"

 all: build

 fmt:
 	@hash gofumpt > /dev/null 2>&1; if [ $$? -ne 0 ]; then \
-		$(GO) install -u mvdan.cc/gofumpt; \
+		$(GO) install mvdan.cc/gofumpt@latest; \
 	fi
-	$(GOFMT) -w $(GOFILES)
+	$(GOFMT) -w $(GO_FMT_FILES)

 vet:
 	$(GO) vet ./...

+.PHONY: go-check
+go-check:
+	$(eval MIN_GO_VERSION_STR := $(shell grep -Eo '^go\s+[0-9]+\.[0-9]+' go.mod | cut -d' ' -f2))
+	$(eval MIN_GO_VERSION := $(shell printf "%03d%03d" $(shell echo '$(MIN_GO_VERSION_STR)' | tr '.' ' ')))
+	$(eval GO_VERSION := $(shell printf "%03d%03d" $(shell $(GO) version | grep -Eo '[0-9]+\.[0-9]+' | tr '.' ' ');))
+	@if [ "$(GO_VERSION)" -lt "$(MIN_GO_VERSION)" ]; then \
+		echo "Act Runner requires Go $(MIN_GO_VERSION_STR) or greater to build. You can get it at https://go.dev/dl/"; \
+		exit 1; \
+	fi
+
 .PHONY: fmt-check
 fmt-check:
 	@hash gofumpt > /dev/null 2>&1; if [ $$? -ne 0 ]; then \
-		$(GO) install -u mvdan.cc/gofumpt; \
+		$(GO) install mvdan.cc/gofumpt@latest; \
 	fi
-	@diff=$$($(GOFMT) -d $(GOFILES)); \
+	@diff=$$($(GOFMT) -d $(GO_FMT_FILES)); \
 	if [ -n "$$diff" ]; then \
 		echo "Please run 'make fmt' and commit the result:"; \
 		echo "$${diff}"; \
@ -92,10 +100,10 @@ test: fmt-check
 install: $(GOFILES)
 	$(GO) install -v -tags '$(TAGS)' -ldflags '$(EXTLDFLAGS)-s -w $(LDFLAGS)'

-build: $(EXECUTABLE)
+build: go-check $(EXECUTABLE)

 $(EXECUTABLE): $(GOFILES)
-	$(GO) build -v -tags '$(TAGS)' -ldflags '$(EXTLDFLAGS)-s -w $(LDFLAGS)' -o $@
+	$(GO) build -v -tags 'netgo osusergo $(TAGS)' -ldflags '$(EXTLDFLAGS)-s -w $(LDFLAGS)' -o $@

 .PHONY: deps-backend
 deps-backend:
--- a/README.md
+++ b/README.md
@ -1,61 +1,6 @@
-# act runner
+# Forgejo Actions runner

-Act runner is a runner for Gitea based on [act](https://gitea.com/gitea/act).
+Runs workflows found in `.forgejo/workflows`, using a format similar to GitHub actions but with a Free Software implementation.

-## Prerequisites
+It is compatible with Forgejo v1.19.0-0-rc0

-Docker Engine Community version is required. To install Docker CE, follow the official [install instructions](https://docs.docker.com/engine/install/).
-
-## Quickstart
-
-### Build
-
-```bash
-make build
-```
-
-### Register
-
-```bash
-./act_runner register
-```
-
-And you will be asked to input:
-
-1. Gitea instance URL, like `http://192.168.8.8:3000/`. You should use your gitea instance ROOT_URL as the instance argument
- and you should not use `localhost` or `127.0.0.1` as instance IP;
-2. Runner token, you can get it from `http://192.168.8.8:3000/admin/runners`;
-3. Runner name, you can just leave it blank;
-4. Runner labels, you can just leave it blank.
-
-The process looks like:
-
-```text
-INFO Registering runner, arch=amd64, os=darwin, version=0.1.5.
-WARN Runner in user-mode.
-INFO Enter the Gitea instance URL (for example, https://gitea.com/):
-http://192.168.8.8:3000/
-INFO Enter the runner token:
-fe884e8027dc292970d4e0303fe82b14xxxxxxxx
-INFO Enter the runner name (if set empty, use hostname:Test.local ):
-
-INFO Enter the runner labels, leave blank to use the default labels (comma-separated, for example, self-hosted,ubuntu-20.04:docker://node:16-bullseye,ubuntu-18.04:docker://node:16-buster):
-
-INFO Registering runner, name=Test.local, instance=http://192.168.8.8:3000/, labels=[ubuntu-latest:docker://node:16-bullseye ubuntu-22.04:docker://node:16-bullseye ubuntu-20.04:docker://node:16-bullseye ubuntu-18.04:docker://node:16-buster].
-DEBU Successfully pinged the Gitea instance server
-INFO Runner registered successfully.
-```
-
-You can also register with command line arguments.
-
-```bash
-./act_runner register --instance http://192.168.8.8:3000 --token <my_runner_token> --no-interactive
-```
-
-If the registry succeed, it will run immediately. Next time, you could run the runner directly.
-
-### Run
-
-```bash
-./act_runner daemon
-```
--- a/artifactcache/README.md
+++ b/artifactcache/README.md
@ -0,0 +1,7 @@
+Inspired by:
+https://github.com/sp-ricard-valverde/github-act-cache-server
+
+TODO:
+- Authorization
+- [Restrictions for accessing a cache](https://docs.github.com/en/actions/using-workflows/caching-dependencies-to-speed-up-workflows#restrictions-for-accessing-a-cache)
+- [Force deleting cache entries](https://docs.github.com/en/actions/using-workflows/caching-dependencies-to-speed-up-workflows#force-deleting-cache-entries)
--- a/artifactcache/handler.go
+++ b/artifactcache/handler.go
@ -0,0 +1,416 @@
+// Copyright 2023 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package artifactcache
+
+import (
+	"context"
+	"fmt"
+	"net"
+	"net/http"
+	"os"
+	"path/filepath"
+	"strconv"
+	"strings"
+	"sync/atomic"
+	"time"
+
+	"github.com/go-chi/chi/v5"
+	"github.com/go-chi/chi/v5/middleware"
+	"github.com/go-chi/render"
+	log "github.com/sirupsen/logrus"
+	_ "modernc.org/sqlite"
+	"xorm.io/builder"
+	"xorm.io/xorm"
+)
+
+const (
+	urlBase = "/_apis/artifactcache"
+)
+
+var logger = log.StandardLogger().WithField("module", "cache_request")
+
+type Handler struct {
+	engine   engine
+	storage  *Storage
+	router   *chi.Mux
+	listener net.Listener
+
+	gc   atomic.Bool
+	gcAt time.Time
+
+	outboundIP string
+}
+
+func NewHandler(dir, outboundIP string, port uint16) (*Handler, error) {
+	h := &Handler{}
+
+	if dir == "" {
+		if home, err := os.UserHomeDir(); err != nil {
+			return nil, err
+		} else {
+			dir = filepath.Join(home, ".cache", "actcache")
+		}
+	}
+	if err := os.MkdirAll(dir, 0o755); err != nil {
+		return nil, err
+	}
+
+	e, err := xorm.NewEngine("sqlite", filepath.Join(dir, "sqlite.db"))
+	if err != nil {
+		return nil, err
+	}
+	if err := e.Sync(&Cache{}); err != nil {
+		return nil, err
+	}
+	h.engine = engine{e: e}
+
+	storage, err := NewStorage(filepath.Join(dir, "cache"))
+	if err != nil {
+		return nil, err
+	}
+	h.storage = storage
+
+	if outboundIP != "" {
+		h.outboundIP = outboundIP
+	} else if ip, err := getOutboundIP(); err != nil {
+		return nil, err
+	} else {
+		h.outboundIP = ip.String()
+	}
+
+	router := chi.NewRouter()
+	router.Use(middleware.RequestLogger(&middleware.DefaultLogFormatter{Logger: logger}))
+	router.Use(func(handler http.Handler) http.Handler {
+		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			handler.ServeHTTP(w, r)
+			go h.gcCache()
+		})
+	})
+	router.Use(middleware.Logger)
+	router.Route(urlBase, func(r chi.Router) {
+		r.Get("/cache", h.find)
+		r.Route("/caches", func(r chi.Router) {
+			r.Post("/", h.reserve)
+			r.Route("/{id}", func(r chi.Router) {
+				r.Patch("/", h.upload)
+				r.Post("/", h.commit)
+			})
+		})
+		r.Get("/artifacts/{id}", h.get)
+		r.Post("/clean", h.clean)
+	})
+
+	h.router = router
+
+	h.gcCache()
+
+	listener, err := net.Listen("tcp", fmt.Sprintf(":%d", port)) // listen on all interfaces
+	if err != nil {
+		return nil, err
+	}
+	go func() {
+		if err := http.Serve(listener, h.router); err != nil {
+			logger.Errorf("http serve: %v", err)
+		}
+	}()
+	h.listener = listener
+
+	return h, nil
+}
+
+func (h *Handler) ExternalURL() string {
+	// TODO: make the external url configurable if necessary
+	return fmt.Sprintf("http://%s:%d",
+		h.outboundIP,
+		h.listener.Addr().(*net.TCPAddr).Port)
+}
+
+// GET /_apis/artifactcache/cache
+func (h *Handler) find(w http.ResponseWriter, r *http.Request) {
+	keys := strings.Split(r.URL.Query().Get("keys"), ",")
+	version := r.URL.Query().Get("version")
+
+	cache, err := h.findCache(r.Context(), keys, version)
+	if err != nil {
+		responseJson(w, r, 500, err)
+		return
+	}
+	if cache == nil {
+		responseJson(w, r, 204)
+		return
+	}
+
+	if ok, err := h.storage.Exist(cache.ID); err != nil {
+		responseJson(w, r, 500, err)
+		return
+	} else if !ok {
+		_ = h.engine.Exec(func(sess *xorm.Session) error {
+			_, err := sess.Delete(cache)
+			return err
+		})
+		responseJson(w, r, 204)
+		return
+	}
+	responseJson(w, r, 200, map[string]any{
+		"result":          "hit",
+		"archiveLocation": fmt.Sprintf("%s%s/artifacts/%d", h.ExternalURL(), urlBase, cache.ID),
+		"cacheKey":        cache.Key,
+	})
+}
+
+// POST /_apis/artifactcache/caches
+func (h *Handler) reserve(w http.ResponseWriter, r *http.Request) {
+	cache := &Cache{}
+	if err := render.Bind(r, cache); err != nil {
+		responseJson(w, r, 400, err)
+		return
+	}
+
+	if ok, err := h.engine.ExecBool(func(sess *xorm.Session) (bool, error) {
+		return sess.Where(builder.Eq{"key": cache.Key, "version": cache.Version}).Get(&Cache{})
+	}); err != nil {
+		responseJson(w, r, 500, err)
+		return
+	} else if ok {
+		responseJson(w, r, 400, fmt.Errorf("already exist"))
+		return
+	}
+
+	if err := h.engine.Exec(func(sess *xorm.Session) error {
+		_, err := sess.Insert(cache)
+		return err
+	}); err != nil {
+		responseJson(w, r, 500, err)
+		return
+	}
+	responseJson(w, r, 200, map[string]any{
+		"cacheId": cache.ID,
+	})
+	return
+}
+
+// PATCH /_apis/artifactcache/caches/:id
+func (h *Handler) upload(w http.ResponseWriter, r *http.Request) {
+	id, err := strconv.ParseInt(chi.URLParam(r, "id"), 10, 64)
+	if err != nil {
+		responseJson(w, r, 400, err)
+		return
+	}
+
+	cache := &Cache{
+		ID: id,
+	}
+
+	if ok, err := h.engine.ExecBool(func(sess *xorm.Session) (bool, error) {
+		return sess.Get(cache)
+	}); err != nil {
+		responseJson(w, r, 500, err)
+		return
+	} else if !ok {
+		responseJson(w, r, 400, fmt.Errorf("cache %d: not reserved", id))
+		return
+	}
+
+	if cache.Complete {
+		responseJson(w, r, 400, fmt.Errorf("cache %v %q: already complete", cache.ID, cache.Key))
+		return
+	}
+	start, _, err := parseContentRange(r.Header.Get("Content-Range"))
+	if err != nil {
+		responseJson(w, r, 400, err)
+		return
+	}
+	if err := h.storage.Write(cache.ID, start, r.Body); err != nil {
+		responseJson(w, r, 500, err)
+	}
+	h.useCache(r.Context(), id)
+	responseJson(w, r, 200)
+}
+
+// POST /_apis/artifactcache/caches/:id
+func (h *Handler) commit(w http.ResponseWriter, r *http.Request) {
+	id, err := strconv.ParseInt(chi.URLParam(r, "id"), 10, 64)
+	if err != nil {
+		responseJson(w, r, 400, err)
+		return
+	}
+
+	cache := &Cache{
+		ID: id,
+	}
+	if ok, err := h.engine.ExecBool(func(sess *xorm.Session) (bool, error) {
+		return sess.Get(cache)
+	}); err != nil {
+		responseJson(w, r, 500, err)
+		return
+	} else if !ok {
+		responseJson(w, r, 400, fmt.Errorf("cache %d: not reserved", id))
+		return
+	}
+
+	if cache.Complete {
+		responseJson(w, r, 400, fmt.Errorf("cache %v %q: already complete", cache.ID, cache.Key))
+		return
+	}
+
+	if err := h.storage.Commit(cache.ID, cache.Size); err != nil {
+		responseJson(w, r, 500, err)
+		return
+	}
+
+	cache.Complete = true
+	if err := h.engine.Exec(func(sess *xorm.Session) error {
+		_, err := sess.ID(cache.ID).Cols("complete").Update(cache)
+		return err
+	}); err != nil {
+		responseJson(w, r, 500, err)
+		return
+	}
+
+	responseJson(w, r, 200)
+}
+
+// GET /_apis/artifactcache/artifacts/:id
+func (h *Handler) get(w http.ResponseWriter, r *http.Request) {
+	id, err := strconv.ParseInt(chi.URLParam(r, "id"), 10, 64)
+	if err != nil {
+		responseJson(w, r, 400, err)
+		return
+	}
+	h.useCache(r.Context(), id)
+	h.storage.Serve(w, r, id)
+}
+
+// POST /_apis/artifactcache/clean
+func (h *Handler) clean(w http.ResponseWriter, r *http.Request) {
+	// TODO: don't support force deleting cache entries
+	// see: https://docs.github.com/en/actions/using-workflows/caching-dependencies-to-speed-up-workflows#force-deleting-cache-entries
+
+	responseJson(w, r, 200)
+}
+
+// if not found, return (nil, nil) instead of an error.
+func (h *Handler) findCache(ctx context.Context, keys []string, version string) (*Cache, error) {
+	if len(keys) == 0 {
+		return nil, nil
+	}
+	key := keys[0] // the first key is for exact match.
+
+	cache := &Cache{}
+	if ok, err := h.engine.ExecBool(func(sess *xorm.Session) (bool, error) {
+		return sess.Where(builder.Eq{"key": key, "version": version, "complete": true}).Get(cache)
+	}); err != nil {
+		return nil, err
+	} else if ok {
+		return cache, nil
+	}
+
+	for _, prefix := range keys[1:] {
+		if ok, err := h.engine.ExecBool(func(sess *xorm.Session) (bool, error) {
+			return sess.Where(builder.And(
+				builder.Like{"key", prefix + "%"},
+				builder.Eq{"version": version, "complete": true},
+			)).OrderBy("id DESC").Get(cache)
+		}); err != nil {
+			return nil, err
+		} else if ok {
+			return cache, nil
+		}
+	}
+	return nil, nil
+}
+
+func (h *Handler) useCache(ctx context.Context, id int64) {
+	// keep quiet
+	_ = h.engine.Exec(func(sess *xorm.Session) error {
+		_, err := sess.Context(ctx).Cols("used_at").Update(&Cache{
+			ID:     id,
+			UsedAt: time.Now().Unix(),
+		})
+		return err
+	})
+}
+
+func (h *Handler) gcCache() {
+	if h.gc.Load() {
+		return
+	}
+	if !h.gc.CompareAndSwap(false, true) {
+		return
+	}
+	defer h.gc.Store(false)
+
+	if time.Since(h.gcAt) < time.Hour {
+		logger.Infof("skip gc: %v", h.gcAt.String())
+		return
+	}
+	h.gcAt = time.Now()
+	logger.Infof("gc: %v", h.gcAt.String())
+
+	const (
+		keepUsed   = 30 * 24 * time.Hour
+		keepUnused = 7 * 24 * time.Hour
+		keepTemp   = 5 * time.Minute
+	)
+
+	var caches []*Cache
+	if err := h.engine.Exec(func(sess *xorm.Session) error {
+		return sess.Where(builder.And(builder.Lt{"used_at": time.Now().Add(-keepTemp).Unix()}, builder.Eq{"complete": false})).
+			Find(&caches)
+	}); err != nil {
+		logger.Warnf("find caches: %v", err)
+	} else {
+		for _, cache := range caches {
+			h.storage.Remove(cache.ID)
+			if err := h.engine.Exec(func(sess *xorm.Session) error {
+				_, err := sess.Delete(cache)
+				return err
+			}); err != nil {
+				logger.Warnf("delete cache: %v", err)
+				continue
+			}
+			logger.Infof("deleted cache: %+v", cache)
+		}
+	}
+
+	caches = caches[:0]
+	if err := h.engine.Exec(func(sess *xorm.Session) error {
+		return sess.Where(builder.Lt{"used_at": time.Now().Add(-keepUnused).Unix()}).
+			Find(&caches)
+	}); err != nil {
+		logger.Warnf("find caches: %v", err)
+	} else {
+		for _, cache := range caches {
+			h.storage.Remove(cache.ID)
+			if err := h.engine.Exec(func(sess *xorm.Session) error {
+				_, err := sess.Delete(cache)
+				return err
+			}); err != nil {
+				logger.Warnf("delete cache: %v", err)
+				continue
+			}
+			logger.Infof("deleted cache: %+v", cache)
+		}
+	}
+
+	caches = caches[:0]
+	if err := h.engine.Exec(func(sess *xorm.Session) error {
+		return sess.Where(builder.Lt{"created_at": time.Now().Add(-keepUsed).Unix()}).
+			Find(&caches)
+	}); err != nil {
+		logger.Warnf("find caches: %v", err)
+	} else {
+		for _, cache := range caches {
+			h.storage.Remove(cache.ID)
+			if err := h.engine.Exec(func(sess *xorm.Session) error {
+				_, err := sess.Delete(cache)
+				return err
+			}); err != nil {
+				logger.Warnf("delete cache: %v", err)
+				continue
+			}
+			logger.Infof("deleted cache: %+v", cache)
+		}
+	}
+}
--- a/artifactcache/model.go
+++ b/artifactcache/model.go
@ -0,0 +1,30 @@
+// Copyright 2023 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package artifactcache
+
+import (
+	"fmt"
+	"net/http"
+)
+
+type Cache struct {
+	ID        int64  `xorm:"id pk autoincr" json:"-"`
+	Key       string `xorm:"TEXT index unique(key_version)" json:"key"`
+	Version   string `xorm:"TEXT unique(key_version)" json:"version"`
+	Size      int64  `json:"cacheSize"`
+	Complete  bool   `xorm:"index(complete_used_at)" json:"-"`
+	UsedAt    int64  `xorm:"index(complete_used_at) updated" json:"-"`
+	CreatedAt int64  `xorm:"index created" json:"-"`
+}
+
+// Bind implements render.Binder
+func (c *Cache) Bind(_ *http.Request) error {
+	if c.Key == "" {
+		return fmt.Errorf("missing key")
+	}
+	if c.Version == "" {
+		return fmt.Errorf("missing version")
+	}
+	return nil
+}
--- a/artifactcache/storage.go
+++ b/artifactcache/storage.go
@ -0,0 +1,129 @@
+// Copyright 2023 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package artifactcache
+
+import (
+	"fmt"
+	"io"
+	"net/http"
+	"os"
+	"path/filepath"
+)
+
+type Storage struct {
+	rootDir string
+}
+
+func NewStorage(rootDir string) (*Storage, error) {
+	if err := os.MkdirAll(rootDir, 0o755); err != nil {
+		return nil, err
+	}
+	return &Storage{
+		rootDir: rootDir,
+	}, nil
+}
+
+func (s *Storage) Exist(id int64) (bool, error) {
+	name := s.filename(id)
+	if _, err := os.Stat(name); os.IsNotExist(err) {
+		return false, nil
+	} else if err != nil {
+		return false, err
+	}
+	return true, nil
+}
+
+func (s *Storage) Write(id int64, offset int64, reader io.Reader) error {
+	name := s.tempName(id, offset)
+	if err := os.MkdirAll(filepath.Dir(name), 0o755); err != nil {
+		return err
+	}
+	file, err := os.Create(name)
+	if err != nil {
+		return err
+	}
+	defer file.Close()
+
+	_, err = io.Copy(file, reader)
+	return err
+}
+
+func (s *Storage) Commit(id int64, size int64) error {
+	defer func() {
+		_ = os.RemoveAll(s.tempDir(id))
+	}()
+
+	name := s.filename(id)
+	tempNames, err := s.tempNames(id)
+	if err != nil {
+		return err
+	}
+
+	if err := os.MkdirAll(filepath.Dir(name), 0o755); err != nil {
+		return err
+	}
+	file, err := os.Create(name)
+	if err != nil {
+		return err
+	}
+	defer file.Close()
+
+	var written int64
+	for _, v := range tempNames {
+		f, err := os.Open(v)
+		if err != nil {
+			return err
+		}
+		n, err := io.Copy(file, f)
+		_ = f.Close()
+		if err != nil {
+			return err
+		}
+		written += n
+	}
+
+	if written != size {
+		_ = file.Close()
+		_ = os.Remove(name)
+		return fmt.Errorf("broken file: %v != %v", written, size)
+	}
+	return nil
+}
+
+func (s *Storage) Serve(w http.ResponseWriter, r *http.Request, id int64) {
+	name := s.filename(id)
+	http.ServeFile(w, r, name)
+}
+
+func (s *Storage) Remove(id int64) {
+	_ = os.Remove(s.filename(id))
+	_ = os.RemoveAll(s.tempDir(id))
+}
+
+func (s *Storage) filename(id int64) string {
+	return filepath.Join(s.rootDir, fmt.Sprintf("%02x", id%0xff), fmt.Sprint(id))
+}
+
+func (s *Storage) tempDir(id int64) string {
+	return filepath.Join(s.rootDir, "tmp", fmt.Sprint(id))
+}
+
+func (s *Storage) tempName(id, offset int64) string {
+	return filepath.Join(s.tempDir(id), fmt.Sprintf("%016x", offset))
+}
+
+func (s *Storage) tempNames(id int64) ([]string, error) {
+	dir := s.tempDir(id)
+	files, err := os.ReadDir(dir)
+	if err != nil {
+		return nil, err
+	}
+	var names []string
+	for _, v := range files {
+		if !v.IsDir() {
+			names = append(names, filepath.Join(dir, v.Name()))
+		}
+	}
+	return names, nil
+}
--- a/artifactcache/util.go
+++ b/artifactcache/util.go
@ -0,0 +1,100 @@
+// Copyright 2023 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package artifactcache
+
+import (
+	"fmt"
+	"net"
+	"net/http"
+	"strconv"
+	"strings"
+	"sync"
+
+	"github.com/go-chi/render"
+	"xorm.io/xorm"
+)
+
+func responseJson(w http.ResponseWriter, r *http.Request, code int, v ...any) {
+	render.Status(r, code)
+	if len(v) == 0 || v[0] == nil {
+		render.JSON(w, r, struct{}{})
+	} else if err, ok := v[0].(error); ok {
+		logger.Errorf("%v %v: %v", r.Method, r.RequestURI, err)
+		render.JSON(w, r, map[string]any{
+			"error": err.Error(),
+		})
+	} else {
+		render.JSON(w, r, v[0])
+	}
+}
+
+func parseContentRange(s string) (int64, int64, error) {
+	// support the format like "bytes 11-22/*" only
+	s, _, _ = strings.Cut(strings.TrimPrefix(s, "bytes "), "/")
+	s1, s2, _ := strings.Cut(s, "-")
+
+	start, err := strconv.ParseInt(s1, 10, 64)
+	if err != nil {
+		return 0, 0, fmt.Errorf("parse %q: %w", s, err)
+	}
+	stop, err := strconv.ParseInt(s2, 10, 64)
+	if err != nil {
+		return 0, 0, fmt.Errorf("parse %q: %w", s, err)
+	}
+	return start, stop, nil
+}
+
+func getOutboundIP() (net.IP, error) {
+	// FIXME: It makes more sense to use the gateway IP address of container network
+	if conn, err := net.Dial("udp", "8.8.8.8:80"); err == nil {
+		defer conn.Close()
+		return conn.LocalAddr().(*net.UDPAddr).IP, nil
+	}
+	if ifaces, err := net.Interfaces(); err == nil {
+		for _, i := range ifaces {
+			if addrs, err := i.Addrs(); err == nil {
+				for _, addr := range addrs {
+					var ip net.IP
+					switch v := addr.(type) {
+					case *net.IPNet:
+						ip = v.IP
+					case *net.IPAddr:
+						ip = v.IP
+					}
+					if ip.IsGlobalUnicast() {
+						return ip, nil
+					}
+				}
+			}
+		}
+	}
+	return nil, fmt.Errorf("no outbound IP address found")
+}
+
+// engine is a wrapper of *xorm.Engine, with a lock.
+// To avoid racing of sqlite, we don't care performance here.
+type engine struct {
+	e *xorm.Engine
+	m sync.Mutex
+}
+
+func (e *engine) Exec(f func(*xorm.Session) error) error {
+	e.m.Lock()
+	defer e.m.Unlock()
+
+	sess := e.e.NewSession()
+	defer sess.Close()
+
+	return f(sess)
+}
+
+func (e *engine) ExecBool(f func(*xorm.Session) (bool, error)) (bool, error) {
+	e.m.Lock()
+	defer e.m.Unlock()
+
+	sess := e.e.NewSession()
+	defer sess.Close()
+
+	return f(sess)
+}
--- a/build.go
+++ b/build.go
@ -0,0 +1,11 @@
+// Copyright 2023 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+//go:build vendor
+
+package main
+
+import (
+	// for vet
+	_ "code.gitea.io/gitea-vet"
+)
--- a/client/header.go
+++ b/client/header.go
@ -0,0 +1,10 @@
+// Copyright 2023 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package client
+
+const (
+	UUIDHeader    = "x-runner-uuid"
+	TokenHeader   = "x-runner-token"
+	VersionHeader = "x-runner-version"
+)
--- a/client/http.go
+++ b/client/http.go
@ -8,7 +8,6 @@ import (

 	"code.gitea.io/actions-proto-go/ping/v1/pingv1connect"
 	"code.gitea.io/actions-proto-go/runner/v1/runnerv1connect"
-	"gitea.com/gitea/act_runner/core"
 	"github.com/bufbuild/connect-go"
 )

@ -26,16 +25,19 @@ func getHttpClient(endpoint string, insecure bool) *http.Client {
 }

 // New returns a new runner client.
-func New(endpoint string, insecure bool, uuid, token string, opts ...connect.ClientOption) *HTTPClient {
+func New(endpoint string, insecure bool, uuid, token, runnerVersion string, opts ...connect.ClientOption) *HTTPClient {
 	baseURL := strings.TrimRight(endpoint, "/") + "/api/actions"

 	opts = append(opts, connect.WithInterceptors(connect.UnaryInterceptorFunc(func(next connect.UnaryFunc) connect.UnaryFunc {
 		return func(ctx context.Context, req connect.AnyRequest) (connect.AnyResponse, error) {
 			if uuid != "" {
-				req.Header().Set(core.UUIDHeader, uuid)
+				req.Header().Set(UUIDHeader, uuid)
 			}
 			if token != "" {
-				req.Header().Set(core.TokenHeader, token)
+				req.Header().Set(TokenHeader, token)
+			}
+			if runnerVersion != "" {
+				req.Header().Set(VersionHeader, runnerVersion)
 			}
 			return next(ctx, req)
 		}
--- a/cmd/cmd.go
+++ b/cmd/cmd.go
@ -1,32 +1,30 @@
+// SPDX-License-Identifier: MIT
 package cmd

 import (
 	"context"
+	"fmt"
 	"os"

 	"github.com/spf13/cobra"
+
+	"codeberg.org/forgejo/runner/config"
 )

-const version = "0.1.5"
-
-type globalArgs struct {
-	EnvFile string
-}
+// the version of act_runner
+var version = "develop"

 func Execute(ctx context.Context) {
-	// task := runtime.NewTask("gitea", 0, nil, nil)
-
-	var gArgs globalArgs
-
 	// ./act_runner
 	rootCmd := &cobra.Command{
-		Use:          "act [event name to run]\nIf no event name passed, will default to \"on: push\"",
+		Use:          "act_runner [event name to run]\nIf no event name passed, will default to \"on: push\"",
 		Short:        "Run GitHub actions locally by specifying the event name (e.g. `push`) or an action name directly.",
 		Args:         cobra.MaximumNArgs(1),
 		Version:      version,
 		SilenceUsage: true,
 	}
-	rootCmd.PersistentFlags().StringVarP(&gArgs.EnvFile, "env-file", "", ".env", "Read in a file of environment variables.")
+	configFile := ""
+	rootCmd.PersistentFlags().StringVarP(&configFile, "config", "c", "", "Config file path")

 	// ./act_runner register
 	var regArgs registerArgs
@ -34,11 +32,10 @@ func Execute(ctx context.Context) {
 		Use:   "register",
 		Short: "Register a runner to the server",
 		Args:  cobra.MaximumNArgs(0),
-		RunE:  runRegister(ctx, &regArgs, gArgs.EnvFile), // must use a pointer to regArgs
+		RunE:  runRegister(ctx, &regArgs, &configFile), // must use a pointer to regArgs
 	}
 	registerCmd.Flags().BoolVar(&regArgs.NoInteractive, "no-interactive", false, "Disable interactive mode")
-	registerCmd.Flags().StringVar(&regArgs.InstanceAddr, "instance", "", "Gitea instance address")
-	registerCmd.Flags().BoolVar(&regArgs.Insecure, "insecure", false, "If check server's certificate if it's https protocol")
+	registerCmd.Flags().StringVar(&regArgs.InstanceAddr, "instance", "", "Forgejo instance address")
 	registerCmd.Flags().StringVar(&regArgs.Token, "token", "", "Runner token")
 	registerCmd.Flags().StringVar(&regArgs.RunnerName, "name", "", "Runner name")
 	registerCmd.Flags().StringVar(&regArgs.Labels, "labels", "", "Runner tags, comma separated")
@ -49,11 +46,23 @@ func Execute(ctx context.Context) {
 		Use:   "daemon",
 		Short: "Run as a runner daemon",
 		Args:  cobra.MaximumNArgs(1),
-		RunE:  runDaemon(ctx, gArgs.EnvFile),
+		RunE:  runDaemon(ctx, &configFile),
 	}
-	// add all command
 	rootCmd.AddCommand(daemonCmd)

+	// ./act_runner exec
+	rootCmd.AddCommand(loadExecCmd(ctx))
+
+	// ./act_runner config
+	rootCmd.AddCommand(&cobra.Command{
+		Use:   "generate-config",
+		Short: "Generate an example config file",
+		Args:  cobra.MaximumNArgs(0),
+		Run: func(_ *cobra.Command, _ []string) {
+			fmt.Printf("%s", config.Example)
+		},
+	})
+
 	// hide completion command
 	rootCmd.CompletionOptions.HiddenDefaultCmd = true

--- a/cmd/daemon.go
+++ b/cmd/daemon.go
@ -2,40 +2,46 @@ package cmd

 import (
 	"context"
+	"fmt"
 	"os"
-	"strings"

-	"gitea.com/gitea/act_runner/client"
-	"gitea.com/gitea/act_runner/config"
-	"gitea.com/gitea/act_runner/engine"
-	"gitea.com/gitea/act_runner/poller"
-	"gitea.com/gitea/act_runner/runtime"
-
-	"github.com/joho/godotenv"
 	"github.com/mattn/go-isatty"
 	log "github.com/sirupsen/logrus"
 	"github.com/spf13/cobra"
 	"golang.org/x/sync/errgroup"
+
+	"codeberg.org/forgejo/runner/artifactcache"
+	"codeberg.org/forgejo/runner/client"
+	"codeberg.org/forgejo/runner/config"
+	"codeberg.org/forgejo/runner/engine"
+	"codeberg.org/forgejo/runner/poller"
+	"codeberg.org/forgejo/runner/runtime"
 )

-func runDaemon(ctx context.Context, envFile string) func(cmd *cobra.Command, args []string) error {
+func runDaemon(ctx context.Context, configFile *string) func(cmd *cobra.Command, args []string) error {
 	return func(cmd *cobra.Command, args []string) error {
 		log.Infoln("Starting runner daemon")

-		_ = godotenv.Load(envFile)
-		cfg, err := config.FromEnviron()
+		cfg, err := config.LoadDefault(*configFile)
 		if err != nil {
-			log.WithError(err).
-				Fatalln("invalid configuration")
+			return fmt.Errorf("invalid configuration: %w", err)
 		}

 		initLogging(cfg)

+		reg, err := config.LoadRegistration(cfg.Runner.File)
+		if os.IsNotExist(err) {
+			log.Error("registration file not found, please register the runner first")
+			return err
+		} else if err != nil {
+			return fmt.Errorf("failed to load registration file: %w", err)
+		}
+
 		// require docker if a runner label uses a docker backend
 		needsDocker := false
-		for _, l := range cfg.Runner.Labels {
-			splits := strings.SplitN(l, ":", 2)
-			if len(splits) == 2 && strings.HasPrefix(splits[1], "docker://") {
+		for _, l := range reg.Labels {
+			_, schema, _, _ := runtime.ParseLabel(l)
+			if schema == "docker" {
 				needsDocker = true
 				break
 			}
@ -52,31 +58,49 @@ func runDaemon(ctx context.Context, envFile string) func(cmd *cobra.Command, arg
 		var g errgroup.Group

 		cli := client.New(
-			cfg.Client.Address,
-			cfg.Client.Insecure,
-			cfg.Runner.UUID,
-			cfg.Runner.Token,
+			reg.Address,
+			cfg.Runner.Insecure,
+			reg.UUID,
+			reg.Token,
+			version,
 		)

+		if cfg.Runner.Envs == nil {
+			cfg.Runner.Envs = make(map[string]string, 10)
+		}
+
+		if _, ok := cfg.Runner.Envs["GITHUB_SERVER_URL"]; !ok {
+			cfg.Runner.Envs["GITHUB_SERVER_URL"] = reg.Address
+		}
+
 		runner := &runtime.Runner{
 			Client:        cli,
-			Machine:       cfg.Runner.Name,
-			ForgeInstance: cfg.Client.Address,
-			Environ:       cfg.Runner.Environ,
-			Labels:        cfg.Runner.Labels,
+			Machine:       reg.Name,
+			ForgeInstance: reg.Address,
+			Environ:       cfg.Runner.Envs,
+			Labels:        reg.Labels,
+			Network:       cfg.Container.Network,
+			Version:       version,
+		}
+
+		if *cfg.Cache.Enabled {
+			if handler, err := artifactcache.NewHandler(cfg.Cache.Dir, cfg.Cache.Host, cfg.Cache.Port); err != nil {
+				log.Errorf("cannot init cache server, it will be disabled: %v", err)
+			} else {
+				log.Infof("cache handler listens on: %v", handler.ExternalURL())
+				runner.CacheHandler = handler
+			}
 		}

 		poller := poller.New(
 			cli,
 			runner.Run,
-			cfg.Runner.Capacity,
+			cfg,
 		)

 		g.Go(func() error {
 			l := log.WithField("capacity", cfg.Runner.Capacity).
-				WithField("endpoint", cfg.Client.Address).
-				WithField("os", cfg.Platform.OS).
-				WithField("arch", cfg.Platform.Arch)
+				WithField("endpoint", reg.Address)
 			l.Infoln("polling the remote server")

 			if err := poller.Poll(ctx); err != nil {
@ -96,17 +120,22 @@ func runDaemon(ctx context.Context, envFile string) func(cmd *cobra.Command, arg
 }

 // initLogging setup the global logrus logger.
-func initLogging(cfg config.Config) {
+func initLogging(cfg *config.Config) {
 	isTerm := isatty.IsTerminal(os.Stdout.Fd())
 	log.SetFormatter(&log.TextFormatter{
 		DisableColors: !isTerm,
 		FullTimestamp: true,
 	})

-	if cfg.Debug {
-		log.SetLevel(log.DebugLevel)
-	}
-	if cfg.Trace {
-		log.SetLevel(log.TraceLevel)
+	if l := cfg.Log.Level; l != "" {
+		level, err := log.ParseLevel(l)
+		if err != nil {
+			log.WithError(err).
+				Errorf("invalid log level: %q", l)
+		}
+		if log.GetLevel() != level {
+			log.Infof("log level changed to %v", level)
+			log.SetLevel(level)
+		}
 	}
 }
--- a/cmd/exec.go
+++ b/cmd/exec.go
@ -0,0 +1,468 @@
+// Copyright 2023 The Gitea Authors. All rights reserved.
+// Copyright 2019 nektos
+// SPDX-License-Identifier: MIT
+
+package cmd
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/joho/godotenv"
+	"github.com/nektos/act/pkg/artifacts"
+	"github.com/nektos/act/pkg/common"
+	"github.com/nektos/act/pkg/model"
+	"github.com/nektos/act/pkg/runner"
+	log "github.com/sirupsen/logrus"
+	"github.com/spf13/cobra"
+	"golang.org/x/term"
+
+	"codeberg.org/forgejo/runner/artifactcache"
+)
+
+type executeArgs struct {
+	runList               bool
+	job                   string
+	event                 string
+	workdir               string
+	workflowsPath         string
+	noWorkflowRecurse     bool
+	autodetectEvent       bool
+	forcePull             bool
+	forceRebuild          bool
+	jsonLogger            bool
+	envs                  []string
+	envfile               string
+	secrets               []string
+	defaultActionsUrl     string
+	insecureSecrets       bool
+	privileged            bool
+	usernsMode            string
+	containerArchitecture string
+	containerDaemonSocket string
+	useGitIgnore          bool
+	containerCapAdd       []string
+	containerCapDrop      []string
+	artifactServerPath    string
+	artifactServerAddr    string
+	artifactServerPort    string
+	noSkipCheckout        bool
+	debug                 bool
+	dryrun                bool
+	image                 string
+	cacheHandler          *artifactcache.Handler
+}
+
+// WorkflowsPath returns path to workflow file(s)
+func (i *executeArgs) WorkflowsPath() string {
+	return i.resolve(i.workflowsPath)
+}
+
+// Envfile returns path to .env
+func (i *executeArgs) Envfile() string {
+	return i.resolve(i.envfile)
+}
+
+func (i *executeArgs) LoadSecrets() map[string]string {
+	s := make(map[string]string)
+	for _, secretPair := range i.secrets {
+		secretPairParts := strings.SplitN(secretPair, "=", 2)
+		secretPairParts[0] = strings.ToUpper(secretPairParts[0])
+		if strings.ToUpper(s[secretPairParts[0]]) == secretPairParts[0] {
+			log.Errorf("Secret %s is already defined (secrets are case insensitive)", secretPairParts[0])
+		}
+		if len(secretPairParts) == 2 {
+			s[secretPairParts[0]] = secretPairParts[1]
+		} else if env, ok := os.LookupEnv(secretPairParts[0]); ok && env != "" {
+			s[secretPairParts[0]] = env
+		} else {
+			fmt.Printf("Provide value for '%s': ", secretPairParts[0])
+			val, err := term.ReadPassword(int(os.Stdin.Fd()))
+			fmt.Println()
+			if err != nil {
+				log.Errorf("failed to read input: %v", err)
+				os.Exit(1)
+			}
+			s[secretPairParts[0]] = string(val)
+		}
+	}
+	return s
+}
+
+func readEnvs(path string, envs map[string]string) bool {
+	if _, err := os.Stat(path); err == nil {
+		env, err := godotenv.Read(path)
+		if err != nil {
+			log.Fatalf("Error loading from %s: %v", path, err)
+		}
+		for k, v := range env {
+			envs[k] = v
+		}
+		return true
+	}
+	return false
+}
+
+func (i *executeArgs) LoadEnvs() map[string]string {
+	envs := make(map[string]string)
+	if i.envs != nil {
+		for _, envVar := range i.envs {
+			e := strings.SplitN(envVar, `=`, 2)
+			if len(e) == 2 {
+				envs[e[0]] = e[1]
+			} else {
+				envs[e[0]] = ""
+			}
+		}
+	}
+	_ = readEnvs(i.Envfile(), envs)
+
+	envs["ACTIONS_CACHE_URL"] = i.cacheHandler.ExternalURL() + "/"
+
+	return envs
+}
+
+// Workdir returns path to workdir
+func (i *executeArgs) Workdir() string {
+	return i.resolve(".")
+}
+
+func (i *executeArgs) resolve(path string) string {
+	basedir, err := filepath.Abs(i.workdir)
+	if err != nil {
+		log.Fatal(err)
+	}
+	if path == "" {
+		return path
+	}
+	if !filepath.IsAbs(path) {
+		path = filepath.Join(basedir, path)
+	}
+	return path
+}
+
+func printList(plan *model.Plan) error {
+	type lineInfoDef struct {
+		jobID   string
+		jobName string
+		stage   string
+		wfName  string
+		wfFile  string
+		events  string
+	}
+	lineInfos := []lineInfoDef{}
+
+	header := lineInfoDef{
+		jobID:   "Job ID",
+		jobName: "Job name",
+		stage:   "Stage",
+		wfName:  "Workflow name",
+		wfFile:  "Workflow file",
+		events:  "Events",
+	}
+
+	jobs := map[string]bool{}
+	duplicateJobIDs := false
+
+	jobIDMaxWidth := len(header.jobID)
+	jobNameMaxWidth := len(header.jobName)
+	stageMaxWidth := len(header.stage)
+	wfNameMaxWidth := len(header.wfName)
+	wfFileMaxWidth := len(header.wfFile)
+	eventsMaxWidth := len(header.events)
+
+	for i, stage := range plan.Stages {
+		for _, r := range stage.Runs {
+			jobID := r.JobID
+			line := lineInfoDef{
+				jobID:   jobID,
+				jobName: r.String(),
+				stage:   strconv.Itoa(i),
+				wfName:  r.Workflow.Name,
+				wfFile:  r.Workflow.File,
+				events:  strings.Join(r.Workflow.On(), `,`),
+			}
+			if _, ok := jobs[jobID]; ok {
+				duplicateJobIDs = true
+			} else {
+				jobs[jobID] = true
+			}
+			lineInfos = append(lineInfos, line)
+			if jobIDMaxWidth < len(line.jobID) {
+				jobIDMaxWidth = len(line.jobID)
+			}
+			if jobNameMaxWidth < len(line.jobName) {
+				jobNameMaxWidth = len(line.jobName)
+			}
+			if stageMaxWidth < len(line.stage) {
+				stageMaxWidth = len(line.stage)
+			}
+			if wfNameMaxWidth < len(line.wfName) {
+				wfNameMaxWidth = len(line.wfName)
+			}
+			if wfFileMaxWidth < len(line.wfFile) {
+				wfFileMaxWidth = len(line.wfFile)
+			}
+			if eventsMaxWidth < len(line.events) {
+				eventsMaxWidth = len(line.events)
+			}
+		}
+	}
+
+	jobIDMaxWidth += 2
+	jobNameMaxWidth += 2
+	stageMaxWidth += 2
+	wfNameMaxWidth += 2
+	wfFileMaxWidth += 2
+
+	fmt.Printf("%*s%*s%*s%*s%*s%*s\n",
+		-stageMaxWidth, header.stage,
+		-jobIDMaxWidth, header.jobID,
+		-jobNameMaxWidth, header.jobName,
+		-wfNameMaxWidth, header.wfName,
+		-wfFileMaxWidth, header.wfFile,
+		-eventsMaxWidth, header.events,
+	)
+	for _, line := range lineInfos {
+		fmt.Printf("%*s%*s%*s%*s%*s%*s\n",
+			-stageMaxWidth, line.stage,
+			-jobIDMaxWidth, line.jobID,
+			-jobNameMaxWidth, line.jobName,
+			-wfNameMaxWidth, line.wfName,
+			-wfFileMaxWidth, line.wfFile,
+			-eventsMaxWidth, line.events,
+		)
+	}
+	if duplicateJobIDs {
+		fmt.Print("\nDetected multiple jobs with the same job name, use `-W` to specify the path to the specific workflow.\n")
+	}
+	return nil
+}
+
+func runExecList(ctx context.Context, planner model.WorkflowPlanner, execArgs *executeArgs) error {
+	// plan with filtered jobs - to be used for filtering only
+	var filterPlan *model.Plan
+
+	// Determine the event name to be filtered
+	var filterEventName string = ""
+
+	if len(execArgs.event) > 0 {
+		log.Infof("Using chosed event for filtering: %s", execArgs.event)
+		filterEventName = execArgs.event
+	} else if execArgs.autodetectEvent {
+		// collect all events from loaded workflows
+		events := planner.GetEvents()
+
+		// set default event type to first event from many available
+		// this way user dont have to specify the event.
+		log.Infof("Using first detected workflow event for filtering: %s", events[0])
+
+		filterEventName = events[0]
+	}
+
+	var err error
+	if execArgs.job != "" {
+		log.Infof("Preparing plan with a job: %s", execArgs.job)
+		filterPlan, err = planner.PlanJob(execArgs.job)
+		if err != nil {
+			return err
+		}
+	} else if filterEventName != "" {
+		log.Infof("Preparing plan for a event: %s", filterEventName)
+		filterPlan, err = planner.PlanEvent(filterEventName)
+		if err != nil {
+			return err
+		}
+	} else {
+		log.Infof("Preparing plan with all jobs")
+		filterPlan, err = planner.PlanAll()
+		if err != nil {
+			return err
+		}
+	}
+
+	printList(filterPlan)
+
+	return nil
+}
+
+func runExec(ctx context.Context, execArgs *executeArgs) func(cmd *cobra.Command, args []string) error {
+	return func(cmd *cobra.Command, args []string) error {
+		planner, err := model.NewWorkflowPlanner(execArgs.WorkflowsPath(), execArgs.noWorkflowRecurse)
+		if err != nil {
+			return err
+		}
+
+		if execArgs.runList {
+			return runExecList(ctx, planner, execArgs)
+		}
+
+		// plan with triggered jobs
+		var plan *model.Plan
+
+		// Determine the event name to be triggered
+		var eventName string
+
+		// collect all events from loaded workflows
+		events := planner.GetEvents()
+
+		if len(execArgs.event) > 0 {
+			log.Infof("Using chosed event for filtering: %s", execArgs.event)
+			eventName = args[0]
+		} else if len(events) == 1 && len(events[0]) > 0 {
+			log.Infof("Using the only detected workflow event: %s", events[0])
+			eventName = events[0]
+		} else if execArgs.autodetectEvent && len(events) > 0 && len(events[0]) > 0 {
+			// set default event type to first event from many available
+			// this way user dont have to specify the event.
+			log.Infof("Using first detected workflow event: %s", events[0])
+			eventName = events[0]
+		} else {
+			log.Infof("Using default workflow event: push")
+			eventName = "push"
+		}
+
+		// build the plan for this run
+		if execArgs.job != "" {
+			log.Infof("Planning job: %s", execArgs.job)
+			plan, err = planner.PlanJob(execArgs.job)
+			if err != nil {
+				return err
+			}
+		} else {
+			log.Infof("Planning jobs for event: %s", eventName)
+			plan, err = planner.PlanEvent(eventName)
+			if err != nil {
+				return err
+			}
+		}
+
+		maxLifetime := 3 * time.Hour
+		if deadline, ok := ctx.Deadline(); ok {
+			maxLifetime = time.Until(deadline)
+		}
+
+		// init a cache server
+		handler, err := artifactcache.NewHandler("", "", 0)
+		if err != nil {
+			return err
+		}
+		log.Infof("cache handler listens on: %v", handler.ExternalURL())
+		execArgs.cacheHandler = handler
+
+		// run the plan
+		config := &runner.Config{
+			Workdir:               execArgs.Workdir(),
+			BindWorkdir:           false,
+			ReuseContainers:       false,
+			ForcePull:             execArgs.forcePull,
+			ForceRebuild:          execArgs.forceRebuild,
+			LogOutput:             true,
+			JSONLogger:            execArgs.jsonLogger,
+			Env:                   execArgs.LoadEnvs(),
+			Secrets:               execArgs.LoadSecrets(),
+			InsecureSecrets:       execArgs.insecureSecrets,
+			Privileged:            execArgs.privileged,
+			UsernsMode:            execArgs.usernsMode,
+			ContainerArchitecture: execArgs.containerArchitecture,
+			ContainerDaemonSocket: execArgs.containerDaemonSocket,
+			UseGitIgnore:          execArgs.useGitIgnore,
+			// GitHubInstance:        t.client.Address(),
+			ContainerCapAdd:    execArgs.containerCapAdd,
+			ContainerCapDrop:   execArgs.containerCapDrop,
+			AutoRemove:         true,
+			ArtifactServerPath: execArgs.artifactServerPath,
+			ArtifactServerPort: execArgs.artifactServerPort,
+			NoSkipCheckout:     execArgs.noSkipCheckout,
+			// PresetGitHubContext:   preset,
+			// EventJSON:             string(eventJSON),
+			ContainerNamePrefix:   fmt.Sprintf("GITEA-ACTIONS-TASK-%s", eventName),
+			ContainerMaxLifetime:  maxLifetime,
+			ContainerNetworkMode:  "bridge",
+			DefaultActionInstance: execArgs.defaultActionsUrl,
+			PlatformPicker: func(_ []string) string {
+				return execArgs.image
+			},
+		}
+
+		// TODO: handle log level config
+		// waiting https://gitea.com/gitea/act/pulls/19
+		// if !execArgs.debug {
+		// 	logLevel := log.Level(log.InfoLevel)
+		// 	config.JobLoggerLevel = &logLevel
+		// }
+
+		r, err := runner.New(config)
+		if err != nil {
+			return err
+		}
+
+		if len(execArgs.artifactServerPath) == 0 {
+			tempDir, err := os.MkdirTemp("", "gitea-act-")
+			if err != nil {
+				fmt.Println(err)
+			}
+			defer os.RemoveAll(tempDir)
+
+			execArgs.artifactServerPath = tempDir
+		}
+
+		artifactCancel := artifacts.Serve(ctx, execArgs.artifactServerPath, execArgs.artifactServerAddr, execArgs.artifactServerPort)
+		log.Debugf("artifacts server started at %s:%s", execArgs.artifactServerPath, execArgs.artifactServerPort)
+
+		ctx = common.WithDryrun(ctx, execArgs.dryrun)
+		executor := r.NewPlanExecutor(plan).Finally(func(ctx context.Context) error {
+			artifactCancel()
+			return nil
+		})
+
+		return executor(ctx)
+	}
+}
+
+func loadExecCmd(ctx context.Context) *cobra.Command {
+	execArg := executeArgs{}
+
+	execCmd := &cobra.Command{
+		Use:   "exec",
+		Short: "Run workflow locally.",
+		Args:  cobra.MaximumNArgs(20),
+		RunE:  runExec(ctx, &execArg),
+	}
+
+	execCmd.Flags().BoolVarP(&execArg.runList, "list", "l", false, "list workflows")
+	execCmd.Flags().StringVarP(&execArg.job, "job", "j", "", "run a specific job ID")
+	execCmd.Flags().StringVarP(&execArg.event, "event", "E", "", "run a event name")
+	execCmd.PersistentFlags().StringVarP(&execArg.workflowsPath, "workflows", "W", "./.forgejo/workflows/", "path to workflow file(s)")
+	execCmd.PersistentFlags().StringVarP(&execArg.workdir, "directory", "C", ".", "working directory")
+	execCmd.PersistentFlags().BoolVarP(&execArg.noWorkflowRecurse, "no-recurse", "", false, "Flag to disable running workflows from subdirectories of specified path in '--workflows'/'-W' flag")
+	execCmd.Flags().BoolVarP(&execArg.autodetectEvent, "detect-event", "", false, "Use first event type from workflow as event that triggered the workflow")
+	execCmd.Flags().BoolVarP(&execArg.forcePull, "pull", "p", false, "pull docker image(s) even if already present")
+	execCmd.Flags().BoolVarP(&execArg.forceRebuild, "rebuild", "", false, "rebuild local action docker image(s) even if already present")
+	execCmd.PersistentFlags().BoolVar(&execArg.jsonLogger, "json", false, "Output logs in json format")
+	execCmd.Flags().StringArrayVarP(&execArg.envs, "env", "", []string{}, "env to make available to actions with optional value (e.g. --env myenv=foo or --env myenv)")
+	execCmd.PersistentFlags().StringVarP(&execArg.envfile, "env-file", "", ".env", "environment file to read and use as env in the containers")
+	execCmd.Flags().StringArrayVarP(&execArg.secrets, "secret", "s", []string{}, "secret to make available to actions with optional value (e.g. -s mysecret=foo or -s mysecret)")
+	execCmd.PersistentFlags().BoolVarP(&execArg.insecureSecrets, "insecure-secrets", "", false, "NOT RECOMMENDED! Doesn't hide secrets while printing logs.")
+	execCmd.Flags().BoolVar(&execArg.privileged, "privileged", false, "use privileged mode")
+	execCmd.Flags().StringVar(&execArg.usernsMode, "userns", "", "user namespace to use")
+	execCmd.PersistentFlags().StringVarP(&execArg.containerArchitecture, "container-architecture", "", "", "Architecture which should be used to run containers, e.g.: linux/amd64. If not specified, will use host default architecture. Requires Docker server API Version 1.41+. Ignored on earlier Docker server platforms.")
+	execCmd.PersistentFlags().StringVarP(&execArg.containerDaemonSocket, "container-daemon-socket", "", "/var/run/docker.sock", "Path to Docker daemon socket which will be mounted to containers")
+	execCmd.Flags().BoolVar(&execArg.useGitIgnore, "use-gitignore", true, "Controls whether paths specified in .gitignore should be copied into container")
+	execCmd.Flags().StringArrayVarP(&execArg.containerCapAdd, "container-cap-add", "", []string{}, "kernel capabilities to add to the workflow containers (e.g. --container-cap-add SYS_PTRACE)")
+	execCmd.Flags().StringArrayVarP(&execArg.containerCapDrop, "container-cap-drop", "", []string{}, "kernel capabilities to remove from the workflow containers (e.g. --container-cap-drop SYS_PTRACE)")
+	execCmd.PersistentFlags().StringVarP(&execArg.artifactServerPath, "artifact-server-path", "", ".", "Defines the path where the artifact server stores uploads and retrieves downloads from. If not specified the artifact server will not start.")
+	execCmd.PersistentFlags().StringVarP(&execArg.artifactServerPort, "artifact-server-port", "", "34567", "Defines the port where the artifact server listens (will only bind to localhost).")
+	execCmd.PersistentFlags().StringVarP(&execArg.defaultActionsUrl, "default-actions-url", "", "https://code.forgejo.org", "Defines the default url of action instance.")
+	execCmd.PersistentFlags().BoolVarP(&execArg.noSkipCheckout, "no-skip-checkout", "", false, "Do not skip actions/checkout")
+	execCmd.PersistentFlags().BoolVarP(&execArg.debug, "debug", "d", false, "enable debug log")
+	execCmd.PersistentFlags().BoolVarP(&execArg.dryrun, "dryrun", "n", false, "dryrun mode")
+	execCmd.PersistentFlags().StringVarP(&execArg.image, "image", "i", "node:16-bullseye", "docker image to use")
+
+	return execCmd
+}
--- a/cmd/register.go
+++ b/cmd/register.go
@ -1,3 +1,6 @@
+// Copyright 2022 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
 package cmd

 import (
@ -6,24 +9,25 @@ import (
 	"fmt"
 	"os"
 	"os/signal"
-	"runtime"
+	goruntime "runtime"
 	"strings"
 	"time"

 	pingv1 "code.gitea.io/actions-proto-go/ping/v1"
-	"gitea.com/gitea/act_runner/client"
-	"gitea.com/gitea/act_runner/config"
-	"gitea.com/gitea/act_runner/register"
+	runnerv1 "code.gitea.io/actions-proto-go/runner/v1"
+
+	"codeberg.org/forgejo/runner/client"
+	"codeberg.org/forgejo/runner/config"
+	"codeberg.org/forgejo/runner/runtime"

 	"github.com/bufbuild/connect-go"
-	"github.com/joho/godotenv"
 	"github.com/mattn/go-isatty"
 	log "github.com/sirupsen/logrus"
 	"github.com/spf13/cobra"
 )

 // runRegister registers a runner to the server
-func runRegister(ctx context.Context, regArgs *registerArgs, envFile string) func(*cobra.Command, []string) error {
+func runRegister(ctx context.Context, regArgs *registerArgs, configFile *string) func(*cobra.Command, []string) error {
 	return func(cmd *cobra.Command, args []string) error {
 		log.SetReportCaller(false)
 		isTerm := isatty.IsTerminal(os.Stdout.Fd())
@ -34,7 +38,7 @@ func runRegister(ctx context.Context, regArgs *registerArgs, envFile string) fun
 		log.SetLevel(log.DebugLevel)

 		log.Infof("Registering runner, arch=%s, os=%s, version=%s.",
-			runtime.GOARCH, runtime.GOOS, version)
+			goruntime.GOARCH, goruntime.GOOS, version)

 		// runner always needs root permission
 		if os.Getuid() != 0 {
@ -43,14 +47,13 @@ func runRegister(ctx context.Context, regArgs *registerArgs, envFile string) fun
 		}

 		if regArgs.NoInteractive {
-			if err := registerNoInteractive(envFile, regArgs); err != nil {
+			if err := registerNoInteractive(*configFile, regArgs); err != nil {
 				return err
 			}
 		} else {
 			go func() {
-				if err := registerInteractive(envFile); err != nil {
-					// log.Errorln(err)
-					os.Exit(2)
+				if err := registerInteractive(*configFile); err != nil {
+					log.Fatal(err)
 					return
 				}
 				os.Exit(0)
@ -69,7 +72,6 @@ func runRegister(ctx context.Context, regArgs *registerArgs, envFile string) fun
 type registerArgs struct {
 	NoInteractive bool
 	InstanceAddr  string
-	Insecure      bool
 	Token         string
 	RunnerName    string
 	Labels        string
@ -97,7 +99,6 @@ var defaultLabels = []string{

 type registerInputs struct {
 	InstanceAddr string
-	Insecure     bool
 	Token        string
 	RunnerName   string
 	CustomLabels []string
@ -118,12 +119,9 @@ func (r *registerInputs) validate() error {

 func validateLabels(labels []string) error {
 	for _, label := range labels {
-		values := strings.SplitN(label, ":", 2)
-		if len(values) > 2 {
-			return fmt.Errorf("Invalid label: %s", label)
+		if _, _, _, err := runtime.ParseLabel(label); err != nil {
+			return err
 		}
-		// len(values) == 1, label for non docker execution environment
-		// TODO: validate value format, like docker://node:16-buster
 	}
 	return nil
 }
@ -164,7 +162,7 @@ func (r *registerInputs) assignToNext(stage registerStage, value string) registe
 		}

 		if validateLabels(r.CustomLabels) != nil {
-			log.Infoln("Invalid labels, please input again, leave blank to use the default labels (for example, ubuntu-20.04:docker://node:16-bullseye,ubuntu-18.04:docker://node:16-buster)")
+			log.Infoln("Invalid labels, please input again, leave blank to use the default labels (for example, ubuntu-20.04:docker://node:16-bullseye,ubuntu-18.04:docker://node:16-buster,linux_arm:host)")
 			return StageInputCustomLabels
 		}
 		return StageWaitingForRegistration
@ -172,16 +170,17 @@ func (r *registerInputs) assignToNext(stage registerStage, value string) registe
 	return StageUnknown
 }

-func registerInteractive(envFile string) error {
+func registerInteractive(configFile string) error {
 	var (
 		reader = bufio.NewReader(os.Stdin)
 		stage  = StageInputInstance
 		inputs = new(registerInputs)
 	)

-	// check if overwrite local config
-	_ = godotenv.Load(envFile)
-	cfg, _ := config.FromEnviron()
+	cfg, err := config.LoadDefault(configFile)
+	if err != nil {
+		return fmt.Errorf("failed to load config: %v", err)
+	}
 	if f, err := os.Stat(cfg.Runner.File); err == nil && !f.IsDir() {
 		stage = StageOverwriteLocalConfig
 	}
@ -197,7 +196,7 @@ func registerInteractive(envFile string) error {

 		if stage == StageWaitingForRegistration {
 			log.Infof("Registering runner, name=%s, instance=%s, labels=%v.", inputs.RunnerName, inputs.InstanceAddr, inputs.CustomLabels)
-			if err := doRegister(&cfg, inputs); err != nil {
+			if err := doRegister(cfg, inputs); err != nil {
 				log.Errorf("Failed to register runner: %v", err)
 			} else {
 				log.Infof("Runner registered successfully.")
@ -226,20 +225,21 @@ func printStageHelp(stage registerStage) {
 		log.Infoln("Enter the runner token:")
 	case StageInputRunnerName:
 		hostname, _ := os.Hostname()
-		log.Infof("Enter the runner name (if set empty, use hostname:%s ):\n", hostname)
+		log.Infof("Enter the runner name (if set empty, use hostname: %s):\n", hostname)
 	case StageInputCustomLabels:
-		log.Infoln("Enter the runner labels, leave blank to use the default labels (comma-separated, for example, self-hosted,ubuntu-20.04:docker://node:16-bullseye,ubuntu-18.04:docker://node:16-buster):")
+		log.Infoln("Enter the runner labels, leave blank to use the default labels (comma-separated, for example, ubuntu-20.04:docker://node:16-bullseye,ubuntu-18.04:docker://node:16-buster,linux_arm:host):")
 	case StageWaitingForRegistration:
 		log.Infoln("Waiting for registration...")
 	}
 }

-func registerNoInteractive(envFile string, regArgs *registerArgs) error {
-	_ = godotenv.Load(envFile)
-	cfg, _ := config.FromEnviron()
+func registerNoInteractive(configFile string, regArgs *registerArgs) error {
+	cfg, err := config.LoadDefault(configFile)
+	if err != nil {
+		return err
+	}
 	inputs := &registerInputs{
 		InstanceAddr: regArgs.InstanceAddr,
-		Insecure:     regArgs.Insecure,
 		Token:        regArgs.Token,
 		RunnerName:   regArgs.RunnerName,
 		CustomLabels: defaultLabels,
@ -256,7 +256,7 @@ func registerNoInteractive(envFile string, regArgs *registerArgs) error {
 		log.WithError(err).Errorf("Invalid input, please re-run act command.")
 		return nil
 	}
-	if err := doRegister(&cfg, inputs); err != nil {
+	if err := doRegister(cfg, inputs); err != nil {
 		log.Errorf("Failed to register runner: %v", err)
 		return nil
 	}
@ -270,8 +270,10 @@ func doRegister(cfg *config.Config, inputs *registerInputs) error {
 	// initial http client
 	cli := client.New(
 		inputs.InstanceAddr,
-		inputs.Insecure,
-		"", "",
+		cfg.Runner.Insecure,
+		"",
+		"",
+		version,
 	)

 	for {
@ -297,9 +299,36 @@ func doRegister(cfg *config.Config, inputs *registerInputs) error {
 		}
 	}

-	cfg.Runner.Name = inputs.RunnerName
-	cfg.Runner.Token = inputs.Token
-	cfg.Runner.Labels = inputs.CustomLabels
-	_, err := register.New(cli).Register(ctx, cfg.Runner)
-	return err
+	reg := &config.Registration{
+		Name:    inputs.RunnerName,
+		Token:   inputs.Token,
+		Address: inputs.InstanceAddr,
+		Labels:  inputs.CustomLabels,
+	}
+
+	labels := make([]string, len(reg.Labels))
+	for i, v := range reg.Labels {
+		l, _, _, _ := runtime.ParseLabel(v)
+		labels[i] = l
+	}
+	// register new runner.
+	resp, err := cli.Register(ctx, connect.NewRequest(&runnerv1.RegisterRequest{
+		Name:        reg.Name,
+		Token:       reg.Token,
+		AgentLabels: labels,
+	}))
+	if err != nil {
+		log.WithError(err).Error("poller: cannot register new runner")
+		return err
+	}
+
+	reg.ID = resp.Msg.Runner.Id
+	reg.UUID = resp.Msg.Runner.Uuid
+	reg.Name = resp.Msg.Runner.Name
+	reg.Token = resp.Msg.Runner.Token
+
+	if err := config.SaveRegistration(cfg.Runner.File, reg); err != nil {
+		return fmt.Errorf("failed to save runner config: %w", err)
+	}
+	return nil
 }
--- a/cmd/register_test.go
+++ b/cmd/register_test.go
@ -1,10 +0,0 @@
-package cmd
-
-import "testing"
-
-func TestValidateLabels(t *testing.T) {
-	labels := []string{"ubuntu-latest:docker://node:16-buster", "self-hosted"}
-	if err := validateLabels(labels); err != nil {
-		t.Errorf("validateLabels() error = %v", err)
-	}
-}
--- a/config/config.example.yaml
+++ b/config/config.example.yaml
@ -0,0 +1,42 @@
+# Example configuration file, it's safe to copy this as the default config file without any modification.
+
+log:
+  # The level of logging, can be trace, debug, info, warn, error, fatal
+  level: info
+
+runner:
+  # Where to store the registration result.
+  file: .runner
+  # Execute how many tasks concurrently at the same time.
+  capacity: 1
+  # Extra environment variables to run jobs.
+  envs:
+    A_TEST_ENV_NAME_1: a_test_env_value_1
+    A_TEST_ENV_NAME_2: a_test_env_value_2
+  # Extra environment variables to run jobs from a file.
+  # It will be ignored if it's empty or the file doesn't exist.
+  env_file: .env
+  # The timeout for a job to be finished.
+  # Please note that the Gitea instance also has a timeout (3h by default) for the job.
+  # So the job could be stopped by the Gitea instance if it's timeout is shorter than this.
+  timeout: 3h
+  # Whether skip verifying the TLS certificate of the Gitea instance.
+  insecure: false
+
+cache:
+  # Enable cache server to use actions/cache.
+  enabled: true
+  # The directory to store the cache data.
+  # If it's empty, the cache data will be stored in $HOME/.cache/actcache.
+  dir: ""
+  # The host of the cache server.
+  # It's not for the address to listen, but the address to connect from job containers.
+  # So 0.0.0.0 is a bad choice, leave it empty to detect automatically.
+  host: ""
+  # The port of the cache server.
+  # 0 means to use a random available port.
+  port: 0
+
+container:
+  # Which network to use for the job containers.
+  network: bridge
--- a/config/config.go
+++ b/config/config.go
@ -1,114 +1,92 @@
 package config

 import (
-	"encoding/json"
-	"io"
+	"fmt"
 	"os"
-	"runtime"
-	"strconv"
-
-	"gitea.com/gitea/act_runner/core"
+	"path/filepath"
+	"time"

 	"github.com/joho/godotenv"
-	"github.com/kelseyhightower/envconfig"
+	"gopkg.in/yaml.v3"
 )

-type (
-	// Config provides the system configuration.
-	Config struct {
-		Debug    bool `envconfig:"GITEA_DEBUG"`
-		Trace    bool `envconfig:"GITEA_TRACE"`
-		Client   Client
-		Runner   Runner
-		Platform Platform
-	}
-
-	Client struct {
-		Address  string `ignored:"true"`
-		Insecure bool
-	}
-
+type Config struct {
+	Log struct {
+		Level string `yaml:"level"`
+	} `yaml:"log"`
 	Runner struct {
-		UUID     string            `ignored:"true"`
-		Name     string            `envconfig:"GITEA_RUNNER_NAME"`
-		Token    string            `ignored:"true"`
-		Capacity int               `envconfig:"GITEA_RUNNER_CAPACITY" default:"1"`
-		File     string            `envconfig:"GITEA_RUNNER_FILE" default:".runner"`
-		Environ  map[string]string `envconfig:"GITEA_RUNNER_ENVIRON"`
-		EnvFile  string            `envconfig:"GITEA_RUNNER_ENV_FILE"`
-		Labels   []string          `envconfig:"GITEA_RUNNER_LABELS"`
+		File     string            `yaml:"file"`
+		Capacity int               `yaml:"capacity"`
+		Envs     map[string]string `yaml:"envs"`
+		EnvFile  string            `yaml:"env_file"`
+		Timeout  time.Duration     `yaml:"timeout"`
+		Insecure bool              `yaml:"insecure"`
+	} `yaml:"runner"`
+	Cache struct {
+		Enabled *bool  `yaml:"enabled"` // pointer to distinguish between false and not set, and it will be true if not set
+		Dir     string `yaml:"dir"`
+		Host    string `yaml:"host"`
+		Port    uint16 `yaml:"port"`
+	} `yaml:"cache"`
+	Container struct {
+		Network string `yaml:"network"`
 	}
+}

-	Platform struct {
-		OS   string `envconfig:"GITEA_PLATFORM_OS"`
-		Arch string `envconfig:"GITEA_PLATFORM_ARCH"`
-	}
-)
-
-// FromEnviron returns the settings from the environment.
-func FromEnviron() (Config, error) {
-	cfg := Config{}
-	if err := envconfig.Process("", &cfg); err != nil {
-		return cfg, err
-	}
-
-	// check runner config exist
-	f, err := os.Stat(cfg.Runner.File)
-	if err == nil && !f.IsDir() {
-		jsonFile, _ := os.Open(cfg.Runner.File)
-		defer jsonFile.Close()
-		byteValue, _ := io.ReadAll(jsonFile)
-		var runner core.Runner
-		if err := json.Unmarshal(byteValue, &runner); err != nil {
-			return cfg, err
-		}
-		if runner.UUID != "" {
-			cfg.Runner.UUID = runner.UUID
-		}
-		if runner.Token != "" {
-			cfg.Runner.Token = runner.Token
-		}
-		if len(runner.Labels) != 0 {
-			cfg.Runner.Labels = runner.Labels
-		}
-		if runner.Address != "" {
-			cfg.Client.Address = runner.Address
-		}
-		if runner.Insecure != "" {
-			cfg.Client.Insecure, _ = strconv.ParseBool(runner.Insecure)
-		}
-	} else if err != nil {
-		return cfg, err
-	}
-
-	// runner config
-	if cfg.Runner.Environ == nil {
-		cfg.Runner.Environ = map[string]string{
-			"GITHUB_API_URL":    cfg.Client.Address + "/api/v1",
-			"GITHUB_SERVER_URL": cfg.Client.Address,
-		}
-	}
-	if cfg.Runner.Name == "" {
-		cfg.Runner.Name, _ = os.Hostname()
-	}
-
-	// platform config
-	if cfg.Platform.OS == "" {
-		cfg.Platform.OS = runtime.GOOS
-	}
-	if cfg.Platform.Arch == "" {
-		cfg.Platform.Arch = runtime.GOARCH
-	}
-
-	if file := cfg.Runner.EnvFile; file != "" {
-		envs, err := godotenv.Read(file)
+// LoadDefault returns the default configuration.
+// If file is not empty, it will be used to load the configuration.
+func LoadDefault(file string) (*Config, error) {
+	cfg := &Config{}
+	if file != "" {
+		f, err := os.Open(file)
 		if err != nil {
-			return cfg, err
+			return nil, err
 		}
-		for k, v := range envs {
-			cfg.Runner.Environ[k] = v
+		defer f.Close()
+		decoder := yaml.NewDecoder(f)
+		if err := decoder.Decode(&cfg); err != nil {
+			return nil, err
 		}
 	}
+	compatibleWithOldEnvs(file != "", cfg)
+
+	if cfg.Runner.EnvFile != "" {
+		if stat, err := os.Stat(cfg.Runner.EnvFile); err == nil && !stat.IsDir() {
+			envs, err := godotenv.Read(cfg.Runner.EnvFile)
+			if err != nil {
+				return nil, fmt.Errorf("read env file %q: %w", cfg.Runner.EnvFile, err)
+			}
+			for k, v := range envs {
+				cfg.Runner.Envs[k] = v
+			}
+		}
+	}
+
+	if cfg.Log.Level == "" {
+		cfg.Log.Level = "info"
+	}
+	if cfg.Runner.File == "" {
+		cfg.Runner.File = ".runner"
+	}
+	if cfg.Runner.Capacity <= 0 {
+		cfg.Runner.Capacity = 1
+	}
+	if cfg.Runner.Timeout <= 0 {
+		cfg.Runner.Timeout = 3 * time.Hour
+	}
+	if cfg.Cache.Enabled == nil {
+		b := true
+		cfg.Cache.Enabled = &b
+	}
+	if *cfg.Cache.Enabled {
+		if cfg.Cache.Dir == "" {
+			home, _ := os.UserHomeDir()
+			cfg.Cache.Dir = filepath.Join(home, ".cache", "actcache")
+		}
+	}
+	if cfg.Container.Network == "" {
+		cfg.Container.Network = "bridge"
+	}

 	return cfg, nil
 }
--- a/config/deprecated.go
+++ b/config/deprecated.go
@ -0,0 +1,62 @@
+// Copyright 2023 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package config
+
+import (
+	"os"
+	"strconv"
+	"strings"
+
+	log "github.com/sirupsen/logrus"
+)
+
+// Deprecated: could be removed in the future. TODO: remove it when Gitea 1.20.0 is released.
+// Be compatible with old envs.
+func compatibleWithOldEnvs(fileUsed bool, cfg *Config) {
+	handleEnv := func(key string) (string, bool) {
+		if v, ok := os.LookupEnv(key); ok {
+			if fileUsed {
+				log.Warnf("env %s has been ignored because config file is used", key)
+				return "", false
+			}
+			log.Warnf("env %s will be deprecated, please use config file instead", key)
+			return v, true
+		}
+		return "", false
+	}
+
+	if v, ok := handleEnv("GITEA_DEBUG"); ok {
+		if b, _ := strconv.ParseBool(v); b {
+			cfg.Log.Level = "debug"
+		}
+	}
+	if v, ok := handleEnv("GITEA_TRACE"); ok {
+		if b, _ := strconv.ParseBool(v); b {
+			cfg.Log.Level = "trace"
+		}
+	}
+	if v, ok := handleEnv("GITEA_RUNNER_CAPACITY"); ok {
+		if i, _ := strconv.Atoi(v); i > 0 {
+			cfg.Runner.Capacity = i
+		}
+	}
+	if v, ok := handleEnv("GITEA_RUNNER_FILE"); ok {
+		cfg.Runner.File = v
+	}
+	if v, ok := handleEnv("GITEA_RUNNER_ENVIRON"); ok {
+		splits := strings.Split(v, ",")
+		if cfg.Runner.Envs == nil {
+			cfg.Runner.Envs = map[string]string{}
+		}
+		for _, split := range splits {
+			kv := strings.SplitN(split, ":", 2)
+			if len(kv) == 2 && kv[0] != "" {
+				cfg.Runner.Envs[kv[0]] = kv[1]
+			}
+		}
+	}
+	if v, ok := handleEnv("GITEA_RUNNER_ENV_FILE"); ok {
+		cfg.Runner.EnvFile = v
+	}
+}
--- a/config/embed.go
+++ b/config/embed.go
@ -0,0 +1,9 @@
+// Copyright 2023 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package config
+
+import _ "embed"
+
+//go:embed config.example.yaml
+var Example []byte
--- a/config/registration.go
+++ b/config/registration.go
@ -0,0 +1,54 @@
+// Copyright 2023 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package config
+
+import (
+	"encoding/json"
+	"os"
+)
+
+const registrationWarning = "This file is automatically generated by act-runner. Do not edit it manually unless you know what you are doing. Removing this file will cause act runner to re-register as a new runner."
+
+// Registration is the registration information for a runner
+type Registration struct {
+	Warning string `json:"WARNING"` // Warning message to display, it's always the registrationWarning constant
+
+	ID      int64    `json:"id"`
+	UUID    string   `json:"uuid"`
+	Name    string   `json:"name"`
+	Token   string   `json:"token"`
+	Address string   `json:"address"`
+	Labels  []string `json:"labels"`
+}
+
+func LoadRegistration(file string) (*Registration, error) {
+	f, err := os.Open(file)
+	if err != nil {
+		return nil, err
+	}
+	defer f.Close()
+
+	var reg Registration
+	if err := json.NewDecoder(f).Decode(&reg); err != nil {
+		return nil, err
+	}
+
+	reg.Warning = ""
+
+	return &reg, nil
+}
+
+func SaveRegistration(file string, reg *Registration) error {
+	f, err := os.Create(file)
+	if err != nil {
+		return err
+	}
+	defer f.Close()
+
+	reg.Warning = registrationWarning
+
+	enc := json.NewEncoder(f)
+	enc.SetIndent("", "  ")
+	return enc.Encode(reg)
+}
--- a/core/runner.go
+++ b/core/runner.go
@ -1,17 +0,0 @@
-package core
-
-const (
-	UUIDHeader  = "x-runner-uuid"
-	TokenHeader = "x-runner-token"
-)
-
-// Runner struct
-type Runner struct {
-	ID       int64    `json:"id"`
-	UUID     string   `json:"uuid"`
-	Name     string   `json:"name"`
-	Token    string   `json:"token"`
-	Address  string   `json:"address"`
-	Insecure string   `json:"insecure"`
-	Labels   []string `json:"labels"`
-}
--- a/go.mod
+++ b/go.mod
@ -1,80 +1,105 @@
-module gitea.com/gitea/act_runner
+module codeberg.org/forgejo/runner

-go 1.18
+go 1.19

 require (
 	code.gitea.io/actions-proto-go v0.2.0
+	code.gitea.io/gitea-vet v0.2.3-0.20230113022436-2b1561217fa5
 	github.com/avast/retry-go/v4 v4.3.1
 	github.com/bufbuild/connect-go v1.3.1
-	github.com/docker/docker v20.10.21+incompatible
-	github.com/joho/godotenv v1.4.0
-	github.com/kelseyhightower/envconfig v1.4.0
-	github.com/mattn/go-isatty v0.0.16
+	github.com/docker/docker v23.0.1+incompatible
+	github.com/go-chi/chi/v5 v5.0.8
+	github.com/go-chi/render v1.0.2
+	github.com/joho/godotenv v1.5.1
+	github.com/mattn/go-isatty v0.0.17
 	github.com/nektos/act v0.0.0
 	github.com/sirupsen/logrus v1.9.0
 	github.com/spf13/cobra v1.6.1
-	golang.org/x/sync v0.0.0-20220819030929-7fc1605a5dde
+	golang.org/x/sync v0.1.0
+	golang.org/x/term v0.6.0
 	google.golang.org/protobuf v1.28.1
+	gopkg.in/yaml.v3 v3.0.1
+	modernc.org/sqlite v1.14.2
+	xorm.io/builder v0.3.11-0.20220531020008-1bd24a7dc978
+	xorm.io/xorm v1.3.2
 )

 require (
+	github.com/Azure/go-ansiterm v0.0.0-20170929234023-d6e3b3328b78 // indirect
 	github.com/Masterminds/semver v1.5.0 // indirect
 	github.com/Microsoft/go-winio v0.5.2 // indirect
-	github.com/Microsoft/hcsshim v0.9.3 // indirect
 	github.com/ProtonMail/go-crypto v0.0.0-20220404123522-616f957b79ad // indirect
 	github.com/acomagu/bufpipe v1.0.3 // indirect
-	github.com/containerd/cgroups v1.0.3 // indirect
-	github.com/containerd/containerd v1.6.6 // indirect
+	github.com/ajg/form v1.5.1 // indirect
+	github.com/containerd/containerd v1.6.18 // indirect
 	github.com/creack/pty v1.1.18 // indirect
-	github.com/docker/cli v20.10.21+incompatible // indirect
+	github.com/docker/cli v23.0.1+incompatible // indirect
 	github.com/docker/distribution v2.8.1+incompatible // indirect
-	github.com/docker/docker-credential-helpers v0.6.4 // indirect
+	github.com/docker/docker-credential-helpers v0.7.0 // indirect
 	github.com/docker/go-connections v0.4.0 // indirect
-	github.com/docker/go-units v0.4.0 // indirect
+	github.com/docker/go-units v0.5.0 // indirect
 	github.com/emirpasic/gods v1.12.0 // indirect
 	github.com/fatih/color v1.13.0 // indirect
 	github.com/go-git/gcfg v1.5.0 // indirect
-	github.com/go-git/go-billy/v5 v5.3.1 // indirect
+	github.com/go-git/go-billy/v5 v5.4.1 // indirect
 	github.com/go-git/go-git/v5 v5.4.2 // indirect
-	github.com/go-ini/ini v1.67.0 // indirect
+	github.com/goccy/go-json v0.8.1 // indirect
 	github.com/gogo/protobuf v1.3.2 // indirect
-	github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da // indirect
+	github.com/golang/snappy v0.0.4 // indirect
 	github.com/google/shlex v0.0.0-20191202100458-e7afc7fbc510 // indirect
+	github.com/google/uuid v1.3.0 // indirect
 	github.com/imdario/mergo v0.3.13 // indirect
 	github.com/inconshreveable/mousetrap v1.0.1 // indirect
 	github.com/jbenet/go-context v0.0.0-20150711004518-d14ea06fba99 // indirect
+	github.com/json-iterator/go v1.1.12 // indirect
 	github.com/julienschmidt/httprouter v1.3.0 // indirect
 	github.com/kballard/go-shellquote v0.0.0-20180428030007-95032a82bc51 // indirect
 	github.com/kevinburke/ssh_config v1.2.0 // indirect
+	github.com/klauspost/compress v1.15.12 // indirect
 	github.com/mattn/go-colorable v0.1.13 // indirect
-	github.com/mattn/go-runewidth v0.0.13 // indirect
+	github.com/mattn/go-runewidth v0.0.14 // indirect
 	github.com/mitchellh/go-homedir v1.1.0 // indirect
 	github.com/mitchellh/mapstructure v1.1.2 // indirect
-	github.com/moby/buildkit v0.10.6 // indirect
-	github.com/moby/sys/mount v0.3.1 // indirect
-	github.com/moby/sys/mountinfo v0.6.0 // indirect
+	github.com/moby/buildkit v0.11.4 // indirect
+	github.com/moby/patternmatcher v0.5.0 // indirect
+	github.com/moby/sys/sequential v0.5.0 // indirect
+	github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
+	github.com/modern-go/reflect2 v1.0.2 // indirect
+	github.com/onsi/ginkgo v1.12.1 // indirect
+	github.com/onsi/gomega v1.10.3 // indirect
 	github.com/opencontainers/go-digest v1.0.0 // indirect
-	github.com/opencontainers/image-spec v1.0.3-0.20211202183452-c5a74bcca799 // indirect
-	github.com/opencontainers/runc v1.1.2 // indirect
-	github.com/opencontainers/selinux v1.10.2 // indirect
+	github.com/opencontainers/image-spec v1.1.0-rc2 // indirect
+	github.com/opencontainers/runc v1.1.3 // indirect
+	github.com/opencontainers/selinux v1.11.0 // indirect
 	github.com/pkg/errors v0.9.1 // indirect
-	github.com/rhysd/actionlint v1.6.22 // indirect
-	github.com/rivo/uniseg v0.3.4 // indirect
+	github.com/remyoudompheng/bigfft v0.0.0-20200410134404-eec4a21b6bb0 // indirect
+	github.com/rhysd/actionlint v1.6.23 // indirect
+	github.com/rivo/uniseg v0.4.3 // indirect
 	github.com/robfig/cron v1.2.0 // indirect
 	github.com/sergi/go-diff v1.2.0 // indirect
 	github.com/spf13/pflag v1.0.5 // indirect
+	github.com/syndtr/goleveldb v1.0.0 // indirect
 	github.com/xanzy/ssh-agent v0.3.1 // indirect
 	github.com/xeipuuv/gojsonpointer v0.0.0-20180127040702-4e3ac2762d5f // indirect
 	github.com/xeipuuv/gojsonreference v0.0.0-20180127040603-bd5ef7bd5415 // indirect
-	github.com/xeipuuv/gojsonschema v0.0.0-20180618132009-1d523034197f // indirect
-	go.opencensus.io v0.23.0 // indirect
-	golang.org/x/crypto v0.0.0-20220331220935-ae2d96664a29 // indirect
-	golang.org/x/net v0.0.0-20220906165146-f3363e06e74c // indirect
-	golang.org/x/sys v0.0.0-20220818161305-2296e01440c6 // indirect
-	golang.org/x/term v0.0.0-20210927222741-03fcf44c2211 // indirect
+	github.com/xeipuuv/gojsonschema v1.2.0 // indirect
+	golang.org/x/crypto v0.2.0 // indirect
+	golang.org/x/mod v0.4.2 // indirect
+	golang.org/x/net v0.7.0 // indirect
+	golang.org/x/sys v0.6.0 // indirect
+	golang.org/x/tools v0.1.5 // indirect
+	golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 // indirect
 	gopkg.in/warnings.v0 v0.1.2 // indirect
 	gopkg.in/yaml.v2 v2.4.0 // indirect
-	gopkg.in/yaml.v3 v3.0.1 // indirect
+	lukechampine.com/uint128 v1.1.1 // indirect
+	modernc.org/cc/v3 v3.35.18 // indirect
+	modernc.org/ccgo/v3 v3.12.82 // indirect
+	modernc.org/libc v1.11.87 // indirect
+	modernc.org/mathutil v1.4.1 // indirect
+	modernc.org/memory v1.0.5 // indirect
+	modernc.org/opt v0.1.1 // indirect
+	modernc.org/strutil v1.1.1 // indirect
+	modernc.org/token v1.0.0 // indirect
 )

-replace github.com/nektos/act => gitea.com/gitea/act v0.234.2
+replace github.com/nektos/act => code.forgejo.org/forgejo/act v1.3.0
--- a/go.sum
+++ b/go.sum
--- a/main.go
+++ b/main.go
@ -6,7 +6,7 @@ import (
 	"os/signal"
 	"syscall"

-	"gitea.com/gitea/act_runner/cmd"
+	"codeberg.org/forgejo/runner/cmd"
 )

 func withContextFunc(ctx context.Context, f func()) context.Context {
--- a/poller/poller.go
+++ b/poller/poller.go
@ -7,22 +7,23 @@ import (
 	"time"

 	runnerv1 "code.gitea.io/actions-proto-go/runner/v1"
-	"gitea.com/gitea/act_runner/client"
-
 	"github.com/bufbuild/connect-go"
 	log "github.com/sirupsen/logrus"
+
+	"codeberg.org/forgejo/runner/client"
+	"codeberg.org/forgejo/runner/config"
 )

 var ErrDataLock = errors.New("Data Lock Error")

-func New(cli client.Client, dispatch func(context.Context, *runnerv1.Task) error, workerNum int) *Poller {
+func New(cli client.Client, dispatch func(context.Context, *runnerv1.Task) error, cfg *config.Config) *Poller {
 	return &Poller{
 		Client:       cli,
 		Dispatch:     dispatch,
 		routineGroup: newRoutineGroup(),
 		metric:       &metric{},
-		workerNum:    workerNum,
 		ready:        make(chan struct{}, 1),
+		cfg:          cfg,
 	}
 }

@ -34,13 +35,13 @@ type Poller struct {
 	routineGroup *routineGroup
 	metric       *metric
 	ready        chan struct{}
-	workerNum    int
+	cfg          *config.Config
 }

 func (p *Poller) schedule() {
 	p.Lock()
 	defer p.Unlock()
-	if int(p.metric.BusyWorkers()) >= p.workerNum {
+	if int(p.metric.BusyWorkers()) >= p.cfg.Runner.Capacity {
 		return
 	}

@ -54,6 +55,40 @@ func (p *Poller) Wait() {
 	p.routineGroup.Wait()
 }

+func (p *Poller) handle(ctx context.Context, l *log.Entry) {
+	defer func() {
+		if r := recover(); r != nil {
+			l.Errorf("handle task panic: %+v", r)
+		}
+	}()
+
+	for {
+		select {
+		case <-ctx.Done():
+			return
+		default:
+			task, err := p.pollTask(ctx)
+			if task == nil || err != nil {
+				if err != nil {
+					l.Errorf("can't find the task: %v", err.Error())
+				}
+				time.Sleep(5 * time.Second)
+				break
+			}
+
+			p.metric.IncBusyWorker()
+			p.routineGroup.Run(func() {
+				defer p.schedule()
+				defer p.metric.DecBusyWorker()
+				if err := p.dispatchTask(ctx, task); err != nil {
+					l.Errorf("execute task: %v", err.Error())
+				}
+			})
+			return
+		}
+	}
+}
+
 func (p *Poller) Poll(ctx context.Context) error {
 	l := log.WithField("func", "Poll")

@ -67,32 +102,7 @@ func (p *Poller) Poll(ctx context.Context) error {
 		case <-ctx.Done():
 			return nil
 		}
-	LOOP:
-		for {
-			select {
-			case <-ctx.Done():
-				break LOOP
-			default:
-				task, err := p.pollTask(ctx)
-				if task == nil || err != nil {
-					if err != nil {
-						l.Errorf("can't find the task: %v", err.Error())
-					}
-					time.Sleep(5 * time.Second)
-					break
-				}
-
-				p.metric.IncBusyWorker()
-				p.routineGroup.Run(func() {
-					defer p.schedule()
-					defer p.metric.DecBusyWorker()
-					if err := p.dispatchTask(ctx, task); err != nil {
-						l.Errorf("execute task: %v", err.Error())
-					}
-				})
-				break LOOP
-			}
-		}
+		p.handle(ctx, l)
 	}
 }

@ -139,7 +149,7 @@ func (p *Poller) dispatchTask(ctx context.Context, task *runnerv1.Task) error {
 		}
 	}()

-	runCtx, cancel := context.WithTimeout(ctx, time.Hour)
+	runCtx, cancel := context.WithTimeout(ctx, p.cfg.Runner.Timeout)
 	defer cancel()

 	return p.Dispatch(runCtx, task)
--- a/register/register.go
+++ b/register/register.go
@ -1,63 +0,0 @@
-package register
-
-import (
-	"context"
-	"encoding/json"
-	"os"
-	"strconv"
-	"strings"
-
-	runnerv1 "code.gitea.io/actions-proto-go/runner/v1"
-	"gitea.com/gitea/act_runner/client"
-	"gitea.com/gitea/act_runner/config"
-	"gitea.com/gitea/act_runner/core"
-
-	"github.com/bufbuild/connect-go"
-	log "github.com/sirupsen/logrus"
-)
-
-func New(cli client.Client) *Register {
-	return &Register{
-		Client: cli,
-	}
-}
-
-type Register struct {
-	Client client.Client
-}
-
-func (p *Register) Register(ctx context.Context, cfg config.Runner) (*core.Runner, error) {
-	labels := make([]string, len(cfg.Labels))
-	for i, v := range cfg.Labels {
-		labels[i] = strings.SplitN(v, ":", 2)[0]
-	}
-	// register new runner.
-	resp, err := p.Client.Register(ctx, connect.NewRequest(&runnerv1.RegisterRequest{
-		Name:        cfg.Name,
-		Token:       cfg.Token,
-		AgentLabels: labels,
-	}))
-	if err != nil {
-		log.WithError(err).Error("poller: cannot register new runner")
-		return nil, err
-	}
-
-	data := &core.Runner{
-		ID:       resp.Msg.Runner.Id,
-		UUID:     resp.Msg.Runner.Uuid,
-		Name:     resp.Msg.Runner.Name,
-		Token:    resp.Msg.Runner.Token,
-		Address:  p.Client.Address(),
-		Insecure: strconv.FormatBool(p.Client.Insecure()),
-		Labels:   cfg.Labels,
-	}
-
-	file, err := json.MarshalIndent(data, "", "  ")
-	if err != nil {
-		log.WithError(err).Error("poller: cannot marshal the json input")
-		return data, err
-	}
-
-	// store runner config in .runner file
-	return data, os.WriteFile(cfg.File, file, 0o644)
-}
--- a/runtime/label.go
+++ b/runtime/label.go
@ -0,0 +1,26 @@
+// Copyright 2023 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package runtime
+
+import (
+	"fmt"
+	"strings"
+)
+
+func ParseLabel(str string) (label, schema, arg string, err error) {
+	splits := strings.SplitN(str, ":", 3)
+	label = splits[0]
+	schema = "host"
+	arg = ""
+	if len(splits) >= 2 {
+		schema = splits[1]
+	}
+	if len(splits) >= 3 {
+		arg = splits[2]
+	}
+	if schema != "host" && schema != "docker" {
+		return "", "", "", fmt.Errorf("unsupported schema: %s", schema)
+	}
+	return
+}
--- a/runtime/label_test.go
+++ b/runtime/label_test.go
@ -0,0 +1,63 @@
+// Copyright 2023 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package runtime
+
+import "testing"
+
+func TestParseLabel(t *testing.T) {
+	tests := []struct {
+		args       string
+		wantLabel  string
+		wantSchema string
+		wantArg    string
+		wantErr    bool
+	}{
+		{
+			args:       "ubuntu:docker://node:18",
+			wantLabel:  "ubuntu",
+			wantSchema: "docker",
+			wantArg:    "//node:18",
+			wantErr:    false,
+		},
+		{
+			args:       "ubuntu:host",
+			wantLabel:  "ubuntu",
+			wantSchema: "host",
+			wantArg:    "",
+			wantErr:    false,
+		},
+		{
+			args:       "ubuntu",
+			wantLabel:  "ubuntu",
+			wantSchema: "host",
+			wantArg:    "",
+			wantErr:    false,
+		},
+		{
+			args:       "ubuntu:vm:ubuntu-18.04",
+			wantLabel:  "",
+			wantSchema: "",
+			wantArg:    "",
+			wantErr:    true,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.args, func(t *testing.T) {
+			gotLabel, gotSchema, gotArg, err := ParseLabel(tt.args)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("parseLabel() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if gotLabel != tt.wantLabel {
+				t.Errorf("parseLabel() gotLabel = %v, want %v", gotLabel, tt.wantLabel)
+			}
+			if gotSchema != tt.wantSchema {
+				t.Errorf("parseLabel() gotSchema = %v, want %v", gotSchema, tt.wantSchema)
+			}
+			if gotArg != tt.wantArg {
+				t.Errorf("parseLabel() gotArg = %v, want %v", gotArg, tt.wantArg)
+			}
+		})
+	}
+}
--- a/runtime/reporter.go
+++ b/runtime/reporter.go
@ -8,7 +8,7 @@ import (
 	"time"

 	runnerv1 "code.gitea.io/actions-proto-go/runner/v1"
-	"gitea.com/gitea/act_runner/client"
+	"codeberg.org/forgejo/runner/client"

 	retry "github.com/avast/retry-go/v4"
 	"github.com/bufbuild/connect-go"
@ -99,7 +99,7 @@ func (r *Reporter) Fire(entry *log.Entry) error {

 	var step *runnerv1.StepState
 	if v, ok := entry.Data["stepNumber"]; ok {
-		if v, ok := v.(int); ok {
+		if v, ok := v.(int); ok && len(r.state.Steps) > v {
 			step = r.state.Steps[v]
 		}
 	}
--- a/runtime/runtime.go
+++ b/runtime/runtime.go
@ -5,46 +5,54 @@ import (
 	"strings"

 	runnerv1 "code.gitea.io/actions-proto-go/runner/v1"
-	"gitea.com/gitea/act_runner/client"
+	"codeberg.org/forgejo/runner/artifactcache"
+	"codeberg.org/forgejo/runner/client"
+	log "github.com/sirupsen/logrus"
 )

 // Runner runs the pipeline.
 type Runner struct {
 	Machine       string
+	Version       string
 	ForgeInstance string
 	Environ       map[string]string
 	Client        client.Client
 	Labels        []string
+	Network       string
+	CacheHandler  *artifactcache.Handler
 }

 // Run runs the pipeline stage.
 func (s *Runner) Run(ctx context.Context, task *runnerv1.Task) error {
-	return NewTask(s.ForgeInstance, task.Id, s.Client, s.Environ, s.platformPicker).Run(ctx, task)
+	env := map[string]string{}
+	for k, v := range s.Environ {
+		env[k] = v
+	}
+	if s.CacheHandler != nil {
+		env["ACTIONS_CACHE_URL"] = s.CacheHandler.ExternalURL() + "/"
+	}
+	return NewTask(task.Id, s.Client, env, s.Network, s.platformPicker).Run(ctx, task, s.Machine, s.Version)
 }

 func (s *Runner) platformPicker(labels []string) string {
-	// "ubuntu-18.04:docker://node:16-buster"
-	// "self-hosted"
-
-	platforms := make(map[string]string, len(labels))
+	platforms := make(map[string]string, len(s.Labels))
 	for _, l := range s.Labels {
-		// "ubuntu-18.04:docker://node:16-buster"
-		splits := strings.SplitN(l, ":", 2)
-		if len(splits) == 1 {
-			// identifier for non docker execution environment
-			platforms[splits[0]] = "-self-hosted"
+		label, schema, arg, err := ParseLabel(l)
+		if err != nil {
+			log.Errorf("invaid label %q: %v", l, err)
 			continue
 		}
-		// ["ubuntu-18.04", "docker://node:16-buster"]
-		k, v := splits[0], splits[1]

-		if prefix := "docker://"; !strings.HasPrefix(v, prefix) {
+		switch schema {
+		case "docker":
+			// TODO "//" will be ignored, maybe we should use 'ubuntu-18.04:docker:node:16-buster' instead
+			platforms[label] = strings.TrimPrefix(arg, "//")
+		case "host":
+			platforms[label] = "-self-hosted"
+		default:
+			// It should not happen, because ParseLabel has checked it.
 			continue
-		} else {
-			v = strings.TrimPrefix(v, prefix)
 		}
-		// ubuntu-18.04 => node:16-buster
-		platforms[k] = v
 	}

 	for _, label := range labels {
@ -59,6 +67,8 @@ func (s *Runner) platformPicker(labels []string) string {
 	//   ["with-gpu"] => "linux:with-gpu"
 	//   ["ubuntu-22.04", "with-gpu"] => "ubuntu:22.04_with-gpu"

-	// return default
-	return "node:16-bullseye"
+	// return default.
+	// So the runner receives a task with a label that the runner doesn't have,
+	// it happens when the user have edited the label of the runner in the web UI.
+	return "node:16-bullseye" // TODO: it may be not correct, what if the runner is used as host mode only?
 }
--- a/runtime/task.go
+++ b/runtime/task.go
@ -11,13 +11,12 @@ import (
 	"time"

 	runnerv1 "code.gitea.io/actions-proto-go/runner/v1"
-	"gitea.com/gitea/act_runner/client"
-
-	"github.com/nektos/act/pkg/artifacts"
 	"github.com/nektos/act/pkg/common"
 	"github.com/nektos/act/pkg/model"
 	"github.com/nektos/act/pkg/runner"
 	log "github.com/sirupsen/logrus"
+
+	"codeberg.org/forgejo/runner/client"
 )

 var globalTaskMap sync.Map
@ -72,11 +71,11 @@ type Task struct {
 }

 // NewTask creates a new task
-func NewTask(forgeInstance string, buildID int64, client client.Client, runnerEnvs map[string]string, picker func([]string) string) *Task {
+func NewTask(buildID int64, client client.Client, runnerEnvs map[string]string, network string, picker func([]string) string) *Task {
 	task := &Task{
 		Input: &TaskInput{
 			envs:                 runnerEnvs,
-			containerNetworkMode: "bridge", // TODO should be configurable
+			containerNetworkMode: network,
 		},
 		BuildID: buildID,

@ -112,7 +111,7 @@ func getToken(task *runnerv1.Task) string {
 	return token
 }

-func (t *Task) Run(ctx context.Context, task *runnerv1.Task) (lastErr error) {
+func (t *Task) Run(ctx context.Context, task *runnerv1.Task, runnerName, runnerVersion string) (lastErr error) {
 	ctx, cancel := context.WithCancel(ctx)
 	defer cancel()
 	_, exist := globalTaskMap.Load(task.Id)
@ -134,13 +133,14 @@ func (t *Task) Run(ctx context.Context, task *runnerv1.Task) (lastErr error) {
 				Data: log.Fields{
 					"jobResult": "failure",
 				},
+				Time: time.Now(),
 			})
 		}
 		_ = reporter.Close(lastWords)
 	}()
 	reporter.RunDaemon()

-	reporter.Logf("received task %v of job %v", task.Id, task.Context.Fields["job"].GetStringValue())
+	reporter.Logf("%s(version:%s) received task %v of job %v, be triggered by event: %s", runnerName, runnerVersion, task.Id, task.Context.Fields["job"].GetStringValue(), task.Context.Fields["event_name"].GetStringValue())

 	workflowsPath, err := getWorkflowsPath(t.Input.repoDirectory)
 	if err != nil {
@ -155,7 +155,6 @@ func (t *Task) Run(ctx context.Context, task *runnerv1.Task) (lastErr error) {
 		return err
 	}

-	var plan *model.Plan
 	jobIDs := workflow.GetJobIDs()
 	if len(jobIDs) != 1 {
 		err := fmt.Errorf("multiple jobs found: %v", jobIDs)
@ -163,7 +162,11 @@ func (t *Task) Run(ctx context.Context, task *runnerv1.Task) (lastErr error) {
 		return err
 	}
 	jobID := jobIDs[0]
-	plan = model.CombineWorkflowPlanner(workflow).PlanJob(jobID)
+	plan, err := model.CombineWorkflowPlanner(workflow).PlanJob(jobID)
+	if err != nil {
+		lastWords = err.Error()
+		return err
+	}
 	job := workflow.GetJob(jobID)
 	reporter.ResetSteps(len(job.Steps))

@ -206,7 +209,7 @@ func (t *Task) Run(ctx context.Context, task *runnerv1.Task) (lastErr error) {

 	input := t.Input
 	config := &runner.Config{
-		Workdir:               "/" + preset.Repository,
+		Workdir:               "." + string(filepath.Separator),
 		BindWorkdir:           false,
 		ReuseContainers:       false,
 		ForcePull:             input.forcePull,
@ -242,13 +245,7 @@ func (t *Task) Run(ctx context.Context, task *runnerv1.Task) (lastErr error) {
 		return err
 	}

-	artifactCancel := artifacts.Serve(ctx, input.artifactServerPath, input.artifactServerPort)
-	t.log.Debugf("artifacts server started at %s:%s", input.artifactServerPath, input.artifactServerPort)
-
-	executor := r.NewPlanExecutor(plan).Finally(func(ctx context.Context) error {
-		artifactCancel()
-		return nil
-	})
+	executor := r.NewPlanExecutor(plan)

 	t.log.Infof("workflow prepared")
 	reporter.Logf("workflow prepared")
Author	SHA1	Message	Date
earl-warren	bcd6096e5b	Merge pull request 'default GITHUB_SERVER_URL with registration address' (#24 ) from earl-warren/runner:wip-sync into main Reviewed-on: https://code.forgejo.org/forgejo/runner/pulls/24 Reviewed-by: dachary <dachary@noreply.code.forgejo.org>	2023-04-05 15:08:01 +00:00
Earl Warren	8b2f1677fe	default GITHUB_SERVER_URL with registration address If unset it will default to whatever is in the GITHUB_SERVER_URL environment variable which is not desirable when in the context of integration tests that run a forgejo instance in the CI of another forgejo instance.	2023-04-05 16:39:09 +02:00
earl-warren	cd20007e4d	Merge pull request 'cherry-pick commits from act_runner' (#23 ) from earl-warren/runner:wip-sync into main Reviewed-on: https://code.forgejo.org/forgejo/runner/pulls/23 Reviewed-by: dachary <dachary@noreply.code.forgejo.org>	2023-04-04 23:07:29 +00:00
Jason Song	7c1801b302	Config for container network (#96 ) Fix #66 Reviewed-on: https://gitea.com/gitea/act_runner/pulls/96 Reviewed-by: Lunny Xiao <xiaolunwen@gmail.com>	2023-04-05 00:53:35 +02:00
Jason Song	c817236aa4	Refactor environment variables to configuration and registration (#90 ) Close #21. Refactor environment variables to configuration file (config.yaml) and registration file (.runner). The old environment variables are still supported, but warning logs will be printed. Like: ```text $ GITEA_DEBUG=true ./act_runner -c config.yaml daemon INFO[0000] Starting runner daemon WARN[0000] env GITEA_DEBUG has been ignored because config file is used $ GITEA_DEBUG=true ./act_runner daemon INFO[0000] Starting runner daemon WARN[0000] env GITEA_DEBUG will be deprecated, please use config file instead ``` Reviewed-on: https://gitea.com/gitea/act_runner/pulls/90 Reviewed-by: Lunny Xiao <xiaolunwen@gmail.com>	2023-04-05 00:53:35 +02:00
telackey	028451bf22	Add CLI flag for specifying the Docker image to use. (#83 ) Since the `exec` command does not use labels from `.runner`, there is no existing way to specify which Docker image to use for task execution. This adds an `--image` flag for specifying it manually. The default remains `node:16-bullseye`. Co-authored-by: Lunny Xiao <xiaolunwen@gmail.com> Reviewed-on: https://gitea.com/gitea/act_runner/pulls/83 Reviewed-by: Jason Song <i@wolfogre.com> Reviewed-by: Lunny Xiao <xiaolunwen@gmail.com> Co-authored-by: telackey <telackey@noreply.gitea.io> Co-committed-by: telackey <telackey@noreply.gitea.io>	2023-04-05 00:53:35 +02:00
Lunny Xiao	0d33f8f520	handle possible panic (#88 ) Reviewed-on: https://gitea.com/gitea/act_runner/pulls/88 Reviewed-by: Jason Song <i@wolfogre.com>	2023-04-05 00:53:35 +02:00
Zettat123	63c1734bb5	Fix potential log panic (#82 ) If a job uses a [reusable workflow](https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#example-of-jobsjob_iduses), the job's steps sequence will be empty. But in log reporter, we don't check the length of `r.state.Steps`, which may cause panic. ``` go if v, ok := entry.Data["stepNumber"]; ok { if v, ok := v.(int); ok { step = r.state.Steps[v] } } ``` Reviewed-on: https://gitea.com/gitea/act_runner/pulls/82 Reviewed-by: Lunny Xiao <xiaolunwen@gmail.com> Co-authored-by: Zettat123 <zettat123@gmail.com> Co-committed-by: Zettat123 <zettat123@gmail.com>	2023-04-05 00:53:35 +02:00
Jason Song	3d78433564	Get outbound IP in multiple ways or disable cache server if failed to init (#74 ) Fix #64 (incompletely). It's still not ideal. It makes more sense to use the gateway IP address of container network as outbound IP of cache server. However, this requires act to cooperate, some think like: - act creates the network for new container, and returns the network to runner. - runner extracts the gateway IP in the network. - runner uses the gateway IP as outbound IP, and pass it to act as cache server endpoint. - act It continues to create the container with the created network. Reviewed-on: https://gitea.com/gitea/act_runner/pulls/74 Reviewed-by: Lunny Xiao <xiaolunwen@gmail.com>	2023-04-05 00:53:35 +02:00
Jason Song	3463f94119	Vet code (#73 ) Reviewed-on: https://gitea.com/gitea/act_runner/pulls/73	2023-04-05 00:53:35 +02:00
Jason Song	616ad7c96a	Clarify labels (#69 ) The label will follow the format `label[:schema[:args]]`, and the schema will be `host` if it's omitted. So - `ubuntu:docker://node:18`: Run jobs with label `ubuntu` via docker with image `node:18` - `ubuntu:host`: Run jobs with label `ubuntu` on the host directly. - `ubuntu`: Same as `ubuntu:host`. - `ubuntu:vm:ubuntu-latest`: (Just a example, not Implemented) Run jobs with label `ubuntu` via virtual machine with iso `ubuntu-latest`. Reviewed-on: https://gitea.com/gitea/act_runner/pulls/69 Reviewed-by: Zettat123 <zettat123@noreply.gitea.io> Reviewed-by: wxiaoguang <wxiaoguang@noreply.gitea.io>	2023-04-05 00:53:35 +02:00
earl-warren	8d8a11052a	Merge pull request 'the test workflow is not meant to release' (#20 ) from earl-warren/runner:wip-release into main Reviewed-on: https://code.forgejo.org/forgejo/runner/pulls/20 Reviewed-by: dachary <dachary@noreply.code.forgejo.org>	2023-04-04 12:44:31 +00:00
Earl Warren	bd439537ba	the test workflow is not meant to release	2023-04-04 14:39:53 +02:00
earl-warren	75c1f66a12	Merge pull request 'sync with act 1.3.0' (#19 ) from earl-warren/runner:wip-sync into main Reviewed-on: https://code.forgejo.org/forgejo/runner/pulls/19 Reviewed-by: dachary <dachary@noreply.code.forgejo.org>	2023-04-04 10:42:35 +00:00
Earl Warren	0125f1302a	a change in dependencies requires and integration test	2023-04-04 12:28:37 +02:00
Earl Warren	45fcb8164f	remove restriction to run unit tests on main	2023-04-04 12:25:36 +02:00
Earl Warren	419989c422	sync with act 1.3.0	2023-04-04 12:20:22 +02:00
earl-warren	9a6cae89e7	Merge pull request 'keep .git on build to extract version from tag' (#15 ) from earl-warren/runner:wip-release into main Reviewed-on: https://code.forgejo.org/forgejo/runner/pulls/15 Reviewed-by: dachary <dachary@noreply.code.forgejo.org>	2023-04-03 15:14:31 +00:00
Earl Warren	56909d2f20	keep .git on build to extract version from tag Otherwise the version is empty and --version does not work Fixes: https://code.forgejo.org/forgejo/runner/issues/14	2023-04-03 16:57:27 +02:00
earl-warren	0048a1dfbc	Merge pull request 'workflows to publish the release' (#11 ) from earl-warren/runner:wip-release into main Reviewed-on: https://code.forgejo.org/forgejo/runner/pulls/11	2023-04-03 11:56:29 +00:00
Earl Warren	93978d8ec0	release integration tests	2023-04-03 10:50:36 +02:00
Earl Warren	8834728285	build static binaries	2023-04-03 01:13:33 +02:00
Earl Warren	70d68a491d	publish release	2023-04-03 01:13:33 +02:00
Earl Warren	a06bc05fd1	run tests on pull requests and when pushing to main	2023-04-02 21:04:24 +02:00
earl-warren	499ee80e57	Merge pull request 'Use go 1.19' (#6 ) from crystal/runner:pr-go119 into main Reviewed-on: https://code.forgejo.org/forgejo/runner/pulls/6	2023-03-23 07:05:12 +00:00
crystal	ceb20b868f	Use go 1.19	2023-03-23 00:12:43 -06:00
earl-warren	d8481f6b1d	Merge pull request 'default actions URL is code.forgejo.org' (#2 ) from earl-warren/runner:wip-default-actions into main Reviewed-on: https://code.forgejo.org/forgejo/runner/pulls/2	2023-03-18 20:05:25 +00:00
Earl Warren	905fb5255d	default actions URL is code.forgejo.org	2023-03-18 13:21:54 +01:00
earl-warren	634846e944	Merge pull request 'cherry-pick some commits from gitea/act_runner' (#1 ) from earl-warren/runner:wip-sync into main Reviewed-on: https://code.forgejo.org/forgejo/runner/pulls/1	2023-03-18 09:25:55 +00:00
Earl Warren	3601466dcf	upgrade act v1.2.0	2023-03-18 09:57:18 +01:00
Jason Song	df4bfdc0d3	Update act to v0.243 (#54 ) - Update act to v0.243.1 - Disable artifacts server when run daemon. - Adjust cmd. Reviewed-on: https://gitea.com/gitea/act_runner/pulls/54 Reviewed-by: Zettat123 <zettat123@noreply.gitea.io>	2023-03-18 09:54:13 +01:00
Lunny Xiao	154555e912	check go version when build (#53 ) Fix #51 Reviewed-on: https://gitea.com/gitea/act_runner/pulls/53	2023-03-16 16:58:13 +01:00
Lunny Xiao	3cc7e8f052	Support cache on ci (#47 ) Fix #46 Co-authored-by: Jason Song <i@wolfogre.com> Reviewed-on: https://gitea.com/gitea/act_runner/pulls/47 Reviewed-by: techknowlogick <techknowlogick@noreply.gitea.io> Reviewed-by: Jason Song <i@wolfogre.com> Co-authored-by: Lunny Xiao <xiaolunwen@gmail.com> Co-committed-by: Lunny Xiao <xiaolunwen@gmail.com>	2023-03-16 16:56:03 +01:00
sillyguodong	0026306515	Print the kind of event that trigger the actions (#48 ) ![image](/attachments/28a866c6-3134-477d-a8c8-d624fa90db0b) Co-authored-by: Lunny Xiao <xiaolunwen@gmail.com> Reviewed-on: https://gitea.com/gitea/act_runner/pulls/48 Reviewed-by: Lunny Xiao <xiaolunwen@gmail.com> Reviewed-by: techknowlogick <techknowlogick@noreply.gitea.io> Co-authored-by: sillyguodong <gedong_1994@163.com> Co-committed-by: sillyguodong <gedong_1994@163.com>	2023-03-16 16:54:46 +01:00
Lunny Xiao	6c7b07be60	Fix make don't rebuild when go.mod changed (#49 ) Fix #13 Reviewed-on: https://gitea.com/gitea/act_runner/pulls/49 Reviewed-by: delvh <dev.lh@web.de>	2023-03-16 16:54:37 +01:00
sillyguodong	0445675a10	Inject version when building and report version to Gitea via log and header (#43 ) close #42 1. Inject runner version when `make build` After building, executing command line: `./act_runner -v` or `./act_runner --version`, the version of runner is printed. ![image](/attachments/e25efbd3-79b3-49a5-b93f-42646d42c707) 2. In `Actions` UI: ![image](/attachments/36c57470-2a1d-4796-9eb0-de3988ab88e1) 3. Set request header in http client interceptor. Co-authored-by: sillyguodong <gedong_1994@163.com> Reviewed-on: https://gitea.com/gitea/act_runner/pulls/43 Reviewed-by: delvh <dev.lh@web.de> Reviewed-by: Jason Song <i@wolfogre.com> Co-authored-by: sillyguodong <sillyguodong@noreply.gitea.io> Co-committed-by: sillyguodong <sillyguodong@noreply.gitea.io>	2023-03-16 16:53:44 +01:00
earl-warren	b202c62bf7	Merge pull request 'upgrade to codeberg.org/forgejo/act v1.1.0' (#1 ) from wip-act-upgrade into main Reviewed-on: https://code.forgejo.org/forgejo/runner/pulls/1	2023-03-11 14:51:11 +00:00
Earl Warren	49f9622eca	upgrade to codeberg.org/forgejo/act v1.1.0	2023-03-11 15:24:54 +01:00
Earl Warren	e160695183	Merge pull request 'run in daemon mode by default' (#8 ) from earl-warren/runner:wip-daemon into main Reviewed-on: https://codeberg.org/forgejo/runner/pulls/8	2023-03-09 22:56:28 +00:00
Earl Warren	b685c432d4	Merge pull request 'define FORGEJO_RUNNER_FILE' (#7 ) from earl-warren/runner:wip-configfile into main Reviewed-on: https://codeberg.org/forgejo/runner/pulls/7	2023-03-09 22:56:17 +00:00
Earl Warren	132b318d8b	run in daemon mode by default	2023-03-09 18:40:19 +01:00
Earl Warren	a02fbdc7af	define FORGEJO_RUNNER_FILE	2023-03-09 18:25:54 +01:00
Loïc Dachary	1bb87d0ebb	Merge pull request 'cherry-pick some changes from the gitea repository' (#6 ) from earl-warren/runner:wip-sync into main Reviewed-on: https://codeberg.org/forgejo/runner/pulls/6	2023-03-08 14:15:12 +00:00
HesterG	048b2e630f	Fix wrong last step duration when job failed (#41 ) This PR is to fix the wrong last step duration when job failed like shown in the screenshot. The reason is because when job failed, `Fire` function did not pass in Time, and `r.state.StoppedAt` is by default set to `0001-01-01 08:05:43 +0805 LMT`, which is later on reported to gitea by `UpdateTask`, which calls `UpdateTaskByState` to update the `task.Stopped`, and `task.Stopped` is used in `FullSteps`, resulting in wrong calcaulation of last step duration. Co-authored-by: nickname <test@123.com> Co-authored-by: Lunny Xiao <xiaolunwen@gmail.com> Reviewed-on: https://gitea.com/gitea/act_runner/pulls/41 Reviewed-by: Jason Song <i@wolfogre.com> Reviewed-by: Lunny Xiao <xiaolunwen@gmail.com> Co-authored-by: HesterG <hesterg@noreply.gitea.io> Co-committed-by: HesterG <hesterg@noreply.gitea.io>	2023-03-08 15:07:09 +01:00
Earl Warren	40954c450d	.gitignore forgejo-runner	2023-03-08 15:02:28 +01:00
Earl Warren	4d5007a333	s/gitea/forgejo/ for exec	2023-03-08 15:01:49 +01:00
a1012112796	65d2485f58	Add `exec` subcommand for runner so that we can run the tasks locally(#39 ) Most codes are copied from https://gitea.com/gitea/act/src/branch/main/cmd and do some small changes to make it run again examples: ```SHELL ./act_runner exec -l ./act_runner exec -j lint ./act_runner exec -j lint -n ``` some example result: ![屏幕截图 2023-03-06 135735](/attachments/547bd05c-ade2-41f7-ba60-c9937fa32d5f) ![屏幕截图 2023-03-06 140643](/attachments/e8f48dba-c7f3-4daa-a163-aa9b36b1dc32) Signed-off-by: a1012112796 <1012112796@qq.com> fix #32 Reviewed-on: https://gitea.com/gitea/act_runner/pulls/39 Reviewed-by: Lunny Xiao <xiaolunwen@gmail.com> Reviewed-by: Jason Song <i@wolfogre.com> Co-authored-by: a1012112796 <1012112796@qq.com> Co-committed-by: a1012112796 <1012112796@qq.com>	2023-03-08 14:59:52 +01:00
Zettat123	ba181d4a50	Add runner name to log (#37 ) User can get the name of the runner that executed the specified job. ![image](/attachments/61328f68-7223-4345-85c7-ac08781e81db) Co-authored-by: Zettat123 <zettat123@gmail.com> Reviewed-on: https://gitea.com/gitea/act_runner/pulls/37 Reviewed-by: Jason Song <i@wolfogre.com> Reviewed-by: Lunny Xiao <xiaolunwen@gmail.com> Co-authored-by: Zettat123 <zettat123@noreply.gitea.io> Co-committed-by: Zettat123 <zettat123@noreply.gitea.io>	2023-03-08 14:58:59 +01:00
ChristopherHX	cbf360f543	fix docker executor on windows and local actions (#34 ) If the Workdir field doesn't ends with the filepath seperator, bad things happen Fixes #33 Sample for host mode on windows, needs be adjusted for linux e.g. replace pwsh with bash Also fixes ```yaml on: push jobs: _: runs-on: self-hosted steps: - uses: actions/checkout@v3 with: path: subdir/action - uses: ./subdir/action ``` with an action.yml in the same repo ```yaml runs: using: composite steps: - run: \| echo "Hello World" shell: pwsh ``` Co-authored-by: Christopher Homberger <christopher.homberger@web.de> Reviewed-on: https://gitea.com/gitea/act_runner/pulls/34 Reviewed-by: Jason Song <i@wolfogre.com> Reviewed-by: Lunny Xiao <xiaolunwen@gmail.com> Co-authored-by: ChristopherHX <christopherhx@noreply.gitea.io> Co-committed-by: ChristopherHX <christopherhx@noreply.gitea.io>	2023-03-08 14:58:04 +01:00
Earl Warren	8833fca093	trigger the build	2023-03-01 00:32:50 +01:00
Earl Warren	7aaa64a648	Merge pull request 'run test from Actions' (#3 ) from earl-warren/runner:wip-test into main Reviewed-on: https://codeberg.org/forgejo/runner/pulls/3	2023-02-28 23:24:31 +00:00
Earl Warren	9213f7dc62	run test from Actions	2023-03-01 00:10:02 +01:00
Earl Warren	af6fea7b97	Merge pull request 'Further rebranding to Forgejo' (#2 ) from crystal/runner:rebrand into main Reviewed-on: https://codeberg.org/forgejo/runner/pulls/2	2023-02-28 23:09:48 +00:00
techknowlogick	1da9c87cac	fix lint error (#30 ) Reviewed-on: https://gitea.com/gitea/act_runner/pulls/30 Reviewed-by: John Olheiser <john+gitea@jolheiser.com>	2023-02-28 23:53:30 +01:00
Jason Song	c5c4e275ac	Support cache (#25 ) See [Caching dependencies to speed up workflows](https://docs.github.com/en/actions/using-workflows/caching-dependencies-to-speed-up-workflows). Reviewed-on: https://gitea.com/gitea/act_runner/pulls/25 Reviewed-by: Lunny Xiao <xiaolunwen@gmail.com> Reviewed-by: Zettat123 <zettat123@noreply.gitea.io> Co-authored-by: Jason Song <i@wolfogre.com> Co-committed-by: Jason Song <i@wolfogre.com>	2023-02-28 23:48:37 +01:00
crystal	9d3406c31d	Further rebranding to Forgejo	2023-02-28 15:38:58 -07:00
Earl Warren	6b85bb17d1	Merge pull request 'Rebrand runner for Forgejo' (#1 ) from crystal/runner:rebrand into main Reviewed-on: https://codeberg.org/forgejo/runner/pulls/1	2023-02-28 22:23:26 +00:00
crystal	fb4284bfae	Rebrand runner for Forgejo	2023-02-28 15:05:33 -07:00
Lunny Xiao	5cb3d6f034	Enable action as CI to test/build/release (#26 ) Reviewed-on: https://gitea.com/gitea/act_runner/pulls/26	2023-02-24 17:52:04 +01:00
Loïc Dachary	7e1a0119c0	upgrade act v1.0.1	2023-02-24 08:40:50 +01:00
Loïc Dachary	3b670a1e42	the canonical name is forgejo-runner	2023-02-23 00:09:12 +01:00
Earl Warren	956fe61fb9	Update README	2023-02-22 18:47:42 +01:00
Earl Warren	c81e7d4beb	upgrade to codeberg.org/forgejo/act v1.0.0	2023-02-22 18:21:23 +01:00
Earl Warren	d5798f067a	s\|gitea.com/gitea/act_runner\|codeberg.org/forgejo/runner\|	2023-02-22 17:19:43 +01:00