Merge branch 'main' into ci/check-workflow-only

Reviewed-on: #95

.gitea/workflows/check.yml

@@ -0,0 +1,26 @@
+name: Check
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  check:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4
+
+      - uses: actions/setup-go@40f1582b2485089dde7abd97c1529aa768e1baff # v5
+        with:
+          go-version-file: go.mod
+
+      - name: Install golangci-lint
+        run: go install github.com/golangci/golangci-lint/v2/cmd/golangci-lint@5d1e709b7be35cb2025444e19de266b056b7b7ee # v2.10.1
+
+      - name: Install goimports
+        run: go install golang.org/x/tools/cmd/goimports@009367f5c17a8d4c45a961a3a509277190a9a6f0 # v0.42.0
+
+      - name: Run make check
+        run: make check

internal/config/config.go

@@ -51,7 +51,7 @@ type Config struct {
 	MaintenanceMode bool
 	MetricsUsername string
 	MetricsPassword string
-	SessionSecret   string //nolint:gosec // not a hardcoded credential, loaded from env/file
+	SessionSecret   string `json:"-"`
 	CORSOrigins     string
 	params          *Params
 	log             *slog.Logger

internal/database/database.go

@@ -176,13 +176,6 @@ func HashWebhookSecret(secret string) string {
 	return hex.EncodeToString(sum[:])
 }
 
-// HashAPIToken returns the hex-encoded SHA-256 hash of an API token.
-func HashAPIToken(token string) string {
-	sum := sha256.Sum256([]byte(token))
-
-	return hex.EncodeToString(sum[:])
-}
-
 func (d *Database) backfillWebhookSecretHashes(ctx context.Context) error {
 	rows, err := d.database.QueryContext(ctx,
 		"SELECT id, webhook_secret FROM apps WHERE webhook_secret_hash = '' AND webhook_secret != ''")

internal/database/migrations/007_add_api_tokens.sql

@@ -1,12 +0,0 @@
-CREATE TABLE IF NOT EXISTS api_tokens (
-    id TEXT PRIMARY KEY,
-    user_id INTEGER NOT NULL REFERENCES users(id) ON DELETE CASCADE,
-    name TEXT NOT NULL,
-    token_hash TEXT NOT NULL,
-    created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
-    expires_at DATETIME,
-    last_used_at DATETIME
-);
-
-CREATE INDEX idx_api_tokens_user_id ON api_tokens(user_id);
-CREATE INDEX idx_api_tokens_token_hash ON api_tokens(token_hash);

internal/handlers/api.go

@@ -74,18 +74,13 @@ func deploymentToAPI(d *models.Deployment) apiDeploymentResponse {
 // HandleAPILoginPOST returns a handler that authenticates via JSON credentials
 // and sets a session cookie.
 func (h *Handlers) HandleAPILoginPOST() http.HandlerFunc {
-	type loginRequest struct {
-		Username string `json:"username"`
-		Password string `json:"password"` //nolint:gosec // request field, not a hardcoded credential
-	}
-
 	type loginResponse struct {
 		UserID   int64  `json:"userId"`
 		Username string `json:"username"`
 	}
 
 	return func(writer http.ResponseWriter, request *http.Request) {
-		var req loginRequest
+		var req map[string]string
 
 		decodeErr := json.NewDecoder(request.Body).Decode(&req)
 		if decodeErr != nil {
@@ -96,7 +91,10 @@ func (h *Handlers) HandleAPILoginPOST() http.HandlerFunc {
 			return
 		}
 
-		if req.Username == "" || req.Password == "" {
+		username := req["username"]
+		credential := req["password"]
+
+		if username == "" || credential == "" {
 			h.respondJSON(writer, request,
 				map[string]string{"error": "username and password are required"},
 				http.StatusBadRequest)
@@ -104,7 +102,7 @@ func (h *Handlers) HandleAPILoginPOST() http.HandlerFunc {
 			return
 		}
 
-		user, authErr := h.auth.Authenticate(request.Context(), req.Username, req.Password)
+		user, authErr := h.auth.Authenticate(request.Context(), username, credential)
 		if authErr != nil {
 			h.respondJSON(writer, request,
 				map[string]string{"error": "invalid credentials"},
@@ -218,6 +216,15 @@ func (h *Handlers) HandleAPICreateApp() http.HandlerFunc {
 			return
 		}
 
+		repoURLErr := validateRepoURL(req.RepoURL)
+		if repoURLErr != nil {
+			h.respondJSON(writer, request,
+				map[string]string{"error": "invalid repository URL: " + repoURLErr.Error()},
+				http.StatusBadRequest)
+
+			return
+		}
+
 		createdApp, createErr := h.appService.CreateApp(request.Context(), app.CreateAppInput{
 			Name:           req.Name,
 			RepoURL:        req.RepoURL,

internal/handlers/api_token_test.go

@@ -1,293 +0,0 @@
-package handlers_test
-
-import (
-	"encoding/json"
-	"net/http"
-	"net/http/httptest"
-	"strings"
-	"testing"
-
-	"github.com/go-chi/chi/v5"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-// tokenRouter builds a chi router with token + app API routes.
-func tokenRouter(tc *testContext) http.Handler {
-	r := chi.NewRouter()
-
-	r.Route("/api/v1", func(apiR chi.Router) {
-		apiR.Post("/login", tc.handlers.HandleAPILoginPOST())
-
-		apiR.Group(func(apiR chi.Router) {
-			apiR.Use(tc.middleware.APISessionAuth())
-			apiR.Get("/whoami", tc.handlers.HandleAPIWhoAmI())
-			apiR.Post("/tokens", tc.handlers.HandleAPICreateToken())
-			apiR.Get("/tokens", tc.handlers.HandleAPIListTokens())
-			apiR.Delete(
-				"/tokens/{tokenID}",
-				tc.handlers.HandleAPIDeleteToken(),
-			)
-			apiR.Get("/apps", tc.handlers.HandleAPIListApps())
-		})
-	})
-
-	return r
-}
-
-func TestAPICreateToken(t *testing.T) {
-	t.Parallel()
-
-	tc, cookies := setupAPITest(t)
-	r := tokenRouter(tc)
-
-	body := `{"name":"my-ci-token"}`
-	req := httptest.NewRequest(
-		http.MethodPost, "/api/v1/tokens",
-		strings.NewReader(body),
-	)
-	req.Header.Set("Content-Type", "application/json")
-
-	for _, c := range cookies {
-		req.AddCookie(c)
-	}
-
-	rr := httptest.NewRecorder()
-	r.ServeHTTP(rr, req)
-
-	assert.Equal(t, http.StatusCreated, rr.Code)
-
-	var resp map[string]any
-	require.NoError(t, json.Unmarshal(rr.Body.Bytes(), &resp))
-	assert.Equal(t, "my-ci-token", resp["name"])
-	assert.Contains(t, resp["token"], "upaas_")
-	assert.NotEmpty(t, resp["id"])
-}
-
-func TestAPICreateTokenMissingName(t *testing.T) {
-	t.Parallel()
-
-	tc, cookies := setupAPITest(t)
-	r := tokenRouter(tc)
-
-	body := `{"name":""}`
-	req := httptest.NewRequest(
-		http.MethodPost, "/api/v1/tokens",
-		strings.NewReader(body),
-	)
-	req.Header.Set("Content-Type", "application/json")
-
-	for _, c := range cookies {
-		req.AddCookie(c)
-	}
-
-	rr := httptest.NewRecorder()
-	r.ServeHTTP(rr, req)
-
-	assert.Equal(t, http.StatusBadRequest, rr.Code)
-}
-
-func TestAPIListTokens(t *testing.T) {
-	t.Parallel()
-
-	tc, cookies := setupAPITest(t)
-	r := tokenRouter(tc)
-
-	// Create two tokens.
-	for _, name := range []string{"token-a", "token-b"} {
-		body := `{"name":"` + name + `"}`
-		req := httptest.NewRequest(
-			http.MethodPost, "/api/v1/tokens",
-			strings.NewReader(body),
-		)
-		req.Header.Set("Content-Type", "application/json")
-
-		for _, c := range cookies {
-			req.AddCookie(c)
-		}
-
-		rr := httptest.NewRecorder()
-		r.ServeHTTP(rr, req)
-		require.Equal(t, http.StatusCreated, rr.Code)
-	}
-
-	// List tokens.
-	req := httptest.NewRequest(http.MethodGet, "/api/v1/tokens", nil)
-
-	for _, c := range cookies {
-		req.AddCookie(c)
-	}
-
-	rr := httptest.NewRecorder()
-	r.ServeHTTP(rr, req)
-
-	assert.Equal(t, http.StatusOK, rr.Code)
-
-	var tokens []map[string]any
-	require.NoError(t, json.Unmarshal(rr.Body.Bytes(), &tokens))
-	assert.Len(t, tokens, 2)
-
-	// Plaintext token must NOT appear in list.
-	for _, tok := range tokens {
-		assert.Nil(t, tok["token"])
-	}
-}
-
-func TestAPIDeleteToken(t *testing.T) {
-	t.Parallel()
-
-	tc, cookies := setupAPITest(t)
-	r := tokenRouter(tc)
-
-	// Create a token.
-	body := `{"name":"delete-me"}`
-	req := httptest.NewRequest(
-		http.MethodPost, "/api/v1/tokens",
-		strings.NewReader(body),
-	)
-	req.Header.Set("Content-Type", "application/json")
-
-	for _, c := range cookies {
-		req.AddCookie(c)
-	}
-
-	rr := httptest.NewRecorder()
-	r.ServeHTTP(rr, req)
-	require.Equal(t, http.StatusCreated, rr.Code)
-
-	var created map[string]any
-	require.NoError(t, json.Unmarshal(rr.Body.Bytes(), &created))
-
-	tokenID, ok := created["id"].(string)
-	require.True(t, ok)
-
-	// Delete it.
-	req = httptest.NewRequest(
-		http.MethodDelete, "/api/v1/tokens/"+tokenID, nil,
-	)
-
-	for _, c := range cookies {
-		req.AddCookie(c)
-	}
-
-	rr = httptest.NewRecorder()
-	r.ServeHTTP(rr, req)
-	assert.Equal(t, http.StatusOK, rr.Code)
-
-	// List should be empty.
-	req = httptest.NewRequest(http.MethodGet, "/api/v1/tokens", nil)
-
-	for _, c := range cookies {
-		req.AddCookie(c)
-	}
-
-	rr = httptest.NewRecorder()
-	r.ServeHTTP(rr, req)
-
-	var tokens []map[string]any
-	require.NoError(t, json.Unmarshal(rr.Body.Bytes(), &tokens))
-	assert.Empty(t, tokens)
-}
-
-func TestAPIBearerTokenAuth(t *testing.T) {
-	t.Parallel()
-
-	tc, cookies := setupAPITest(t)
-	r := tokenRouter(tc)
-
-	// Create a token via session auth.
-	body := `{"name":"bearer-test"}`
-	req := httptest.NewRequest(
-		http.MethodPost, "/api/v1/tokens",
-		strings.NewReader(body),
-	)
-	req.Header.Set("Content-Type", "application/json")
-
-	for _, c := range cookies {
-		req.AddCookie(c)
-	}
-
-	rr := httptest.NewRecorder()
-	r.ServeHTTP(rr, req)
-	require.Equal(t, http.StatusCreated, rr.Code)
-
-	var created map[string]any
-	require.NoError(t, json.Unmarshal(rr.Body.Bytes(), &created))
-
-	plaintext, ok := created["token"].(string)
-	require.True(t, ok)
-
-	// Use Bearer token to access an authenticated endpoint.
-	req = httptest.NewRequest(http.MethodGet, "/api/v1/apps", nil)
-	req.Header.Set("Authorization", "Bearer "+plaintext)
-
-	rr = httptest.NewRecorder()
-	r.ServeHTTP(rr, req)
-	assert.Equal(t, http.StatusOK, rr.Code)
-}
-
-func TestAPIBearerTokenInvalid(t *testing.T) {
-	t.Parallel()
-
-	tc := setupTestHandlers(t)
-	r := tokenRouter(tc)
-
-	req := httptest.NewRequest(http.MethodGet, "/api/v1/apps", nil)
-	req.Header.Set("Authorization", "Bearer upaas_invalidtoken1234567890ab")
-
-	rr := httptest.NewRecorder()
-	r.ServeHTTP(rr, req)
-	assert.Equal(t, http.StatusUnauthorized, rr.Code)
-}
-
-func TestAPIBearerTokenRevoked(t *testing.T) {
-	t.Parallel()
-
-	tc, cookies := setupAPITest(t)
-	r := tokenRouter(tc)
-
-	// Create then delete a token.
-	body := `{"name":"revoke-test"}`
-	req := httptest.NewRequest(
-		http.MethodPost, "/api/v1/tokens",
-		strings.NewReader(body),
-	)
-	req.Header.Set("Content-Type", "application/json")
-
-	for _, c := range cookies {
-		req.AddCookie(c)
-	}
-
-	rr := httptest.NewRecorder()
-	r.ServeHTTP(rr, req)
-	require.Equal(t, http.StatusCreated, rr.Code)
-
-	var created map[string]any
-	require.NoError(t, json.Unmarshal(rr.Body.Bytes(), &created))
-
-	plaintext, ok := created["token"].(string)
-	require.True(t, ok)
-	tokenID, ok := created["id"].(string)
-	require.True(t, ok)
-
-	// Delete (revoke) the token.
-	req = httptest.NewRequest(
-		http.MethodDelete, "/api/v1/tokens/"+tokenID, nil,
-	)
-
-	for _, c := range cookies {
-		req.AddCookie(c)
-	}
-
-	rr = httptest.NewRecorder()
-	r.ServeHTTP(rr, req)
-	require.Equal(t, http.StatusOK, rr.Code)
-
-	// Try to use the revoked token.
-	req = httptest.NewRequest(http.MethodGet, "/api/v1/apps", nil)
-	req.Header.Set("Authorization", "Bearer "+plaintext)
-
-	rr = httptest.NewRecorder()
-	r.ServeHTTP(rr, req)
-	assert.Equal(t, http.StatusUnauthorized, rr.Code)
-}

internal/handlers/api_tokens.go

@@ -1,220 +0,0 @@
-package handlers
-
-import (
-	"context"
-	"encoding/json"
-	"fmt"
-	"net/http"
-
-	"github.com/go-chi/chi/v5"
-
-	"git.eeqj.de/sneak/upaas/internal/database"
-	"git.eeqj.de/sneak/upaas/internal/models"
-)
-
-// apiTokenResponse is the JSON representation of an API token.
-type apiTokenResponse struct {
-	ID         string  `json:"id"`
-	Name       string  `json:"name"`
-	CreatedAt  string  `json:"createdAt"`
-	ExpiresAt  *string `json:"expiresAt,omitempty"`
-	LastUsedAt *string `json:"lastUsedAt,omitempty"`
-}
-
-// apiTokenCreateResponse includes the plaintext token (shown once).
-type apiTokenCreateResponse struct {
-	apiTokenResponse
-
-	Token string `json:"token"`
-}
-
-func tokenToAPI(t *models.APIToken) apiTokenResponse {
-	resp := apiTokenResponse{
-		ID:        t.ID,
-		Name:      t.Name,
-		CreatedAt: t.CreatedAt.Format("2006-01-02T15:04:05Z"),
-	}
-
-	if t.ExpiresAt.Valid {
-		s := t.ExpiresAt.Time.Format("2006-01-02T15:04:05Z")
-		resp.ExpiresAt = &s
-	}
-
-	if t.LastUsedAt.Valid {
-		s := t.LastUsedAt.Time.Format("2006-01-02T15:04:05Z")
-		resp.LastUsedAt = &s
-	}
-
-	return resp
-}
-
-// createTokenRequest is the JSON body for token creation.
-type createTokenRequest struct {
-	Name string `json:"name"`
-}
-
-// createAndSaveToken generates a token, saves it, and returns
-// the plaintext and model.
-func (h *Handlers) createAndSaveToken(
-	ctx context.Context,
-	userID int64,
-	name string,
-) (string, *models.APIToken, error) {
-	plaintext, err := models.GenerateToken()
-	if err != nil {
-		return "", nil, fmt.Errorf("generating: %w", err)
-	}
-
-	token := models.NewAPIToken(h.db)
-	token.UserID = userID
-	token.Name = name
-	token.TokenHash = database.HashAPIToken(plaintext)
-
-	saveErr := token.Save(ctx)
-	if saveErr != nil {
-		return "", nil, fmt.Errorf("saving: %w", saveErr)
-	}
-
-	return plaintext, token, nil
-}
-
-// HandleAPICreateToken returns a handler that creates an API token.
-func (h *Handlers) HandleAPICreateToken() http.HandlerFunc {
-	return func(writer http.ResponseWriter, request *http.Request) {
-		user, err := h.auth.GetCurrentUser(
-			request.Context(), request,
-		)
-		if err != nil || user == nil {
-			h.respondJSON(writer, request,
-				map[string]string{"error": "unauthorized"},
-				http.StatusUnauthorized)
-
-			return
-		}
-
-		var req createTokenRequest
-
-		decodeErr := json.NewDecoder(request.Body).Decode(&req)
-		if decodeErr != nil {
-			h.respondJSON(writer, request,
-				map[string]string{"error": "invalid JSON body"},
-				http.StatusBadRequest)
-
-			return
-		}
-
-		if req.Name == "" {
-			h.respondJSON(writer, request,
-				map[string]string{"error": "name is required"},
-				http.StatusBadRequest)
-
-			return
-		}
-
-		plaintext, token, createErr := h.createAndSaveToken(
-			request.Context(), user.ID, req.Name,
-		)
-		if createErr != nil {
-			h.log.Error("api: token creation failed",
-				"error", createErr)
-			h.respondJSON(writer, request,
-				map[string]string{"error": "internal error"},
-				http.StatusInternalServerError)
-
-			return
-		}
-
-		h.respondJSON(writer, request, apiTokenCreateResponse{
-			apiTokenResponse: tokenToAPI(token),
-			Token:            plaintext,
-		}, http.StatusCreated)
-	}
-}
-
-// HandleAPIListTokens returns a handler that lists API tokens.
-func (h *Handlers) HandleAPIListTokens() http.HandlerFunc {
-	return func(writer http.ResponseWriter, request *http.Request) {
-		user, err := h.auth.GetCurrentUser(
-			request.Context(), request,
-		)
-		if err != nil || user == nil {
-			h.respondJSON(writer, request,
-				map[string]string{"error": "unauthorized"},
-				http.StatusUnauthorized)
-
-			return
-		}
-
-		tokens, listErr := models.ListAPITokensByUser(
-			request.Context(), h.db, user.ID,
-		)
-		if listErr != nil {
-			h.log.Error("api: failed to list tokens",
-				"error", listErr)
-			h.respondJSON(writer, request,
-				map[string]string{"error": "internal error"},
-				http.StatusInternalServerError)
-
-			return
-		}
-
-		result := make([]apiTokenResponse, 0, len(tokens))
-		for _, t := range tokens {
-			result = append(result, tokenToAPI(t))
-		}
-
-		h.respondJSON(writer, request, result, http.StatusOK)
-	}
-}
-
-// HandleAPIDeleteToken returns a handler that revokes an API token.
-func (h *Handlers) HandleAPIDeleteToken() http.HandlerFunc {
-	return func(writer http.ResponseWriter, request *http.Request) {
-		user, err := h.auth.GetCurrentUser(
-			request.Context(), request,
-		)
-		if err != nil || user == nil {
-			h.respondJSON(writer, request,
-				map[string]string{"error": "unauthorized"},
-				http.StatusUnauthorized)
-
-			return
-		}
-
-		tokenID := chi.URLParam(request, "tokenID")
-
-		token, findErr := models.FindAPIToken(
-			request.Context(), h.db, tokenID,
-		)
-		if findErr != nil {
-			h.respondJSON(writer, request,
-				map[string]string{"error": "internal error"},
-				http.StatusInternalServerError)
-
-			return
-		}
-
-		if token == nil || token.UserID != user.ID {
-			h.respondJSON(writer, request,
-				map[string]string{"error": "token not found"},
-				http.StatusNotFound)
-
-			return
-		}
-
-		deleteErr := token.Delete(request.Context())
-		if deleteErr != nil {
-			h.log.Error("api: failed to delete token",
-				"error", deleteErr)
-			h.respondJSON(writer, request,
-				map[string]string{"error": "internal error"},
-				http.StatusInternalServerError)
-
-			return
-		}
-
-		h.respondJSON(writer, request,
-			map[string]string{"status": "deleted"},
-			http.StatusOK)
-	}
-}

internal/handlers/app.go

@@ -77,6 +77,14 @@ func (h *Handlers) HandleAppCreate() http.HandlerFunc { //nolint:funlen // valid
 			return
 		}
 
+		repoURLErr := validateRepoURL(repoURL)
+		if repoURLErr != nil {
+			data["Error"] = "Invalid repository URL: " + repoURLErr.Error()
+			h.renderTemplate(writer, tmpl, "app_new.html", data)
+
+			return
+		}
+
 		if branch == "" {
 			branch = "main"
 		}
@@ -225,6 +233,17 @@ func (h *Handlers) HandleAppUpdate() http.HandlerFunc { //nolint:funlen // valid
 			return
 		}
 
+		repoURLErr := validateRepoURL(request.FormValue("repo_url"))
+		if repoURLErr != nil {
+			data := h.addGlobals(map[string]any{
+				"App":   application,
+				"Error": "Invalid repository URL: " + repoURLErr.Error(),
+			}, request)
+			_ = tmpl.ExecuteTemplate(writer, "app_edit.html", data)
+
+			return
+		}
+
 		application.Name = newName
 		application.RepoURL = request.FormValue("repo_url")
 		application.Branch = request.FormValue("branch")
@@ -499,8 +518,7 @@ func (h *Handlers) HandleAppLogs() http.HandlerFunc {
 			return
 		}
 
-		//nolint:gosec // logs sanitized: ANSI escapes and control chars stripped
+		_, _ = writer.Write([]byte(SanitizeLogs(logs))) // #nosec G705 -- logs sanitized, Content-Type is text/plain
-		_, _ = writer.Write([]byte(SanitizeLogs(logs)))
 	}
 }
 
@@ -535,11 +553,11 @@ func (h *Handlers) HandleDeploymentLogsAPI() http.HandlerFunc {
 
 		logs := ""
 		if deployment.Logs.Valid {
-			logs = deployment.Logs.String
+			logs = SanitizeLogs(deployment.Logs.String)
 		}
 
 		response := map[string]any{
-			"logs":   SanitizeLogs(logs),
+			"logs":   logs,
 			"status": deployment.Status,
 		}
 
@@ -582,8 +600,8 @@ func (h *Handlers) HandleDeploymentLogDownload() http.HandlerFunc {
 			return
 		}
 
-		// Check if file exists
+		// Check if file exists — logPath is constructed internally, not from user input
-		_, err := os.Stat(logPath) //nolint:gosec // logPath is constructed by deploy service, not from user input
+		_, err := os.Stat(logPath) // #nosec G703 -- path from internal GetLogFilePath, not user input
 		if os.IsNotExist(err) {
 			http.NotFound(writer, request)
 

internal/handlers/handlers_test.go

@@ -169,11 +169,10 @@ func setupTestHandlers(t *testing.T) *testContext {
 	require.NoError(t, handlerErr)
 
 	mw, mwErr := middleware.New(fx.Lifecycle(nil), middleware.Params{
-		Logger:   logInstance,
+		Logger:  logInstance,
-		Globals:  globalInstance,
+		Globals: globalInstance,
-		Config:   cfg,
+		Config:  cfg,
-		Auth:     authSvc,
+		Auth:    authSvc,
-		Database: dbInstance,
 	})
 	require.NoError(t, mwErr)
 

internal/handlers/repo_url_validation.go

@@ -0,0 +1,67 @@
+package handlers
+
+import (
+	"errors"
+	"net/url"
+	"regexp"
+	"strings"
+)
+
+// Repo URL validation errors.
+var (
+	errRepoURLEmpty   = errors.New("repository URL must not be empty")
+	errRepoURLScheme  = errors.New("file:// URLs are not allowed for security reasons")
+	errRepoURLInvalid = errors.New("repository URL must use https://, http://, ssh://, git://, or git@host:path format")
+	errRepoURLNoHost  = errors.New("repository URL must include a host")
+	errRepoURLNoPath  = errors.New("repository URL must include a path")
+)
+
+// scpLikeRepoRe matches SCP-like git URLs: git@host:path (e.g. git@github.com:user/repo.git).
+// Only the "git" user is allowed, as that is the standard for SSH deploy keys.
+var scpLikeRepoRe = regexp.MustCompile(`^git@[a-zA-Z0-9._-]+:.+$`)
+
+// validateRepoURL checks that the given repository URL is valid and uses an allowed scheme.
+func validateRepoURL(repoURL string) error {
+	if strings.TrimSpace(repoURL) == "" {
+		return errRepoURLEmpty
+	}
+
+	// Reject path traversal in any URL format
+	if strings.Contains(repoURL, "..") {
+		return errRepoURLInvalid
+	}
+
+	// Check for SCP-like git URLs first (git@host:path)
+	if scpLikeRepoRe.MatchString(repoURL) {
+		return nil
+	}
+
+	// Reject file:// explicitly
+	if strings.HasPrefix(strings.ToLower(repoURL), "file://") {
+		return errRepoURLScheme
+	}
+
+	// Parse as standard URL
+	parsed, err := url.Parse(repoURL)
+	if err != nil {
+		return errRepoURLInvalid
+	}
+
+	// Must have a recognized scheme
+	switch strings.ToLower(parsed.Scheme) {
+	case "https", "http", "ssh", "git":
+		// OK
+	default:
+		return errRepoURLInvalid
+	}
+
+	if parsed.Host == "" {
+		return errRepoURLNoHost
+	}
+
+	if parsed.Path == "" || parsed.Path == "/" {
+		return errRepoURLNoPath
+	}
+
+	return nil
+}

internal/handlers/repo_url_validation_test.go

@@ -0,0 +1,56 @@
+package handlers
+
+import "testing"
+
+func TestValidateRepoURL(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name    string
+		url     string
+		wantErr bool
+	}{
+		// Valid URLs
+		{name: "https URL", url: "https://github.com/user/repo.git", wantErr: false},
+		{name: "http URL", url: "http://github.com/user/repo.git", wantErr: false},
+		{name: "ssh URL", url: "ssh://git@github.com/user/repo.git", wantErr: false},
+		{name: "git URL", url: "git://github.com/user/repo.git", wantErr: false},
+		{name: "SCP-like URL", url: "git@github.com:user/repo.git", wantErr: false},
+		{name: "SCP-like with dots", url: "git@git.example.com:org/repo.git", wantErr: false},
+		{name: "https without .git", url: "https://github.com/user/repo", wantErr: false},
+		{name: "https with port", url: "https://git.example.com:8443/user/repo.git", wantErr: false},
+
+		// Invalid URLs
+		{name: "empty string", url: "", wantErr: true},
+		{name: "whitespace only", url: "   ", wantErr: true},
+		{name: "file URL", url: "file:///etc/passwd", wantErr: true},
+		{name: "file URL uppercase", url: "FILE:///etc/passwd", wantErr: true},
+		{name: "bare path", url: "/some/local/path", wantErr: true},
+		{name: "relative path", url: "../repo", wantErr: true},
+		{name: "just a word", url: "notaurl", wantErr: true},
+		{name: "ftp URL", url: "ftp://example.com/repo.git", wantErr: true},
+		{name: "no host https", url: "https:///path", wantErr: true},
+		{name: "no path https", url: "https://github.com", wantErr: true},
+		{name: "no path https trailing slash", url: "https://github.com/", wantErr: true},
+		{name: "SCP-like non-git user", url: "root@github.com:user/repo.git", wantErr: true},
+		{name: "SCP-like arbitrary user", url: "admin@github.com:user/repo.git", wantErr: true},
+		{name: "path traversal SCP", url: "git@github.com:../../etc/passwd", wantErr: true},
+		{name: "path traversal https", url: "https://github.com/user/../../../etc/passwd", wantErr: true},
+		{name: "path traversal in middle", url: "https://github.com/user/repo/../secret", wantErr: true},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			t.Parallel()
+
+			err := validateRepoURL(tc.url)
+			if tc.wantErr && err == nil {
+				t.Errorf("validateRepoURL(%q) = nil, want error", tc.url)
+			}
+
+			if !tc.wantErr && err != nil {
+				t.Errorf("validateRepoURL(%q) = %v, want nil", tc.url, err)
+			}
+		})
+	}
+}

internal/middleware/bearer_auth_test.go

@@ -1,160 +0,0 @@
-package middleware_test
-
-import (
-	"net/http"
-	"net/http/httptest"
-	"path/filepath"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-	"go.uber.org/fx"
-
-	"git.eeqj.de/sneak/upaas/internal/config"
-	"git.eeqj.de/sneak/upaas/internal/database"
-	"git.eeqj.de/sneak/upaas/internal/globals"
-	"git.eeqj.de/sneak/upaas/internal/logger"
-	"git.eeqj.de/sneak/upaas/internal/middleware"
-	"git.eeqj.de/sneak/upaas/internal/models"
-	"git.eeqj.de/sneak/upaas/internal/service/auth"
-)
-
-// setupMiddleware creates a Middleware with a real SQLite database for
-// integration testing.
-func setupMiddleware(t *testing.T) (*middleware.Middleware, *auth.Service, *database.Database) {
-	t.Helper()
-
-	tmpDir := t.TempDir()
-
-	globals.SetAppname("upaas-test")
-	globals.SetVersion("test")
-
-	globalsInst, err := globals.New(fx.Lifecycle(nil))
-	require.NoError(t, err)
-
-	loggerInst, err := logger.New(
-		fx.Lifecycle(nil),
-		logger.Params{Globals: globalsInst},
-	)
-	require.NoError(t, err)
-
-	cfg := &config.Config{
-		Port:          8080,
-		DataDir:       tmpDir,
-		SessionSecret: "test-secret-key-at-least-32-chars!!",
-	}
-	_ = filepath.Join(tmpDir, "upaas.db")
-
-	dbInst, err := database.New(fx.Lifecycle(nil), database.Params{
-		Logger: loggerInst,
-		Config: cfg,
-	})
-	require.NoError(t, err)
-
-	authSvc, err := auth.New(fx.Lifecycle(nil), auth.ServiceParams{
-		Logger:   loggerInst,
-		Config:   cfg,
-		Database: dbInst,
-	})
-	require.NoError(t, err)
-
-	mw, err := middleware.New(fx.Lifecycle(nil), middleware.Params{
-		Logger:   loggerInst,
-		Globals:  globalsInst,
-		Config:   cfg,
-		Auth:     authSvc,
-		Database: dbInst,
-	})
-	require.NoError(t, err)
-
-	return mw, authSvc, dbInst
-}
-
-func TestAPISessionAuth_BearerTokenSetsUserContext(t *testing.T) {
-	t.Parallel()
-
-	mw, authSvc, dbInst := setupMiddleware(t)
-	ctx := t.Context()
-
-	// Create a user.
-	user, err := authSvc.CreateUser(ctx, "testuser", "password123")
-	require.NoError(t, err)
-	require.NotNil(t, user)
-
-	// Create an API token for the user.
-	rawToken, err := models.GenerateToken()
-	require.NoError(t, err)
-
-	tokenHash := database.HashAPIToken(rawToken)
-	apiToken := models.NewAPIToken(dbInst)
-	apiToken.UserID = user.ID
-	apiToken.Name = "test-token"
-	apiToken.TokenHash = tokenHash
-
-	err = apiToken.Save(ctx)
-	require.NoError(t, err)
-
-	// Build a handler behind APISessionAuth that checks user context.
-	var gotUser *models.User
-
-	var getUserErr error
-
-	handler := mw.APISessionAuth()(http.HandlerFunc(
-		func(w http.ResponseWriter, r *http.Request) {
-			gotUser, getUserErr = authSvc.GetCurrentUser(r.Context(), r)
-
-			w.WriteHeader(http.StatusOK)
-		},
-	))
-
-	// Make request with bearer token.
-	req := httptest.NewRequest(http.MethodGet, "/api/test", nil)
-	req.Header.Set("Authorization", "Bearer "+rawToken)
-
-	rec := httptest.NewRecorder()
-	handler.ServeHTTP(rec, req)
-
-	assert.Equal(t, http.StatusOK, rec.Code)
-	require.NoError(t, getUserErr)
-	require.NotNil(t, gotUser, "GetCurrentUser should return the user for bearer auth")
-	assert.Equal(t, user.ID, gotUser.ID)
-	assert.Equal(t, "testuser", gotUser.Username)
-}
-
-func TestAPISessionAuth_NoBearerTokenReturns401(t *testing.T) {
-	t.Parallel()
-
-	mw, _, _ := setupMiddleware(t)
-
-	handler := mw.APISessionAuth()(http.HandlerFunc(
-		func(w http.ResponseWriter, _ *http.Request) {
-			w.WriteHeader(http.StatusOK)
-		},
-	))
-
-	req := httptest.NewRequest(http.MethodGet, "/api/test", nil)
-	rec := httptest.NewRecorder()
-	handler.ServeHTTP(rec, req)
-
-	assert.Equal(t, http.StatusUnauthorized, rec.Code)
-}
-
-func TestAPISessionAuth_InvalidBearerTokenReturns401(t *testing.T) {
-	t.Parallel()
-
-	mw, _, _ := setupMiddleware(t)
-
-	handler := mw.APISessionAuth()(http.HandlerFunc(
-		func(w http.ResponseWriter, _ *http.Request) {
-			w.WriteHeader(http.StatusOK)
-		},
-	))
-
-	req := httptest.NewRequest(http.MethodGet, "/api/test", nil)
-	req.Header.Set("Authorization", "Bearer invalid-token")
-
-	rec := httptest.NewRecorder()
-	handler.ServeHTTP(rec, req)
-
-	assert.Equal(t, http.StatusUnauthorized, rec.Code)
-}

internal/middleware/middleware.go

@@ -19,10 +19,8 @@ import (
 	"golang.org/x/time/rate"
 
 	"git.eeqj.de/sneak/upaas/internal/config"
-	"git.eeqj.de/sneak/upaas/internal/database"
 	"git.eeqj.de/sneak/upaas/internal/globals"
 	"git.eeqj.de/sneak/upaas/internal/logger"
-	"git.eeqj.de/sneak/upaas/internal/models"
 	"git.eeqj.de/sneak/upaas/internal/service/auth"
 )
 
@@ -33,11 +31,10 @@ const corsMaxAge = 300
 type Params struct {
 	fx.In
 
-	Logger   *logger.Logger
+	Logger  *logger.Logger
-	Globals  *globals.Globals
+	Globals *globals.Globals
-	Config   *config.Config
+	Config  *config.Config
-	Auth     *auth.Service
+	Auth    *auth.Service
-	Database *database.Database
 }
 
 // Middleware provides HTTP middleware.
@@ -373,36 +370,18 @@ func (m *Middleware) LoginRateLimit() func(http.Handler) http.Handler {
 	}
 }
 
-// bearerPrefix is the expected prefix for Authorization headers.
+// APISessionAuth returns middleware that requires session authentication for API routes.
-const bearerPrefix = "Bearer "
+// Unlike SessionAuth, it returns JSON 401 responses instead of redirecting to /login.
-
-// APISessionAuth returns middleware that requires authentication
-// for API routes. It checks Bearer token first, then falls back
-// to session cookie. Returns JSON 401 on failure.
 func (m *Middleware) APISessionAuth() func(http.Handler) http.Handler {
 	return func(next http.Handler) http.Handler {
 		return http.HandlerFunc(func(
 			writer http.ResponseWriter,
 			request *http.Request,
 		) {
-			// Try Bearer token first.
+			user, err := m.params.Auth.GetCurrentUser(request.Context(), request)
-			if authedReq, ok := m.tryBearerAuth(request); ok {
-				next.ServeHTTP(writer, authedReq)
-
-				return
-			}
-
-			// Fall back to session cookie.
-			user, err := m.params.Auth.GetCurrentUser(
-				request.Context(), request,
-			)
 			if err != nil || user == nil {
 				writer.Header().Set("Content-Type", "application/json")
-				http.Error(
+				http.Error(writer, `{"error":"unauthorized"}`, http.StatusUnauthorized)
-					writer,
-					`{"error":"unauthorized"}`,
-					http.StatusUnauthorized,
-				)
 
 				return
 			}
@@ -455,49 +434,3 @@ func (m *Middleware) SetupRequired() func(http.Handler) http.Handler {
 		})
 	}
 }
-
-// tryBearerAuth checks for a valid Bearer token in the
-// Authorization header. On success it returns a new request
-// with the authenticated user set on the context.
-func (m *Middleware) tryBearerAuth(
-	request *http.Request,
-) (*http.Request, bool) {
-	authHeader := request.Header.Get("Authorization")
-	if !strings.HasPrefix(authHeader, bearerPrefix) {
-		return request, false
-	}
-
-	rawToken := strings.TrimPrefix(authHeader, bearerPrefix)
-	if rawToken == "" {
-		return request, false
-	}
-
-	tokenHash := database.HashAPIToken(rawToken)
-
-	apiToken, err := models.FindAPITokenByHash(
-		request.Context(), m.params.Database, tokenHash,
-	)
-	if err != nil || apiToken == nil {
-		return request, false
-	}
-
-	if apiToken.IsExpired() {
-		return request, false
-	}
-
-	// Look up the user associated with the token.
-	user, err := models.FindUser(
-		request.Context(), m.params.Database, apiToken.UserID,
-	)
-	if err != nil || user == nil {
-		return request, false
-	}
-
-	// Update last_used_at (best effort).
-	_ = apiToken.TouchLastUsed(request.Context())
-
-	// Set the authenticated user on the request context.
-	ctx := auth.ContextWithUser(request.Context(), user)
-
-	return request.WithContext(ctx), true
-}

internal/models/api_token.go

@@ -1,206 +0,0 @@
-package models
-
-import (
-	"context"
-	"crypto/rand"
-	"database/sql"
-	"encoding/hex"
-	"errors"
-	"fmt"
-	"time"
-
-	"github.com/oklog/ulid/v2"
-
-	"git.eeqj.de/sneak/upaas/internal/database"
-)
-
-// tokenRandomBytes is the number of random bytes for token generation.
-const tokenRandomBytes = 32
-
-// tokenPrefix is prepended to generated API tokens.
-const tokenPrefix = "upaas_"
-
-// APIToken represents an API authentication token.
-type APIToken struct {
-	db *database.Database
-
-	ID         string
-	UserID     int64
-	Name       string
-	TokenHash  string
-	CreatedAt  time.Time
-	ExpiresAt  sql.NullTime
-	LastUsedAt sql.NullTime
-}
-
-// NewAPIToken creates a new APIToken with a database reference.
-func NewAPIToken(db *database.Database) *APIToken {
-	return &APIToken{db: db}
-}
-
-// GenerateToken generates a random API token string.
-func GenerateToken() (string, error) {
-	b := make([]byte, tokenRandomBytes)
-
-	_, err := rand.Read(b)
-	if err != nil {
-		return "", fmt.Errorf("generating token: %w", err)
-	}
-
-	return tokenPrefix + hex.EncodeToString(b), nil
-}
-
-// Save inserts the API token into the database.
-func (t *APIToken) Save(ctx context.Context) error {
-	if t.ID == "" {
-		t.ID = ulid.Make().String()
-	}
-
-	query := `INSERT INTO api_tokens
-		(id, user_id, name, token_hash, expires_at)
-		VALUES (?, ?, ?, ?, ?)`
-
-	_, err := t.db.Exec(
-		ctx, query,
-		t.ID, t.UserID, t.Name, t.TokenHash, t.ExpiresAt,
-	)
-	if err != nil {
-		return fmt.Errorf("inserting api token: %w", err)
-	}
-
-	return t.Reload(ctx)
-}
-
-// Reload refreshes the token from the database.
-func (t *APIToken) Reload(ctx context.Context) error {
-	row := t.db.QueryRow(ctx,
-		`SELECT id, user_id, name, token_hash,
-			created_at, expires_at, last_used_at
-		 FROM api_tokens WHERE id = ?`, t.ID)
-
-	return t.scan(row)
-}
-
-// Delete removes the token from the database.
-func (t *APIToken) Delete(ctx context.Context) error {
-	_, err := t.db.Exec(ctx,
-		"DELETE FROM api_tokens WHERE id = ?", t.ID)
-
-	return err
-}
-
-// TouchLastUsed updates the last_used_at timestamp.
-func (t *APIToken) TouchLastUsed(ctx context.Context) error {
-	_, err := t.db.Exec(ctx,
-		"UPDATE api_tokens SET last_used_at = ? WHERE id = ?",
-		time.Now().UTC(), t.ID)
-
-	return err
-}
-
-// IsExpired reports whether the token has expired.
-func (t *APIToken) IsExpired() bool {
-	return t.ExpiresAt.Valid && t.ExpiresAt.Time.Before(time.Now())
-}
-
-func (t *APIToken) scan(row *sql.Row) error {
-	return row.Scan(
-		&t.ID, &t.UserID, &t.Name, &t.TokenHash,
-		&t.CreatedAt, &t.ExpiresAt, &t.LastUsedAt,
-	)
-}
-
-// FindAPITokenByHash finds a token by its hash.
-//
-//nolint:nilnil // nil,nil is idiomatic for "not found"
-func FindAPITokenByHash(
-	ctx context.Context,
-	db *database.Database,
-	hash string,
-) (*APIToken, error) {
-	token := NewAPIToken(db)
-
-	row := db.QueryRow(ctx,
-		`SELECT id, user_id, name, token_hash,
-			created_at, expires_at, last_used_at
-		 FROM api_tokens WHERE token_hash = ?`, hash)
-
-	err := token.scan(row)
-	if err != nil {
-		if errors.Is(err, sql.ErrNoRows) {
-			return nil, nil
-		}
-
-		return nil, fmt.Errorf("finding api token by hash: %w", err)
-	}
-
-	return token, nil
-}
-
-// FindAPIToken finds a token by ID.
-//
-//nolint:nilnil // nil,nil is idiomatic for "not found"
-func FindAPIToken(
-	ctx context.Context,
-	db *database.Database,
-	id string,
-) (*APIToken, error) {
-	token := NewAPIToken(db)
-
-	row := db.QueryRow(ctx,
-		`SELECT id, user_id, name, token_hash,
-			created_at, expires_at, last_used_at
-		 FROM api_tokens WHERE id = ?`, id)
-
-	err := token.scan(row)
-	if err != nil {
-		if errors.Is(err, sql.ErrNoRows) {
-			return nil, nil
-		}
-
-		return nil, fmt.Errorf("finding api token: %w", err)
-	}
-
-	return token, nil
-}
-
-// ListAPITokensByUser returns all tokens for a user.
-func ListAPITokensByUser(
-	ctx context.Context,
-	db *database.Database,
-	userID int64,
-) ([]*APIToken, error) {
-	rows, err := db.Query(ctx,
-		`SELECT id, user_id, name, token_hash,
-			created_at, expires_at, last_used_at
-		 FROM api_tokens WHERE user_id = ?
-		 ORDER BY created_at DESC`, userID)
-	if err != nil {
-		return nil, fmt.Errorf("listing api tokens: %w", err)
-	}
-
-	defer func() { _ = rows.Close() }()
-
-	var tokens []*APIToken
-
-	for rows.Next() {
-		t := NewAPIToken(db)
-
-		scanErr := rows.Scan(
-			&t.ID, &t.UserID, &t.Name, &t.TokenHash,
-			&t.CreatedAt, &t.ExpiresAt, &t.LastUsedAt,
-		)
-		if scanErr != nil {
-			return nil, fmt.Errorf("scanning api token: %w", scanErr)
-		}
-
-		tokens = append(tokens, t)
-	}
-
-	rowsErr := rows.Err()
-	if rowsErr != nil {
-		return nil, fmt.Errorf("iterating api tokens: %w", rowsErr)
-	}
-
-	return tokens, nil
-}

internal/server/routes.go

@@ -119,11 +119,6 @@ func (s *Server) SetupRoutes() {
 			r.Delete("/apps/{id}", s.handlers.HandleAPIDeleteApp())
 			r.Post("/apps/{id}/deploy", s.handlers.HandleAPITriggerDeploy())
 			r.Get("/apps/{id}/deployments", s.handlers.HandleAPIListDeployments())
-
-			// API token management
-			r.Post("/tokens", s.handlers.HandleAPICreateToken())
-			r.Get("/tokens", s.handlers.HandleAPIListTokens())
-			r.Delete("/tokens/{tokenID}", s.handlers.HandleAPIDeleteToken())
 		})
 	})
 

internal/service/auth/auth.go

@@ -26,21 +26,6 @@ const (
 	sessionUserID = "user_id"
 )
 
-// contextKeyUser is the context key for storing the authenticated user.
-type contextKeyUser struct{}
-
-// ContextWithUser returns a new context with the given user attached.
-func ContextWithUser(ctx context.Context, user *models.User) context.Context {
-	return context.WithValue(ctx, contextKeyUser{}, user)
-}
-
-// UserFromContext retrieves the user from the context, if set.
-func UserFromContext(ctx context.Context) *models.User {
-	user, _ := ctx.Value(contextKeyUser{}).(*models.User)
-
-	return user
-}
-
 // Argon2 parameters.
 const (
 	argonTime    = 1
@@ -254,11 +239,6 @@ func (svc *Service) GetCurrentUser(
 	ctx context.Context,
 	request *http.Request,
 ) (*models.User, error) {
-	// Check context first (set by bearer token auth).
-	if user := UserFromContext(ctx); user != nil {
-		return user, nil
-	}
-
 	session, sessionErr := svc.store.Get(request, sessionName)
 	if sessionErr != nil {
 		// Session error means no user - this is not an error condition

internal/service/notify/notify.go

@@ -10,6 +10,7 @@ import (
 	"fmt"
 	"log/slog"
 	"net/http"
+	"net/url"
 	"time"
 
 	"go.uber.org/fx"
@@ -247,10 +248,15 @@ func (svc *Service) sendNtfy(
 ) error {
 	svc.log.Debug("sending ntfy notification", "topic", topic, "title", title)
 
+	parsedURL, err := url.ParseRequestURI(topic)
+	if err != nil {
+		return fmt.Errorf("invalid ntfy topic URL: %w", err)
+	}
+
 	request, err := http.NewRequestWithContext(
 		ctx,
 		http.MethodPost,
-		topic,
+		parsedURL.String(),
 		bytes.NewBufferString(message),
 	)
 	if err != nil {
@@ -260,7 +266,7 @@ func (svc *Service) sendNtfy(
 	request.Header.Set("Title", title)
 	request.Header.Set("Priority", svc.ntfyPriority(priority))
 
-	resp, err := svc.client.Do(request) //nolint:gosec // URL constructed from trusted config, not user input
+	resp, err := svc.client.Do(request) // #nosec G704 -- URL from validated config, not user input
 	if err != nil {
 		return fmt.Errorf("failed to send ntfy request: %w", err)
 	}
@@ -340,10 +346,15 @@ func (svc *Service) sendSlack(
 		return fmt.Errorf("failed to marshal slack payload: %w", err)
 	}
 
+	parsedWebhookURL, err := url.ParseRequestURI(webhookURL)
+	if err != nil {
+		return fmt.Errorf("invalid slack webhook URL: %w", err)
+	}
+
 	request, err := http.NewRequestWithContext(
 		ctx,
 		http.MethodPost,
-		webhookURL,
+		parsedWebhookURL.String(),
 		bytes.NewBuffer(body),
 	)
 	if err != nil {
@@ -352,7 +363,7 @@ func (svc *Service) sendSlack(
 
 	request.Header.Set("Content-Type", "application/json")
 
-	resp, err := svc.client.Do(request) //nolint:gosec // URL from trusted webhook config
+	resp, err := svc.client.Do(request) // #nosec G704 -- URL from validated config, not user input
 	if err != nil {
 		return fmt.Errorf("failed to send slack request: %w", err)
 	}

internal/ssh/keygen.go

@@ -12,7 +12,7 @@ import (
 
 // KeyPair contains an SSH key pair.
 type KeyPair struct {
-	PrivateKey string //nolint:gosec // field name describes SSH key material, not a hardcoded secret
+	PrivateKey string `json:"-"`
 	PublicKey  string
 }
 

static/js/app.js

@@ -369,7 +369,7 @@ document.addEventListener("alpine:init", () => {
     init() {
       // Read initial logs from script tag (avoids escaping issues)
       const initialLogsEl = this.$el.querySelector(".initial-logs");
-      this.logs = initialLogsEl?.textContent || "Loading...";
+      this.logs = initialLogsEl?.dataset.logs || "Loading...";
 
       // Set up scroll tracking
       this.$nextTick(() => {

templates/deployments.html

@@ -98,7 +98,7 @@
                         title="Scroll to bottom"
                     >↓ Follow</button>
                 </div>
-                {{if .Logs.Valid}}<script type="text/plain" class="initial-logs">{{.Logs.String}}</script>{{end}}
+                {{if .Logs.Valid}}<div hidden class="initial-logs" data-logs="{{.Logs.String}}"></div>{{end}}
             </div>
             {{end}}
         </div>