appview: knotclient: init knot server client package

Lets us use it without an import cycle.

appview/oauth/handler/handler.go

···
 	"github.com/lestrrat-go/jwx/v2/jwk"
 	"tangled.sh/tangled.sh/core/appview"
 	"tangled.sh/tangled.sh/core/appview/db"
+	"tangled.sh/tangled.sh/core/appview/knotclient"
 	"tangled.sh/tangled.sh/core/appview/middleware"
 	"tangled.sh/tangled.sh/core/appview/oauth"
 	"tangled.sh/tangled.sh/core/appview/oauth/client"
 	"tangled.sh/tangled.sh/core/appview/pages"
+	"tangled.sh/tangled.sh/core/rbac"
 )
 
 const (
···
 	Db       *db.DB
 	Store    *sessions.CookieStore
 	OAuth    *oauth.OAuth
+	Enforcer *rbac.Enforcer
 }
 
 func (o *OAuthHandler) Router() http.Handler {
···
 	}
 
 	log.Println("session saved successfully")
+	go o.addToDefaultKnot(oauthRequest.Did)
 
 	http.Redirect(w, r, "/", http.StatusFound)
 }
···
 	}
 	return pubKey, nil
 }
+
+func (o *OAuthHandler) addToDefaultKnot(did string) {
+	defaultKnot := "knot1.tangled.sh"
+
+	log.Printf("adding %s to default knot", did)
+	err := o.Enforcer.AddMember(defaultKnot, did)
+	if err != nil {
+		log.Println("failed to add user to knot1.tangled.sh: ", err)
+		return
+	}
+	err = o.Enforcer.E.SavePolicy()
+	if err != nil {
+		log.Println("failed to add user to knot1.tangled.sh: ", err)
+		return
+	}
+
+	secret, err := db.GetRegistrationKey(o.Db, defaultKnot)
+	if err != nil {
+		log.Println("failed to get registration key for knot1.tangled.sh")
+		return
+	}
+	signedClient, err := knotclient.NewSignedClient(defaultKnot, secret, o.Config.Core.Dev)
+	resp, err := signedClient.AddMember(did)
+	if err != nil {
+		log.Println("failed to add user to knot1.tangled.sh: ", err)
+		return
+	}
+
+	if resp.StatusCode != http.StatusNoContent {
+		log.Println("failed to add user to knot1.tangled.sh: ", resp.StatusCode)
+		return
+	}
+}

appview/state/artifact.go

···
 	"tangled.sh/tangled.sh/core/api/tangled"
 	"tangled.sh/tangled.sh/core/appview"
 	"tangled.sh/tangled.sh/core/appview/db"
+	"tangled.sh/tangled.sh/core/appview/knotclient"
 	"tangled.sh/tangled.sh/core/appview/pages"
 	"tangled.sh/tangled.sh/core/types"
 )
···
 		return nil, err
 	}
 
-	us, err := NewUnsignedClient(f.Knot, s.config.Core.Dev)
+	us, err := knotclient.NewUnsignedClient(f.Knot, s.config.Core.Dev)
 	if err != nil {
 		return nil, err
 	}

appview/state/pull.go

···
 	"tangled.sh/tangled.sh/core/api/tangled"
 	"tangled.sh/tangled.sh/core/appview"
 	"tangled.sh/tangled.sh/core/appview/db"
+	"tangled.sh/tangled.sh/core/appview/knotclient"
 	"tangled.sh/tangled.sh/core/appview/oauth"
 	"tangled.sh/tangled.sh/core/appview/pages"
 	"tangled.sh/tangled.sh/core/patchutil"
···
 		}
 	}
 
-	ksClient, err := NewSignedClient(f.Knot, secret, s.config.Core.Dev)
+	ksClient, err := knotclient.NewSignedClient(f.Knot, secret, s.config.Core.Dev)
 	if err != nil {
 		log.Printf("failed to setup signed client for %s; ignoring: %v", f.Knot, err)
 		return types.MergeCheckResponse{
···
 		repoName = f.RepoName
 	}
 
-	us, err := NewUnsignedClient(knot, s.config.Core.Dev)
+	us, err := knotclient.NewUnsignedClient(knot, s.config.Core.Dev)
 	if err != nil {
 		log.Printf("failed to setup client for %s; ignoring: %v", knot, err)
 		return pages.Unknown
···
 
 	switch r.Method {
 	case http.MethodGet:
-		us, err := NewUnsignedClient(f.Knot, s.config.Core.Dev)
+		us, err := knotclient.NewUnsignedClient(f.Knot, s.config.Core.Dev)
 		if err != nil {
 			log.Printf("failed to create unsigned client for %s", f.Knot)
 			s.pages.Error503(w)
···
 			return
 		}
 
-		us, err := NewUnsignedClient(f.Knot, s.config.Core.Dev)
+		us, err := knotclient.NewUnsignedClient(f.Knot, s.config.Core.Dev)
 		if err != nil {
 			log.Printf("failed to create unsigned client to %s: %v", f.Knot, err)
 			s.pages.Notice(w, "pull", "Failed to create a pull request. Try again later.")
···
 	}
 
 	// Generate a patch using /compare
-	ksClient, err := NewUnsignedClient(f.Knot, s.config.Core.Dev)
+	ksClient, err := knotclient.NewUnsignedClient(f.Knot, s.config.Core.Dev)
 	if err != nil {
 		log.Printf("failed to create signed client for %s: %s", f.Knot, err)
 		s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.")
···
 		return
 	}
 
-	sc, err := NewSignedClient(fork.Knot, secret, s.config.Core.Dev)
+	sc, err := knotclient.NewSignedClient(fork.Knot, secret, s.config.Core.Dev)
 	if err != nil {
 		log.Println("failed to create signed client:", err)
 		s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.")
 		return
 	}
 
-	us, err := NewUnsignedClient(fork.Knot, s.config.Core.Dev)
+	us, err := knotclient.NewUnsignedClient(fork.Knot, s.config.Core.Dev)
 	if err != nil {
 		log.Println("failed to create unsigned client:", err)
 		s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.")
···
 		return
 	}
 
-	us, err := NewUnsignedClient(f.Knot, s.config.Core.Dev)
+	us, err := knotclient.NewUnsignedClient(f.Knot, s.config.Core.Dev)
 	if err != nil {
 		log.Printf("failed to create unsigned client for %s", f.Knot)
 		s.pages.Error503(w)
···
 		return
 	}
 
-	sourceBranchesClient, err := NewUnsignedClient(repo.Knot, s.config.Core.Dev)
+	sourceBranchesClient, err := knotclient.NewUnsignedClient(repo.Knot, s.config.Core.Dev)
 	if err != nil {
 		log.Printf("failed to create unsigned client for %s", repo.Knot)
 		s.pages.Error503(w)
···
 		return
 	}
 
-	targetBranchesClient, err := NewUnsignedClient(f.Knot, s.config.Core.Dev)
+	targetBranchesClient, err := knotclient.NewUnsignedClient(f.Knot, s.config.Core.Dev)
 	if err != nil {
 		log.Printf("failed to create unsigned client for target knot %s", f.Knot)
 		s.pages.Error503(w)
···
 		return
 	}
 
-	ksClient, err := NewUnsignedClient(f.Knot, s.config.Core.Dev)
+	ksClient, err := knotclient.NewUnsignedClient(f.Knot, s.config.Core.Dev)
 	if err != nil {
 		log.Printf("failed to create client for %s: %s", f.Knot, err)
 		s.pages.Notice(w, "resubmit-error", "Failed to create pull request. Try again later.")
···
 	}
 
 	// extract patch by performing compare
-	ksClient, err := NewUnsignedClient(forkRepo.Knot, s.config.Core.Dev)
+	ksClient, err := knotclient.NewUnsignedClient(forkRepo.Knot, s.config.Core.Dev)
 	if err != nil {
 		log.Printf("failed to create client for %s: %s", forkRepo.Knot, err)
 		s.pages.Notice(w, "resubmit-error", "Failed to create pull request. Try again later.")
···
 	}
 
 	// update the hidden tracking branch to latest
-	signedClient, err := NewSignedClient(forkRepo.Knot, secret, s.config.Core.Dev)
+	signedClient, err := knotclient.NewSignedClient(forkRepo.Knot, secret, s.config.Core.Dev)
 	if err != nil {
 		log.Printf("failed to create signed client for %s: %s", forkRepo.Knot, err)
 		s.pages.Notice(w, "resubmit-error", "Failed to create pull request. Try again later.")
···
 		log.Printf("failed to get primary email: %s", err)
 	}
 
-	ksClient, err := NewSignedClient(f.Knot, secret, s.config.Core.Dev)
+	ksClient, err := knotclient.NewSignedClient(f.Knot, secret, s.config.Core.Dev)
 	if err != nil {
 		log.Printf("failed to create signed client for %s: %s", f.Knot, err)
 		s.pages.Notice(w, "pull-merge-error", "Failed to merge pull request. Try again later.")

appview/state/repo.go

···
 	"tangled.sh/tangled.sh/core/api/tangled"
 	"tangled.sh/tangled.sh/core/appview"
 	"tangled.sh/tangled.sh/core/appview/db"
+	"tangled.sh/tangled.sh/core/appview/knotclient"
 	"tangled.sh/tangled.sh/core/appview/oauth"
 	"tangled.sh/tangled.sh/core/appview/pages"
 	"tangled.sh/tangled.sh/core/appview/pages/markup"
···
 		return
 	}
 
-	us, err := NewUnsignedClient(f.Knot, s.config.Core.Dev)
+	us, err := knotclient.NewUnsignedClient(f.Knot, s.config.Core.Dev)
 	if err != nil {
 		log.Printf("failed to create unsigned client for %s", f.Knot)
 		s.pages.Error503(w)
···
 
 	ref := chi.URLParam(r, "ref")
 
-	us, err := NewUnsignedClient(f.Knot, s.config.Core.Dev)
+	us, err := knotclient.NewUnsignedClient(f.Knot, s.config.Core.Dev)
 	if err != nil {
 		log.Println("failed to create unsigned client", err)
 		return
···
 		return
 	}
 
-	us, err := NewUnsignedClient(f.Knot, s.config.Core.Dev)
+	us, err := knotclient.NewUnsignedClient(f.Knot, s.config.Core.Dev)
 	if err != nil {
 		log.Println("failed to create unsigned client", err)
 		return
···
 		return
 	}
 
-	us, err := NewUnsignedClient(f.Knot, s.config.Core.Dev)
+	us, err := knotclient.NewUnsignedClient(f.Knot, s.config.Core.Dev)
 	if err != nil {
 		log.Println("failed to create unsigned client", err)
 		return
···
 		return
 	}
 
-	ksClient, err := NewSignedClient(f.Knot, secret, s.config.Core.Dev)
+	ksClient, err := knotclient.NewSignedClient(f.Knot, secret, s.config.Core.Dev)
 	if err != nil {
 		log.Println("failed to create client to ", f.Knot)
 		return
···
 		return
 	}
 
-	ksClient, err := NewSignedClient(f.Knot, secret, s.config.Core.Dev)
+	ksClient, err := knotclient.NewSignedClient(f.Knot, secret, s.config.Core.Dev)
 	if err != nil {
 		log.Println("failed to create client to ", f.Knot)
 		return
···
 		return
 	}
 
-	ksClient, err := NewSignedClient(f.Knot, secret, s.config.Core.Dev)
+	ksClient, err := knotclient.NewSignedClient(f.Knot, secret, s.config.Core.Dev)
 	if err != nil {
 		log.Println("failed to create client to ", f.Knot)
 		return
···
 
 		var branchNames []string
 		var defaultBranch string
-		us, err := NewUnsignedClient(f.Knot, s.config.Core.Dev)
+		us, err := knotclient.NewUnsignedClient(f.Knot, s.config.Core.Dev)
 		if err != nil {
 			log.Println("failed to create unsigned client", err)
 		} else {
···
 
 	knot := f.Knot
 	var disableFork bool
-	us, err := NewUnsignedClient(knot, s.config.Core.Dev)
+	us, err := knotclient.NewUnsignedClient(knot, s.config.Core.Dev)
 	if err != nil {
 		log.Printf("failed to create unsigned client for %s: %v", knot, err)
 	} else {
···
 			return
 		}
 
-		client, err := NewSignedClient(knot, secret, s.config.Core.Dev)
+		client, err := knotclient.NewSignedClient(knot, secret, s.config.Core.Dev)
 		if err != nil {
 			s.pages.Notice(w, "repo", "Failed to reach knot server.")
 			return

appview/state/repo_util.go

···
 	"github.com/go-chi/chi/v5"
 	"github.com/go-git/go-git/v5/plumbing/object"
 	"tangled.sh/tangled.sh/core/appview/db"
+	"tangled.sh/tangled.sh/core/appview/knotclient"
 	"tangled.sh/tangled.sh/core/appview/oauth"
 	"tangled.sh/tangled.sh/core/appview/pages/repoinfo"
 )
···
 	ref := chi.URLParam(r, "ref")
 
 	if ref == "" {
-		us, err := NewUnsignedClient(knot, s.config.Core.Dev)
+		us, err := knotclient.NewUnsignedClient(knot, s.config.Core.Dev)
 		if err != nil {
 			return nil, err
 		}

appview/state/router.go

···
 		Db:       s.db,
 		Store:    sessions.NewCookieStore([]byte(s.config.Core.CookieSecret)),
 		OAuth:    s.oauth,
+		Enforcer: s.enforcer,
 	}
 
 	return oauth.Router()

appview/state/signer.go appview/knotclient/signer.go

···
-package state
+package knotclient
 
 import (
 	"bytes"

appview/state/state.go

···
 	"tangled.sh/tangled.sh/core/api/tangled"
 	"tangled.sh/tangled.sh/core/appview"
 	"tangled.sh/tangled.sh/core/appview/db"
+	"tangled.sh/tangled.sh/core/appview/knotclient"
 	"tangled.sh/tangled.sh/core/appview/oauth"
 	"tangled.sh/tangled.sh/core/appview/pages"
 	"tangled.sh/tangled.sh/core/jetstream"
···
 		return
 	}
 
-	client, err := NewSignedClient(domain, secret, s.config.Core.Dev)
+	client, err := knotclient.NewSignedClient(domain, secret, s.config.Core.Dev)
 	if err != nil {
 		log.Println("failed to create client to ", domain)
 	}
···
 		return
 	}
 
-	ksClient, err := NewSignedClient(domain, secret, s.config.Core.Dev)
+	ksClient, err := knotclient.NewSignedClient(domain, secret, s.config.Core.Dev)
 	if err != nil {
 		log.Println("failed to create client to ", domain)
 		return
···
 			return
 		}
 
-		client, err := NewSignedClient(domain, secret, s.config.Core.Dev)
+		client, err := knotclient.NewSignedClient(domain, secret, s.config.Core.Dev)
 		if err != nil {
 			s.pages.Notice(w, "repo", "Failed to connect to knot server.")
 			return