Rebaptise AJEAN en Loki (fork, lignée conservée)

- module github.com/R0m1k3/Loki, cmd/loki, internal/loki (package loki)
- LOKI_HOME, LOKI_MODEL_DIRS, LOKI_SERVICE, LOKI_DL_CONNS ; /etc/loki ;
  units loki-engine / loki-ui ; binaire et aide CLI
- updateRepo pointe sur R0m1k3/Loki (l'auto-update ne tirera plus les
  binaires AJEAN amont)

Conservé à l'identique : le domaine ajean.link (service de tunnel amont),
les littéraux de migration 0.7.x (migrate_07.go), RELEASE_NOTES.md et
LICENSE (historique et licence de l'amont).

go build/vet/test : verts.

internal/loki/relay_localauth_test.go

@@ -0,0 +1,64 @@
+package loki
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"testing"
+)
+
+// Changer la clé de pilotage ne doit PAS couper l'accès distant jusqu'au
+// prochain redémarrage. La clé était capturée à l'ouverture du tunnel : après un
+// `loki set-web-key`, le tunnel injectait l'ancienne, tout passait en 401, et
+// le portail restait bloqué sur « chargement de la conversation » sans jamais
+// dire pourquoi.
+func TestWithLocalAuthSuitLaCleCourante(t *testing.T) {
+	testHome(t)
+	if err := putStr(bkState, "web_key", "cle-numero-1"); err != nil {
+		t.Fatal(err)
+	}
+	// Handler protégé, comme l'API web réelle.
+	protege := withLocalAuth(requireWebAuth(func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(200)
+	}))
+	appel := func() int {
+		rr := httptest.NewRecorder()
+		protege.ServeHTTP(rr, httptest.NewRequest("GET", "/api/status", nil))
+		return rr.Code
+	}
+	if code := appel(); code != 200 {
+		t.Fatalf("clé initiale : HTTP %d", code)
+	}
+	// La clé change pendant que le tunnel tourne (bouton de l'interface, CLI).
+	if err := putStr(bkState, "web_key", "cle-numero-2"); err != nil {
+		t.Fatal(err)
+	}
+	if code := appel(); code != 200 {
+		t.Fatalf("après changement de clé : HTTP %d — le tunnel injecte encore l'ancienne", code)
+	}
+	// Clé retirée : l'API est ouverte, le tunnel ne doit rien casser non plus.
+	if err := putStr(bkState, "web_key", ""); err != nil {
+		t.Fatal(err)
+	}
+	if code := appel(); code != 200 {
+		t.Fatalf("sans clé : HTTP %d", code)
+	}
+}
+
+// Une requête qui porte DÉJÀ une autorisation n'est pas réécrite : c'est le
+// client distant qui décide dans ce cas.
+func TestWithLocalAuthNecraseAucunEnTete(t *testing.T) {
+	testHome(t)
+	if err := putStr(bkState, "web_key", "cle-locale"); err != nil {
+		t.Fatal(err)
+	}
+	var vu string
+	protege := withLocalAuth(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		vu = r.Header.Get("Authorization")
+	}))
+	req := httptest.NewRequest("GET", "/api/status", nil)
+	req.Header.Set("Authorization", "Bearer venue-du-client")
+	protege.ServeHTTP(httptest.NewRecorder(), req)
+	if vu != "Bearer venue-du-client" {
+		t.Fatalf("en-tête client écrasé : %q", vu)
+	}
+}