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/node_proto_test.go

@@ -0,0 +1,89 @@
+package loki
+
+import (
+	"path/filepath"
+	"runtime"
+	"testing"
+)
+
+func TestNodeCapIntersect(t *testing.T) {
+	got := nodeCapIntersect(
+		[]string{nodeCapShell, nodeCapRead, nodeCapWrite}, // autorisées par le propriétaire
+		[]string{nodeCapRead, nodeCapList},                // déclarées par le poste
+	)
+	// Seul read est dans les deux ; l'ordre doit être canonique.
+	if len(got) != 1 || got[0] != nodeCapRead {
+		t.Fatalf("intersection attendue [read], obtenu %v", got)
+	}
+}
+
+func TestNodeSanitizeCapsDropsUnknown(t *testing.T) {
+	got := nodeSanitizeCaps([]string{"write", "danger", "read", "read"})
+	// Ordre canonique (read avant write), doublon et inconnu retirés.
+	want := []string{nodeCapRead, nodeCapWrite}
+	if len(got) != len(want) || got[0] != want[0] || got[1] != want[1] {
+		t.Fatalf("attendu %v, obtenu %v", want, got)
+	}
+}
+
+func TestNodeToolNameRoundTrip(t *testing.T) {
+	name := nodeToolName("mon_poste", nodeCapShell)
+	if !isNodeTool(name) {
+		t.Fatalf("%s devrait être reconnu comme outil de poste", name)
+	}
+	slug, cap, ok := parseNodeToolName(name)
+	if !ok || slug != "mon_poste" || cap != nodeCapShell {
+		t.Fatalf("parse: ok=%v slug=%q cap=%q", ok, slug, cap)
+	}
+}
+
+func TestNodeToolNameSlugWithDoubleUnderscore(t *testing.T) {
+	// Un slug contenant « __ » ne doit pas casser la reconstitution : on coupe
+	// sur le DERNIER séparateur, et la capacité n'en contient jamais.
+	name := nodeToolName("a__b", nodeCapWrite)
+	slug, cap, ok := parseNodeToolName(name)
+	if !ok || slug != "a__b" || cap != nodeCapWrite {
+		t.Fatalf("parse: ok=%v slug=%q cap=%q", ok, slug, cap)
+	}
+}
+
+func TestNodeResolvePathConfinement(t *testing.T) {
+	root := t.TempDir()
+
+	// Chemin relatif normal : accepté, sous la racine.
+	got, err := nodeResolvePath(root, "sous/dossier/f.txt")
+	if err != nil {
+		t.Fatalf("chemin relatif refusé à tort: %v", err)
+	}
+	if want := filepath.Join(root, "sous", "dossier", "f.txt"); got != want {
+		t.Fatalf("attendu %q, obtenu %q", want, got)
+	}
+
+	// Traversée « .. » : refusée.
+	if _, err := nodeResolvePath(root, "../evade.txt"); err == nil {
+		t.Fatal("la traversée .. aurait dû être refusée")
+	}
+	if _, err := nodeResolvePath(root, "a/../../evade.txt"); err == nil {
+		t.Fatal("la traversée imbriquée aurait dû être refusée")
+	}
+
+	// Chemin absolu hors racine : refusé.
+	outside := filepath.Join(filepath.Dir(root), "ailleurs.txt")
+	if runtime.GOOS == "windows" {
+		outside = `C:\Windows\System32\evil.txt`
+	}
+	if _, err := nodeResolvePath(root, outside); err == nil {
+		t.Fatalf("un chemin absolu hors racine (%s) aurait dû être refusé", outside)
+	}
+
+	// Chemin absolu SOUS la racine : accepté.
+	inside := filepath.Join(root, "ok.txt")
+	if _, err := nodeResolvePath(root, inside); err != nil {
+		t.Fatalf("un chemin absolu sous la racine refusé à tort: %v", err)
+	}
+
+	// Racine vide : refusée (aucun dossier autorisé = aucun accès).
+	if _, err := nodeResolvePath("", "f.txt"); err == nil {
+		t.Fatal("une racine vide aurait dû refuser tout chemin")
+	}
+}