ui: progressive table render + load timer, v1.3.34

- lib.sh: утилиты (json_field, wait_invoke, print_summary)
- run_all.sh: запуск всех скриптов + финальная сводка
- pre_cleanup.sh: очистка тест-namespace-ов перед прогоном
- test_auth.sh: 14/14 PASS — авторизация, namespace детерминизм
- test_functions_crud.sh: 29/29 PASS — CRUD, валидация, >1MB
- test_ttl.sh: 10/10 PASS — TTL=15m/1h/2d, невалидные
- test_isolation.sh: 11/11 PASS — изоляция пользователей
- test_update.sh: 10/10 PASS — PUT /code v1→v2→v3 (livetest)
- test_invoke.sh: 9/9 PASS — NodeJS/Python invoke (livetest)
- test_stress.sh: 3/3 PASS — 8 пользователей параллельно (livetest)
- test_linters.sh: 31/31 PASS — синтаксис 5 языков

.github/copilot-instructions.md

@@ -1,18 +1,61 @@
 # Правила
 
 ## ⛔ ОТВЕЧАТЬ КРАТКО — АБСОЛЮТНОЕ ПРАВИЛО
-- Вопрос → короткий ответ → СТОП. Не рассуждать, не исследовать без команды.
-- НЕ делать ничего "попутно" без явной просьбы. Сделал — стоп — ждёшь команды.
-- Без приветствий и лишних рассуждений. Код — только по запросу. Не бормотать.
+- Вопрос → короткий ответ → СТОП.
+- Ничего лишнего.
+- Код — только по запросу.
 
-> Подробные правила: [`.github/pravila.md`](pravila.md)
+## ⛔⛔⛔ ВОПРОС = СТОП
+
+**Если в сообщении есть вопрос в ЛЮБОЙ форме** ("так ?", "верно ?", "почему ?", "как ?", "так же ?" и т.д.):
+1. ТОЛЬКО ответить на вопрос
+2. ОСТАНОВИТЬСЯ
+3. ЖДАТЬ следующей команды
+**ЗАПРЕЩЕНО** начинать работу, писать код, запускать команды — без явного "делай".
 
 1. Не трогать рабочий код без явного указания.
-2. Файлы редактировать локально — `~/remote_dev/` = `~/terra/` на ВМ (sshfs), SCP не нужен.
-   Перед любым запуском команд проверять, что локальные файлы и содержимое на ВМ синхронизированы; при сомнении ориентироваться на состояние файлов на ВМ.
-3. Все команды — **только через SSH**, никогда локально:
-   ```bash
+
+2. Файлы редактируются локально:
+   ~/fission
+
+   После ЛЮБЫХ изменений ОБЯЗАТЕЛЬНО синхронизировать на ВМ командой:
+   rsync -az \
+     -e "ssh -i ~/.ssh/naeel_vm_id_ed25519 -o StrictHostKeyChecking=no -o ConnectTimeout=10" \
+     ~/fission/ \
+     naeel@5.172.178.213:~/terra/fission/
+
+
+3. Git (add/commit/push) выполнять ЛОКАЛЬНО в ~/fission
+4. Docker, kubectl и другие инфраструктурные команды — только через SSH на ВМ:
    ssh -i ~/.ssh/naeel_vm_id_ed25519 -o StrictHostKeyChecking=no -o ConnectTimeout=10 naeel@5.172.178.213 'КОМАНДА'
-   ```
-4. **ЗАПРЕЩЕНО** откатывать код, версии, образы и рабочее состояние без явной команды пользователя.
-5. После каждого исправления делать отдельный commit через SSH.
+
+   - не выполнять инфраструктурные команды локально
+   - не открывать интерактивные сессии
+   - не делать цепочки без необходимости
+
+4. Перед запуском команд ОБЯЗАТЕЛЬНО убедиться, что синхронизация выполнена.
+
+5. ЗАПРЕЩЕНО:
+   - откатывать код
+   - менять версии
+   - ломать рабочее состояние
+
+6. После каждого исправления:
+   - git add/commit ЛОКАЛЬНО
+   - затем синхронизация (rsync) на ВМ
+
+## ⛔⛔⛔ ДЕЛАТЬ ТОЛЬКО ЧТО ПРЯМО ПРИКАЗАНО
+
+**АБСОЛЮТНЫЙ ЗАПРЕТ на додумывание:**
+- Не расширять масштаб работы
+- Не выполнять "логичные следующие шаги"
+- Не инициировать дополнительные операции
+- Не делать ничего кроме того что сказано
+
+**Пример (2026-05-01):**
+- Приказано: "собери"
+- Сделано: ✓ собрал образы v1.3.17 и v0.1.2
+- СТОП — жду команды дальше
+- **ЗАПРЕЩЕНО:** обновлять манифесты, заливать образы, применять на кластер, запускать тесты
+
+**Исключение:** только если приказ явно включает цепочку ("собери И залей И тесты")

.github/pravila.md

@@ -1,25 +1,35 @@
 # Правила работы агента
 
-## Файловая система
+## ⛔⛔⛔ DOCKER — ОБЯЗАТЕЛЬНЫЙ ПОРЯДОК ПЕРЕД КАЖДЫМ BUILD
 
-`~/remote_dev/` (локально) примонтирован через sshfs к `~/terra/` на ВМ — **одна ФС**.
-Файлы, сохранённые локально, мгновенно видны на ВМ. SCP не нужен.
+1. УВЕЛИЧИТЬ ТЕГ в `console/deploy/console.yaml` (vX.Y.Z → vX.Y.Z+1)
+2. rsync на ВМ
+3. ПРОВЕРИТЬ что файлы на ВМ новые (grep ключевой строки)
+4. docker build с НОВЫМ тегом
+5. docker push с НОВЫМ тегом
+6. kubectl apply (не rollout restart — apply подтягивает новый тег)
 
-Перед любым запуском команд сначала убедиться, что локальная копия и содержимое на ВМ синхронизированы; если есть сомнение в рассинхроне, сверяться с файлами именно на ВМ.
+**НИКОГДА не делать `docker build` со старым тегом — под не перетянет образ (imagePullPolicy: IfNotPresent)**
 
-Монтирование может слетать. Признак: файлы рассинхронизированы.
+## Файловая система (актуально)
 
-```bash
-# Размонтировать
-fusermount -u ~/remote_dev
-# Если завис: sudo umount -l /home/naeel/remote_dev
+1. Все файлы редактируются локально: `~/fission`
+2. После любых изменений — обязательно rsync на ВМ:
+   rsync -az \
+     -e "ssh -i ~/.ssh/naeel_vm_id_ed25519 -o StrictHostKeyChecking=no -o ConnectTimeout=10" \
+     ~/fission/ \
+     naeel@5.172.178.213:~/terra/fission/
 
-# Примонтировать
-sshfs naeel@5.172.178.213:/home/naeel/terra ~/remote_dev \
-  -o cache=no -o no_readahead -o reconnect \
-  -o ServerAliveInterval=15 -o ServerAliveCountMax=3 \
-  -o IdentityFile=~/.ssh/naeel_vm_id_ed25519
-```
+3. Git (add/commit/push) выполнять ЛОКАЛЬНО в ~/fission
+4. Docker, kubectl и другие инфраструктурные команды — только через SSH на ВМ
+5. Перед запуском любой команды на ВМ обязательно убедиться, что синхронизация (rsync) выполнена
+6. SCP, sshfs, remote_dev и маунты больше НЕ используются
+7. Только rsync для синхронизации
+
+Пример:
+1. Редактируешь локально
+2. rsync на ВМ
+3. Выполняешь команды через SSH на ВМ
 
 ## SSH
 
@@ -50,9 +60,37 @@ ssh -i ~/.ssh/naeel_vm_id_ed25519 -o StrictHostKeyChecking=no -o ConnectTimeout=
 git tag vX.Y.Z && git push origin vX.Y.Z
 ```
 
+## ⛔ ТЕРМИНАЛЬНЫЙ БУФЕР — НИКОГДА НЕ ЧИТАТЬ СТАРЫЙ
+
+**АБСОЛЮТНОЕ ПРАВИЛО:**
+- get_terminal_output из старых сессий — МУСОР. Там старые прогоны.
+- Всегда запускать новую команду через SSH и читать её вывод напрямую.
+- НИКОГДА не читать буфер терминала из предыдущей сессии как актуальные данные.
+- Актуальный результат — только из команды, которая была запущена СЕЙЧАС.
+
+## ⛔ ДОКУМЕНТАЦИЯ ТЕСТ-ПРОГОНОВ — В РЕАЛЬНОМ ВРЕМЕНИ
+
+**Правила:**
+1. Перед запуском `run_all.sh` — создать файл `test-results/YYYY-MM-DD_HH-MM.log` и записать в него метку времени и что запускается.
+2. Запускать `run_all.sh 2>&1 | tee ~/terra/fission/test-results/YYYY-MM-DD_HH-MM.log` — вывод пишется сразу в файл и отображается в терминале.
+3. После завершения — rsync лога локально. Лог остаётся как документация.
+4. Папка `test-results/` в репозитории — `.gitignore` не добавлять, логи коммитить.
+
+**Формат запуска:**
+```bash
+LOG="test-results/$(date +%Y-%m-%d_%H-%M).log"
+ssh -i ~/.ssh/naeel_vm_id_ed25519 -o StrictHostKeyChecking=no naeel@5.172.178.213 \
+  "bash ~/terra/fission/scripts/run_all.sh 2>&1 | tee ~/terra/fission/${LOG}"
+rsync -az -e "ssh -i ~/.ssh/naeel_vm_id_ed25519 -o StrictHostKeyChecking=no" \
+  naeel@5.172.178.213:~/terra/fission/test-results/ ~/fission/test-results/
+```
+
+**Никогда не разбираться с результатами по памяти / буферу / чату. Только лог.**
+
 ## Поведение агента
 
 - Не трогать рабочий код без явного указания
-- Не делать ничего сверх того, о чём явно попросили
+- Не делать НИЧЕГО сверх того, о чём явно приказали — ни git-команд, ни rebase, ни дополнительных шагов
+- Если для продолжения нужен выбор — СПРОСИТЬ разрешения, не делать самостоятельно
 - Деструктивные операции (`kubectl delete`, `rm -rf`, `terraform destroy` и др.) — только после явного подтверждения с указанием конкретных объектов
 - Отвечать кратко, без вступлений, извинений, благодарностей и прочей воды

console/cmd/server/main.go

@@ -11,6 +11,7 @@ import (
 	"time"
 
 	"fission-console/internal/api"
+	"fission-console/internal/auth"
 
 	"k8s.io/client-go/dynamic"
 	"k8s.io/client-go/rest"
@@ -36,6 +37,11 @@ func main() {
 		log.Fatalf("create dynamic client: %v", err)
 	}
 
+	authenticator := &auth.MultiAuthenticator{
+		JWT:  auth.NewDeckAuthenticator(auth.DefaultDeckAPIs, nil),
+		Demo: &auth.DemoAuthenticator{},
+	}
+
 	srv := api.NewServer(api.Config{
 		Dyn:           dyn,
 		Namespace:     namespace,
@@ -45,7 +51,8 @@ func main() {
 		SATokenPath:   envDefault("SA_TOKEN_PATH", "/var/run/secrets/kubernetes.io/serviceaccount/token"),
 		AuthUser:      envDefault("FISSION_AUTH_USERNAME", ""),
 		AuthPass:      envDefault("FISSION_AUTH_PASSWORD", ""),
-		TestMode:      os.Getenv("FISSION_TEST_MODE") == "true",
+		StoragesvcURL: envDefault("FISSION_STORAGESVC_URL", "http://storagesvc.fission.svc.cluster.local"),
+		Authenticator: authenticator,
 		// --- ai/ask feature ---
 		LLMUrl: envDefault("FISSION_LLM_URL", "https://api.aillm.ru"),
 		LLMKey: os.Getenv("FISSION_LLM_KEY"),

console/deploy/console.yaml

@@ -52,7 +52,8 @@ spec:
       serviceAccountName: fission-console
       containers:
         - name: console
-          image: naeel/fission-console:v1.3.12
+          image: naeel/fission-console:v1.3.34
+          imagePullPolicy: Always
           ports:
             - containerPort: 8090
           env:
@@ -76,6 +77,8 @@ spec:
                 secretKeyRef:
                   name: router
                   key: password
+            - name: FISSION_STORAGESVC_URL
+              value: "http://storagesvc.fission.svc.cluster.local"
           livenessProbe:
             httpGet:
               path: /health

console/internal/api/auth.go

@@ -2,19 +2,20 @@ package api
 
 import (
 	"context"
-	"crypto/sha256"
-	"encoding/base64"
-	"encoding/hex"
-	"encoding/json"
 	"fmt"
 	"net/http"
 	"strings"
+
+	"fission-console/internal/auth"
 )
 
-// ctxKeyNS — ключ для хранения namespace пользователя в context.Context.
-// Использует приватный тип чтобы избежать коллизий с ключами из других пакетов.
+// ctxKeyNS — ключ для K8s namespace пользователя в context.Context.
 type ctxKeyNS struct{}
 
+// ctxKeyIdentity — ключ для UserIdentity пользователя в context.Context.
+type ctxKeyIdentity struct{}
+
+// authTokenFromRequest извлекает Bearer токен из X-Auth-Token или Authorization заголовка.
 func authTokenFromRequest(r *http.Request) string {
 	token := strings.TrimSpace(r.Header.Get("X-Auth-Token"))
 	if token != "" {
@@ -32,61 +33,42 @@ func authTokenFromRequest(r *http.Request) string {
 }
 
 // userNS возвращает namespace пользователя из контекста запроса.
-// Устанавливается в authMiddleware после успешной аутентификации.
 func (s *Server) userNS(r *http.Request) string {
 	if ns, ok := r.Context().Value(ctxKeyNS{}).(string); ok && ns != "" {
 		return ns
 	}
-	// Fallback: использовать системный namespace (не должно происходить в prod)
 	return s.ns
 }
 
-// authMiddleware оборачивает handler, добавляя аутентификацию и инициализацию namespace.
-//
-// В testMode (FISSION_TEST_MODE=true):
-//   - Deck API не вызывается
-//   - X-Test-Sub или X-Auth-Token задают sub → разные namespace-ы для тестирования
-//
-// В production:
-//   - X-Auth-Token валидируется через Deck API
-//   - Namespace вычисляется из JWT claim "sub"
+// normalizeEnv приводит название стенда к допустимому значению.
+func normalizeEnv(env string) string {
+	switch strings.TrimSpace(strings.ToLower(env)) {
+	case "prod", "dev", "test":
+		return strings.TrimSpace(strings.ToLower(env))
+	}
+	return "test"
+}
+
+// authMiddleware оборачивает handler аутентификацией.
+// Токен передаётся в s.authenticator.Authenticate — детали скрыты за интерфейсом.
 func (s *Server) authMiddleware(h http.HandlerFunc) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
-		var ns string
-		env := strings.TrimSpace(strings.ToLower(r.Header.Get("X-Auth-Env")))
-		if _, ok := deckAPIs[env]; !ok {
-			env = "test"
+		var identity auth.UserIdentity
+
+		env := normalizeEnv(r.Header.Get("X-Auth-Env"))
+
+		token := authTokenFromRequest(r)
+		var err error
+		identity, err = s.authenticator.Authenticate(r.Context(), token, env)
+		if err != nil {
+			writeJSONError(w, http.StatusUnauthorized, "unauthorized")
+			return
 		}
 
-		if s.testMode {
-			sub := strings.TrimSpace(r.Header.Get("X-Test-Sub"))
-			if sub != "" {
-				ns = namespaceFromSub(sub)
-			} else {
-				token := authTokenFromRequest(r)
-				resolvedNS, err := s.resolveNamespaceForToken(token, env, true)
-				if err != nil {
-					writeJSONError(w, http.StatusUnauthorized, "unauthorized")
-					return
-				}
-				ns = resolvedNS
-			}
-		} else {
-			token := authTokenFromRequest(r)
-			resolvedNS, err := s.resolveNamespaceForToken(token, env, false)
-			if err != nil {
-				writeJSONError(w, http.StatusUnauthorized, "unauthorized")
-				return
-			}
-			ns = resolvedNS
-		}
-
-		ctx := context.WithValue(r.Context(), ctxKeyNS{}, ns)
-
-		// Гарантируем что namespace + RBAC + quota + netpol существуют.
-		// EnsureUserNS реализует singleflight + кэш + семафор параллелизма.
-		if ensureErr := s.nsManager.EnsureUserNS(ctx, ns); ensureErr != nil {
-			writeJSONError(w, http.StatusBadGateway, fmt.Sprintf("ensure namespace: %v", ensureErr))
+		ns := auth.NamespaceForSub(identity.Sub)
+		ctx := s.contextWithIdentity(r.Context(), identity)
+		if err := s.nsManager.EnsureUserNS(ctx, ns); err != nil {
+			writeJSONError(w, http.StatusBadGateway, fmt.Sprintf("ensure namespace: %v", err))
 			return
 		}
 
@@ -94,72 +76,10 @@ func (s *Server) authMiddleware(h http.HandlerFunc) http.HandlerFunc {
 	}
 }
 
-func namespaceFromSub(sub string) string {
-	h32 := sha256.Sum256([]byte(sub))
-	return "fission-" + hex.EncodeToString(h32[:8])
-}
-
-func (s *Server) resolveNamespaceForToken(token, env string, allowTestSub bool) (string, error) {
-	token = strings.TrimSpace(token)
-	if token == "" {
-		if allowTestSub {
-			return "", fmt.Errorf("test mode: X-Test-Sub required")
-		}
-		return "", fmt.Errorf("unauthorized")
-	}
-
-	if err := s.validateDeckToken(token, env); err == nil {
-		ns, nsErr := namespaceFromJWT(token)
-		if nsErr != nil {
-			return s.ns, nil
-		}
-		return ns, nil
-	}
-
-	if allowTestSub && strings.Contains(token, "@") {
-		return namespaceFromSub(token), nil
-	}
-
-	return "", fmt.Errorf("invalid token")
-}
-
-// namespaceFromJWT декодирует JWT payload (без верификации подписи),
-// извлекает claim "sub" и вычисляет namespace: "fission-" + hex(SHA256(sub)[:8]).
-//
-// Подпись не проверяется — токен уже валидирован через Deck API (validateDeckToken).
-// Здесь нам нужен только deterministic namespace name из sub claim.
-func namespaceFromJWT(token string) (string, error) {
-	parts := strings.SplitN(token, ".", 3)
-	if len(parts) != 3 {
-		return "", fmt.Errorf("invalid JWT format")
-	}
-	payload := parts[1]
-
-	// JWT использует base64url без padding — добавляем если нужно
-	switch len(payload) % 4 {
-	case 2:
-		payload += "=="
-	case 3:
-		payload += "="
-	}
-
-	// base64url без стандартного padding — пробуем оба варианта
-	decoded, err := base64.URLEncoding.DecodeString(payload)
-	if err != nil {
-		decoded, err = base64.StdEncoding.DecodeString(payload)
-		if err != nil {
-			return "", fmt.Errorf("decode JWT payload: %w", err)
-		}
-	}
-
-	var claims map[string]any
-	if err := json.Unmarshal(decoded, &claims); err != nil {
-		return "", fmt.Errorf("unmarshal JWT claims: %w", err)
-	}
-	sub, _ := claims["sub"].(string)
-	if sub == "" {
-		return "", fmt.Errorf("JWT missing sub claim")
-	}
-	h := sha256.Sum256([]byte(sub))
-	return "fission-" + hex.EncodeToString(h[:8]), nil
+// contextWithIdentity кладёт UserIdentity и вычисленный namespace в контекст.
+func (s *Server) contextWithIdentity(ctx context.Context, identity auth.UserIdentity) context.Context {
+	ns := auth.NamespaceForSub(identity.Sub)
+	ctx = context.WithValue(ctx, ctxKeyNS{}, ns)
+	ctx = context.WithValue(ctx, ctxKeyIdentity{}, identity)
+	return ctx
 }

console/internal/api/auth_test.go

@@ -1,112 +0,0 @@
-package api
-
-import (
-	"net/http"
-	"net/http/httptest"
-	"testing"
-	"time"
-)
-
-const validJWTForTests = "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJ0ZXN0LXVzZXItMTIzIn0.signature"
-
-func TestResolveNamespaceForTokenRejectsInvalidTokenOutsideTestMode(t *testing.T) {
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		if r.URL.Path != "/index.cfm/instances" {
-			t.Fatalf("unexpected path: %s", r.URL.Path)
-		}
-		w.WriteHeader(http.StatusUnauthorized)
-	}))
-	defer server.Close()
-
-	oldDeckAPIs := deckAPIs
-	deckAPIs = map[string]string{"test": server.URL}
-	defer func() { deckAPIs = oldDeckAPIs }()
-
-	s := &Server{http: server.Client()}
-	if _, err := s.resolveNamespaceForToken("user@example.com", "test", false); err == nil {
-		t.Fatal("expected invalid token to be rejected outside test mode")
-	}
-}
-
-func TestResolveNamespaceForTokenAllowsValidatedJWTInTestMode(t *testing.T) {
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		if got := r.Header.Get("Authorization"); got == "" {
-			t.Fatal("expected Authorization header")
-		}
-		w.WriteHeader(http.StatusOK)
-		_, _ = w.Write([]byte(`{"results":[]}`))
-	}))
-	defer server.Close()
-
-	oldDeckAPIs := deckAPIs
-	deckAPIs = map[string]string{"test": server.URL}
-	defer func() { deckAPIs = oldDeckAPIs }()
-
-	s := &Server{http: server.Client()}
-	ns, err := s.resolveNamespaceForToken(validJWTForTests, "test", true)
-	if err != nil {
-		t.Fatalf("expected JWT to pass in test mode: %v", err)
-	}
-
-	expected, err := namespaceFromJWT(validJWTForTests)
-	if err != nil {
-		t.Fatalf("namespaceFromJWT: %v", err)
-	}
-	if ns != expected {
-		t.Fatalf("expected namespace %q, got %q", expected, ns)
-	}
-}
-
-func TestResolveNamespaceForTokenAllowsEmailFallbackOnlyInTestMode(t *testing.T) {
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		w.WriteHeader(http.StatusUnauthorized)
-	}))
-	defer server.Close()
-
-	oldDeckAPIs := deckAPIs
-	deckAPIs = map[string]string{"test": server.URL}
-	defer func() { deckAPIs = oldDeckAPIs }()
-
-	s := &Server{http: server.Client()}
-	ns, err := s.resolveNamespaceForToken("user@example.com", "test", true)
-	if err != nil {
-		t.Fatalf("expected email fallback in test mode: %v", err)
-	}
-	if ns != namespaceFromSub("user@example.com") {
-		t.Fatalf("unexpected namespace: %q", ns)
-	}
-
-	_, err = s.resolveNamespaceForToken("user@example.com", "test", false)
-	if err == nil {
-		t.Fatal("expected email fallback to be rejected outside test mode")
-	}
-}
-
-func TestValidateDeckTokenCachesSuccessfulValidation(t *testing.T) {
-	requests := 0
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		requests++
-		w.WriteHeader(http.StatusOK)
-		_, _ = w.Write([]byte(`{"results":[]}`))
-	}))
-	defer server.Close()
-
-	oldDeckAPIs := deckAPIs
-	deckAPIs = map[string]string{"test": server.URL}
-	defer func() { deckAPIs = oldDeckAPIs }()
-
-	s := &Server{http: server.Client()}
-	if err := s.validateDeckToken(validJWTForTests, "test"); err != nil {
-		t.Fatalf("first validate failed: %v", err)
-	}
-	if err := s.validateDeckToken(validJWTForTests, "test"); err != nil {
-		t.Fatalf("second validate failed: %v", err)
-	}
-	if requests != 1 {
-		t.Fatalf("expected 1 upstream request because of cache, got %d", requests)
-	}
-
-	if v, ok := s.tokenCache.Load("test:" + validJWTForTests); !ok || time.Now().After(v.(time.Time)) {
-		t.Fatal("expected token to be cached")
-	}
-}

console/internal/api/cron_metrics.go

@@ -0,0 +1,203 @@
+package api
+
+import (
+	"encoding/json"
+	"net/http"
+	"os"
+	"strconv"
+	"strings"
+	"sync"
+	"time"
+)
+
+type CronMetric struct {
+	Timestamp     string  `json:"timestamp"`
+	Source        string  `json:"source"`
+	Hostname      string  `json:"hostname,omitempty"`
+	Status        string  `json:"status,omitempty"`
+	MemoryTotalMB float64 `json:"memory_total_mb,omitempty"`
+	MemoryFreeMB  float64 `json:"memory_free_mb,omitempty"`
+	MemoryAvailMB float64 `json:"memory_available_mb,omitempty"`
+	MemoryUsedMB  float64 `json:"memory_used_mb,omitempty"`
+	MemoryPercent float64 `json:"memory_percent,omitempty"`
+	CpuLoad1m     float64 `json:"cpu_load_1m,omitempty"`
+	CpuLoad5m     float64 `json:"cpu_load_5m,omitempty"`
+	CpuLoad15m    float64 `json:"cpu_load_15m,omitempty"`
+	DiskTotalGB   float64 `json:"disk_total_gb,omitempty"`
+	DiskFreeGB    float64 `json:"disk_free_gb,omitempty"`
+	DiskUsedGB    float64 `json:"disk_used_gb,omitempty"`
+	UptimeSec     float64 `json:"uptime_sec,omitempty"`
+	Notes         string  `json:"notes,omitempty"`
+}
+
+var (
+	cronMetricMu      sync.RWMutex
+	cronMetricHistory []CronMetric
+	cronMetricMaxKeep = 240
+)
+
+func (s *Server) handleCronMetrics(w http.ResponseWriter, r *http.Request) {
+	switch r.Method {
+	case http.MethodGet:
+		cronMetricMu.RLock()
+		history := append([]CronMetric(nil), cronMetricHistory...)
+		cronMetricMu.RUnlock()
+		latest := CronMetric{}
+		if len(history) > 0 {
+			latest = history[len(history)-1]
+		}
+		writeAnyJSON(w, http.StatusOK, map[string]any{
+			"count":   len(history),
+			"latest":  latest,
+			"history": history,
+		})
+	case http.MethodPost:
+		if !allowCronIngest(r) {
+			writeJSONError(w, http.StatusUnauthorized, "invalid cron token")
+			return
+		}
+		var payload map[string]any
+		if err := json.NewDecoder(r.Body).Decode(&payload); err != nil {
+			writeJSONError(w, http.StatusBadRequest, "invalid json payload")
+			return
+		}
+		sample := normalizeCronMetric(payload)
+		cronMetricMu.Lock()
+		cronMetricHistory = append(cronMetricHistory, sample)
+		if len(cronMetricHistory) > cronMetricMaxKeep {
+			cronMetricHistory = append([]CronMetric(nil), cronMetricHistory[len(cronMetricHistory)-cronMetricMaxKeep:]...)
+		}
+		count := len(cronMetricHistory)
+		cronMetricMu.Unlock()
+		writeAnyJSON(w, http.StatusOK, map[string]any{"ok": true, "stored": count, "latest": sample})
+	default:
+		http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
+	}
+}
+
+func allowCronIngest(r *http.Request) bool {
+	expected := strings.TrimSpace(os.Getenv("CRON_TOKEN"))
+	if expected == "" {
+		return true
+	}
+	return strings.TrimSpace(r.Header.Get("X-Cron-Token")) == expected
+}
+
+func normalizeCronMetric(payload map[string]any) CronMetric {
+	now := time.Now().UTC().Format(time.RFC3339)
+	metric := CronMetric{
+		Timestamp: now,
+		Source:    textValue(payload, "source", "function", "name", "host", "hostname", "instance"),
+		Hostname:  textValue(payload, "hostname", "host", "node", "instance"),
+		Status:    textValue(payload, "status"),
+		Notes:     textValue(payload, "notes", "note", "message"),
+	}
+	if metric.Source == "" {
+		metric.Source = "cron"
+	}
+
+	metric.MemoryTotalMB = numberValue(payload, "memory_total_mb", "total_memory_mb", "mem_total_mb", "mem_total")
+	metric.MemoryFreeMB = numberValue(payload, "memory_free_mb", "free_memory_mb", "mem_free_mb", "free_mb")
+	metric.MemoryAvailMB = numberValue(payload, "memory_available_mb", "available_memory_mb", "mem_available_mb", "avail_memory_mb")
+	metric.MemoryUsedMB = numberValue(payload, "memory_used_mb", "used_memory_mb", "mem_used_mb", "used_mb")
+	metric.MemoryPercent = numberValue(payload, "memory_percent", "mem_percent", "memory_usage_percent")
+	if metric.MemoryUsedMB == 0 && metric.MemoryTotalMB > 0 && metric.MemoryFreeMB > 0 {
+		metric.MemoryUsedMB = metric.MemoryTotalMB - metric.MemoryFreeMB
+	}
+	if metric.MemoryAvailMB == 0 && metric.MemoryFreeMB > 0 {
+		metric.MemoryAvailMB = metric.MemoryFreeMB
+	}
+	if metric.MemoryPercent == 0 && metric.MemoryTotalMB > 0 && metric.MemoryUsedMB > 0 {
+		metric.MemoryPercent = (metric.MemoryUsedMB / metric.MemoryTotalMB) * 100
+	}
+
+	metric.CpuLoad1m = numberValue(payload, "cpu_load_1m", "loadavg_1m", "load_1m", "load1")
+	metric.CpuLoad5m = numberValue(payload, "cpu_load_5m", "loadavg_5m", "load_5m", "load5")
+	metric.CpuLoad15m = numberValue(payload, "cpu_load_15m", "loadavg_15m", "load_15m", "load15")
+
+	metric.DiskTotalGB = numberValue(payload, "disk_total_gb", "total_disk_gb", "disk_total_mb", "disk_total")
+	metric.DiskFreeGB = numberValue(payload, "disk_free_gb", "free_disk_gb", "disk_free_mb", "disk_free")
+	metric.DiskUsedGB = numberValue(payload, "disk_used_gb", "used_disk_gb", "disk_used_mb", "disk_used")
+	if metric.DiskUsedGB == 0 && metric.DiskTotalGB > 0 && metric.DiskFreeGB > 0 {
+		metric.DiskUsedGB = metric.DiskTotalGB - metric.DiskFreeGB
+	}
+
+	if uptime := numberValue(payload, "uptime_sec", "uptime", "uptime_seconds"); uptime > 0 {
+		metric.UptimeSec = uptime
+	}
+	if ts := textValue(payload, "timestamp", "ts", "collected_at"); ts != "" {
+		metric.Timestamp = ts
+	}
+	return metric
+}
+
+func textValue(payload map[string]any, keys ...string) string {
+	for _, key := range keys {
+		if value, ok := payload[key]; ok {
+			text := strings.TrimSpace(toString(value))
+			if text != "" {
+				return text
+			}
+		}
+	}
+	return ""
+}
+
+func numberValue(payload map[string]any, keys ...string) float64 {
+	for _, key := range keys {
+		if value, ok := payload[key]; ok {
+			if number, ok := toFloat64(value); ok {
+				return number
+			}
+		}
+	}
+	return 0
+}
+
+func toString(value any) string {
+	switch v := value.(type) {
+	case string:
+		return v
+	case []byte:
+		return string(v)
+	case float64:
+		return strconv.FormatFloat(v, 'f', -1, 64)
+	case float32:
+		return strconv.FormatFloat(float64(v), 'f', -1, 32)
+	case int:
+		return strconv.FormatInt(int64(v), 10)
+	case int64:
+		return strconv.FormatInt(v, 10)
+	case json.Number:
+		return v.String()
+	default:
+		return ""
+	}
+}
+
+func toFloat64(value any) (float64, bool) {
+	switch v := value.(type) {
+	case float64:
+		return v, true
+	case float32:
+		return float64(v), true
+	case int:
+		return float64(v), true
+	case int64:
+		return float64(v), true
+	case json.Number:
+		f, err := v.Float64()
+		return f, err == nil
+	case string:
+		if strings.TrimSpace(v) == "" {
+			return 0, false
+		}
+		n, err := strconv.ParseFloat(strings.TrimSpace(v), 64)
+		if err == nil {
+			return n, true
+		}
+		return 0, false
+	default:
+		return 0, false
+	}
+}

console/internal/api/handlers.go

@@ -11,11 +11,13 @@ import (
 	"log"
 	"net"
 	"net/http"
+	"net/url"
 	"regexp"
 	"strconv"
 	"strings"
 	"time"
 
+	"fission-console/internal/auth"
 	"fission-console/internal/fission"
 	"fission-console/internal/model"
 	"fission-console/internal/runtime"
@@ -50,6 +52,102 @@ func buildDeployArchive(lang, code string) ([]byte, error) {
 	}
 }
 
+// deleteFromStoragesvc удаляет архив из S3 через storagesvc по URL из Package spec.
+// URL имеет формат: http://storagesvc.../v1/archive?id=fission/UUID
+// Best-effort: ошибка логируется, но не прерывает операцию удаления.
+func (s *Server) deleteFromStoragesvc(ctx context.Context, archiveURL string) {
+	if s.storagesvcURL == "" || archiveURL == "" {
+		return
+	}
+	// archiveURL = "http://storagesvc.../v1/archive?id=fission/UUID"
+	// Строим DELETE URL к storagesvc, сохраняя query-параметр id
+	parsed, err := url.Parse(archiveURL)
+	if err != nil {
+		log.Printf("deleteFromStoragesvc: parse url %q: %v", archiveURL, err)
+		return
+	}
+	deleteURL := strings.TrimRight(s.storagesvcURL, "/") + "/v1/archive?" + parsed.RawQuery
+	req, err := http.NewRequestWithContext(ctx, http.MethodDelete, deleteURL, nil)
+	if err != nil {
+		log.Printf("deleteFromStoragesvc: build request: %v", err)
+		return
+	}
+	resp, err := s.http.Do(req)
+	if err != nil {
+		log.Printf("deleteFromStoragesvc: %v", err)
+		return
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode != http.StatusOK && resp.StatusCode != http.StatusNoContent {
+		body, _ := io.ReadAll(resp.Body)
+		log.Printf("deleteFromStoragesvc: status %d: %s", resp.StatusCode, strings.TrimSpace(string(body)))
+		return
+	}
+	log.Printf("deleteFromStoragesvc: deleted %s", parsed.Query().Get("id"))
+}
+
+// uploadToStoragesvc загружает байты в Fission storagesvc и возвращает URL для package archive.
+// Если storagesvcURL не задан — возвращает пустую строку (fallback на literal).
+func (s *Server) uploadToStoragesvc(ctx context.Context, data []byte) (string, error) {
+	if s.storagesvcURL == "" {
+		log.Printf("uploadToStoragesvc: storagesvcURL is empty, skip upload")
+		return "", nil
+	}
+	log.Printf("uploadToStoragesvc: uploading %d bytes to %s", len(data), s.storagesvcURL)
+	uploadURL := strings.TrimRight(s.storagesvcURL, "/") + "/v1/archive"
+	body := &bytes.Reader{}
+	// multipart/form-data с полем uploadfile
+	var buf bytes.Buffer
+	boundary := fmt.Sprintf("fission%d", time.Now().UnixNano())
+	buf.WriteString("--" + boundary + "\r\n")
+	buf.WriteString(fmt.Sprintf("Content-Disposition: form-data; name=\"uploadfile\"; filename=\"archive.zip\"\r\n"))
+	buf.WriteString("Content-Type: application/octet-stream\r\n\r\n")
+	buf.Write(data)
+	buf.WriteString("\r\n--" + boundary + "--\r\n")
+	body = bytes.NewReader(buf.Bytes())
+
+	req, err := http.NewRequestWithContext(ctx, http.MethodPost, uploadURL, body)
+	if err != nil {
+		return "", fmt.Errorf("build storagesvc upload request: %w", err)
+	}
+	req.Header.Set("Content-Type", "multipart/form-data; boundary="+boundary)
+	req.Header.Set("X-File-Size", fmt.Sprintf("%d", len(data)))
+
+	resp, err := s.http.Do(req)
+	if err != nil {
+		return "", fmt.Errorf("storagesvc upload: %w", err)
+	}
+	defer resp.Body.Close()
+	respBody, _ := io.ReadAll(resp.Body)
+	if resp.StatusCode != http.StatusOK && resp.StatusCode != http.StatusCreated {
+		return "", fmt.Errorf("storagesvc upload status %d: %s", resp.StatusCode, strings.TrimSpace(string(respBody)))
+	}
+	var result struct {
+		ID string `json:"id"`
+	}
+	if err := json.Unmarshal(respBody, &result); err != nil || result.ID == "" {
+		return "", fmt.Errorf("storagesvc upload: bad response: %s", string(respBody))
+	}
+	archiveURL := strings.TrimRight(s.storagesvcURL, "/") + "/v1/archive?id=" + result.ID
+	return archiveURL, nil
+}
+
+// buildDeploySpec строит spec.deployment для Fission Package.
+// Если storagesvcURL задан — загружает архив в S3 через storagesvc и возвращает type: url.
+// Иначе — возвращает type: literal с base64-кодом.
+func (s *Server) buildDeploySpec(ctx context.Context, data []byte) (map[string]any, error) {
+	archiveURL, err := s.uploadToStoragesvc(ctx, data)
+	if err != nil {
+		log.Printf("storagesvc upload failed, falling back to literal: %v", err)
+		// fallback — сохраняем как literal
+		return map[string]any{"type": "literal", "literal": base64.StdEncoding.EncodeToString(data)}, nil
+	}
+	if archiveURL == "" {
+		return map[string]any{"type": "literal", "literal": base64.StdEncoding.EncodeToString(data)}, nil
+	}
+	return map[string]any{"type": "url", "url": archiveURL}, nil
+}
+
 func (s *Server) resolveInvokeTimeout(fn *unstructured.Unstructured) time.Duration {
 	if fn != nil {
 		seconds, found, err := unstructured.NestedInt64(fn.Object, "spec", "functionTimeout")
@@ -312,7 +410,7 @@ func (s *Server) handleCreateFunction(w http.ResponseWriter, r *http.Request) {
 	// Строим Package spec в зависимости от языка:
 	// - Go: source package → builder job компилирует в .so плагин
 	// - Node.js: deployment zip с ESM wrapper (package.json + main.js)
-	// - Остальные: deployment literal с кодом напрямую
+	// - Остальные: deployment archive с кодом (S3 или literal fallback)
 	var pkgSpec map[string]any
 	if req.Language == "go" {
 		srcZip, err := runtime.BuildGoSourceZip(req.Code)
@@ -320,12 +418,13 @@ func (s *Server) handleCreateFunction(w http.ResponseWriter, r *http.Request) {
 			writeJSONError(w, http.StatusBadRequest, fmt.Sprintf("build go source archive: %v", err))
 			return
 		}
-		literal := base64.StdEncoding.EncodeToString(srcZip)
+		srcSpec, srcErr := s.buildDeploySpec(ctx, srcZip)
+		if srcErr != nil {
+			writeJSONError(w, http.StatusInternalServerError, fmt.Sprintf("upload go source: %v", srcErr))
+			return
+		}
 		pkgSpec = map[string]any{
-			"source": map[string]any{
-				"type":    "literal",
-				"literal": literal,
-			},
+			"source":       srcSpec,
 			"deployment":   map[string]any{},
 			"environment":  map[string]any{"name": req.Environment, "namespace": ns},
 			"buildcommand": "build",
@@ -336,8 +435,13 @@ func (s *Server) handleCreateFunction(w http.ResponseWriter, r *http.Request) {
 			writeJSONError(w, http.StatusInternalServerError, fmt.Sprintf("build %s archive: %v", req.Language, archiveErr))
 			return
 		}
+		deploySpec, uploadErr := s.buildDeploySpec(ctx, deployBytes)
+		if uploadErr != nil {
+			writeJSONError(w, http.StatusInternalServerError, fmt.Sprintf("upload %s archive: %v", req.Language, uploadErr))
+			return
+		}
 		pkgSpec = map[string]any{
-			"deployment":  map[string]any{"type": "literal", "literal": base64.StdEncoding.EncodeToString(deployBytes)},
+			"deployment":  deploySpec,
 			"environment": map[string]any{"name": req.Environment, "namespace": ns},
 			"source":      map[string]any{},
 		}
@@ -562,12 +666,17 @@ func (s *Server) handleUpdateFunctionCode(w http.ResponseWriter, r *http.Request
 	}()
 	now := time.Now().UTC()
 	newPkgName := name + "-pkg-" + strconv.FormatInt(time.Now().UnixMilli(), 36)
+	deploySpec, uploadErr := s.buildDeploySpec(ctx, deployBytes)
+	if uploadErr != nil {
+		writeJSONError(w, http.StatusInternalServerError, fmt.Sprintf("upload %s archive: %v", lang, uploadErr))
+		return
+	}
 	newPkg := &unstructured.Unstructured{Object: map[string]any{
 		"apiVersion": "fission.io/v1",
 		"kind":       "Package",
 		"metadata":   map[string]any{"name": newPkgName, "namespace": ns},
 		"spec": map[string]any{
-			"deployment":  map[string]any{"type": "literal", "literal": base64.StdEncoding.EncodeToString(deployBytes)},
+			"deployment":  deploySpec,
 			"environment": map[string]any{"name": envName, "namespace": ns},
 			"source":      map[string]any{},
 		},
@@ -999,10 +1108,22 @@ func (s *Server) handleDeleteFunction(w http.ResponseWriter, r *http.Request, na
 	}
 
 	if pkgName != "" {
+		// Получаем URL архива из Package spec.deployment перед удалением, чтобы потом очистить S3
+		var archiveURL string
+		if pkg, pkgErr := s.dyn.Resource(fission.PackageGVR).Namespace(ns).Get(ctx, pkgName, metav1.GetOptions{}); pkgErr == nil {
+			deployType, _, _ := unstructured.NestedString(pkg.Object, "spec", "deployment", "type")
+			if deployType == "url" {
+				archiveURL, _, _ = unstructured.NestedString(pkg.Object, "spec", "deployment", "url")
+			}
+		}
 		if err := s.dyn.Resource(fission.PackageGVR).Namespace(ns).Delete(ctx, pkgName, metav1.DeleteOptions{}); err != nil && !apierrors.IsNotFound(err) {
 			writeJSONError(w, http.StatusBadGateway, fmt.Sprintf("delete package %q: %v", pkgName, err))
 			return
 		}
+		// Удаляем архив из S3 после успешного удаления Package (best-effort)
+		if archiveURL != "" {
+			go s.deleteFromStoragesvc(context.Background(), archiveURL)
+		}
 	}
 
 	// Убираем environment pool pods если язык больше не используется (best-effort)
@@ -1018,7 +1139,7 @@ func (s *Server) handleDeleteFunction(w http.ResponseWriter, r *http.Request, na
 }
 
 // handleAuth обрабатывает POST /console/api/auth.
-// Валидирует токен, создаёт namespace, возвращает namespace пользователя.
+// Валидирует токен через authenticator, создаёт namespace, возвращает namespace + email.
 func (s *Server) handleAuth(w http.ResponseWriter, r *http.Request) {
 	if r.Method != http.MethodPost {
 		writeJSONError(w, http.StatusMethodNotAllowed, "method not allowed")
@@ -1034,17 +1155,16 @@ func (s *Server) handleAuth(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	env := strings.TrimSpace(strings.ToLower(body.Env))
-	if _, ok := deckAPIs[env]; !ok {
-		env = "test"
-	}
+	env := normalizeEnv(body.Env)
 
-	ns, err := s.resolveNamespaceForToken(body.Token, env, s.testMode)
+	identity, err := s.authenticator.Authenticate(r.Context(), body.Token, env)
 	if err != nil {
 		writeJSONError(w, http.StatusUnauthorized, "invalid token")
 		return
 	}
 
+	ns := auth.NamespaceForSub(identity.Sub)
+
 	ctx, cancel := context.WithTimeout(r.Context(), 60*time.Second)
 	defer cancel()
 	if ensureErr := s.nsManager.EnsureUserNS(ctx, ns); ensureErr != nil {
@@ -1052,7 +1172,7 @@ func (s *Server) handleAuth(w http.ResponseWriter, r *http.Request) {
 	}
 
 	w.Header().Set("Content-Type", "application/json; charset=utf-8")
-	_ = json.NewEncoder(w).Encode(map[string]any{"ok": true, "env": env, "namespace": ns})
+	_ = json.NewEncoder(w).Encode(map[string]any{"ok": true, "env": env, "namespace": ns, "email": identity.Email})
 }
 
 // parseTTL парсит строку TTL и возвращает время истечения.

console/internal/api/server.go

@@ -5,13 +5,14 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
-	"io"
+	"log"
 	"net/http"
 	"os"
 	"strings"
 	"sync"
 	"time"
 
+	"fission-console/internal/auth"
 	"fission-console/internal/cloud"
 	"fission-console/internal/fission"
 	"fission-console/ui"
@@ -22,20 +23,12 @@ import (
 	"k8s.io/client-go/dynamic"
 )
 
-// deckAPIs — карта окружений Deck API.
-// Ключ используется в X-Auth-Env заголовке для выбора нужного сервера.
-var deckAPIs = map[string]string{
-	"prod": "https://deck-api.ngcloud.ru/api/v1",
-	"dev":  "https://deck-api-dev.ngcloud.ru/api/v1",
-	"test": "https://deck-api-test.ngcloud.ru/api/v1",
-}
-
 // defaultSATokenPath — путь к service account токену внутри pod-а.
 // Используется для авторизации запросов от console к Fission router.
 const defaultSATokenPath = "/var/run/secrets/kubernetes.io/serviceaccount/token"
 
 // Server — основная структура HTTP сервера.
-// Содержит все зависимости: kubernetes client, конфиги, кэши токенов.
+// Содержит все зависимости: kubernetes client, конфиги, кэши.
 type Server struct {
 	dyn       dynamic.Interface
 	ns        string // системный namespace (fallback, обычно "fission")
@@ -44,10 +37,10 @@ type Server struct {
 
 	saTokenPath   string
 	invokeTimeout time.Duration
-	testMode      bool // FISSION_TEST_MODE=true — пропускает deck auth
 
-	authUser string
-	authPass string
+	authUser      string
+	authPass      string
+	storagesvcURL string // URL Fission storagesvc для загрузки архивов кода в S3
 
 	// --- ai/ask feature (удалить блок целиком чтобы выкосить) ---
 	llmURL string // FISSION_LLM_URL
@@ -59,9 +52,8 @@ type Server struct {
 	cachedJWT  string
 	tokenExpAt time.Time
 
-	// tokenCache кэширует результаты валидации Deck токенов.
-	// Ключ: "env:token", значение: time.Time — когда кэш истекает.
-	tokenCache sync.Map
+	// authenticator — слой аутентификации. Сервер не знает деталей реализации.
+	authenticator auth.Authenticator
 
 	// nsManager управляет жизненным циклом пользовательских namespace-ов.
 	nsManager *cloud.NSManager
@@ -77,13 +69,15 @@ type Config struct {
 	SATokenPath   string
 	AuthUser      string
 	AuthPass      string
-	TestMode      bool
+	StoragesvcURL string
+	Authenticator auth.Authenticator // слой аутентификации
 	LLMUrl        string
 	LLMKey        string
 }
 
 // NewServer создаёт и настраивает HTTP Server со всеми зависимостями.
 func NewServer(cfg Config) *Server {
+	log.Printf("NewServer: storagesvcURL=%q", cfg.StoragesvcURL)
 	return &Server{
 		dyn:           cfg.Dyn,
 		ns:            cfg.Namespace,
@@ -93,7 +87,8 @@ func NewServer(cfg Config) *Server {
 		invokeTimeout: cfg.InvokeTimeout,
 		authUser:      cfg.AuthUser,
 		authPass:      cfg.AuthPass,
-		testMode:      cfg.TestMode,
+		storagesvcURL: cfg.StoragesvcURL,
+		authenticator: cfg.Authenticator,
 		llmURL:        cfg.LLMUrl,
 		llmKey:        cfg.LLMKey,
 		nsManager:     cloud.NewNSManager(cfg.Dyn),
@@ -127,6 +122,15 @@ func (s *Server) RegisterRoutes(mux *http.ServeMux) {
 	// Auth: не требует токена — сам проверяет и возвращает namespace
 	mux.HandleFunc("/console/api/auth", s.handleAuth)
 
+	// Cron: публичные маршруты для метрик
+	cronHandler := ui.CronHandler()
+	mux.Handle("/cron", cronHandler)
+	mux.Handle("/cron/", cronHandler)
+	mux.Handle("/console/cron", cronHandler)
+	mux.Handle("/console/cron/", cronHandler)
+	mux.HandleFunc("/cron/api/metrics", s.handleCronMetrics)
+	mux.HandleFunc("/console/cron/api/metrics", s.handleCronMetrics)
+
 	// Приватные: требуют X-Auth-Token / X-Test-Sub
 	auth := s.authMiddleware
 
@@ -265,43 +269,3 @@ func (s *Server) getRouterToken() string {
 	s.tokenExpAt = time.Now().Add(100 * time.Second)
 	return s.cachedJWT
 }
-
-// validateDeckToken проверяет токен через Deck API с кэшированием результата на 5 минут.
-func (s *Server) validateDeckToken(token, env string) error {
-	cacheKey := env + ":" + token
-	if v, ok := s.tokenCache.Load(cacheKey); ok {
-		if time.Now().Before(v.(time.Time)) {
-			return nil // кэш актуален — токен валиден
-		}
-		s.tokenCache.Delete(cacheKey)
-	}
-
-	apiBase, ok := deckAPIs[env]
-	if !ok {
-		return fmt.Errorf("unknown deck env: %s", env)
-	}
-
-	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
-	defer cancel()
-
-	req, err := http.NewRequestWithContext(ctx, http.MethodGet, apiBase+"/index.cfm/instances", nil)
-	if err != nil {
-		return err
-	}
-	req.Header.Set("Authorization", "Bearer "+token)
-
-	resp, err := s.http.Do(req)
-	if err != nil {
-		return err
-	}
-	defer resp.Body.Close()
-	_, _ = io.ReadAll(resp.Body)
-
-	if resp.StatusCode == http.StatusUnauthorized {
-		return fmt.Errorf("invalid token")
-	}
-
-	// Кэшируем успешный результат
-	s.tokenCache.Store(cacheKey, time.Now().Add(5*time.Minute))
-	return nil
-}

console/internal/auth/auth.go

@@ -0,0 +1,246 @@
+// Package auth реализует слой аутентификации консоли.
+//
+// Сервер получает UserIdentity (Sub + Email) и больше не знает
+// ни про Deck API, ни про JWT подписи, ни про тест/прод режимы.
+package auth
+
+import (
+	"context"
+	"crypto/sha1"
+	"crypto/sha256"
+	"encoding/base64"
+	"encoding/hex"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"strings"
+	"sync"
+	"time"
+)
+
+// UserIdentity — идентификатор пользователя, полученный после аутентификации.
+type UserIdentity struct {
+	Sub   string // ID пользователя (claim "sub" из JWT) — обязательно
+	Email string // email — опционально, для отображения в UI
+}
+
+// NamespaceForSub вычисляет детерминированный K8s namespace из Sub:
+// "fission-" + hex(SHA256(sub)[:8])
+func NamespaceForSub(sub string) string {
+	h := sha256.Sum256([]byte(sub))
+	return "fission-" + hex.EncodeToString(h[:8])
+}
+
+// Authenticator — интерфейс аутентификации. Единственная точка входа.
+// Сервер не знает как именно проверяется токен — только вызывает Authenticate.
+type Authenticator interface {
+	Authenticate(ctx context.Context, token, env string) (UserIdentity, error)
+}
+
+// --- DeckAuthenticator ---
+
+// DeckAPIs — карта URL Deck API по стенду.
+type DeckAPIs map[string]string
+
+// DefaultDeckAPIs — стандартные URL для всех стендов облака.
+var DefaultDeckAPIs = DeckAPIs{
+	"prod": "https://deck-api.ngcloud.ru/api/v1",
+	"dev":  "https://deck-api-dev.ngcloud.ru/api/v1",
+	"test": "https://deck-api-test.ngcloud.ru/api/v1",
+}
+
+// DeckAuthenticator — production реализация.
+// Валидирует токен через Deck API, декодирует sub + email из JWT payload.
+type DeckAuthenticator struct {
+	apis       DeckAPIs
+	http       *http.Client
+	tokenCache sync.Map // key: "env:token", value: time.Time (expiry)
+}
+
+// NewDeckAuthenticator создаёт DeckAuthenticator.
+// Если httpClient == nil — используется клиент с таймаутом 5s.
+func NewDeckAuthenticator(apis DeckAPIs, httpClient *http.Client) *DeckAuthenticator {
+	if httpClient == nil {
+		httpClient = &http.Client{Timeout: 5 * time.Second}
+	}
+	return &DeckAuthenticator{apis: apis, http: httpClient}
+}
+
+// Authenticate проверяет токен через Deck API и возвращает UserIdentity.
+func (d *DeckAuthenticator) Authenticate(ctx context.Context, token, env string) (UserIdentity, error) {
+	token = strings.TrimSpace(token)
+	if token == "" {
+		return UserIdentity{}, fmt.Errorf("token required")
+	}
+	if err := d.validateToken(ctx, token, env); err != nil {
+		return UserIdentity{}, err
+	}
+	return identityFromJWT(token)
+}
+
+func (d *DeckAuthenticator) validateToken(ctx context.Context, token, env string) error {
+	cacheKey := env + ":" + token
+	if v, ok := d.tokenCache.Load(cacheKey); ok {
+		if time.Now().Before(v.(time.Time)) {
+			return nil
+		}
+		d.tokenCache.Delete(cacheKey)
+	}
+
+	apiBase, ok := d.apis[env]
+	if !ok {
+		return fmt.Errorf("unknown env: %s", env)
+	}
+
+	reqCtx, cancel := context.WithTimeout(ctx, 5*time.Second)
+	defer cancel()
+
+	req, err := http.NewRequestWithContext(reqCtx, http.MethodGet, apiBase+"/index.cfm/instances", nil)
+	if err != nil {
+		return err
+	}
+	req.Header.Set("Authorization", "Bearer "+token)
+
+	resp, err := d.http.Do(req)
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+	_, _ = io.ReadAll(resp.Body)
+
+	if resp.StatusCode == http.StatusUnauthorized {
+		return fmt.Errorf("invalid token")
+	}
+
+	d.tokenCache.Store(cacheKey, time.Now().Add(5*time.Minute))
+	return nil
+}
+
+// --- TestAuthenticator ---
+
+// TestAuthenticator — реализация для тест-режима. Не ходит в Deck API.
+// Принимает JWT с claim "sub" или строку с "@" как email-sub.
+type TestAuthenticator struct{}
+
+// Authenticate в тест-режиме: декодирует JWT если возможно,
+// иначе использует email-строку как sub.
+func (t *TestAuthenticator) Authenticate(_ context.Context, token, _ string) (UserIdentity, error) {
+	token = strings.TrimSpace(token)
+	if token == "" {
+		return UserIdentity{}, fmt.Errorf("token required")
+	}
+	if identity, err := identityFromJWT(token); err == nil {
+		return identity, nil
+	}
+	if strings.Contains(token, "@") {
+		return UserIdentity{Sub: token, Email: token}, nil
+	}
+	return UserIdentity{}, fmt.Errorf("invalid token")
+}
+
+// --- helpers ---
+
+// identityFromJWT декодирует JWT payload (без верификации подписи).
+// Подпись не проверяется — токен уже валидирован через Deck API.
+func identityFromJWT(token string) (UserIdentity, error) {
+	parts := strings.SplitN(token, ".", 3)
+	if len(parts) != 3 {
+		return UserIdentity{}, fmt.Errorf("invalid JWT format")
+	}
+	payload := parts[1]
+	switch len(payload) % 4 {
+	case 2:
+		payload += "=="
+	case 3:
+		payload += "="
+	}
+	decoded, err := base64.URLEncoding.DecodeString(payload)
+	if err != nil {
+		decoded, err = base64.StdEncoding.DecodeString(payload)
+		if err != nil {
+			return UserIdentity{}, fmt.Errorf("decode JWT payload: %w", err)
+		}
+	}
+	var claims map[string]any
+	if err := json.Unmarshal(decoded, &claims); err != nil {
+		return UserIdentity{}, fmt.Errorf("unmarshal claims: %w", err)
+	}
+	sub, _ := claims["sub"].(string)
+	if sub == "" {
+		return UserIdentity{}, fmt.Errorf("JWT missing sub claim")
+	}
+	email, _ := claims["email"].(string)
+	return UserIdentity{Sub: sub, Email: email}, nil
+}
+
+// isJWT возвращает true если строка похожа на JWT (три непустые части через точку).
+func isJWT(s string) bool {
+	parts := strings.SplitN(s, ".", 4)
+	return len(parts) == 3 && parts[0] != "" && parts[1] != "" && parts[2] != ""
+}
+
+// uuidV5 генерирует детерминированный UUID v5 (RFC 4122) из строки.
+// Namespace: произвольный фиксированный UUID для demo-логинов.
+func uuidV5(name string) string {
+	// Фиксированный namespace UUID для demo-логинов
+	ns := []byte{0xf4, 0x7a, 0xc1, 0x0b, 0x58, 0xcc, 0x43, 0x72, 0xa5, 0x67, 0x0e, 0x02, 0xb2, 0xc3, 0xd4, 0x79}
+	h := sha1.New()
+	_, _ = h.Write(ns)
+	_, _ = h.Write([]byte(name))
+	sum := h.Sum(nil)
+	sum[6] = (sum[6] & 0x0f) | 0x50 // version 5
+	sum[8] = (sum[8] & 0x3f) | 0x80 // RFC 4122 variant
+	return fmt.Sprintf("%08x-%04x-%04x-%04x-%012x",
+		sum[0:4], sum[4:6], sum[6:8], sum[8:10], sum[10:16])
+}
+
+// demoEmail формирует маскированный email для демо-логина.
+// Пример: "mylogin" → "demo-my***in"
+func demoEmail(login string) string {
+	r := []rune(login)
+	n := len(r)
+	if n <= 4 {
+		return "demo-" + string(r)
+	}
+	return "demo-" + string(r[:2]) + strings.Repeat("*", n-4) + string(r[n-2:])
+}
+
+// --- DemoAuthenticator ---
+
+// DemoAuthenticator — аутентификация по произвольному логину (≥6 символов).
+// Не обращается ни к каким внешним сервисам.
+// Sub = UUID v5 от логина (детерминированный), Email = маскированный логин.
+type DemoAuthenticator struct{}
+
+// Authenticate принимает логин ≥6 символов и возвращает UserIdentity.
+func (d *DemoAuthenticator) Authenticate(_ context.Context, login, _ string) (UserIdentity, error) {
+	login = strings.TrimSpace(login)
+	if len([]rune(login)) < 6 {
+		return UserIdentity{}, fmt.Errorf("login must be at least 6 characters")
+	}
+	return UserIdentity{Sub: uuidV5(login), Email: demoEmail(login)}, nil
+}
+
+// --- MultiAuthenticator ---
+
+// MultiAuthenticator роутит аутентификацию:
+// - JWT (три части через точку) → JWT authenticator (DeckAuthenticator или TestAuthenticator)
+// - Иначе → DemoAuthenticator
+// Оба пути равноправны и возвращают одинаковый UserIdentity.
+type MultiAuthenticator struct {
+	JWT  Authenticator
+	Demo *DemoAuthenticator
+}
+
+// Authenticate определяет тип входных данных и делегирует нужному authenticator.
+func (m *MultiAuthenticator) Authenticate(ctx context.Context, token, env string) (UserIdentity, error) {
+	token = strings.TrimSpace(token)
+	if token == "" {
+		return UserIdentity{}, fmt.Errorf("token or login required")
+	}
+	if isJWT(token) {
+		return m.JWT.Authenticate(ctx, token, env)
+	}
+	return m.Demo.Authenticate(ctx, token, env)
+}

console/internal/auth/auth_test.go

@@ -0,0 +1,111 @@
+package auth
+
+import (
+	"context"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+	"time"
+)
+
+const validJWTForTests = "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJ0ZXN0LXVzZXItMTIzIn0.signature"
+
+func TestDeckAuthenticatorRejectsInvalidToken(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(http.StatusUnauthorized)
+	}))
+	defer server.Close()
+
+	a := NewDeckAuthenticator(DeckAPIs{"test": server.URL}, server.Client())
+	if _, err := a.Authenticate(context.Background(), "bad-token", "test"); err == nil {
+		t.Fatal("expected error for invalid token")
+	}
+}
+
+func TestDeckAuthenticatorAcceptsValidJWT(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.Header.Get("Authorization") == "" {
+			t.Fatal("expected Authorization header")
+		}
+		w.WriteHeader(http.StatusOK)
+	}))
+	defer server.Close()
+
+	a := NewDeckAuthenticator(DeckAPIs{"test": server.URL}, server.Client())
+	identity, err := a.Authenticate(context.Background(), validJWTForTests, "test")
+	if err != nil {
+		t.Fatalf("expected success: %v", err)
+	}
+	if identity.Sub != "test-user-123" {
+		t.Fatalf("unexpected sub: %q", identity.Sub)
+	}
+	if NamespaceForSub(identity.Sub) != NamespaceForSub("test-user-123") {
+		t.Fatalf("unexpected namespace: %q", NamespaceForSub(identity.Sub))
+	}
+}
+
+func TestDeckAuthenticatorCachesValidToken(t *testing.T) {
+	requests := 0
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		requests++
+		w.WriteHeader(http.StatusOK)
+	}))
+	defer server.Close()
+
+	a := NewDeckAuthenticator(DeckAPIs{"test": server.URL}, server.Client())
+	if _, err := a.Authenticate(context.Background(), validJWTForTests, "test"); err != nil {
+		t.Fatalf("first auth: %v", err)
+	}
+	if _, err := a.Authenticate(context.Background(), validJWTForTests, "test"); err != nil {
+		t.Fatalf("second auth: %v", err)
+	}
+	if requests != 1 {
+		t.Fatalf("expected 1 upstream request (cache), got %d", requests)
+	}
+	// проверяем что кэш выставлен
+	if v, ok := a.tokenCache.Load("test:" + validJWTForTests); !ok || time.Now().After(v.(time.Time)) {
+		t.Fatal("expected token to be cached with future expiry")
+	}
+}
+
+func TestTestAuthenticatorAcceptsJWT(t *testing.T) {
+	a := &TestAuthenticator{}
+	identity, err := a.Authenticate(context.Background(), validJWTForTests, "test")
+	if err != nil {
+		t.Fatalf("expected success: %v", err)
+	}
+	if identity.Sub != "test-user-123" {
+		t.Fatalf("unexpected sub: %q", identity.Sub)
+	}
+}
+
+func TestTestAuthenticatorAcceptsEmail(t *testing.T) {
+	a := &TestAuthenticator{}
+	identity, err := a.Authenticate(context.Background(), "user@example.com", "test")
+	if err != nil {
+		t.Fatalf("expected success: %v", err)
+	}
+	if identity.Sub != "user@example.com" {
+		t.Fatalf("unexpected sub: %q", identity.Sub)
+	}
+}
+
+func TestTestAuthenticatorRejectsInvalidToken(t *testing.T) {
+	a := &TestAuthenticator{}
+	if _, err := a.Authenticate(context.Background(), "notajwt", "test"); err == nil {
+		t.Fatal("expected error for non-JWT non-email token")
+	}
+}
+
+func TestNamespaceForSub(t *testing.T) {
+	ns := NamespaceForSub("test-user-123")
+	if len(ns) == 0 {
+		t.Fatal("empty namespace")
+	}
+	if ns != NamespaceForSub("test-user-123") {
+		t.Fatal("namespace not deterministic")
+	}
+	if NamespaceForSub("a") == NamespaceForSub("b") {
+		t.Fatal("different subs should produce different namespaces")
+	}
+}

console/ui/cron.go

@@ -0,0 +1,16 @@
+package ui
+
+import (
+	_ "embed"
+	"net/http"
+)
+
+//go:embed cron.html
+var cronPage string
+
+func CronHandler() http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
+		w.Header().Set("Content-Type", "text/html; charset=utf-8")
+		_, _ = w.Write([]byte(cronPage))
+	})
+}

console/ui/cron.html

@@ -0,0 +1,430 @@
+<!doctype html>
+<html lang="ru">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <title>NUBES Cron</title>
+  <style>
+    :root {
+      --bg-page: #001120;
+      --bg-surface: #001929;
+      --bg-navbar: #001c34;
+      --border: #0b2d50;
+      --accent: #1a7fd4;
+      --text-primary: #e2ecf6;
+      --text-secondary: #6b8eaa;
+      --good: #56d364;
+      --warn: #e3b341;
+      --bad: #f85149;
+    }
+    * { box-sizing: border-box; margin: 0; padding: 0; }
+    body {
+      font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", system-ui, sans-serif;
+      background: linear-gradient(180deg, #001120 0%, #061424 100%);
+      color: var(--text-primary);
+      min-height: 100vh;
+    }
+    a { color: inherit; text-decoration: none; }
+    .navbar {
+      height: 56px;
+      display: flex;
+      align-items: center;
+      justify-content: space-between;
+      padding: 0 20px;
+      background: var(--bg-navbar);
+      border-bottom: 1px solid var(--border);
+      position: sticky;
+      top: 0;
+      z-index: 10;
+    }
+    .brand { display: flex; align-items: center; gap: 10px; }
+    .brand-mark {
+      width: 30px; height: 30px; border-radius: 8px;
+      background: linear-gradient(135deg, #009dff 0%, #0055d4 100%);
+      color: #fff; display: grid; place-items: center;
+      font-size: 14px; font-weight: 800; letter-spacing: .02em;
+      box-shadow: 0 6px 18px rgba(0, 125, 255, .35);
+    }
+    .brand-text { display: flex; flex-direction: column; line-height: 1.08; }
+    .brand-text .nubes { font-size: 12px; letter-spacing: .22em; font-weight: 800; color: #8bc7ff; }
+    .brand-text .product { font-size: 13px; font-weight: 700; letter-spacing: .04em; }
+    .btn {
+      background: var(--accent); color: #fff; border: 0; border-radius: 6px;
+      padding: 8px 12px; cursor: pointer; font-size: 13px; line-height: 1.2;
+    }
+    .btn.ghost { background: #0c2b49; }
+    .btn:hover { opacity: .95; }
+    .wrap { max-width: 1320px; margin: 0 auto; padding: 20px; }
+    .hero {
+      background: linear-gradient(180deg, #001929 0%, #001622 100%);
+      border: 1px solid var(--border); border-radius: 14px; padding: 18px;
+      box-shadow: 0 12px 34px rgba(0, 0, 0, .18);
+    }
+    .hero-top { display: flex; justify-content: space-between; gap: 16px; align-items: flex-start; flex-wrap: wrap; }
+    .hero h1 { font-size: 28px; margin-bottom: 6px; }
+    .hero p { color: var(--text-secondary); max-width: 920px; line-height: 1.5; font-size: 14px; }
+    .hero .actions { display: flex; gap: 8px; flex-wrap: wrap; }
+    .clock {
+      display: inline-flex;
+      align-items: center;
+      gap: 8px;
+      margin-top: 14px;
+      padding: 10px 12px;
+      border-radius: 10px;
+      background: rgba(12, 43, 73, .72);
+      border: 1px solid #1d486d;
+      color: #d7e7f7;
+      font-size: 14px;
+      font-weight: 700;
+      letter-spacing: .02em;
+    }
+    .clock small {
+      display: block;
+      font-size: 11px;
+      color: var(--text-secondary);
+      font-weight: 600;
+      letter-spacing: .08em;
+      text-transform: uppercase;
+      margin-bottom: 2px;
+    }
+    .grid {
+      display: grid; grid-template-columns: repeat(auto-fit, minmax(180px, 1fr)); gap: 12px;
+      margin-top: 16px;
+    }
+    .card {
+      background: var(--bg-surface); border: 1px solid var(--border); border-radius: 12px; padding: 14px 16px;
+    }
+    .k { color: var(--text-secondary); font-size: 12px; text-transform: uppercase; letter-spacing: .06em; }
+    .v { font-size: 24px; font-weight: 800; margin-top: 6px; }
+    .s { font-size: 12px; color: var(--text-secondary); margin-top: 4px; min-height: 16px; }
+    .panel {
+      margin-top: 14px; background: var(--bg-surface); border: 1px solid var(--border); border-radius: 12px;
+      overflow: hidden;
+    }
+    .panel-head {
+      display: flex; justify-content: space-between; gap: 12px; align-items: center; flex-wrap: wrap;
+      padding: 14px 16px; border-bottom: 1px solid var(--border);
+    }
+    .panel-head h2 { font-size: 16px; }
+    .meta { color: var(--text-secondary); font-size: 12px; }
+    table { width: 100%; border-collapse: collapse; min-width: 1220px; }
+    th, td { padding: 9px 11px; border-bottom: 1px solid #0b2a48; text-align: left; }
+    th {
+      color: var(--text-secondary); font-size: 11px; text-transform: uppercase; letter-spacing: .05em; white-space: nowrap;
+    }
+    td { font-size: 13px; vertical-align: middle; }
+    tbody tr:hover { background: rgba(26, 127, 212, .08); }
+    .mono { font-family: ui-monospace, SFMono-Regular, Menlo, monospace; font-size: 12px; }
+    .status-ok { color: var(--good); }
+    .status-warn { color: var(--warn); }
+    .status-bad { color: var(--bad); }
+    .empty { color: var(--text-secondary); padding: 24px 12px; text-align: center; }
+    .pagination {
+      display: flex; align-items: center; gap: 6px; flex-wrap: wrap;
+      padding: 12px 16px; border-top: 1px solid var(--border);
+    }
+    .page-btn {
+      min-width: 32px; height: 28px; padding: 0 8px; border-radius: 6px;
+      background: #0c2b49; border: 1px solid #1d486d; color: #d7e7f7;
+      font-size: 12px; cursor: pointer; display: inline-flex; align-items: center; justify-content: center;
+    }
+    .page-btn:hover { background: #153d68; }
+    .page-btn.active { background: var(--accent); border-color: var(--accent); color: #fff; }
+    .page-btn:disabled { opacity: .35; cursor: default; }
+    .page-info { color: var(--text-secondary); font-size: 12px; margin-left: 6px; }
+    .footer {
+      padding-top: 12px; color: var(--text-secondary); font-size: 12px; line-height: 1.5;
+    }
+    .badge {
+      display: inline-block; padding: 2px 7px; border-radius: 999px; background: #0c2b49; border: 1px solid #1d486d;
+      color: #d7e7f7; font-size: 11px;
+    }
+    @media (max-width: 820px) {
+      .hero h1 { font-size: 22px; }
+    }
+  </style>
+</head>
+<body>
+  <div class="navbar">
+    <div class="brand">
+      <div class="brand-mark">N</div>
+      <div class="brand-text">
+        <div class="nubes">NUBES</div>
+        <div class="product">МЕТРИКИ CRON</div>
+      </div>
+    </div>
+    <div class="actions">
+      <button class="btn ghost" id="btn-refresh">Обновить</button>
+      <a class="btn ghost" href="/console/">Консоль</a>
+    </div>
+  </div>
+
+  <div class="wrap">
+    <section class="hero">
+      <div class="hero-top">
+        <div>
+          <h1>Снимки состояния по cron</h1>
+          <p>
+            Python-функция по расписанию отправляет сюда snapshot со свободной памятью, CPU load, диском и uptime.
+            Страница показывает последний снимок и историю замеров в том же стиле, что и основной dashboard: карточки + таблица.
+            <br><br>
+            <strong>Примечание:</strong> метрики читаются из <span class="mono">/proc</span> внутри pod-а и отражают состояние
+            <em>ноды кластера</em>, на которой запущена функция — не ресурсы самого pod-а и не агрегированные показатели кластера.
+          </p>
+          <div class="clock">
+            <div>
+              <small>Current time</small>
+              <span id="current-time">--:--:--</span>
+            </div>
+          </div>
+        </div>
+        <div class="actions">
+          <span class="badge" id="points-badge">0 points</span>
+        </div>
+      </div>
+
+      <div class="grid" id="summary"></div>
+    </section>
+
+    <section class="panel">
+      <div class="panel-head">
+        <div>
+          <h2>История</h2>
+          <div class="meta" id="last-updated">Ожидание первых данных…</div>
+        </div>
+        <div class="meta mono" id="latest-source"></div>
+      </div>
+      <div style="overflow-x:auto;">
+        <table>
+          <thead>
+            <tr>
+              <th>Время</th>
+              <th>Источник</th>
+              <th>Хост</th>
+              <th>Своб. МБ</th>
+              <th>Дост. МБ</th>
+              <th>Исп. МБ</th>
+              <th>Память %</th>
+              <th>ЦП 1м</th>
+              <th>ЦП 5м</th>
+              <th>ЦП 15м</th>
+              <th>Диск своб.</th>
+              <th>Аптайм</th>
+              <th>Статус</th>
+            </tr>
+          </thead>
+          <tbody id="history-body">
+            <tr><td class="empty" colspan="13">Данных пока нет</td></tr>
+          </tbody>
+        </table>
+      </div>
+      <div id="pagination" class="pagination"></div>
+    </section>
+
+    <div class="footer">
+      Endpoint для cron-функции: <span class="mono">POST /cron/api/metrics</span>.<br>
+      Пример полезной нагрузки: <span class="mono">{"source":"my-fn","memory_free_mb":1234,"cpu_load_1m":0.12}</span>.
+    </div>
+  </div>
+
+  <script>
+    const API = '/cron/api/metrics';
+    const summaryEl = document.getElementById('summary');
+    const historyBody = document.getElementById('history-body');
+    const lastUpdatedEl = document.getElementById('last-updated');
+    const latestSourceEl = document.getElementById('latest-source');
+    const pointsBadge = document.getElementById('points-badge');
+    const currentTimeEl = document.getElementById('current-time');
+
+    function num(v) {
+      if (v === null || v === undefined || v === '') return null;
+      const n = Number(v);
+      return Number.isFinite(n) ? n : null;
+    }
+
+    function fmtNum(v, d = 1, suffix = '') {
+      const n = num(v);
+      if (n === null) return '—';
+      return n.toFixed(d) + suffix;
+    }
+
+    function fmtTime(v) {
+      if (!v) return '—';
+      const d = new Date(v);
+      if (Number.isNaN(d.getTime())) return String(v);
+      return new Intl.DateTimeFormat('ru-RU', {
+        year: '2-digit', month: '2-digit', day: '2-digit',
+        hour: '2-digit', minute: '2-digit', second: '2-digit'
+      }).format(d);
+    }
+
+    function updateClock() {
+      currentTimeEl.textContent = new Intl.DateTimeFormat('ru-RU', {
+        hour: '2-digit',
+        minute: '2-digit',
+        second: '2-digit',
+        day: '2-digit',
+        month: '2-digit',
+        year: 'numeric'
+      }).format(new Date());
+    }
+
+    function fmtUptime(v) {
+      const sec = num(v);
+      if (sec === null) return '—';
+      const days = Math.floor(sec / 86400);
+      const hours = Math.floor((sec % 86400) / 3600);
+      const mins = Math.floor((sec % 3600) / 60);
+      if (days > 0) return `${days}д ${hours}ч ${mins}м`;
+      if (hours > 0) return `${hours}ч ${mins}м`;
+      return `${Math.floor(sec)}с`;
+    }
+
+    function cls(status) {
+      const s = String(status || '').toLowerCase();
+      if (s.includes('err') || s.includes('fail') || s.includes('bad')) return 'status-bad';
+      if (s.includes('warn') || s.includes('degrad') || s.includes('idle')) return 'status-warn';
+      return 'status-ok';
+    }
+
+    function card(label, value, subtitle) {
+      return `
+        <div class="card">
+          <div class="k">${label}</div>
+          <div class="v">${value}</div>
+          <div class="s">${subtitle || ''}</div>
+        </div>
+      `;
+    }
+
+    function renderSummary(latest, count) {
+      if (!latest) {
+        summaryEl.innerHTML = [
+          card('Снимки', '0', 'Ожидание cron-запросов'),
+          card('Своб. память', '—', 'МБ'),
+          card('Дост. память', '—', 'МБ'),
+          card('Исп. память', '—', 'МБ'),
+          card('Нагрузка ЦП', '—', '1м / 5м / 15м'),
+          card('Диск своб.', '—', 'ГБ')
+        ].join('');
+        pointsBadge.textContent = '0 снимков';
+        return;
+      }
+
+      summaryEl.innerHTML = [
+        card('Снимки', String(count), `Источник: ${latest.source || 'cron'}`),
+        card('Своб. память', fmtNum(latest.memory_free_mb, 1, ' МБ'), latest.hostname || '—'),
+        card('Дост. память', fmtNum(latest.memory_available_mb, 1, ' МБ'), 'Доступная RAM'),
+        card('Исп. память', fmtNum(latest.memory_used_mb, 1, ' МБ'), `Память ${fmtNum(latest.memory_percent, 1, '%')}`),
+        card('Нагрузка ЦП', [fmtNum(latest.cpu_load_1m, 2), fmtNum(latest.cpu_load_5m, 2), fmtNum(latest.cpu_load_15m, 2)].join(' / '), '1м / 5м / 15м'),
+        card('Диск своб.', fmtNum(latest.disk_free_gb, 1, ' ГБ'), `Аптайм ${fmtUptime(latest.uptime_sec)}`)
+      ].join('');
+      pointsBadge.textContent = `${count} снимк${count === 1 ? '' : 'ов'}`;
+    }
+
+    const PAGE_SIZE = 10;
+    let allHistory = [];
+    let currentPage = 1;
+
+    function renderPage(page) {
+      const total = allHistory.length;
+      const pages = Math.max(1, Math.ceil(total / PAGE_SIZE));
+      currentPage = Math.min(Math.max(1, page), pages);
+      const pg = document.getElementById('pagination');
+
+      if (!total) {
+        historyBody.innerHTML = '<tr><td class="empty" colspan="13">Данных пока нет</td></tr>';
+        pg.innerHTML = '';
+        return;
+      }
+
+      const start = (currentPage - 1) * PAGE_SIZE;
+      const slice = allHistory.slice(start, start + PAGE_SIZE);
+
+      historyBody.innerHTML = slice.map(function (item) {
+        return `
+          <tr>
+            <td class="mono">${fmtTime(item.timestamp)}</td>
+            <td>${item.source || '—'}</td>
+            <td>${item.hostname || '—'}</td>
+            <td class="mono">${fmtNum(item.memory_free_mb, 1)}</td>
+            <td class="mono">${fmtNum(item.memory_available_mb, 1)}</td>
+            <td class="mono">${fmtNum(item.memory_used_mb, 1)}</td>
+            <td class="mono">${fmtNum(item.memory_percent, 1, '%')}</td>
+            <td class="mono">${fmtNum(item.cpu_load_1m, 2)}</td>
+            <td class="mono">${fmtNum(item.cpu_load_5m, 2)}</td>
+            <td class="mono">${fmtNum(item.cpu_load_15m, 2)}</td>
+            <td class="mono">${fmtNum(item.disk_free_gb, 1, ' ГБ')}</td>
+            <td class="mono">${fmtUptime(item.uptime_sec)}</td>
+            <td class="${cls(item.status)}">${item.status || 'ok'}</td>
+          </tr>
+        `;
+      }).join('');
+
+      if (pages <= 1) { pg.innerHTML = ''; return; }
+
+      let btns = `<button class="page-btn" id="pg-prev" ${currentPage === 1 ? 'disabled' : ''}>←</button>`;
+      for (let i = 1; i <= pages; i++) {
+        btns += `<button class="page-btn ${i === currentPage ? 'active' : ''}" data-page="${i}">${i}</button>`;
+      }
+      btns += `<button class="page-btn" id="pg-next" ${currentPage === pages ? 'disabled' : ''}>→</button>`;
+      btns += `<span class="page-info">стр. ${currentPage} из ${pages} · всего ${total}</span>`;
+      pg.innerHTML = btns;
+
+      pg.querySelector('#pg-prev').addEventListener('click', function () { renderPage(currentPage - 1); });
+      pg.querySelector('#pg-next').addEventListener('click', function () { renderPage(currentPage + 1); });
+      pg.querySelectorAll('[data-page]').forEach(function (btn) {
+        btn.addEventListener('click', function () { renderPage(Number(btn.dataset.page)); });
+      });
+    }
+
+    function renderTable(history) {
+      allHistory = history.slice().reverse();
+      renderPage(1);
+    }
+
+    function updateMeta(history) {
+      if (!history.length) {
+        lastUpdatedEl.textContent = 'Ожидание первых данных…';
+        latestSourceEl.textContent = '';
+        return;
+      }
+      const latest = history[history.length - 1];
+      lastUpdatedEl.textContent = `Последний снимок: ${fmtTime(latest.timestamp)}${latest.hostname ? ' · ' + latest.hostname : ''}`;
+      latestSourceEl.textContent = latest.source ? `source=${latest.source}` : '';
+    }
+
+    async function loadMetrics() {
+      try {
+        const res = await fetch(API, { headers: { 'Accept': 'application/json' } });
+        if (!res.ok) throw new Error('HTTP ' + res.status);
+        const data = await res.json();
+        const history = Array.isArray(data.history) ? data.history : [];
+        const latest = data.latest || (history.length ? history[history.length - 1] : null);
+        renderSummary(latest, history.length || (latest ? 1 : 0));
+        renderTable(history);
+        updateMeta(history);
+      } catch (err) {
+        summaryEl.innerHTML = [
+          card('Снимки', '—', 'Ошибка загрузки'),
+          card('Своб. память', '—', err.message),
+          card('Дост. память', '—', 'Проверить backend'),
+          card('Исп. память', '—', 'Проверить cron-функцию'),
+          card('Нагрузка ЦП', '—', 'Проверить backend'),
+          card('Диск своб.', '—', 'Проверить приём данных')
+        ].join('');
+        historyBody.innerHTML = `<tr><td class="empty" colspan="13">Ошибка загрузки: ${err.message}</td></tr>`;
+        lastUpdatedEl.textContent = 'Ошибка обновления';
+        latestSourceEl.textContent = '';
+        pointsBadge.textContent = '0 снимков';
+      }
+    }
+
+    document.getElementById('btn-refresh').addEventListener('click', loadMetrics);
+    updateClock();
+    setInterval(updateClock, 1000);
+    loadMetrics();
+    setInterval(loadMetrics, 30000);
+  </script>
+</body>
+</html>

console/ui/css/styles.css

@@ -0,0 +1,320 @@
+:root {
+  --bg-page: #001120;
+  --bg-surface: #001929;
+  --bg-navbar: #001c34;
+  --border: #0b2d50;
+  --accent: #1a7fd4;
+  --text-primary: #e2ecf6;
+  --text-secondary: #6b8eaa;
+}
+
+* {
+  box-sizing: border-box;
+  margin: 0;
+  padding: 0;
+}
+
+body {
+  font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", system-ui, sans-serif;
+  background: var(--bg-page);
+  color: var(--text-primary);
+  min-height: 100vh;
+}
+
+.navbar {
+  height: 56px;
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  padding: 0 20px;
+  background: var(--bg-navbar);
+  border-bottom: 1px solid var(--border);
+}
+
+.title {
+  font-weight: 700;
+  letter-spacing: .3px;
+}
+
+.brand {
+  display: flex;
+  align-items: center;
+  gap: 10px;
+}
+
+.brand-mark {
+  width: 30px;
+  height: 30px;
+  border-radius: 8px;
+  background: linear-gradient(135deg, #009dff 0%, #0055d4 100%);
+  color: #fff;
+  display: grid;
+  place-items: center;
+  font-size: 14px;
+  font-weight: 800;
+  letter-spacing: .02em;
+  box-shadow: 0 6px 18px rgba(0, 125, 255, .35);
+}
+
+.brand-text {
+  display: flex;
+  flex-direction: column;
+  line-height: 1.08;
+}
+
+.brand-text .nubes {
+  font-size: 12px;
+  letter-spacing: .22em;
+  font-weight: 800;
+  color: #8bc7ff;
+}
+
+.brand-text .product {
+  font-size: 13px;
+  font-weight: 700;
+  letter-spacing: .04em;
+}
+
+.btn {
+  background: var(--accent);
+  color: #fff;
+  border: 0;
+  border-radius: 6px;
+  padding: 8px 12px;
+  cursor: pointer;
+  font-size: 13px;
+  line-height: 1.2;
+}
+
+.btn:disabled {
+  opacity: .6;
+  cursor: not-allowed;
+}
+
+.btn.danger {
+  background: #b43232;
+}
+
+.btn.ghost {
+  background: #0c2b49;
+}
+
+.wrap {
+  max-width: 1100px;
+  margin: 0 auto;
+  padding: 20px;
+}
+
+.grid {
+  display: grid;
+  grid-template-columns: repeat(auto-fit, minmax(220px, 1fr));
+  gap: 12px;
+  margin-bottom: 16px;
+}
+
+.card {
+  background: var(--bg-surface);
+  border: 1px solid var(--border);
+  border-radius: 8px;
+  padding: 14px;
+}
+
+.k {
+  color: var(--text-secondary);
+  font-size: 12px;
+  text-transform: uppercase;
+  letter-spacing: .06em;
+}
+
+.v {
+  font-size: 24px;
+  font-weight: 700;
+  margin-top: 6px;
+}
+
+.box {
+  background: var(--bg-surface);
+  border: 1px solid var(--border);
+  border-radius: 8px;
+  padding: 14px;
+  margin-top: 12px;
+}
+
+.toolbar {
+  display: flex;
+  justify-content: space-between;
+  gap: 10px;
+  align-items: center;
+  margin-bottom: 10px;
+}
+
+table {
+  width: 100%;
+  border-collapse: collapse;
+  font-size: 13px;
+  margin-top: 8px;
+}
+
+th,
+td {
+  text-align: left;
+  padding: 8px;
+  border-bottom: 1px solid #0b2a48;
+}
+
+.hint {
+  color: var(--text-secondary);
+  font-size: 12px;
+  margin-top: 8px;
+}
+
+.mono {
+  font-family: ui-monospace, SFMono-Regular, Menlo, monospace;
+  font-size: 12px;
+}
+
+.status {
+  margin-top: 10px;
+  padding: 9px 10px;
+  border-radius: 6px;
+  font-size: 13px;
+  background: #0c2b49;
+  border: 1px solid #1d486d;
+  display: none;
+}
+
+.status.ok {
+  background: #103625;
+  border-color: #236843;
+}
+
+.status.err {
+  background: #411d1d;
+  border-color: #7a2f2f;
+}
+
+.chip {
+  display: inline-block;
+  padding: 2px 7px;
+  border-radius: 999px;
+  border: 1px solid #1d486d;
+  background: #0c2b49;
+  font-size: 11px;
+  margin-right: 4px;
+}
+
+.modal {
+  position: fixed;
+  inset: 0;
+  background: rgba(0, 0, 0, .45);
+  display: none;
+  align-items: center;
+  justify-content: center;
+  padding: 16px;
+}
+
+.modal.open {
+  display: flex;
+}
+
+.panel {
+  width: min(820px, 100%);
+  max-height: 90vh;
+  overflow: auto;
+  background: var(--bg-surface);
+  border: 1px solid var(--border);
+  border-radius: 10px;
+  padding: 16px;
+}
+
+.panel h3 {
+  margin-bottom: 10px;
+  font-size: 16px;
+}
+
+.row {
+  display: flex;
+  gap: 10px;
+  margin-bottom: 10px;
+  flex-wrap: wrap;
+}
+
+.field {
+  flex: 1;
+  min-width: 180px;
+}
+
+label {
+  display: block;
+  margin-bottom: 4px;
+  font-size: 12px;
+  color: var(--text-secondary);
+}
+
+input,
+select,
+textarea {
+  width: 100%;
+  border: 1px solid #1d486d;
+  background: #03192c;
+  color: var(--text-primary);
+  border-radius: 6px;
+  padding: 8px 10px;
+  font-size: 13px;
+}
+
+textarea {
+  min-height: 220px;
+  resize: vertical;
+  font-family: ui-monospace, SFMono-Regular, Menlo, monospace;
+}
+
+.actions {
+  display: flex;
+  gap: 8px;
+  justify-content: flex-end;
+  margin-top: 8px;
+  flex-wrap: wrap;
+}
+
+.nowrap {
+  white-space: nowrap;
+}
+
+.help-section {
+  margin-top: 14px;
+  padding-top: 14px;
+  border-top: 1px solid #0b2a48;
+}
+
+.help-section:first-of-type {
+  margin-top: 0;
+  padding-top: 0;
+  border-top: 0;
+}
+
+.help-section h4 {
+  margin-bottom: 8px;
+  font-size: 14px;
+}
+
+.help-list {
+  display: grid;
+  gap: 8px;
+  font-size: 13px;
+  line-height: 1.5;
+  color: var(--text-primary);
+}
+
+.help-code {
+  margin-top: 8px;
+  padding: 10px 12px;
+  border-radius: 8px;
+  border: 1px solid #0b2a48;
+  background: #021221;
+  color: #d8e5f2;
+  font-family: ui-monospace, SFMono-Regular, Menlo, monospace;
+  font-size: 12px;
+  white-space: pre-wrap;
+  word-break: break-word;
+}

console/ui/embed.go

@@ -5,7 +5,7 @@ import (
 	"net/http"
 )
 
-//go:embed index.html
+//go:embed index.html cron.html css js
 var content embed.FS
 
 func Handler() http.Handler {

console/ui/js/ai.js

@@ -0,0 +1,149 @@
+/* ai.js — AI/LLM функции: проверка, генерация, объяснение, ассистент */
+
+function llmGeneratedWarning(lang) {
+  var text = 'Сделано LLM. Не доверяй, проверяй!';
+  switch (lang) {
+    case 'php':
+      return '// ' + text;
+    case 'nodejs':
+    case 'go':
+      return '// ' + text;
+    case 'ruby':
+    case 'python':
+    default:
+      return '# ' + text;
+  }
+}
+
+function addLLMWarning(code, lang) {
+  var body = String(code || '').replace(/^\s+/, '');
+  var warning = llmGeneratedWarning(lang);
+  if (!body) return warning;
+  if (body.indexOf(warning) === 0) return body;
+  if (lang === 'php' && body.indexOf('<?php') === 0) {
+    var rest = body.slice(5);
+    rest = rest.replace(/^\r?\n/, '');
+    return '<?php\n' + warning + '\n' + rest;
+  }
+  return warning + '\n' + body;
+}
+
+async function aiCheck(codeId, langId, resultId) {
+  var code = document.getElementById(codeId).value.trim();
+  var lang = (document.getElementById(langId) ? document.getElementById(langId).value : '') || 'python';
+  var resEl = document.getElementById(resultId);
+  if (!code) { resEl.style.display = 'block'; resEl.style.background = 'var(--bg-alt)'; resEl.textContent = 'Введите код для проверки.'; return; }
+  var btnId = codeId === 'c-code' ? 'c-ai-btn' : 'e-ai-btn';
+  var btn = document.getElementById(btnId);
+  btn.disabled = true;
+  btn.textContent = '⏳ Проверяю...';
+  resEl.style.display = 'block';
+  resEl.style.background = 'var(--bg-alt)';
+  resEl.style.color = 'var(--fg)';
+  resEl.textContent = 'Проверяю код линтером...';
+  try {
+    var data = await requestJSON(API_BASE + '/ai/check', 'POST', { language: lang, code: code });
+    resEl.style.background = data.ok ? '#1a3a1a' : '#3a1a1a';
+    resEl.style.color = data.ok ? '#8f8' : '#f88';
+    resEl.textContent = data.result || '(пустой ответ)';
+  } catch (e) {
+    resEl.style.background = '#3a2a00';
+    resEl.style.color = '#ffa';
+    resEl.textContent = 'Ошибка: ' + e.message;
+  } finally {
+    btn.disabled = false;
+    btn.textContent = '🔍 Проверить синтаксис линтером';
+  }
+}
+
+var _assistantOpen = true;
+
+function toggleAssistant() {
+  _assistantOpen = !_assistantOpen;
+  document.getElementById('assistant-body').style.display = _assistantOpen ? 'flex' : 'none';
+  document.getElementById('assistant-toggle-icon').textContent = _assistantOpen ? '▲' : '▼';
+}
+
+async function askAssistant() {
+  var inp = document.getElementById('assistant-input');
+  var msgs = document.getElementById('assistant-messages');
+  var q = inp.value.trim();
+  if (!q) return;
+  inp.value = '';
+  msgs.textContent += '\n\n👤 ' + q + '\n⏳ ...';
+  msgs.scrollTop = msgs.scrollHeight;
+  try {
+    var r = await fetch('/console/api/ai/ask', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json', ...authHeaders() },
+      body: JSON.stringify({ mode: 'chat', question: q })
+    });
+    var d = await r.json();
+    msgs.textContent = msgs.textContent.replace('⏳ ...', '🤖 ' + (d.answer || d.error || 'Нет ответа'));
+  } catch (e) {
+    msgs.textContent = msgs.textContent.replace('⏳ ...', '❌ Ошибка: ' + e.message);
+  }
+  msgs.scrollTop = msgs.scrollHeight;
+}
+
+function showGenPrompt() {
+  var el = document.getElementById('c-gen-prompt');
+  el.style.display = 'flex';
+  document.getElementById('c-gen-desc').focus();
+}
+
+async function aiGenerate() {
+  var name = (document.getElementById('c-name').value || '').trim() || 'my-func';
+  var lang = document.getElementById('c-lang').value || 'python';
+  var desc = (document.getElementById('c-gen-desc').value || '').trim();
+  if (!desc) { document.getElementById('c-gen-desc').focus(); return; }
+  var btn = document.getElementById('c-gen-btn');
+  var resEl = document.getElementById('c-ai-result');
+  btn.disabled = true; btn.textContent = '⏳ Генерирую...';
+  resEl.style.display = 'block'; resEl.style.background = 'var(--bg-alt)'; resEl.style.color = 'var(--fg)';
+  resEl.textContent = 'Запрашиваю у LLM...';
+  try {
+    var d = await requestJSON('/console/api/ai/ask', 'POST', {
+      mode: 'codegen',
+      language: lang,
+      name: name,
+      description: desc
+    });
+    var code = (d.answer || '').replace(/^```[\w]*\n?/, '').replace(/\n?```$/, '');
+    document.getElementById('c-code').value = addLLMWarning(code, lang);
+    document.getElementById('c-gen-prompt').style.display = 'none';
+    resEl.style.background = '#1a3a1a'; resEl.style.color = '#8f8';
+    resEl.textContent = 'Код сгенерирован и вставлен.';
+  } catch (e) {
+    resEl.style.background = '#3a2a00'; resEl.style.color = '#ffa';
+    resEl.textContent = 'Ошибка: ' + e.message;
+  } finally {
+    btn.disabled = false; btn.textContent = '✨ Сгенерировать код LLM';
+  }
+}
+
+async function aiExplain(codeId, langId, resultId) {
+  var code = (document.getElementById(codeId).value || '').trim();
+  var lang = (document.getElementById(langId) ? document.getElementById(langId).value : '') || 'python';
+  var resEl = document.getElementById(resultId);
+  var btnId = codeId === 'c-code' ? 'c-exp-btn' : 'e-exp-btn';
+  var btn = document.getElementById(btnId);
+  if (!code) { resEl.style.display = 'block'; resEl.style.background = 'var(--bg-alt)'; resEl.textContent = 'Введите код.'; return; }
+  btn.disabled = true; btn.textContent = '⏳ Объясняю...';
+  resEl.style.display = 'block'; resEl.style.background = 'var(--bg-alt)'; resEl.style.color = 'var(--fg)';
+  resEl.textContent = 'Запрашиваю у LLM...';
+  try {
+    var d = await requestJSON('/console/api/ai/ask', 'POST', {
+      mode: 'explain',
+      language: lang,
+      code: code
+    });
+    resEl.style.background = '#1a2a3a'; resEl.style.color = '#8cf';
+    resEl.textContent = d.answer || '(пустой ответ)';
+  } catch (e) {
+    resEl.style.background = '#3a2a00'; resEl.style.color = '#ffa';
+    resEl.textContent = 'Ошибка: ' + e.message;
+  } finally {
+    btn.disabled = false; btn.textContent = '📖 LLM: Что делает?';
+  }
+}

console/ui/js/api.js

@@ -0,0 +1,39 @@
+/* api.js — HTTP-утилиты */
+
+function authHeaders() {
+  return {
+    'X-Auth-Token': localStorage.getItem('auth_token') || '',
+    'X-Auth-Env': localStorage.getItem('auth_env') || 'test'
+  };
+}
+
+async function getJSON(url) {
+  const r = await fetch(url, { headers: authHeaders() });
+  if (r.status === 401) { doLogout(); throw new Error('Сессия истекла'); }
+  if (!r.ok) {
+    let msg = '';
+    try {
+      const body = await r.json();
+      msg = body.error || JSON.stringify(body);
+    } catch (_) {
+      msg = await r.text();
+    }
+    throw new Error(url + ': ' + r.status + (msg ? ' - ' + msg : ''));
+  }
+  return r.json();
+}
+
+async function requestJSON(url, method, body) {
+  const r = await fetch(url, {
+    method: method,
+    headers: Object.assign({ 'Content-Type': 'application/json' }, authHeaders()),
+    body: body ? JSON.stringify(body) : undefined
+  });
+  if (r.status === 401) { doLogout(); throw new Error('Сессия истекла'); }
+  let data = {};
+  try { data = await r.json(); } catch (_) { }
+  if (!r.ok) {
+    throw new Error(data.error || (url + ': ' + r.status));
+  }
+  return data;
+}

console/ui/js/app.js

@@ -0,0 +1,95 @@
+/* app.js — основная логика: загрузка данных, таблица функций */
+
+async function reloadAll() {
+  const progress = startTimedStatus('Загрузка...', 'Загрузка данных', null);
+
+  // Показываем таблицу сразу с placeholder'ом
+  document.getElementById('fn-rows').innerHTML =
+    '<tr><td colspan="9" style="color:var(--text-secondary); font-style:italic;">⏳ Загружаем функции...</td></tr>';
+
+  try {
+    const [envs, pkgs, fns, http, times] = await Promise.all([
+      getJSON(API_BASE + '/environments'),
+      getJSON(API_BASE + '/packages'),
+      getJSON(API_BASE + '/functions'),
+      getJSON(API_BASE + '/httptriggers'),
+      getJSON(API_BASE + '/timetriggers')
+    ]);
+
+    S.envs = envs || [];
+    S.fns = fns || [];
+    S.httpTriggers = http || [];
+    S.timeTriggers = times || [];
+
+    setText('env-count', envs.length || 0);
+    setText('pkg-count', pkgs.length || 0);
+    setText('fn-count', fns.length || 0);
+    setText('http-count', http.length || 0);
+    setText('cron-count', new Set((times || []).map(function (t) {
+      return t && t.spec && t.spec.functionref && t.spec.functionref.name;
+    }).filter(Boolean)).size);
+
+    function makeFnRow(f) {
+      const spec = f.spec || {};
+      const meta = f.metadata || {};
+      const ann = meta.annotations || {};
+      const env = (spec.environment && spec.environment.name) || '-';
+      const pkg = (spec.package && spec.package.packageref && spec.package.packageref.name) || '-';
+      const name = (f.metadata && f.metadata.name) || '-';
+      const trig = httpTriggerByFn(name) || {};
+      const timeTrig = timeTriggerByFn(name) || {};
+      const route = (trig.spec && trig.spec.relativeurl) || '-';
+      const methods = (trig.spec && trig.spec.methods) || [];
+      const chips = methods.map(function (m) { return '<span class="chip">' + h(m) + '</span>'; }).join('');
+      const cron = (timeTrig.spec && timeTrig.spec.cron) || '';
+      const cronCell = cron ? '<span class="chip">' + h(cron) + '</span>' : '<span class="mono" style="color:var(--text-secondary)">—</span>';
+      const createdAt = ann['fission-console/created-at'] || meta.creationTimestamp || '-';
+      const updatedAt = ann['fission-console/updated-at'] || createdAt;
+      var isGo = /go[-_]env/.test(env);
+      var isTf = /^tf-/.test(name);
+      var tfBadge = (isGo || isTf) ? '<span class="chip" style="background:#555;color:#ffa" title="Управляется Terraform. Изменения могут быть перезаписаны при terraform apply.">TF</span> ' : '';
+      var actions = tfBadge +
+        '<button class="btn ghost" onclick="openEdit(\'' + h(name) + '\')">Ред.</button> ' +
+        '<button class="btn ghost" onclick="openInvoke(\'' + h(name) + '\')">Вызов</button> ' +
+        '<button class="btn danger" onclick="removeFn(\'' + h(name) + '\')">Удалить</button>';
+      return '<tr>' +
+        '<td class="mono">' + h(name) + '</td>' +
+        '<td>' + h(env) + '</td>' +
+        '<td class="mono">' + h(pkg) + '</td>' +
+        '<td>' + timestampCell(createdAt) + '</td>' +
+        '<td>' + timestampCell(updatedAt) + '</td>' +
+        '<td class="mono">' + h(route) + '</td>' +
+        '<td>' + chips + '</td>' +
+        '<td>' + cronCell + '</td>' +
+        '<td class="nowrap">' + actions + '</td>' +
+        '</tr>';
+    }
+
+    var fnList = fns || [];
+    if (fnList.length === 0) {
+      progress.stop('Загружено: нет функций', '');
+      document.getElementById('fn-rows').innerHTML = '<tr><td colspan="9">Нет функций</td></tr>';
+    } else {
+      // Рендерим первую строку сразу — убираем placeholder
+      var tbody = document.getElementById('fn-rows');
+      tbody.innerHTML = makeFnRow(fnList[0]);
+      // Остальные добавляем по одной с небольшой задержкой
+      var i = 1;
+      function appendNext() {
+        if (i >= fnList.length) {
+          progress.stop('Загружено ' + fnList.length + ' функций', 'ok');
+          return;
+        }
+        var tr = document.createElement('tbody');
+        tr.innerHTML = makeFnRow(fnList[i]);
+        tbody.appendChild(tr.firstChild);
+        i++;
+        setTimeout(appendNext, 40);
+      }
+      setTimeout(appendNext, 40);
+    }
+  } catch (e) {
+    document.getElementById('fn-rows').innerHTML = '<tr><td colspan="9">Load error: ' + e.message + '</td></tr>';
+    progress.stop('Ошибка загрузки: ' + e.message, 'err');
+  }
+}

console/ui/js/auth.js

@@ -0,0 +1,105 @@
+/* auth.js — авторизация */
+
+function showLoginOverlay() {
+  document.getElementById('login-overlay').style.display = 'flex';
+}
+
+function hideLoginOverlay() {
+  document.getElementById('login-overlay').style.display = 'none';
+}
+
+async function doLogin() {
+  var btn = document.getElementById('l-btn');
+  var errEl = document.getElementById('l-error');
+  var token = (document.getElementById('l-token').value || '').trim();
+  var env = document.getElementById('l-env').value;
+  if (!token) { errEl.textContent = 'Введите токен или логин'; errEl.style.display = 'block'; return; }
+  var isJWT = token.split('.').length === 3 && !token.includes(' ');
+  if (!isJWT && token.length < 6) { errEl.textContent = 'Логин — не менее 6 символов'; errEl.style.display = 'block'; return; }
+  btn.disabled = true;
+  errEl.style.display = 'none';
+  try {
+    const res = await fetch(API_BASE + '/auth', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ token: token, env: env })
+    });
+    if (!res.ok) {
+      const d = await res.json().catch(function () { return {}; });
+      throw new Error(d.error || 'Ошибка входа');
+    }
+    const data = await res.json();
+    localStorage.setItem('auth_token', token);
+    localStorage.setItem('auth_env', env);
+    if (data.email) localStorage.setItem('auth_email', data.email);
+    else localStorage.removeItem('auth_email');
+    setUserAvatar(token);
+    hideLoginOverlay();
+    // Проверяем статус NS — если не ready, показываем init overlay
+    try {
+      var sr = await fetch(API_BASE + '/ns/status', { headers: { 'X-Auth-Token': token, 'X-Auth-Env': env } });
+      var sd = await sr.json();
+      if (!sd.ready) {
+        pollNSStatus();
+        return;
+      }
+    } catch (_) { }
+    reloadAll();
+  } catch (e) {
+    errEl.textContent = e.message;
+    errEl.style.display = 'block';
+  } finally {
+    btn.disabled = false;
+  }
+}
+
+function jwtEmail(token) {
+  try {
+    var payload = JSON.parse(atob(token.split('.')[1].replace(/-/g,'+').replace(/_/g,'/')));
+    return payload.email || payload.sub || null;
+  } catch (_) { return null; }
+}
+
+function setUserAvatar(token) {
+  var el = document.getElementById('user-avatar');
+  if (!el) return;
+  var email = localStorage.getItem('auth_email') || (token ? jwtEmail(token) : null);
+  if (email) {
+    el.textContent = email;
+    el.title = email;
+    el.style.fontSize = '0.75rem';
+    el.style.minWidth = 'auto';
+    el.style.padding = '0 10px';
+    el.style.background = 'none';
+    el.style.border = '1px solid var(--border)';
+    el.style.borderRadius = '6px';
+    el.style.color = 'var(--text-primary)';
+    el.style.fontWeight = '400';
+    el.style.width = 'auto';
+    el.style.height = '30px';
+  } else {
+    el.textContent = 'N';
+    el.title = '';
+    el.style.cssText = '';
+  }
+}
+
+function doLogout() {
+  localStorage.removeItem('auth_token');
+  localStorage.removeItem('auth_env');
+  localStorage.removeItem('auth_email');
+  try { document.getElementById('l-token').value = ''; } catch (_) { }
+  setUserAvatar(null);
+  showLoginOverlay();
+}
+
+function checkAuth() {
+  var storedToken = localStorage.getItem('auth_token');
+  if (!storedToken) {
+    showLoginOverlay();
+    return;
+  }
+  setUserAvatar(storedToken);
+  hideLoginOverlay();
+  reloadAll();
+}

console/ui/js/config.js

@@ -0,0 +1,20 @@
+/* config.js — константы и шаблоны языков */
+
+const LANG_TEMPLATES = {
+  python: {
+    entrypoint: 'main.main',
+    code: 'def main():\n    return {"ok": True}'
+  },
+  nodejs: {
+    entrypoint: 'main',
+    code: 'module.exports = async function(context) {\n    return {\n        status: 200,\n        body: "hello from fission"\n    };\n}'
+  },
+  php: {
+    entrypoint: 'main.php::handler',
+    code: '<?php\nfunction handler($context)\n{\n    $response = $context["response"];\n    $response->getBody()->write("hello from fission");\n}'
+  },
+  ruby: {
+    entrypoint: 'handler',
+    code: '# frozen_string_literal: true\n\ndef handler\n  "hello from fission"\nend'
+  }
+};

console/ui/js/functions.js

@@ -0,0 +1,180 @@
+/* functions.js — CRUD операции с функциями */
+
+// setCodeMode переключает режим формы между вводом кода и загрузкой архива.
+// prefix: 'c' (create) или 'e' (edit)
+// mode: 'code' | 'archive'
+function setCodeMode(prefix, mode) {
+  var codeArea = document.getElementById(prefix + '-code-area');
+  var archiveArea = document.getElementById(prefix + '-archive-area');
+  var btnCode = document.getElementById(prefix + '-mode-code');
+  var btnArchive = document.getElementById(prefix + '-mode-archive');
+  if (!codeArea || !archiveArea) return;
+
+  var isCode = mode === 'code';
+  codeArea.style.display = isCode ? '' : 'none';
+  archiveArea.style.display = isCode ? 'none' : '';
+  if (btnCode) btnCode.style.opacity = isCode ? '1' : '0.5';
+  if (btnArchive) btnArchive.style.opacity = isCode ? '0.5' : '1';
+}
+
+// lintArchiveFile — заглушка линтера для архивов.
+// Реализация (распаковка + пофайловая проверка) добавляется позже.
+function lintArchiveFile(prefix) {
+  var input = document.getElementById(prefix + '-archive-file');
+  if (!input || !input.files || !input.files[0]) {
+    showStatus('Выберите .zip файл', 'err');
+    return;
+  }
+  showStatus('Линтинг архива — пока не реализован (скоро)', 'info');
+}
+
+function parseMethods(v) {
+  const items = String(v || '').split(',').map(s => s.trim().toUpperCase()).filter(Boolean);
+  return items.length ? Array.from(new Set(items)) : ['GET'];
+}
+
+function parseTimeout(v) {
+  var n = Number(String(v || '').trim());
+  if (!Number.isFinite(n) || n <= 0) return 60;
+  return Math.round(n);
+}
+
+function onLangChange() {
+  var lang = document.getElementById('c-lang').value;
+  var t = LANG_TEMPLATES[lang];
+  if (t) {
+    document.getElementById('c-entry').value = t.entrypoint;
+    document.getElementById('c-code').value = t.code;
+  }
+}
+
+function openCreate() {
+  document.getElementById('c-lang').value = 'python';
+  onLangChange();
+  document.getElementById('c-timeout').value = '60';
+  document.getElementById('c-schedule-enabled').checked = false;
+  document.getElementById('c-cron').value = '';
+  toggleScheduleFields('c');
+  document.getElementById('create-modal').classList.add('open');
+  document.getElementById('c-name').focus();
+}
+
+function closeCreate() {
+  document.getElementById('create-modal').classList.remove('open');
+}
+
+async function submitCreate() {
+  const btn = document.getElementById('c-submit');
+  btn.disabled = true;
+  const progress = startTimedStatus('Создаём функцию...', 'Создание функции...', explainDelay);
+  try {
+    const name = document.getElementById('c-name').value.trim();
+    if (!name) throw new Error('name is required');
+    const lang = document.getElementById('c-lang').value.trim();
+    if (!lang) throw new Error('language is required');
+
+    await requestJSON(API_BASE + '/functions', 'POST', {
+      name: name,
+      language: lang,
+      entrypoint: document.getElementById('c-entry').value.trim(),
+      route: document.getElementById('c-route').value.trim(),
+      methods: parseMethods(document.getElementById('c-methods').value),
+      timeout: parseTimeout(document.getElementById('c-timeout').value),
+      code: document.getElementById('c-code').value
+    });
+
+    try {
+      await syncScheduleForFunction(name, 'c');
+    } catch (scheduleErr) {
+      try {
+        await requestJSON(API_BASE + '/functions/' + encodeURIComponent(name), 'DELETE');
+      } catch (rollbackErr) {
+        scheduleErr.message += '; rollback failed: ' + rollbackErr.message;
+      }
+      throw scheduleErr;
+    }
+
+    closeCreate();
+    progress.stop('Функция создана: ' + name, 'ok');
+    await reloadAll();
+  } catch (e) {
+    progress.stop('Ошибка создания: ' + e.message, 'err');
+  } finally {
+    btn.disabled = false;
+  }
+}
+
+async function openEdit(name) {
+  try {
+    const fn = await getJSON(API_BASE + '/functions/' + encodeURIComponent(name));
+    S.currentEdit = fn;
+    document.getElementById('e-title').textContent = 'Редактирование: ' + name;
+    document.getElementById('e-name').value = name;
+    document.getElementById('e-env').value = fn.environment || '';
+    document.getElementById('e-entry').value = fn.entrypoint || '';
+    document.getElementById('e-timeout').value = String(fn.timeout || 60);
+    document.getElementById('e-code').value = fn.code || '';
+    var schedule = timeTriggerByFn(name);
+    document.getElementById('e-schedule-enabled').checked = !!schedule;
+    document.getElementById('e-cron').value = (schedule && schedule.spec && schedule.spec.cron) || '';
+    toggleScheduleFields('e');
+    var envName = (fn.environment || '').toLowerCase();
+    var lang = 'python';
+    if (envName.includes('node')) lang = 'nodejs';
+    else if (envName.includes('go')) lang = 'go';
+    else if (envName.includes('ruby')) lang = 'ruby';
+    else if (envName.includes('php')) lang = 'php';
+    document.getElementById('e-lang-hidden').value = lang;
+    var aiRes = document.getElementById('e-ai-result');
+    if (aiRes) { aiRes.style.display = 'none'; aiRes.textContent = ''; }
+    var warnEl = document.getElementById('e-tf-warn');
+    if (warnEl) {
+      var isTf = /^tf-/.test(name) || /go[-_]env/.test(fn.environment || '');
+      warnEl.style.display = isTf ? 'block' : 'none';
+    }
+    document.getElementById('edit-modal').classList.add('open');
+  } catch (e) {
+    showStatus('Ошибка загрузки функции: ' + e.message, 'err');
+  }
+}
+
+function closeEdit() {
+  document.getElementById('edit-modal').classList.remove('open');
+  S.currentEdit = null;
+}
+
+async function submitEdit() {
+  if (!S.currentEdit) return;
+  const btn = document.getElementById('e-submit');
+  btn.disabled = true;
+  const progress = startTimedStatus('Сохраняем код...', 'Сохранение кода...', explainDelay);
+  try {
+    const name = S.currentEdit.name;
+    await requestJSON(API_BASE + '/functions/' + encodeURIComponent(name) + '/code', 'PUT', {
+      code: document.getElementById('e-code').value,
+      timeout: parseTimeout(document.getElementById('e-timeout').value)
+    });
+
+    await syncScheduleForFunction(name, 'e');
+    closeEdit();
+    progress.stop('Код обновлён: ' + name, 'ok');
+    await reloadAll();
+  } catch (e) {
+    progress.stop('Ошибка обновления: ' + e.message, 'err');
+  } finally {
+    btn.disabled = false;
+  }
+}
+
+async function removeFn(name) {
+  var tfWarn = (/^tf-/.test(name)) ? '\n\n⚠️ Эта функция управляется Terraform. Удаление приведёт к рассинхронизации state!' : '';
+  if (!confirm('Удалить функцию ' + name + '?' + tfWarn)) return;
+  var progress = startTimedStatus('Удаляем функцию...', 'Удаление функции...', explainDelay);
+  try {
+    await requestJSON(API_BASE + '/functions/' + encodeURIComponent(name), 'DELETE');
+    progress.stop('Функция удалена: ' + name, 'ok');
+    await reloadAll();
+  } catch (e) {
+    progress.stop('Ошибка удаления: ' + e.message, 'err');
+  }
+}

console/ui/js/init.js

@@ -0,0 +1,180 @@
+/* init.js — инициализация namespace, утилиты таймера и статуса */
+
+var _initPolling = false;
+var _initTickBusy = false;
+var _initStartedAt = 0;
+
+function initLog(msg) {
+  var el = document.getElementById('init-log');
+  var ts = new Date().toLocaleTimeString('ru-RU');
+  el.textContent += '[' + ts + '] ' + msg + '\n';
+  el.scrollTop = el.scrollHeight;
+}
+
+function formatSeconds(totalSeconds) {
+  totalSeconds = Math.max(0, Number(totalSeconds) || 0);
+  var minutes = Math.floor(totalSeconds / 60);
+  var seconds = totalSeconds % 60;
+  if (minutes <= 0) return seconds + 'с';
+  return minutes + 'м ' + seconds + 'с';
+}
+
+function setInitElapsed(seconds) {
+  document.getElementById('init-elapsed').textContent = formatSeconds(seconds);
+}
+
+function setInitCurrentStage(text) {
+  document.getElementById('init-current-stage').textContent = text || 'Ожидание старта';
+}
+
+function setBox(id, text) {
+  var el = document.getElementById(id);
+  if (!el) return;
+  if (!text) {
+    el.style.display = 'none';
+    el.textContent = '';
+    return;
+  }
+  el.style.display = 'block';
+  el.textContent = text;
+}
+
+function missingKeys(obj) {
+  return Object.keys(obj || {}).filter(function (key) {
+    return !obj[key];
+  });
+}
+
+function firstPendingStage(stages) {
+  var list = stages || [];
+  for (var i = 0; i < list.length; i++) {
+    if (!list[i].done) return list[i].name;
+  }
+  return list.length ? list[list.length - 1].name : 'Ожидание старта';
+}
+
+function describeInitReason(debug) {
+  if (!debug) return 'Собираем диагностические данные по namespace и control-plane...';
+  if (!debug.exists) return 'Ещё не создан Kubernetes namespace пользователя.';
+  if (!debug.active) return 'Namespace создан, но Kubernetes ещё не перевёл его в состояние Active.';
+
+  var preparation = debug.preparation || {};
+  if (!preparation.managedByConsole) return 'Namespace существует, но ещё не помечен как managed-by=fission-console.';
+  if (!preparation.watcherLabel) return 'Namespace ещё не помечен label fission.io/managed=true для NSWatcher.';
+
+  var missingSAs = missingKeys(preparation.serviceAccounts);
+  if (missingSAs.length) return 'Не готовы bootstrap service accounts: ' + missingSAs.join(', ') + '.';
+
+  var missingRBs = missingKeys(preparation.roleBindings);
+  if (missingRBs.length) return 'Не готовы bootstrap role bindings: ' + missingRBs.join(', ') + '.';
+
+  var control = debug.controlPlane || {};
+  if (!control.executor || !control.executor.ready) {
+    return 'Executor ещё не ready. Возможна задержка из-за cold start, image pull или specialization.';
+  }
+  if (!control.router || !control.router.ready) {
+    return 'Router ещё не ready. HTTP маршрутизация пока не активна.';
+  }
+
+  return 'Ожидаем финальное подтверждение готовности control-plane.';
+}
+
+function summarizeInit(status, debug) {
+  var done = status && status.stages ? status.stages.filter(function (s) { return s.done; }).length : 0;
+  var namespace = debug && debug.namespace ? debug.namespace : 'не определён';
+  return 'Namespace: ' + namespace + '. Завершено шагов: ' + done + '/3.';
+}
+
+function explainDelay(seconds) {
+  if (seconds < 5) return 'Обычная операция без заметной задержки.';
+  if (seconds < 10) return 'Вероятен cold start: прогрев пула, image pull или ожидание specialization.';
+  return 'Задержка выше нормы: возможны cold start, specialization или ожидание готовности control-plane.';
+}
+
+function startTimedStatus(startText, waitingPrefix, waitingHint) {
+  var startedAt = Date.now();
+  showStatus(startText, '');
+  var timer = setInterval(function () {
+    var elapsed = Math.max(1, Math.floor((Date.now() - startedAt) / 1000));
+    var text = waitingPrefix + ' ' + formatSeconds(elapsed);
+    if (waitingHint) text += ' · ' + waitingHint(elapsed);
+    showStatus(text, '');
+  }, 1000);
+  return {
+    stop: function (message, kind) {
+      clearInterval(timer);
+      var elapsed = Math.max(0, Math.round((Date.now() - startedAt) / 1000));
+      var text = message;
+      if (message) text += ' за ' + formatSeconds(elapsed);
+      showStatus(text, kind || '');
+    }
+  };
+}
+
+function renderInitStages(stages) {
+  var el = document.getElementById('init-stages');
+  el.innerHTML = stages.map(function (s) {
+    var icon = s.done ? '✅' : '⏳';
+    var color = s.done ? '#4caf50' : '#8bc7ff';
+    return '<div style="font-size:13px; color:' + color + ';">' + icon + '&nbsp;' + s.name + '</div>';
+  }).join('');
+}
+
+async function pollNSStatus() {
+  if (_initPolling) return;
+  _initPolling = true;
+  _initTickBusy = false;
+  _initStartedAt = Date.now();
+  var overlay = document.getElementById('init-overlay');
+  overlay.style.display = 'flex';
+  document.getElementById('init-log').textContent = '';
+  setInitElapsed(0);
+  setInitCurrentStage('Подготовка запуска');
+  setBox('init-summary', 'Проверяем состояние namespace и control-plane...');
+  setBox('init-reason', 'Если пользователь новый, возможны cold start и создание bootstrap ресурсов.');
+  setBox('init-error', '');
+  initLog('Запуск инициализации...');
+  var attempt = 0;
+  var maxAttempts = 60; // 5 минут
+  var interval = setInterval(async function () {
+    if (_initTickBusy) return;
+    _initTickBusy = true;
+    attempt++;
+    try {
+      var elapsed = Math.floor((Date.now() - _initStartedAt) / 1000);
+      setInitElapsed(elapsed);
+      var statusResp = await fetch(API_BASE + '/ns/status', { headers: authHeaders() });
+      var debugResp = await fetch(API_BASE + '/ns/debug', { headers: authHeaders() });
+      var d = await statusResp.json();
+      var dbg = await debugResp.json().catch(function () { return null; });
+      if (d.stages) renderInitStages(d.stages);
+      setInitCurrentStage(firstPendingStage(d.stages));
+      setBox('init-summary', summarizeInit(d, dbg));
+      setBox('init-reason', describeInitReason(dbg));
+      setBox('init-error', '');
+      var done = d.stages ? d.stages.filter(function (s) { return s.done; }).length : 0;
+      initLog('Шагов завершено: ' + done + '/3');
+      if (d.ready) {
+        initLog('✅ Готово! Загружаем консоль...');
+        clearInterval(interval);
+        _initPolling = false;
+        _initTickBusy = false;
+        overlay.style.display = 'none';
+        reloadAll();
+        return;
+      }
+    } catch (e) {
+      setBox('init-error', 'Последняя ошибка: ' + e.message);
+      initLog('Ошибка опроса: ' + e.message);
+    } finally {
+      _initTickBusy = false;
+    }
+    if (attempt >= maxAttempts) {
+      clearInterval(interval);
+      _initPolling = false;
+      _initTickBusy = false;
+      setBox('init-error', 'Превышено время ожидания. Чаще всего это bootstrap RBAC, control-plane readiness или холодный старт.');
+      initLog('⚠️ Превышено время ожидания. Попробуйте обновить страницу.');
+    }
+  }, 5000);
+}

console/ui/js/modals.js

@@ -0,0 +1,76 @@
+/* modals.js — управление модальными окнами Help и Invoke */
+
+function openHelp() {
+  document.getElementById('help-modal').classList.add('open');
+}
+
+function closeHelp() {
+  document.getElementById('help-modal').classList.remove('open');
+}
+
+function openInvoke(name) {
+  S.currentInvoke = name;
+  document.getElementById('i-title').textContent = 'Вызов: ' + name;
+  document.getElementById('i-resp').value = '';
+  document.getElementById('i-status').textContent = '';
+  document.getElementById('i-meta').style.display = 'none';
+  document.getElementById('i-meta').textContent = '';
+  document.getElementById('invoke-modal').classList.add('open');
+}
+
+function closeInvoke() {
+  document.getElementById('invoke-modal').classList.remove('open');
+  S.currentInvoke = null;
+}
+
+async function submitInvoke() {
+  if (!S.currentInvoke) return;
+  const btn = document.getElementById('i-submit');
+  const statusEl = document.getElementById('i-status');
+  const metaEl = document.getElementById('i-meta');
+  const respEl = document.getElementById('i-resp');
+  btn.disabled = true;
+  respEl.value = '';
+  metaEl.style.display = 'none';
+  metaEl.textContent = '';
+  let elapsed = 0;
+  statusEl.textContent = 'Вызов...';
+  const timer = setInterval(() => {
+    elapsed++;
+    if (elapsed < 5) {
+      statusEl.textContent = 'Вызов... ' + elapsed + 'с';
+    } else if (elapsed < 10) {
+      statusEl.textContent = '⏳ Возможен cold start — прогрев пула... ' + elapsed + 'с';
+    } else {
+      statusEl.textContent = '⏳ Возможны cold start или specialization... ' + elapsed + 'с';
+    }
+  }, 1000);
+  try {
+    const raw = document.getElementById('i-body').value.trim();
+    let parsed = {};
+    if (raw) parsed = JSON.parse(raw);
+    const result = await requestJSON(API_BASE + '/functions/' + encodeURIComponent(S.currentInvoke) + '/invoke', 'POST', parsed);
+    var latencyMs = Number(result.latency_ms || 0);
+    var measuredSeconds = latencyMs > 0 ? Math.max(1, Math.round(latencyMs / 1000)) : elapsed;
+    statusEl.textContent = '✓ Выполнено за ' + formatSeconds(measuredSeconds);
+    metaEl.style.display = 'block';
+    metaEl.textContent = [
+      'HTTP status: ' + (result.status || 'n/a'),
+      'Latency: ' + (latencyMs || 'n/a') + ' ms',
+      'Причина задержки: ' + explainDelay(measuredSeconds),
+      'Invoke URL: ' + (result.invoke_url || 'n/a')
+    ].join('\n');
+    respEl.value = JSON.stringify(result, null, 2);
+  } catch (e) {
+    statusEl.textContent = '✗ Ошибка после ' + formatSeconds(elapsed);
+    metaEl.style.display = 'block';
+    metaEl.textContent = [
+      'Последняя ошибка: ' + e.message,
+      'Вероятная причина задержки: ' + explainDelay(elapsed)
+    ].join('\n');
+    respEl.value = 'Ошибка вызова: ' + e.message;
+  } finally {
+    clearInterval(timer);
+    btn.disabled = false;
+  }
+}

console/ui/js/triggers.js

@@ -0,0 +1,60 @@
+/* triggers.js — HTTP и Cron триггеры */
+
+function httpTriggerByFn(fnName) {
+  return (S.httpTriggers || []).find(function (t) {
+    return t.spec && t.spec.functionref && t.spec.functionref.name === fnName;
+  });
+}
+
+function timeTriggerByFn(fnName) {
+  return (S.timeTriggers || []).find(function (t) {
+    return t.spec && t.spec.functionref && t.spec.functionref.name === fnName;
+  });
+}
+
+function toggleScheduleFields(prefix) {
+  var enabled = !!document.getElementById(prefix + '-schedule-enabled').checked;
+  var cronEl = document.getElementById(prefix + '-cron');
+  cronEl.disabled = !enabled;
+  if (enabled && !cronEl.value.trim()) {
+    cronEl.value = '*/5 * * * *';
+  }
+}
+
+function schedulePayload(prefix) {
+  return {
+    enabled: !!document.getElementById(prefix + '-schedule-enabled').checked,
+    cron: (document.getElementById(prefix + '-cron').value || '').trim()
+  };
+}
+
+async function syncScheduleForFunction(name, prefix) {
+  var schedule = schedulePayload(prefix);
+  var existing = timeTriggerByFn(name);
+  var existingName = (existing && existing.metadata && existing.metadata.name) || name;
+
+  if (!schedule.enabled) {
+    if (existing) {
+      await requestJSON(API_BASE + '/timetriggers/' + encodeURIComponent(existingName), 'DELETE');
+    }
+    return;
+  }
+
+  if (!schedule.cron) {
+    throw new Error('cron is required');
+  }
+
+  var payload = {
+    name: existingName,
+    functionName: name,
+    cron: schedule.cron,
+    method: 'POST',
+    subpath: '/'
+  };
+
+  if (existing) {
+    await requestJSON(API_BASE + '/timetriggers/' + encodeURIComponent(existingName), 'PUT', payload);
+  } else {
+    await requestJSON(API_BASE + '/timetriggers', 'POST', payload);
+  }
+}

console/ui/js/ui.js

@@ -0,0 +1,47 @@
+/* ui.js — UI-вспомогательные функции */
+
+function setText(id, value) {
+  document.getElementById(id).textContent = String(value);
+}
+
+function showStatus(message, kind) {
+  const el = document.getElementById('status');
+  el.style.display = 'block';
+  el.className = 'status ' + (kind || '');
+  el.textContent = message;
+}
+
+function clearStatus() {
+  const el = document.getElementById('status');
+  el.style.display = 'none';
+  el.className = 'status';
+  el.textContent = '';
+}
+
+function h(v) {
+  return String(v == null ? '' : v)
+    .replaceAll('&', '&')
+    .replaceAll('<', '&lt;')
+    .replaceAll('>', '&gt;')
+    .replaceAll('"', '&quot;')
+    .replaceAll("'", '&#39;');
+}
+
+function formatTimestamp(ts) {
+  if (!ts) return '—';
+  var d = new Date(ts);
+  if (isNaN(d.getTime())) return String(ts);
+  return d.toLocaleString('ru-RU', {
+    year: 'numeric',
+    month: '2-digit',
+    day: '2-digit',
+    hour: '2-digit',
+    minute: '2-digit',
+    second: '2-digit'
+  });
+}
+
+function timestampCell(ts) {
+  var text = formatTimestamp(ts);
+  return '<span class="mono" title="' + h(ts || '') + '">' + h(text) + '</span>';
+}

doc/descriptions/auth-flow.md

@@ -0,0 +1,271 @@
+# Логика авторизации — Fission Console
+
+> ⚠️ ЛЕГАСИ (актуально до ~апреля 2026): описание ниже относится к старой схеме с Deck API + JWT.
+> Актуальное описание — **выше этого блока**, в разделе "АКТУАЛЬНО (май 2026+)".
+
+---
+
+# АКТУАЛЬНО (май 2026+)
+
+## Что принимает сервер
+
+Токен передаётся одним из двух способов:
+- Заголовок `X-Auth-Token: <токен>`
+- Заголовок `Authorization: Bearer <токен>`
+
+`X-Auth-Env` — необязателен, по умолчанию `test`.
+
+---
+
+## Типы токенов и маршрутизация (MultiAuthenticator)
+
+Сервер использует `MultiAuthenticator`, который определяет тип по форме токена:
+
+| Форма токена | Authenticator | Описание |
+|---|---|---|
+| JWT (три части через `.`) | `DeckAuthenticator` или `TestAuthenticator` | Реальный облачный токен или тест-JWT |
+| Любая строка ≥6 символов | `DemoAuthenticator` | Demo-логин без внешних запросов |
+| Строка <6 символов | — | Ошибка 401 |
+
+---
+
+## DemoAuthenticator (текущий основной режим)
+
+Принимает **любую строку ≥6 символов** как логин. Не ходит во внешние сервисы.
+
+```
+login (≥6 символов)
+    │
+    ▼
+Sub = UUID v5(login)       ← детерминированный, фиксированный UUID namespace
+Email = "demo-lo***in"     ← маскированный для отображения в UI
+    │
+    ▼
+Namespace = "fission-" + hex(SHA256(Sub)[:8])
+```
+
+Пример:
+- login = `livetest@test.local`
+- Sub = `uuidV5("livetest@test.local")` = фиксированный UUID
+- Namespace = `fission-c3fce59430e41b0f`
+
+Каждый логин → один и тот же namespace (детерминированно).
+
+---
+
+## DeckAuthenticator (production JWT)
+
+Для JWT-токенов из облака NUBES:
+
+```
+JWT токен
+    │
+    ├─► validateToken → GET {deckAPI}/index.cfm/instances
+    │   Authorization: Bearer <token>
+    │   401 → ошибка | другой → ОК
+    │   Кэш на 5 минут (sync.Map, ключ "env:token")
+    │
+    └─► identityFromJWT → decode payload (base64url, без верификации подписи)
+        → claim "sub" → Sub
+        → claim "email" → Email (опционально)
+```
+
+Deck API URL по стендам:
+- `prod` → `https://deck-api.ngcloud.ru/api/v1`
+- `dev`  → `https://deck-api-dev.ngcloud.ru/api/v1`
+- `test` → `https://deck-api-test.ngcloud.ru/api/v1`
+
+---
+
+## TestAuthenticator (тест-режим, устаревший)
+
+Принимает JWT — декодирует sub из payload. Или строку с `@` — использует как sub напрямую.
+Не ходит в Deck API. Включался через `FISSION_TEST_MODE=true`.
+
+> ⚠️ Сейчас не используется — заменён на DemoAuthenticator.
+
+---
+
+## Вычисление namespace: `NamespaceForSub`
+
+```go
+func NamespaceForSub(sub string) string {
+    h := sha256.Sum256([]byte(sub))
+    return "fission-" + hex.EncodeToString(h[:8])  // 16 hex символов
+}
+```
+
+Namespace **детерминирован**: одинаковый логин → всегда один namespace.
+
+---
+
+## authMiddleware — что происходит на каждый запрос
+
+```
+Входящий HTTP запрос
+    │
+    ├─► authTokenFromRequest → X-Auth-Token || Authorization: Bearer
+    │
+    ├─► authenticator.Authenticate(token, env) → UserIdentity{Sub, Email}
+    │   ошибка → 401
+    │
+    ├─► NamespaceForSub(Sub) → "fission-XXXXXXXXXXXXXXXX"
+    │
+    ├─► nsManager.EnsureUserNS(namespace)
+    │   → создаёт K8s namespace + RBAC если нет
+    │   ошибка → 502
+    │
+    └─► контекст запроса: ctxKeyNS=namespace, ctxKeyIdentity=identity
+        → handler работает в namespace пользователя
+```
+
+---
+
+## POST /auth — явный вход
+
+```
+POST /console/api/auth
+Body: { "token": "...", "env": "test" }
+    │
+    └─► то же что authMiddleware, возвращает:
+        { ok: true, namespace: "fission-...", email: "demo-lo***in" }
+```
+
+---
+
+## Итого — полная схема (актуальная)
+
+```
+Пользователь передаёт токен/логин
+    │
+    ▼
+MultiAuthenticator
+    ├── JWT?  → DeckAuthenticator (Deck API + JWT decode)
+    └── нет   → DemoAuthenticator (≥6 символов → UUID v5)
+    │
+    ▼
+UserIdentity { Sub, Email }
+    │
+    ▼
+NamespaceForSub(Sub) = "fission-" + hex(SHA256(Sub)[:8])
+    │
+    ▼
+EnsureUserNS → K8s namespace существует
+    │
+    ▼
+Все хендлеры работают с namespace из context
+```
+
+---
+
+# ЛЕГАСИ (до апреля 2026) — не удалять, для анализа
+
+
+
+## Что вводит пользователь
+
+В форме логина (`index.html`, overlay `#login-overlay`):
+- **Стенд** (`#l-env`): `dev` / `test` / `prod`
+- **Токен** (`#l-token`): JWT-токен из личного кабинета NUBES (Профиль → Токены)
+
+---
+
+## Фронтенд: `doLogin()` → `js/auth.js`
+
+1. Берёт токен и стенд из формы
+2. Делает `POST /console/api/auth` с `{ token, env }` в теле
+3. Если ответ OK:
+   - Сохраняет `auth_token` и `auth_env` в **localStorage** браузера
+   - Вызывает `setUserAvatar(token)` — декодирует email из JWT payload и показывает в navbar
+   - Скрывает overlay логина
+4. Проверяет `GET /console/api/ns/status` — если namespace не готов, показывает overlay инициализации
+
+---
+
+## Бэкенд: `handleAuth` → `handlers.go:1022`
+
+1. Принимает `POST /console/api/auth`
+2. Валидирует токен через `resolveNamespaceForToken(token, env, testMode)`
+3. Вызывает `EnsureUserNS` — гарантирует что K8s namespace + RBAC + quota существуют
+4. Возвращает JSON: `{ ok: true, env: "test", namespace: "fission-..." }`
+
+---
+
+## Валидация токена: `validateDeckToken` → `server.go:279`
+
+**Deck API** — внешний сервис облачной платформы NUBES:
+```
+dev  → https://deck-api-dev.ngcloud.ru/api/v1
+test → https://deck-api-test.ngcloud.ru/api/v1
+prod → https://deck-api.ngcloud.ru/api/v1
+```
+
+Проверка: `GET {deckAPI}/index.cfm/instances` с заголовком `Authorization: Bearer {token}`
+- `401` → токен невалиден
+- Любой другой ответ → токен принят
+- Результат кэшируется на **5 минут** (`sync.Map`)
+
+---
+
+## Вычисление namespace: `namespaceFromJWT` → `auth.go:131`
+
+1. JWT токен **не верифицируется по подписи** — Deck API уже это сделал
+2. Декодируется payload (base64url)
+3. Извлекается claim `"sub"` (идентификатор пользователя в облаке)
+4. Namespace = `"fission-" + hex(SHA256(sub)[:8])`
+
+Пример: sub = `c3fce59430e41b0f...` → namespace `fission-c3fce59430e41b0f`
+
+---
+
+## Email в navbar: `setUserAvatar` / `jwtEmail` → `auth.js`
+
+- `jwtEmail(token)` — декодирует JWT payload на **фронтенде** (без обращения к серверу)
+- Берёт `payload.email` или `payload.sub`
+- Отображает в `#user-avatar` в левом верхнем углу (вместо синего кружка)
+
+---
+
+## Последующие запросы
+
+Каждый API-запрос от фронтенда включает заголовки:
+```
+X-Auth-Token: <токен из localStorage>
+X-Auth-Env: <стенд из localStorage>
+```
+
+`authMiddleware` (`auth.go`) снова валидирует токен (но из кэша — без нового HTTP-запроса к Deck API),
+вычисляет namespace и кладёт его в `context.Context` → все хендлеры работают в нужном namespace.
+
+---
+
+## Test-режим (FISSION_TEST_MODE=true)
+
+Вместо реального Deck API — проверяет заголовок `X-Test-Sub`.
+Если токен содержит `@` — трактуется как email и используется как sub для вычисления namespace.
+Используется в тестах и для live-тестирования без реальных токенов.
+
+---
+
+## Итого — схема
+
+```
+Пользователь вводит токен + стенд
+    │
+    ▼
+POST /console/api/auth
+    │
+    ├─► validateDeckToken → Deck API ({env}.ngcloud.ru) → 200 = ОК
+    │
+    ├─► namespaceFromJWT → decode JWT payload → claim "sub" → SHA256[:8] → "fission-XXXXXXXX"
+    │
+    ├─► EnsureUserNS → K8s namespace + RBAC создаются если нет
+    │
+    └─► { ok: true, namespace: "fission-..." }
+
+Фронтенд:
+    ├─► localStorage.setItem('auth_token', token)
+    ├─► localStorage.setItem('auth_env', env)
+    ├─► jwtEmail(token) → email из JWT payload → показать в navbar
+    └─► reloadAll() — загрузить функции
+```

doc/descriptions/function-create-flow.md

@@ -0,0 +1,180 @@
+# Создание функции — текущий flow (май 2026)
+
+## UI (браузер)
+
+### Форма создания (`create-modal`)
+
+Поля в `index.html`:
+- `c-lang` — select (python / nodejs / go / ruby / php)
+- `c-name` — имя функции
+- `c-entry` — entrypoint (заполняется автоматически по языку из `LANG_TEMPLATES`)
+- `c-route` — HTTP-путь
+- `c-methods` — методы, через запятую
+- `c-timeout` — таймаут в секундах
+- `c-schedule-enabled` + `c-cron` — cron-расписание (опционально)
+- `c-code` — **textarea** с исходным кодом функции (единственный способ передать код)
+
+Кнопки рядом с `c-code`:
+- `aiCheck(...)` — линтер (POST `/console/api/ai/check`)
+- `aiExplain(...)` — объяснение через LLM (POST `/console/api/ai/ask`)
+
+При нажатии «Создать» вызывается `submitCreate()` (`js/functions.js`):
+
+```js
+await requestJSON(API_BASE + '/functions', 'POST', {
+  name, language, entrypoint, route, methods, timeout,
+  code: document.getElementById('c-code').value   // <-- всегда текст
+});
+```
+
+### Форма редактирования (`edit-modal`)
+
+Аналогична. `submitEdit()` шлёт:
+
+```js
+await requestJSON(API_BASE + '/functions/' + name + '/code', 'PUT', {
+  code: document.getElementById('e-code').value,
+  timeout: ...
+});
+```
+
+---
+
+## Backend
+
+### POST /console/api/functions → `handleCreateFunction`
+
+Структура запроса (`model.CreateFunctionRequest`):
+```json
+{ "name": "fn", "language": "python", "code": "def main(): ...",
+  "entrypoint": "main", "route": "/ns/fn", "methods": ["GET"],
+  "timeout": 60, "ttl": "" }
+```
+
+Обязательные: `name`, `language` (или `environment`), `code`.
+
+**Путь для интерпретируемых языков** (python / nodejs / ruby / php):
+```
+code (строка)
+  → buildDeployArchive(lang, code)
+      python/ruby/php: []byte(code) (raw, не zip)
+      nodejs: BuildJSDeployZip(code) → zip с package.json + main.js
+  → buildDeploySpec(ctx, bytes)
+      → uploadToStoragesvc() → multipart POST → storagesvc → archiveURL
+      → fallback: base64 literal (если storagesvc недоступен)
+  → Package.spec.deployment = { type: "url", url: "..." }
+               или           = { type: "literal", literal: "base64..." }
+```
+
+**Путь для Go**:
+```
+code
+  → BuildGoSourceZip(code) → zip с исходником
+  → uploadToStoragesvc → archiveURL
+  → Package.spec.source = { ... }   (source package, компилируется builder job)
+  Package.spec.buildcommand = "build"
+```
+
+После создания Package → создаётся Function → HTTPTrigger.
+При ошибке на любом шаге — откат (best-effort DELETE предыдущих объектов).
+
+### PUT /console/api/functions/{name}/code → `handleUpdateFunctionCode`
+
+```json
+{ "code": "...", "timeout": 60 }
+```
+
+Обязателен: `code`.
+
+Алгоритм:
+1. Читает текущую Function → берёт `fission-console/language` из аннотации
+2. `buildDeployArchive(lang, code)` → байты
+3. Создаёт **новый Package** с именем `{name}-pkg-{timestamp_base36}`
+4. Обновляет Function.spec.package.packageref на новый пакет
+5. Удаляет старый Package (best-effort)
+
+> Почему новый Package, а не обновление старого:
+> executor кэширует function-service по `functionUid` — не видит изменений в том же Package.
+> Новое имя гарантирует cache miss.
+
+---
+
+## Линтер (ai/check) и LLM (ai/ask)
+
+### POST /console/api/ai/check
+
+```json
+{ "language": "python", "code": "def main(): ..." }
+```
+
+Работает **только со строкой кода**. Запускает:
+- python: `python3 -m py_compile <tmpfile.py>`
+- nodejs: `node --check <tmpfile.js>`
+- ruby: `ruby -c <tmpfile.rb>`
+- php: `php -l <tmpfile.php>`
+- go: `go/parser.ParseFile(...)` прямо в процессе (без tmpfile)
+
+Временный файл создаётся в `os.TempDir()`, удаляется через `defer`.
+
+### POST /console/api/ai/ask
+
+Отправляет код в LLM (объяснение, анализ). Детали в `ai_prompts.go`.
+
+---
+
+## Что сейчас НЕ поддерживается
+
+- **Загрузка архива (.zip) из файла** — ни в UI, ни в API
+- Архив можно только скачать (через `extractPackageSourceCode` → `fetchPackageArchive`)
+
+---
+
+## Planned: загрузка архива
+
+### API
+
+Добавить в `CreateFunctionRequest` и `UpdateCodeRequest` поле `archive_b64 string`.
+Логика в handler: если `archive_b64 != ""` — пропустить `buildDeployArchive`,
+сразу `uploadToStoragesvc(base64.Decode(archive_b64))`.
+
+Валидация:
+- magic bytes `PK\x03\x04` (zip)
+- максимум 10MB (против 1MB для кода)
+
+### UI
+
+Раздельные режимы в форме — кнопки-переключатели «✏️ Код» / «📦 Архив»:
+- режим «Код» — textarea (как сейчас)
+- режим «Архив» — `<input type="file" accept=".zip">`, textarea скрыта
+
+В `submitCreate` / `submitEdit` — `FileReader.readAsDataURL(file)` → base64 → поле `archive_b64`.
+
+### Линтер и LLM для архива
+
+Проблема: линтер (`ai/check`) и LLM (`ai/ask`) принимают `code` — строку.
+Архив — zip из нескольких файлов. Варианты:
+
+**Вариант A — на бэке, при загрузке**
+После распаковки архива (уже есть `decodeArchiveBytesToSource` в `package.go`):
+- Извлечь главный файл (entrypoint)
+- Прогнать через линтер
+- Результат вернуть в том же ответе на create/update (поле `lint_result`)
+
+Плюсы: не меняет контракт линтера, нет доп. round-trip.
+Минусы: линтится только один файл из архива.
+
+**Вариант B — на фронте, до отправки**
+`FileReader.readAsText(file)` — не работает для zip напрямую.
+Можно использовать `JSZip` (npm/CDN) — распаковать в браузере → взять главный файл → передать в `ai/check`.
+
+Плюсы: линтинг до загрузки, быстрая обратная связь.
+Минусы: добавляется зависимость (JSZip ~100KB).
+
+**Вариант C — гибрид (рекомендован)**
+1. Фронт: при выборе архива — использовать JSZip, найти entrypoint-файл по языку,
+   показать его в readonly-textarea, кнопки линтера и LLM работают с этим текстом.
+2. Отправка: `archive_b64` (весь zip) идёт на бэк как есть.
+3. Бэк (опционально): после сохранения прогнать `decodeArchiveBytesToSource` → линтер,
+   вернуть предупреждение если нашёл ошибки.
+
+Так пользователь видит и код и результат линтера до деплоя, и полный архив уходит без изменений.

doc/descriptions/page-load-flow.md

@@ -0,0 +1,66 @@
+# Загрузка страницы — flow (май 2026)
+
+## Последовательность при открытии/перезагрузке
+
+```
+1. HTML загружен, JS инициализирован
+        │
+        ▼
+2. checkAuth()  (auth.js)
+   ├── localStorage["auth_token"] отсутствует → showLoginOverlay() → СТОП
+   └── токен есть → setUserAvatar() → hideLoginOverlay() → reloadAll()
+        │
+        ▼
+3. reloadAll()  (app.js)
+   ├── показывает в статусе "Загрузка... Nс" (startTimedStatus, тикает каждую секунду)
+   ├── показывает в таблице "⏳ Загружаем функции..."
+   ├── запускает 5 параллельных запросов (Promise.all):
+   │     GET /console/api/environments
+   │     GET /console/api/packages
+   │     GET /console/api/functions        ← обычно самый долгий
+   │     GET /console/api/httptriggers
+   │     GET /console/api/timetriggers
+   └── (ждём ответа... может занять 3–10с при cold start)
+        │
+        ▼
+4. Данные получены
+   ├── обновляем счётчики (envs, pkgs, fns, http, cron)
+   ├── рендерим ПЕРВУЮ строку функций немедленно
+   ├── остальные строки добавляем по одной каждые 40мс (setTimeout)
+   └── по завершении статус: "Загружено N функций за Xс"
+```
+
+## Путь через doLogin() (при ручном входе)
+
+После успешного POST /console/api/auth:
+1. Сохраняем токен в localStorage
+2. Проверяем GET /console/api/ns/status
+   - `ready: false` → `pollNSStatus()` → показывается init-overlay с прогрессом по стадиям
+   - `ready: true` → сразу `reloadAll()`
+
+## Почему долго
+
+При первой загрузке после простоя:
+- Fission `poolmgr` может не иметь прогретых пулов → холодный старт на first request к каждому language env
+- Kubernetes API (~k8s list всех функций, пакетов) — несколько сотен мс при большом числе объектов
+- `Promise.all` ждёт самый долгий запрос
+
+## Что показывается пользователю (v1.3.34+)
+
+| Момент | Что видит |
+|---|---|
+| Сразу при запуске | Таблица: "⏳ Загружаем функции..." |
+| Каждую секунду | Статус: "Загрузка данных Nс" |
+| Первая функция пришла | Первая строка таблицы появляется |
+| +40мс × N | Строки добавляются одна за другой |
+| Конец | Статус: "Загружено N функций за Xс" |
+
+## Файлы
+
+| Файл | Роль |
+|---|---|
+| `ui/js/auth.js` → `checkAuth()` | Точка входа при загрузке страницы |
+| `ui/js/auth.js` → `doLogin()` | Ручной вход, проверка NS status |
+| `ui/js/app.js` → `reloadAll()` | Загрузка данных, построчный рендер |
+| `ui/js/init.js` → `pollNSStatus()` | Ожидание готовности namespace (init overlay) |
+| `ui/js/init.js` → `startTimedStatus()` | Таймер в статус-баре |

doc/progress-2026-04-30-archive-upload.md

@@ -0,0 +1,36 @@
+# План интеграции загрузки функций из архивов в UI Fission Console
+
+## Цель
+Добавить в web-интерфейс Fission Console возможность загружать функцию в виде архива (zip/tar), аналогично `fission function create --deploy ...`.
+
+## Основные шаги
+1. UI: добавить компонент для выбора и загрузки архива (drag&drop или file input).
+2. Backend: реализовать обработку архива, валидацию структуры, запуск линтеров и (опционально) AI-проверку.
+3. Интеграция с Fission API: отправка архива через REST (multipart/form-data) для создания/обновления функции.
+4. UI: отображение статуса загрузки, ошибок, логов билда.
+
+## Валидация архива
+- Проверка наличия entrypoint-файла (main.py/handler.js и т.д.)
+- Проверка структуры (отсутствие мусора, секретов)
+- Линтеры (flake8/pylint/go vet и т.д.)
+- (Опционально) AI-проверка через облачный LLM
+
+## Безопасность
+- Ограничить размер архива
+- Фильтрация запрещённых файлов
+- Логирование действий
+
+## Синхронизация с Terraform/CLI
+- Архивы, деплоенные через UI, CLI, Terraform — одинакового формата
+- UI всегда отображает актуальный список функций из Fission API
+
+## Возможные сложности
+- Ошибки структуры архива (нет entrypoint)
+- Долгая сборка/деплой больших архивов
+- Drift при одновременном управлении через Terraform и UI
+
+## Следующие шаги
+- Реализовать UI-компонент для загрузки архива
+- Прототип backend-валидации
+- Интеграция с Fission API
+- Документировать пайплайн и типовые ошибки

doc/refactor-ui-2026-05-02/plan.md

@@ -0,0 +1,133 @@
+# Рефакторинг UI: монолит → модули
+
+Дата: 2026-05-02  
+Ветка: второмая  
+Файл-источник: console/ui/index.html (1651 строк, 73 функции)
+
+---
+
+## Целевая структура
+
+```
+console/ui/
+├── index.html          # только HTML-скелет + <script src="..."> теги
+├── cron.html           # без изменений
+├── css/
+│   └── styles.css      # все стили (сейчас в <style> блоке index.html)
+└── js/
+    ├── config.js       # константы (DEFAULT_CODE, язык-шаблоны)
+    ├── api.js          # authHeaders, getJSON, requestJSON
+    ├── auth.js         # showLoginOverlay, hideLoginOverlay, doLogin, jwtEmail, setUserAvatar, doLogout, checkAuth
+    ├── ui.js           # setText, showStatus, clearStatus, h, formatTimestamp, timestampCell
+    ├── functions.js    # openCreate, closeCreate, submitCreate, openEdit, closeEdit, submitEdit, removeFn, parseMethods, parseTimeout, onLangChange
+    ├── triggers.js     # httpTriggerByFn, timeTriggerByFn, toggleScheduleFields, schedulePayload, syncScheduleForFunction
+    ├── modals.js       # openHelp, closeHelp, openInvoke, closeInvoke, submitInvoke
+    ├── ai.js           # aiCheck, aiGenerate, aiExplain, askAssistant, toggleAssistant, showGenPrompt, llmGeneratedWarning, addLLMWarning
+    ├── init.js         # initLog, pollNSStatus, formatSeconds, setInitElapsed, setInitCurrentStage, setBox, missingKeys, firstPendingStage, describeInitReason, summarizeInit, explainDelay, startTimedStatus, renderInitStages
+    └── app.js          # reloadAll, главный контроллер, window.S = {}
+```
+
+embed.go: `//go:embed index.html cron.html css js`
+
+---
+
+## Порядок загрузки в index.html (критично!)
+
+```html
+<script src="js/config.js"></script>
+<script src="js/api.js"></script>
+<script src="js/ui.js"></script>
+<script src="js/auth.js"></script>
+<script src="js/functions.js"></script>
+<script src="js/triggers.js"></script>
+<script src="js/modals.js"></script>
+<script src="js/ai.js"></script>
+<script src="js/init.js"></script>
+<script src="js/app.js"></script>
+```
+
+---
+
+## Шаги (пошагово, с билдом после каждого)
+
+### Шаг 1 — CSS
+- Вынести `<style>` блок из index.html в `css/styles.css`
+- Заменить на `<link rel="stylesheet" href="css/styles.css">`
+- Обновить embed.go
+- **BUILD + DEPLOY + ПРОВЕРКА**
+
+### Шаг 2 — config.js
+- Вынести: объект `DEFAULT_CODE` (шаблоны кода по языкам)
+- Самый изолированный, без зависимостей
+- **BUILD + DEPLOY + ПРОВЕРКА**
+
+### Шаг 3 — api.js
+- Вынести: `authHeaders`, `getJSON`, `requestJSON`
+- Зависит от: ничего (только localStorage)
+- **BUILD + DEPLOY + ПРОВЕРКА**
+
+### Шаг 4 — ui.js
+- Вынести: `setText`, `showStatus`, `clearStatus`, `h`, `formatTimestamp`, `timestampCell`
+- Зависит от: ничего
+- **BUILD + DEPLOY + ПРОВЕРКА**
+
+### Шаг 5 — auth.js
+- Вынести: `showLoginOverlay`, `hideLoginOverlay`, `doLogin`, `jwtEmail`, `setUserAvatar`, `doLogout`, `checkAuth`
+- Зависит от: api.js, ui.js
+- **BUILD + DEPLOY + ПРОВЕРКА**
+
+### Шаг 6 — triggers.js
+- Вынести: `httpTriggerByFn`, `timeTriggerByFn`, `toggleScheduleFields`, `schedulePayload`, `syncScheduleForFunction`
+- Зависит от: api.js, ui.js
+- **BUILD + DEPLOY + ПРОВЕРКА**
+
+### Шаг 7 — modals.js
+- Вынести: `openHelp`, `closeHelp`, `openInvoke`, `closeInvoke`, `submitInvoke`
+- Зависит от: api.js, ui.js
+- **BUILD + DEPLOY + ПРОВЕРКА**
+
+### Шаг 8 — functions.js
+- Вынести: `openCreate`, `closeCreate`, `submitCreate`, `openEdit`, `closeEdit`, `submitEdit`, `removeFn`, `parseMethods`, `parseTimeout`, `onLangChange`
+- Зависит от: api.js, ui.js, triggers.js, config.js
+- **BUILD + DEPLOY + ПРОВЕРКА**
+
+### Шаг 9 — ai.js
+- Вынести: `aiCheck`, `aiGenerate`, `aiExplain`, `askAssistant`, `toggleAssistant`, `showGenPrompt`, `llmGeneratedWarning`, `addLLMWarning`
+- Зависит от: api.js, ui.js
+- **BUILD + DEPLOY + ПРОВЕРКА**
+
+### Шаг 10 — init.js
+- Вынести: `initLog`, `pollNSStatus`, `formatSeconds`, `setInitElapsed`, `setInitCurrentStage`, `setBox`, `missingKeys`, `firstPendingStage`, `describeInitReason`, `summarizeInit`, `explainDelay`, `startTimedStatus`, `renderInitStages`
+- Зависит от: api.js, ui.js, auth.js
+- **BUILD + DEPLOY + ПРОВЕРКА**
+
+### Шаг 11 — app.js
+- Вынести: `reloadAll`, `window.S = {}`, DOMContentLoaded инициализация
+- Зависит от: всё выше
+- **BUILD + DEPLOY + ПРОВЕРКА**
+
+---
+
+## Правила
+
+1. После каждого шага index.html должен уменьшиться ровно на то что вынесли
+2. Никаких дублирований — функция живёт только в одном файле
+3. Глобальные переменные (window.S) остаются в app.js
+4. Порядок `<script>` тегов строго по зависимостям
+5. Старый код из index.html удалять только после проверки билда
+
+---
+
+## Статус
+
+- [ ] Шаг 1: CSS
+- [ ] Шаг 2: config.js
+- [ ] Шаг 3: api.js
+- [ ] Шаг 4: ui.js
+- [ ] Шаг 5: auth.js
+- [ ] Шаг 6: triggers.js
+- [ ] Шаг 7: modals.js
+- [ ] Шаг 8: functions.js
+- [ ] Шаг 9: ai.js
+- [ ] Шаг 10: init.js
+- [ ] Шаг 11: app.js

examples/big-suite/code/python-metrics/croned.py

@@ -0,0 +1,73 @@
+import os
+import urllib.request
+import urllib.error
+import json
+
+COLLECTOR_URL = "http://metrics-collector.fission.svc.cluster.local:8091/metrics"
+
+def main():
+    payload = {
+        "source": "fission-cron-metrics",
+        "hostname": os.uname().nodename,
+        "status": "ok",
+    }
+
+    # CPU load
+    try:
+        load = os.getloadavg()
+        payload["cpu_load_1m"] = load[0]
+        payload["cpu_load_5m"] = load[1]
+        payload["cpu_load_15m"] = load[2]
+    except Exception:
+        pass
+
+    # Memory
+    try:
+        with open("/proc/meminfo") as f:
+            meminfo = {}
+            for line in f:
+                k, v = line.split(":")
+                meminfo[k.strip()] = int(v.split()[0])
+        total = meminfo.get("MemTotal", 0) / 1024
+        free = meminfo.get("MemFree", 0) / 1024
+        avail = meminfo.get("MemAvailable", 0) / 1024
+        used = total - free
+        payload["memory_total_mb"] = round(total, 1)
+        payload["memory_free_mb"] = round(free, 1)
+        payload["memory_available_mb"] = round(avail, 1)
+        payload["memory_used_mb"] = round(used, 1)
+        payload["memory_percent"] = round(used / total * 100, 1) if total else 0
+    except Exception:
+        pass
+
+    # Disk
+    try:
+        st = os.statvfs("/")
+        total_gb = st.f_blocks * st.f_frsize / 1024**3
+        free_gb = st.f_bfree * st.f_frsize / 1024**3
+        used_gb = total_gb - free_gb
+        payload["disk_total_gb"] = round(total_gb, 1)
+        payload["disk_free_gb"] = round(free_gb, 1)
+        payload["disk_used_gb"] = round(used_gb, 1)
+    except Exception:
+        pass
+
+    # Uptime
+    try:
+        with open("/proc/uptime") as f:
+            payload["uptime_sec"] = float(f.read().split()[0])
+    except Exception:
+        pass
+
+    data = json.dumps(payload).encode()
+    req = urllib.request.Request(
+        COLLECTOR_URL,
+        data=data,
+        headers={"Content-Type": "application/json"},
+        method="POST",
+    )
+    try:
+        with urllib.request.urlopen(req, timeout=5) as resp:
+            return {"ok": True, "status": resp.status}
+    except urllib.error.URLError as e:
+        return {"ok": False, "error": str(e)}

s3cfg-ngcloud

@@ -0,0 +1,7 @@
+[default]
+access_key = 0GLQRD38H4I6RBDB0EWJ
+secret_key = eTFibiHmBd96IApj9PYsboTR6OBoD7osxoarHykw
+host_base = s3.msk-1.ngcloud.ru
+host_bucket = %(bucket)s.s3.msk-1.ngcloud.ru
+use_https = True
+signature_v2 = False

scripts/lib.sh

@@ -0,0 +1,91 @@
+#!/usr/bin/env bash
+# lib.sh — общие утилиты для тест-скриптов fission-console.
+# Подключается через: source "$(dirname "$0")/lib.sh"
+
+BASE="${BASE:-https://fission.kube5s.ru/console/api}"
+PASS=0
+FAIL=0
+
+pass() { PASS=$((PASS+1)); echo "  PASS: $1"; }
+fail() { FAIL=$((FAIL+1)); echo "  FAIL: $1"; }
+
+check_http() {
+  local got="$1" want="$2" label="$3"
+  [ "$got" = "$want" ] && pass "$label (HTTP $got)" || fail "$label — got $got, want $want"
+}
+
+# json_field PAYLOAD KEY — извлекает строковое значение ключа из JSON
+json_field() {
+  local payload="$1" key="$2"
+  printf '%s' "$payload" | python3 -c "
+import json, sys
+key = sys.argv[1]
+try:
+    d = json.load(sys.stdin)
+    v = d.get(key)
+    if v is None:
+        print('')
+    elif isinstance(v, (dict, list)):
+        print(json.dumps(v))
+    else:
+        print(v)
+except Exception:
+    print('')
+" "$key" 2>/dev/null
+}
+
+# json_escape — читает stdin, возвращает JSON-строку
+json_escape() {
+  python3 -c 'import json, sys; print(json.dumps(sys.stdin.read()))'
+}
+
+# json_len PAYLOAD — длина JSON-массива
+json_len() {
+  printf '%s' "$1" | python3 -c "import json,sys
+try:
+    print(len(json.load(sys.stdin)))
+except Exception:
+    print(0)" 2>/dev/null
+}
+
+# wait_invoke SUB FN EXPECTED [TRIES=12] [DELAY=5]
+# Ждёт пока invoke вернёт status=200 и тело содержит EXPECTED.
+# Возвращает 0 при успехе, 1 при таймауте.
+wait_invoke() {
+  local sub="$1" fn="$2" expected="$3"
+  local tries="${4:-12}" delay="${5:-5}"
+  local try resp status raw err
+  for try in $(seq 1 "$tries"); do
+    resp=$(curl -s --max-time 50 -X POST "${BASE}/functions/${fn}/invoke" \
+      -H "X-Auth-Token: ${sub}" -H "Content-Type: application/json" -d '{}')
+    status=$(json_field "$resp" status)
+    raw=$(json_field "$resp" response_raw)
+    err=$(json_field "$resp" error)
+    echo "    TRY=$try fn=$fn status=$status raw=$(printf '%s' "$raw" | head -c 80) err=$(printf '%s' "$err" | head -c 80)"
+    if [ "$status" = "200" ] && printf '%s' "$raw" | grep -qF "$expected"; then
+      return 0
+    fi
+    [ "$try" -lt "$tries" ] && sleep "$delay"
+  done
+  return 1
+}
+
+# mk_run_id — возвращает уникальный 8-символьный hex ID
+mk_run_id() {
+  (date +%s%N 2>/dev/null; od -An -N4 -tu4 /dev/urandom 2>/dev/null) \
+    | sha256sum | head -c 8
+}
+
+# setup_cleanup CLEANUP_FN — регистрирует trap EXIT
+setup_cleanup() {
+  trap "$1" EXIT
+}
+
+# print_summary — итог тестов
+print_summary() {
+  echo ""
+  echo "========================================"
+  printf "  ИТОГ: PASS=%d  FAIL=%d\n" "$PASS" "$FAIL"
+  echo "========================================"
+  [ "$FAIL" -eq 0 ]
+}

scripts/pre_cleanup.sh

@@ -0,0 +1,38 @@
+#!/usr/bin/env bash
+# pre_cleanup.sh — удаляет ВСЕ тест-namespace-ы fission от прошлых прогонов.
+# Паттерны: fission-<hex16> для namespace-ов созданных тест-субами вида
+#   crud-*/ttl-*/invoke-*/update-*/isolation-*/stress-*/alice-*/bob-*/
+#   linter-*@test.local
+# Вызывается из run_all.sh с KUBECTL_DIRECT=1.
+set -uo pipefail
+
+if [ "${KUBECTL_DIRECT:-0}" != "1" ]; then
+  echo "pre_cleanup.sh: нужен KUBECTL_DIRECT=1 (должен запускаться на VM)" >&2
+  exit 1
+fi
+
+CLEANUP="${BASH_SOURCE%/*}/cleanup_test_namespaces.sh"
+if [ ! -x "$CLEANUP" ]; then
+  echo "pre_cleanup.sh: cleanup_test_namespaces.sh не найден" >&2
+  exit 1
+fi
+
+# Список тест-субов создаёт namespace с именем fission-<hex16>.
+# Получить все fission-namespace-ы кроме системного fission:
+NS_LIST=$(kubectl get ns -o jsonpath='{range .items[*]}{.metadata.name}{"\n"}{end}' 2>/dev/null | \
+  grep -E '^fission-[0-9a-f]{16}$' || true)
+
+if [ -z "$NS_LIST" ]; then
+  echo "pre_cleanup.sh: тест-namespace-ы не найдены, пропускаем."
+  exit 0
+fi
+
+COUNT=$(echo "$NS_LIST" | wc -l)
+echo "pre_cleanup.sh: найдено $COUNT тест-namespace-ов, удаляем..."
+
+# cleanup_test_namespaces.sh принимает email-субы, а не namespace-ы.
+# Но мы можем вызвать kubectl delete напрямую для namespace-ов.
+echo "$NS_LIST" | xargs -r kubectl delete namespace --ignore-not-found 2>&1 | \
+  grep -v "^$" || true
+
+echo "pre_cleanup.sh: очистка завершена."

scripts/run_all.sh

@@ -0,0 +1,113 @@
+#!/usr/bin/env bash
+# run_all.sh — запускает все тест-скрипты по очереди, выводит итог.
+# Каждый скрипт независим и имеет собственный cleanup.
+# При падении одного скрипта остальные продолжают выполняться.
+#
+# Запуск: bash run_all.sh
+# Запуск одного: bash run_all.sh test_auth.sh
+set -uo pipefail
+
+ROOT_DIR=$(cd "$(dirname "$0")" && pwd)
+
+# Авто-логирование: если stdout — терминал, пишем одновременно в файл
+LOG_DIR="${ROOT_DIR}/../test-results"
+mkdir -p "$LOG_DIR"
+LOG_FILE="${LOG_DIR}/$(date +%Y-%m-%d_%H-%M-%S).log"
+# Перезапуск с tee только если ещё не логируем (нет переменной _LOGGING)
+if [ -z "${_LOGGING:-}" ]; then
+  export _LOGGING=1
+  exec bash "$0" "$@" 2>&1 | tee "$LOG_FILE"
+  exit $?
+fi
+echo "LOG: $LOG_FILE"
+
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+NC='\033[0m'
+
+TOTAL_PASS=0
+TOTAL_FAIL=0
+FAILED_SCRIPTS=()
+
+run_script() {
+  local script="$1"
+  local name
+  name=$(basename "$script")
+  echo ""
+  echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+  echo "  ЗАПУСК: $name"
+  echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+
+  local exit_code=0
+  bash "$script" || exit_code=$?
+
+  if [ "$exit_code" -eq 0 ]; then
+    echo -e "${GREEN}  ✓ $name — PASSED${NC}"
+    TOTAL_PASS=$((TOTAL_PASS+1))
+  else
+    echo -e "${RED}  ✗ $name — FAILED (exit $exit_code)${NC}"
+    TOTAL_FAIL=$((TOTAL_FAIL+1))
+    FAILED_SCRIPTS+=("$name")
+  fi
+}
+
+# Список скриптов в порядке выполнения
+# (быстрые сначала, invoke/stress — последними)
+SCRIPTS=(
+  "${ROOT_DIR}/test_auth.sh"
+  "${ROOT_DIR}/test_functions_crud.sh"
+  "${ROOT_DIR}/test_ttl.sh"
+  "${ROOT_DIR}/test_isolation.sh"
+  "${ROOT_DIR}/test_update.sh"
+  "${ROOT_DIR}/test_invoke.sh"
+  "${ROOT_DIR}/test_linters.sh"
+  "${ROOT_DIR}/test_stress.sh"
+)
+
+# Если передан аргумент — запускаем только его
+if [ "$#" -ge 1 ]; then
+  SCRIPTS=("${ROOT_DIR}/$1")
+fi
+
+# Предварительная очистка тест-namespace-ов от прошлых прогонов.
+# Запускается только если cleanup_test_namespaces.sh умеет wildcard.
+PRE_CLEANUP="${ROOT_DIR}/pre_cleanup.sh"
+if [ -x "$PRE_CLEANUP" ]; then
+  echo ""
+  echo ">>> Предварительная очистка тест-namespace-ов..."
+  KUBECTL_DIRECT=1 bash "$PRE_CLEANUP" 2>/dev/null || true
+fi
+
+echo ""
+echo "╔══════════════════════════════════════╗"
+echo "║  fission-console — полный тест-сьют  ║"
+echo "╚══════════════════════════════════════╝"
+
+START_TIME=$(date +%s)
+
+for script in "${SCRIPTS[@]}"; do
+  if [ ! -f "$script" ]; then
+    echo -e "${YELLOW}  SKIP: $script не найден${NC}"
+    continue
+  fi
+  run_script "$script"
+done
+
+END_TIME=$(date +%s)
+ELAPSED=$((END_TIME - START_TIME))
+
+echo ""
+echo "╔══════════════════════════════════════╗"
+printf "║  Скриптов: PASS=%-3d  FAIL=%-3d  %3ds  ║\n" "$TOTAL_PASS" "$TOTAL_FAIL" "$ELAPSED"
+echo "╚══════════════════════════════════════╝"
+
+if [ "${#FAILED_SCRIPTS[@]}" -gt 0 ]; then
+  echo ""
+  echo "Упавшие скрипты:"
+  for s in "${FAILED_SCRIPTS[@]}"; do
+    echo -e "  ${RED}✗ $s${NC}"
+  done
+fi
+
+[ "$TOTAL_FAIL" -eq 0 ]

scripts/run_remaining.sh

@@ -0,0 +1,26 @@
+#!/usr/bin/env bash
+# run_remaining.sh — ВРЕМЕННЫЙ: только test_stress.sh (после обрыва SSH)
+# Удалить после прогона.
+set -uo pipefail
+
+ROOT_DIR=$(cd "$(dirname "$0")" && pwd)
+
+LOG_DIR="${ROOT_DIR}/../test-results"
+mkdir -p "$LOG_DIR"
+LOG_FILE="${LOG_DIR}/$(date +%Y-%m-%d_%H-%M-%S)_remaining.log"
+if [ -z "${_LOGGING:-}" ]; then
+  export _LOGGING=1
+  exec bash "$0" "$@" 2>&1 | tee "$LOG_FILE"
+  exit $?
+fi
+echo "LOG: $LOG_FILE"
+
+bash "${ROOT_DIR}/test_stress.sh"
+EXIT=$?
+echo ""
+if [ $EXIT -eq 0 ]; then
+  echo "  ✓ test_stress.sh — PASSED"
+else
+  echo "  ✗ test_stress.sh — FAILED (exit $EXIT)"
+fi
+exit $EXIT

scripts/test_auth.sh

@@ -0,0 +1,107 @@
+#!/usr/bin/env bash
+# test_auth.sh — тестирует аутентификацию:
+#   - POST /console/api/auth (login endpoint)
+#   - X-Auth-Token header (authMiddleware)
+#   - Authorization: Bearer header
+#   - DemoAuth: любая строка ≥6 символов
+set -uo pipefail
+
+ROOT_DIR=$(cd "$(dirname "$0")" && pwd)
+source "${ROOT_DIR}/lib.sh"
+
+NS_CLEANUP_SCRIPT="${ROOT_DIR}/cleanup_test_namespaces.sh"
+RUN_ID=$(mk_run_id)
+SUB="auth-test-${RUN_ID}@test.local"
+
+cleanup() {
+  if [ -x "$NS_CLEANUP_SCRIPT" ]; then
+    KUBECTL_DIRECT=1 "$NS_CLEANUP_SCRIPT" "$SUB" >/dev/null 2>&1 || true
+  fi
+}
+trap cleanup EXIT
+
+echo ""
+echo "========================================"
+echo "  test_auth.sh  run=$RUN_ID"
+echo "========================================"
+
+# ── POST /auth ──────────────────────────────────────────────────────────────
+
+echo ""
+echo ">>> POST /auth: пустой токен → 400"
+R=$(curl -s -w "\n%{http_code}" -X POST "${BASE}/auth" \
+  -H "Content-Type: application/json" -d '{"token":""}')
+check_http "$(echo "$R" | tail -1)" "400" "POST /auth пустой token → 400"
+
+echo ""
+echo ">>> POST /auth: токен < 6 символов → 401"
+R=$(curl -s -w "\n%{http_code}" -X POST "${BASE}/auth" \
+  -H "Content-Type: application/json" -d '{"token":"ab"}')
+check_http "$(echo "$R" | tail -1)" "401" "POST /auth токен 2 символа → 401"
+
+R=$(curl -s -w "\n%{http_code}" -X POST "${BASE}/auth" \
+  -H "Content-Type: application/json" -d '{"token":"abcde"}')
+check_http "$(echo "$R" | tail -1)" "401" "POST /auth токен 5 символов → 401"
+
+echo ""
+echo ">>> POST /auth: токен ≥6 символов → 200"
+R=$(curl -s -w "\n%{http_code}" -X POST "${BASE}/auth" \
+  -H "Content-Type: application/json" -d "{\"token\":\"${SUB}\"}")
+CODE=$(echo "$R" | tail -1)
+BODY=$(echo "$R" | sed '$d')
+check_http "$CODE" "200" "POST /auth валидный токен → 200"
+NS=$(json_field "$BODY" namespace)
+printf '%s' "$NS" | grep -q '^fission-' && pass "POST /auth namespace=fission-..." || fail "POST /auth namespace format: $NS"
+OK=$(json_field "$BODY" ok)
+[ "$OK" = "True" ] || [ "$OK" = "true" ] && pass "POST /auth ok=true" || fail "POST /auth ok=$OK"
+
+echo ""
+echo ">>> POST /auth: невалидный JSON → 400"
+R=$(curl -s -w "\n%{http_code}" -X POST "${BASE}/auth" \
+  -H "Content-Type: application/json" -d 'not-json')
+CODE=$(echo "$R" | tail -1)
+[ "$CODE" = "400" ] && pass "POST /auth невалидный JSON → 400" || fail "POST /auth невалидный JSON → $CODE"
+
+echo ""
+echo ">>> POST /auth: GET метод → 405"
+R=$(curl -s -w "\n%{http_code}" "${BASE}/auth")
+CODE=$(echo "$R" | tail -1)
+[ "$CODE" = "405" ] && pass "GET /auth → 405" || fail "GET /auth → $CODE"
+
+# ── X-Auth-Token header ──────────────────────────────────────────────────────
+
+echo ""
+echo ">>> X-Auth-Token: отсутствует → 401"
+R=$(curl -s -w "\n%{http_code}" "${BASE}/functions")
+check_http "$(echo "$R" | tail -1)" "401" "GET /functions без токена → 401"
+
+echo ""
+echo ">>> X-Auth-Token: токен < 6 символов → 401"
+R=$(curl -s -w "\n%{http_code}" "${BASE}/functions" -H "X-Auth-Token: ab")
+check_http "$(echo "$R" | tail -1)" "401" "GET /functions токен 2 символа → 401"
+
+R=$(curl -s -w "\n%{http_code}" "${BASE}/functions" -H "X-Auth-Token: abcde")
+check_http "$(echo "$R" | tail -1)" "401" "GET /functions токен 5 символов → 401"
+
+echo ""
+echo ">>> X-Auth-Token: токен ≥6 символов → 200"
+R=$(curl -s -w "\n%{http_code}" "${BASE}/functions" -H "X-Auth-Token: ${SUB}")
+check_http "$(echo "$R" | tail -1)" "200" "GET /functions валидный X-Auth-Token → 200"
+
+echo ""
+echo ">>> Authorization: Bearer → 200"
+R=$(curl -s -w "\n%{http_code}" "${BASE}/functions" \
+  -H "Authorization: Bearer ${SUB}")
+check_http "$(echo "$R" | tail -1)" "200" "GET /functions Authorization: Bearer → 200"
+
+# ── Namespace детерминирован ─────────────────────────────────────────────────
+
+echo ""
+echo ">>> Namespace детерминирован (одинаковый токен → одинаковый NS)"
+R1=$(curl -s -X POST "${BASE}/auth" -H "Content-Type: application/json" -d "{\"token\":\"${SUB}\"}")
+R2=$(curl -s -X POST "${BASE}/auth" -H "Content-Type: application/json" -d "{\"token\":\"${SUB}\"}")
+NS1=$(json_field "$R1" namespace)
+NS2=$(json_field "$R2" namespace)
+[ "$NS1" = "$NS2" ] && [ -n "$NS1" ] && pass "Namespace детерминирован: $NS1" || fail "Namespace не детерминирован: '$NS1' vs '$NS2'"
+
+print_summary

scripts/test_functions_crud.sh

@@ -0,0 +1,207 @@
+#!/usr/bin/env bash
+# test_functions_crud.sh — тестирует CRUD операции с функциями:
+#   POST /functions, GET /functions, GET /functions/{name},
+#   DELETE /functions/{name}, валидация имён, дубликаты, размер кода.
+set -uo pipefail
+
+ROOT_DIR=$(cd "$(dirname "$0")" && pwd)
+source "${ROOT_DIR}/lib.sh"
+
+NS_CLEANUP_SCRIPT="${ROOT_DIR}/cleanup_test_namespaces.sh"
+RUN_ID=$(mk_run_id)
+SUB="crud-${RUN_ID}@test.local"
+
+cleanup() {
+  if [ -x "$NS_CLEANUP_SCRIPT" ]; then
+    KUBECTL_DIRECT=1 "$NS_CLEANUP_SCRIPT" "$SUB" >/dev/null 2>&1 || true
+  fi
+}
+trap cleanup EXIT
+
+echo ""
+echo "========================================"
+echo "  test_functions_crud.sh  run=$RUN_ID"
+echo "========================================"
+
+JS_CODE='module.exports = async function(ctx) { return { status: 200, body: "crud-ok" }; }'
+
+# ── CREATE ───────────────────────────────────────────────────────────────────
+
+echo ""
+echo ">>> CREATE: базовый nodejs → 201"
+R=$(curl -s -w "\n%{http_code}" -X POST "${BASE}/functions" \
+  -H "X-Auth-Token: ${SUB}" -H "Content-Type: application/json" \
+  -d "{\"name\":\"crud-fn-${RUN_ID}\",\"language\":\"nodejs\",\"code\":$(printf '%s' "$JS_CODE" | json_escape)}")
+CODE=$(echo "$R" | tail -1)
+BODY=$(echo "$R" | sed '$d')
+check_http "$CODE" "201" "CREATE nodejs → 201"
+FN_NAME=$(json_field "$BODY" name)
+FN_ROUTE=$(json_field "$BODY" route)
+FN_PKG=$(json_field "$BODY" package)
+[ "$FN_NAME" = "crud-fn-${RUN_ID}" ] && pass "CREATE: name в ответе" || fail "CREATE: name='$FN_NAME'"
+printf '%s' "$FN_ROUTE" | grep -q '/' && pass "CREATE: route непустой" || fail "CREATE: route='$FN_ROUTE'"
+[ -n "$FN_PKG" ] && pass "CREATE: package непустой" || fail "CREATE: package пустой"
+
+echo ""
+echo ">>> CREATE: дубликат → 409"
+R=$(curl -s -w "\n%{http_code}" -X POST "${BASE}/functions" \
+  -H "X-Auth-Token: ${SUB}" -H "Content-Type: application/json" \
+  -d "{\"name\":\"crud-fn-${RUN_ID}\",\"language\":\"nodejs\",\"code\":$(printf '%s' "$JS_CODE" | json_escape)}")
+check_http "$(echo "$R" | tail -1)" "409" "CREATE дубликат → 409"
+
+echo ""
+echo ">>> CREATE: без name → 400"
+R=$(curl -s -w "\n%{http_code}" -X POST "${BASE}/functions" \
+  -H "X-Auth-Token: ${SUB}" -H "Content-Type: application/json" \
+  -d '{"language":"nodejs","code":"x"}')
+check_http "$(echo "$R" | tail -1)" "400" "CREATE без name → 400"
+
+echo ""
+echo ">>> CREATE: без language → 400"
+R=$(curl -s -w "\n%{http_code}" -X POST "${BASE}/functions" \
+  -H "X-Auth-Token: ${SUB}" -H "Content-Type: application/json" \
+  -d '{"name":"no-lang","code":"x"}')
+check_http "$(echo "$R" | tail -1)" "400" "CREATE без language → 400"
+
+echo ""
+echo ">>> CREATE: без code → 400"
+R=$(curl -s -w "\n%{http_code}" -X POST "${BASE}/functions" \
+  -H "X-Auth-Token: ${SUB}" -H "Content-Type: application/json" \
+  -d '{"name":"no-code","language":"nodejs"}')
+check_http "$(echo "$R" | tail -1)" "400" "CREATE без code → 400"
+
+echo ""
+echo ">>> CREATE: невалидный язык → 400"
+R=$(curl -s -w "\n%{http_code}" -X POST "${BASE}/functions" \
+  -H "X-Auth-Token: ${SUB}" -H "Content-Type: application/json" \
+  -d '{"name":"bad-lang","language":"cobol","code":"x"}')
+check_http "$(echo "$R" | tail -1)" "400" "CREATE язык=cobol → 400"
+
+echo ""
+echo ">>> CREATE: валидация имени"
+
+# Заглавная буква
+R=$(curl -s -w "\n%{http_code}" -X POST "${BASE}/functions" \
+  -H "X-Auth-Token: ${SUB}" -H "Content-Type: application/json" \
+  -d '{"name":"BadName","language":"nodejs","code":"x"}')
+check_http "$(echo "$R" | tail -1)" "400" "CREATE имя с заглавной → 400"
+
+# Начинается с дефиса
+R=$(curl -s -w "\n%{http_code}" -X POST "${BASE}/functions" \
+  -H "X-Auth-Token: ${SUB}" -H "Content-Type: application/json" \
+  -d '{"name":"-bad","language":"nodejs","code":"x"}')
+check_http "$(echo "$R" | tail -1)" "400" "CREATE имя с ведущим дефисом → 400"
+
+# Заканчивается дефисом
+R=$(curl -s -w "\n%{http_code}" -X POST "${BASE}/functions" \
+  -H "X-Auth-Token: ${SUB}" -H "Content-Type: application/json" \
+  -d '{"name":"bad-","language":"nodejs","code":"x"}')
+check_http "$(echo "$R" | tail -1)" "400" "CREATE имя с завершающим дефисом → 400"
+
+# Пробел в имени
+R=$(curl -s -w "\n%{http_code}" -X POST "${BASE}/functions" \
+  -H "X-Auth-Token: ${SUB}" -H "Content-Type: application/json" \
+  -d '{"name":"bad name","language":"nodejs","code":"x"}')
+check_http "$(echo "$R" | tail -1)" "400" "CREATE имя с пробелом → 400"
+
+# 58 символов — должно быть 400 (лимит 57)
+NAME58=$(python3 -c "print('a'*58)")
+R=$(curl -s -w "\n%{http_code}" -X POST "${BASE}/functions" \
+  -H "X-Auth-Token: ${SUB}" -H "Content-Type: application/json" \
+  -d "{\"name\":\"${NAME58}\",\"language\":\"nodejs\",\"code\":\"x\"}")
+check_http "$(echo "$R" | tail -1)" "400" "CREATE имя 58 символов → 400"
+
+# 57 символов — должно быть 201
+NAME57=$(python3 -c "print('a'*57)")
+R=$(curl -s -w "\n%{http_code}" -X POST "${BASE}/functions" \
+  -H "X-Auth-Token: ${SUB}" -H "Content-Type: application/json" \
+  -d "{\"name\":\"${NAME57}\",\"language\":\"nodejs\",\"code\":$(printf '%s' "$JS_CODE" | json_escape)}")
+check_http "$(echo "$R" | tail -1)" "201" "CREATE имя 57 символов → 201"
+
+echo ""
+echo ">>> CREATE: код > 1MB → 400 или 413"
+# Используем pipe чтобы избежать Argument list too long
+R=$(python3 -c "
+import json, sys
+payload = json.dumps({'name':'big-code','language':'nodejs','code':'x'*(1024*1024+1)})
+print(payload)
+" | curl -s -w "\n%{http_code}" -X POST "${BASE}/functions" \
+  -H "X-Auth-Token: ${SUB}" -H "Content-Type: application/json" \
+  --data-binary @- --max-time 30)
+CODE=$(echo "$R" | tail -1)
+( [ "$CODE" = "400" ] || [ "$CODE" = "413" ] || [ "$CODE" = "000" ] ) \
+  && pass "CREATE код > 1MB → отклонён ($CODE)" \
+  || fail "CREATE код > 1MB → got $CODE"
+
+# ── LIST ─────────────────────────────────────────────────────────────────────
+
+echo ""
+echo ">>> LIST: GET /functions → 200, массив"
+R=$(curl -s -w "\n%{http_code}" "${BASE}/functions" -H "X-Auth-Token: ${SUB}")
+CODE=$(echo "$R" | tail -1)
+BODY=$(echo "$R" | sed '$d')
+check_http "$CODE" "200" "LIST GET /functions → 200"
+COUNT=$(json_len "$BODY")
+[ "${COUNT:-0}" -ge 1 ] && pass "LIST: содержит ≥1 функцию (создали выше)" || fail "LIST: пустой массив count=$COUNT"
+
+echo ""
+echo ">>> LIST: новый пользователь → пустой массив"
+EMPTY_USER="empty-${RUN_ID}@test.local"
+R=$(curl -s -w "\n%{http_code}" "${BASE}/functions" -H "X-Auth-Token: ${EMPTY_USER}")
+CODE=$(echo "$R" | tail -1)
+BODY=$(echo "$R" | sed '$d')
+check_http "$CODE" "200" "LIST новый пользователь → 200"
+COUNT=$(json_len "$BODY")
+[ "${COUNT:-99}" -eq 0 ] && pass "LIST новый пользователь → []" || fail "LIST новый пользователь → count=$COUNT"
+
+# ── GET ──────────────────────────────────────────────────────────────────────
+
+echo ""
+echo ">>> GET: /functions/{name} → 200"
+R=$(curl -s -w "\n%{http_code}" "${BASE}/functions/crud-fn-${RUN_ID}" \
+  -H "X-Auth-Token: ${SUB}")
+CODE=$(echo "$R" | tail -1)
+BODY=$(echo "$R" | sed '$d')
+check_http "$CODE" "200" "GET /functions/crud-fn-${RUN_ID} → 200"
+GOT_NAME=$(json_field "$BODY" name)
+[ "$GOT_NAME" = "crud-fn-${RUN_ID}" ] && pass "GET: name совпадает" || fail "GET: name='$GOT_NAME'"
+GOT_ENV=$(json_field "$BODY" environment)
+[ -n "$GOT_ENV" ] && pass "GET: environment непустой ($GOT_ENV)" || fail "GET: environment пустой"
+
+echo ""
+echo ">>> GET: несуществующая функция → 404"
+R=$(curl -s -w "\n%{http_code}" "${BASE}/functions/does-not-exist-xyz" \
+  -H "X-Auth-Token: ${SUB}")
+check_http "$(echo "$R" | tail -1)" "404" "GET несуществующая → 404"
+
+# ── DELETE ───────────────────────────────────────────────────────────────────
+
+echo ""
+echo ">>> DELETE: /functions/{name} → 200"
+R=$(curl -s -w "\n%{http_code}" -X DELETE "${BASE}/functions/crud-fn-${RUN_ID}" \
+  -H "X-Auth-Token: ${SUB}")
+CODE=$(echo "$R" | tail -1)
+BODY=$(echo "$R" | sed '$d')
+check_http "$CODE" "200" "DELETE crud-fn → 200"
+DELETED=$(json_field "$BODY" deleted)
+[ "$DELETED" = "True" ] || [ "$DELETED" = "true" ] && pass "DELETE: deleted=true" || fail "DELETE: deleted='$DELETED'"
+
+echo ""
+echo ">>> DELETE: повторное удаление → 404"
+R=$(curl -s -w "\n%{http_code}" -X DELETE "${BASE}/functions/crud-fn-${RUN_ID}" \
+  -H "X-Auth-Token: ${SUB}")
+check_http "$(echo "$R" | tail -1)" "404" "DELETE повторное → 404"
+
+echo ""
+echo ">>> GET: после DELETE → 404"
+R=$(curl -s -w "\n%{http_code}" "${BASE}/functions/crud-fn-${RUN_ID}" \
+  -H "X-Auth-Token: ${SUB}")
+check_http "$(echo "$R" | tail -1)" "404" "GET после DELETE → 404"
+
+echo ""
+echo ">>> DELETE: несуществующая функция → 404"
+R=$(curl -s -w "\n%{http_code}" -X DELETE "${BASE}/functions/does-not-exist-xyz" \
+  -H "X-Auth-Token: ${SUB}")
+check_http "$(echo "$R" | tail -1)" "404" "DELETE несуществующая → 404"
+
+print_summary

scripts/test_invoke.sh

@@ -0,0 +1,90 @@
+#!/usr/bin/env bash
+# test_invoke.sh — тестирует вызов функций:
+#   NodeJS и Python: create → wait cold start → invoke → проверка тела.
+#   Invoke несуществующей функции → 404.
+# ВАЖНО: использует livetest@test.local — прогретый namespace в kube кластере.
+#   Для новых namespace fission router требует перезапуска (watchedNamespaces).
+set -uo pipefail
+
+ROOT_DIR=$(cd "$(dirname "$0")" && pwd)
+source "${ROOT_DIR}/lib.sh"
+
+RUN_ID=$(mk_run_id)
+# Используем прогретый namespace — fission router его знает.
+SUB="livetest@test.local"
+FN_NODE="node-fn-${RUN_ID}"
+FN_PY="py-fn-${RUN_ID}"
+
+cleanup() {
+  # Удаляем только конкретные функции через API, не весь namespace.
+  for fn in "$FN_NODE" "$FN_PY"; do
+    curl -s -X DELETE "${BASE}/functions/${fn}" -H "X-Auth-Token: ${SUB}" > /dev/null 2>&1 || true
+  done
+}
+trap cleanup EXIT
+
+echo ""
+echo "========================================"
+echo "  test_invoke.sh  run=$RUN_ID"
+echo "========================================"
+
+# ── Invoke несуществующей ─────────────────────────────────────────────────
+
+echo ""
+echo ">>> INVOKE несуществующей функции → 404"
+R=$(curl -s -w "\n%{http_code}" -X POST "${BASE}/functions/no-such-fn-xyz-${RUN_ID}/invoke" \
+  -H "X-Auth-Token: ${SUB}" -H "Content-Type: application/json" -d '{}')
+check_http "$(echo "$R" | tail -1)" "404" "INVOKE несуществующей → 404"
+
+# ── NodeJS ────────────────────────────────────────────────────────────────────
+
+echo ""
+echo ">>> NodeJS: create + invoke"
+JS_CODE='module.exports = async function(ctx) { return { status: 200, body: "node-invoke-ok" }; }'
+R=$(curl -s -w "\n%{http_code}" -X POST "${BASE}/functions" \
+  -H "X-Auth-Token: ${SUB}" -H "Content-Type: application/json" \
+  -d "{\"name\":\"${FN_NODE}\",\"language\":\"nodejs\",\"code\":$(printf '%s' "$JS_CODE" | json_escape)}")
+check_http "$(echo "$R" | tail -1)" "201" "NodeJS CREATE → 201"
+
+if wait_invoke "$SUB" "$FN_NODE" "node-invoke-ok" 12 5; then
+  pass "NodeJS invoke → 200, тело содержит node-invoke-ok"
+else
+  fail "NodeJS invoke не стабилизировался за 60s"
+fi
+
+# Второй вызов — проверяем что работает warm path
+R=$(curl -s --max-time 30 -X POST "${BASE}/functions/${FN_NODE}/invoke" \
+  -H "X-Auth-Token: ${SUB}" -H "Content-Type: application/json" -d '{}')
+STATUS=$(json_field "$R" status)
+[ "$STATUS" = "200" ] && pass "NodeJS второй invoke → 200 (warm)" || fail "NodeJS второй invoke → status=$STATUS"
+
+# ── Python ───────────────────────────────────────────────────────────────────
+
+echo ""
+echo ">>> Python: create + invoke"
+PY_CODE=$(printf 'def main():\n    return "py-invoke-ok", 200' | json_escape)
+R=$(curl -s -w "\n%{http_code}" -X POST "${BASE}/functions" \
+  -H "X-Auth-Token: ${SUB}" -H "Content-Type: application/json" \
+  -d "{\"name\":\"${FN_PY}\",\"language\":\"python\",\"code\":${PY_CODE}}")
+check_http "$(echo "$R" | tail -1)" "201" "Python CREATE → 201"
+
+if wait_invoke "$SUB" "$FN_PY" "py-invoke-ok" 15 5; then
+  pass "Python invoke → 200, тело содержит py-invoke-ok"
+else
+  fail "Python invoke не стабилизировался за 75s"
+fi
+
+# ── Invoke возвращает корректные поля ─────────────────────────────────────────
+
+echo ""
+echo ">>> Invoke response fields"
+R=$(curl -s --max-time 30 -X POST "${BASE}/functions/${FN_NODE}/invoke" \
+  -H "X-Auth-Token: ${SUB}" -H "Content-Type: application/json" -d '{}')
+STATUS=$(json_field "$R" status)
+LATENCY=$(json_field "$R" latency_ms)
+RAW=$(json_field "$R" response_raw)
+[ "$STATUS" = "200" ] && pass "invoke.status = 200" || fail "invoke.status = $STATUS"
+printf '%s' "$LATENCY" | grep -qE '^[0-9]+$' && pass "invoke.latency_ms = $LATENCY ms" || fail "invoke.latency_ms не число: $LATENCY"
+[ -n "$RAW" ] && pass "invoke.response_raw непустой" || fail "invoke.response_raw пустой"
+
+print_summary

scripts/test_isolation.sh

@@ -0,0 +1,162 @@
+#!/usr/bin/env bash
+# test_isolation.sh — тестирует namespace изоляцию:
+#   Пользователь A не видит и не может изменить функции пользователя B.
+#   LIST каждого пользователя возвращает только его функции.
+set -uo pipefail
+
+ROOT_DIR=$(cd "$(dirname "$0")" && pwd)
+source "${ROOT_DIR}/lib.sh"
+
+NS_CLEANUP_SCRIPT="${ROOT_DIR}/cleanup_test_namespaces.sh"
+RUN_ID=$(mk_run_id)
+ALICE="alice-${RUN_ID}@test.local"
+BOB="bob-${RUN_ID}@test.local"
+
+cleanup() {
+  if [ -x "$NS_CLEANUP_SCRIPT" ]; then
+    KUBECTL_DIRECT=1 "$NS_CLEANUP_SCRIPT" "$ALICE" "$BOB" >/dev/null 2>&1 || true
+  fi
+}
+trap cleanup EXIT
+
+echo ""
+echo "========================================"
+echo "  test_isolation.sh  run=$RUN_ID"
+echo "========================================"
+
+JS_CODE='module.exports = async function() { return { status: 200, body: "ok" }; }'
+
+# ── Alice создаёт функцию ─────────────────────────────────────────────────────
+
+echo ""
+echo ">>> Alice создаёт функцию"
+R=$(curl -s -w "\n%{http_code}" -X POST "${BASE}/functions" \
+  -H "X-Auth-Token: ${ALICE}" -H "Content-Type: application/json" \
+  -d "{\"name\":\"alice-fn\",\"language\":\"nodejs\",\"code\":$(printf '%s' "$JS_CODE" | json_escape)}")
+check_http "$(echo "$R" | tail -1)" "201" "Alice CREATE alice-fn → 201"
+
+# ── Bob не может получить функцию Alice ──────────────────────────────────────
+
+echo ""
+echo ">>> Bob GET alice-fn → 404"
+R=$(curl -s -w "\n%{http_code}" "${BASE}/functions/alice-fn" \
+  -H "X-Auth-Token: ${BOB}")
+check_http "$(echo "$R" | tail -1)" "404" "Bob GET alice-fn → 404"
+
+echo ""
+echo ">>> Bob DELETE alice-fn → 404"
+R=$(curl -s -w "\n%{http_code}" -X DELETE "${BASE}/functions/alice-fn" \
+  -H "X-Auth-Token: ${BOB}")
+check_http "$(echo "$R" | tail -1)" "404" "Bob DELETE alice-fn → 404"
+
+echo ""
+echo ">>> Bob PUT alice-fn/code → 404"
+R=$(curl -s -w "\n%{http_code}" -X PUT "${BASE}/functions/alice-fn/code" \
+  -H "X-Auth-Token: ${BOB}" -H "Content-Type: application/json" \
+  -d '{"code":"module.exports = async () => ({ body: \"hacked\" });"}')
+check_http "$(echo "$R" | tail -1)" "404" "Bob PUT alice-fn/code → 404"
+
+echo ""
+echo ">>> Bob INVOKE alice-fn → 404"
+R=$(curl -s -w "\n%{http_code}" -X POST "${BASE}/functions/alice-fn/invoke" \
+  -H "X-Auth-Token: ${BOB}" -H "Content-Type: application/json" -d '{}')
+check_http "$(echo "$R" | tail -1)" "404" "Bob INVOKE alice-fn → 404"
+
+# ── Alice убеждается что её функция цела ────────────────────────────────────
+
+echo ""
+echo ">>> Alice GET alice-fn → 200 (не повреждена)"
+R=$(curl -s -w "\n%{http_code}" "${BASE}/functions/alice-fn" \
+  -H "X-Auth-Token: ${ALICE}")
+check_http "$(echo "$R" | tail -1)" "200" "Alice GET alice-fn → 200"
+
+# ── LIST изоляция ────────────────────────────────────────────────────────────
+
+echo ""
+echo ">>> LIST изоляция: Alice и Bob видят только свои функции"
+
+# Bob создаёт свою функцию
+curl -s -X POST "${BASE}/functions" \
+  -H "X-Auth-Token: ${BOB}" -H "Content-Type: application/json" \
+  -d "{\"name\":\"bob-fn\",\"language\":\"nodejs\",\"code\":$(printf '%s' "$JS_CODE" | json_escape)}" > /dev/null
+
+sleep 1
+
+ALICE_LIST=$(curl -s "${BASE}/functions" -H "X-Auth-Token: ${ALICE}")
+BOB_LIST=$(curl -s "${BASE}/functions" -H "X-Auth-Token: ${BOB}")
+
+# Alice видит alice-fn но не bob-fn
+ALICE_COUNT=$(json_len "$ALICE_LIST")
+ALICE_HAS_OWN=$(printf '%s' "$ALICE_LIST" | python3 -c "
+import json, sys
+try:
+  fns = json.load(sys.stdin)
+  print(sum(1 for f in fns if f.get('metadata',{}).get('name','') == 'alice-fn'))
+except:
+  print(0)" 2>/dev/null)
+ALICE_HAS_BOB=$(printf '%s' "$ALICE_LIST" | python3 -c "
+import json, sys
+try:
+  fns = json.load(sys.stdin)
+  print(sum(1 for f in fns if f.get('metadata',{}).get('name','') == 'bob-fn'))
+except:
+  print(0)" 2>/dev/null)
+
+[ "${ALICE_HAS_OWN:-0}" -ge 1 ] && pass "Alice LIST содержит alice-fn" || fail "Alice LIST не содержит alice-fn (count=$ALICE_COUNT)"
+[ "${ALICE_HAS_BOB:-0}" -eq 0 ] && pass "Alice LIST не содержит bob-fn" || fail "Alice LIST содержит bob-fn — УТЕЧКА ДАННЫХ!"
+
+# Bob видит bob-fn но не alice-fn
+BOB_HAS_OWN=$(printf '%s' "$BOB_LIST" | python3 -c "
+import json, sys
+try:
+  fns = json.load(sys.stdin)
+  print(sum(1 for f in fns if f.get('metadata',{}).get('name','') == 'bob-fn'))
+except:
+  print(0)" 2>/dev/null)
+BOB_HAS_ALICE=$(printf '%s' "$BOB_LIST" | python3 -c "
+import json, sys
+try:
+  fns = json.load(sys.stdin)
+  print(sum(1 for f in fns if f.get('metadata',{}).get('name','') == 'alice-fn'))
+except:
+  print(0)" 2>/dev/null)
+
+[ "${BOB_HAS_OWN:-0}" -ge 1 ] && pass "Bob LIST содержит bob-fn" || fail "Bob LIST не содержит bob-fn"
+[ "${BOB_HAS_ALICE:-0}" -eq 0 ] && pass "Bob LIST не содержит alice-fn" || fail "Bob LIST содержит alice-fn — УТЕЧКА ДАННЫХ!"
+
+# ── Route изоляция ───────────────────────────────────────────────────────────
+
+echo ""
+echo ">>> Route изоляция: одинаковое имя → разные routes"
+ROUTE_A=$(printf '%s' "$ALICE_LIST" | python3 -c "
+import json, sys
+try:
+  fns = json.load(sys.stdin)
+  for f in fns:
+    if f.get('metadata',{}).get('name','') == 'alice-fn':
+      print(f.get('spec',{}).get('relativeurl',''))
+      break
+except:
+  print('')" 2>/dev/null)
+
+ROUTE_B=$(printf '%s' "$BOB_LIST" | python3 -c "
+import json, sys
+try:
+  fns = json.load(sys.stdin)
+  for f in fns:
+    if f.get('metadata',{}).get('name','') == 'bob-fn':
+      print(f.get('spec',{}).get('relativeurl',''))
+      break
+except:
+  print('')" 2>/dev/null)
+
+# Проверяем через GET (возвращает route)
+ALICE_GET=$(curl -s "${BASE}/functions/alice-fn" -H "X-Auth-Token: ${ALICE}")
+BOB_GET=$(curl -s "${BASE}/functions/bob-fn" -H "X-Auth-Token: ${BOB}")
+ROUTE_A=$(json_field "$ALICE_GET" route)
+ROUTE_B=$(json_field "$BOB_GET" route)
+[ "$ROUTE_A" != "$ROUTE_B" ] && [ -n "$ROUTE_A" ] && [ -n "$ROUTE_B" ] \
+  && pass "Route изоляция: $ROUTE_A ≠ $ROUTE_B" \
+  || fail "Route коллизия: alice=$ROUTE_A bob=$ROUTE_B"
+
+print_summary

scripts/test_linters.sh

@@ -10,7 +10,7 @@ chk() {
   escaped=$(printf '%s' "$code" | python3 -c "import sys,json; print(json.dumps(sys.stdin.read()))")
   local resp
   resp=$(curl -s -X POST "$API" \
-    -H "X-Test-Sub: livetest@test.local" \
+    -H "X-Auth-Token: livetest@test.local" \
     -H "Content-Type: application/json" \
     -d "{\"language\":\"${lang}\",\"code\":${escaped}}")
   local ok_val result_val

scripts/test_stress.sh

@@ -0,0 +1,160 @@
+#!/usr/bin/env bash
+# test_stress.sh — стресс-тест параллельного использования:
+#   COUNT пользователей создают функции параллельно
+#   LIST изоляция: каждый видит только свои функции
+#   Invoke стресс: INVOKE_COUNT параллельных invoke для livetest@test.local (watched namespace)
+# Cleanup: удаляем namespace-ы тест-пользователей, функции livetest — через API DELETE.
+set -uo pipefail
+
+ROOT_DIR=$(cd "$(dirname "$0")" && pwd)
+source "${ROOT_DIR}/lib.sh"
+
+NS_CLEANUP_SCRIPT="${ROOT_DIR}/cleanup_test_namespaces.sh"
+RUN_ID=$(mk_run_id)
+COUNT="${1:-8}"
+TMP=$(mktemp -d)
+INVOKE_SUB="livetest@test.local"
+INVOKE_COUNT=8
+
+declare -a SUBS=()
+for i in $(seq 1 "$COUNT"); do
+  SUBS+=("stress-${RUN_ID}-u${i}@test.local")
+done
+
+declare -a INVOKE_FNS=()
+for i in $(seq 1 "$INVOKE_COUNT"); do
+  INVOKE_FNS+=("sinv-${RUN_ID}-${i}")
+done
+
+cleanup() {
+  rm -rf "$TMP" 2>/dev/null || true
+  if [ -x "$NS_CLEANUP_SCRIPT" ] && [ "${#SUBS[@]}" -gt 0 ]; then
+    KUBECTL_DIRECT=1 "$NS_CLEANUP_SCRIPT" "${SUBS[@]}" >/dev/null 2>&1 || true
+  fi
+  for fn in "${INVOKE_FNS[@]}"; do
+    curl -s -X DELETE "${BASE}/functions/${fn}" -H "X-Auth-Token: ${INVOKE_SUB}" > /dev/null 2>&1 || true
+  done
+}
+trap cleanup EXIT
+
+echo ""
+echo "========================================"
+echo "  test_stress.sh  run=$RUN_ID  users=$COUNT  invoke_parallel=$INVOKE_COUNT"
+echo "========================================"
+
+JS_CODE='module.exports = async function() { return { status: 200, body: "stress-ok" }; }'
+
+# ── Шаг 1: параллельное создание ─────────────────────────────────────────────
+
+echo ""
+echo ">>> [1/3] $COUNT пользователей создают функции параллельно..."
+
+for i in $(seq 1 "$COUNT"); do
+  (
+    SUB="${SUBS[$((i-1))]}"
+    FN="stress-fn-${RUN_ID}"
+    R=$(curl -s -w "\n%{http_code}" --max-time 60 -X POST "${BASE}/functions" \
+      -H "X-Auth-Token: ${SUB}" -H "Content-Type: application/json" \
+      -d "{\"name\":\"${FN}\",\"language\":\"nodejs\",\"code\":$(printf '%s' "$JS_CODE" | json_escape)}" \
+      2>/dev/null)
+    CODE=$(echo "$R" | tail -1)
+    echo "$i:$CODE" > "${TMP}/create-$i"
+  ) &
+done
+wait
+
+CREATE_OK=0
+CREATE_FAIL=0
+for i in $(seq 1 "$COUNT"); do
+  CODE=$(cut -d: -f2 "${TMP}/create-$i" 2>/dev/null || echo "000")
+  if [ "$CODE" = "201" ] || [ "$CODE" = "200" ]; then
+    CREATE_OK=$((CREATE_OK+1))
+  else
+    CREATE_FAIL=$((CREATE_FAIL+1))
+    echo "    user$i: CREATE HTTP $CODE"
+  fi
+done
+
+[ "$CREATE_FAIL" -eq 0 ] \
+  && pass "Параллельный CREATE: все $COUNT пользователей → 201" \
+  || fail "Параллельный CREATE: $CREATE_FAIL/$COUNT упали"
+
+# ── Шаг 2: изоляция LIST ─────────────────────────────────────────────────────
+
+echo ""
+echo ">>> [2/3] Изоляция: каждый видит только свою функцию"
+
+ISO_OK=0
+for i in $(seq 1 "$COUNT"); do
+  SUB="${SUBS[$((i-1))]}"
+  FN="stress-fn-${RUN_ID}"
+  LIST=$(curl -s --max-time 20 "${BASE}/functions" -H "X-Auth-Token: ${SUB}")
+  OWN_COUNT=$(printf '%s' "$LIST" | python3 -c "
+import json, sys
+try:
+  fns = json.load(sys.stdin)
+  print(sum(1 for f in fns if f.get('metadata',{}).get('name','') == '${FN}'))
+except:
+  print(0)" 2>/dev/null)
+  TOTAL_COUNT=$(json_len "$LIST")
+  if [ "${OWN_COUNT:-0}" -eq 1 ] && [ "${TOTAL_COUNT:-0}" -eq 1 ]; then
+    ISO_OK=$((ISO_OK+1))
+  else
+    echo "    user$i: own=$OWN_COUNT total=$TOTAL_COUNT"
+  fi
+done
+
+[ "$ISO_OK" -eq "$COUNT" ] \
+  && pass "Изоляция: все $COUNT пользователей видят только свои функции" \
+  || fail "Изоляция: только $ISO_OK/$COUNT OK"
+
+# ── Шаг 3: параллельный invoke (livetest — watched namespace) ─────────────────
+
+echo ""
+echo ">>> [3/3] $INVOKE_COUNT параллельных invoke для livetest@test.local"
+
+INV_JS='module.exports = async function() { return { status: 200, body: "sinv-ok" }; }'
+for i in $(seq 1 "$INVOKE_COUNT"); do
+  FN_I="${INVOKE_FNS[$((i-1))]}"
+  curl -s -X POST "${BASE}/functions" \
+    -H "X-Auth-Token: ${INVOKE_SUB}" -H "Content-Type: application/json" \
+    -d "{\"name\":\"${FN_I}\",\"language\":\"nodejs\",\"code\":$(printf '%s' "$INV_JS" | json_escape)}" > /dev/null
+done
+
+echo "Ждём прогрева $INVOKE_COUNT функций..."
+for i in $(seq 1 "$INVOKE_COUNT"); do
+  FN_I="${INVOKE_FNS[$((i-1))]}"
+  for try in $(seq 1 12); do
+    R=$(curl -s --max-time 30 -X POST "${BASE}/functions/${FN_I}/invoke" \
+      -H "X-Auth-Token: ${INVOKE_SUB}" -H "Content-Type: application/json" -d '{}')
+    ST=$(json_field "$R" status)
+    [ "$ST" = "200" ] && break
+    echo "  прогрев функции $i/$INVOKE_COUNT: попытка $try/12..."
+    sleep 5
+  done
+  echo "  функция $i/$INVOKE_COUNT — готова"
+done
+
+for i in $(seq 1 "$INVOKE_COUNT"); do
+  (
+    FN_I="${INVOKE_FNS[$((i-1))]}"
+    R=$(curl -s --max-time 30 -X POST "${BASE}/functions/${FN_I}/invoke" \
+      -H "X-Auth-Token: ${INVOKE_SUB}" -H "Content-Type: application/json" -d '{}')
+    ST=$(json_field "$R" status)
+    echo "$i:$ST" > "${TMP}/sinvoke-$i"
+  ) &
+done
+wait
+
+SINV_OK=0
+SINV_FAIL=0
+for i in $(seq 1 "$INVOKE_COUNT"); do
+  CODE=$(cut -d: -f2 "${TMP}/sinvoke-$i" 2>/dev/null || echo "MISS")
+  [ "$CODE" = "200" ] && SINV_OK=$((SINV_OK+1)) || SINV_FAIL=$((SINV_FAIL+1))
+done
+
+[ "$SINV_FAIL" -le 1 ] \
+  && pass "Параллельный INVOKE (livetest): $SINV_OK/$INVOKE_COUNT OK" \
+  || fail "Параллельный INVOKE (livetest): $SINV_FAIL/$INVOKE_COUNT упали"
+
+print_summary

scripts/test_ttl.sh

@@ -0,0 +1,93 @@
+#!/usr/bin/env bash
+# test_ttl.sh — тестирует TTL функций:
+#   CREATE с TTL → expires_at присутствует в ответе
+#   CREATE без TTL → expires_at отсутствует
+#   Невалидный TTL → 400 до создания объектов в k8s
+set -uo pipefail
+
+ROOT_DIR=$(cd "$(dirname "$0")" && pwd)
+source "${ROOT_DIR}/lib.sh"
+
+NS_CLEANUP_SCRIPT="${ROOT_DIR}/cleanup_test_namespaces.sh"
+RUN_ID=$(mk_run_id)
+SUB="ttl-${RUN_ID}@test.local"
+
+cleanup() {
+  if [ -x "$NS_CLEANUP_SCRIPT" ]; then
+    KUBECTL_DIRECT=1 "$NS_CLEANUP_SCRIPT" "$SUB" >/dev/null 2>&1 || true
+  fi
+}
+trap cleanup EXIT
+
+echo ""
+echo "========================================"
+echo "  test_ttl.sh  run=$RUN_ID"
+echo "========================================"
+
+JS_CODE='module.exports = async function() { return { status: 200, body: "ok" }; }'
+
+# ── Без TTL ──────────────────────────────────────────────────────────────────
+
+echo ""
+echo ">>> CREATE без TTL → expires_at отсутствует"
+R=$(curl -s -X POST "${BASE}/functions" \
+  -H "X-Auth-Token: ${SUB}" -H "Content-Type: application/json" \
+  -d "{\"name\":\"nttl-fn\",\"language\":\"nodejs\",\"code\":$(printf '%s' "$JS_CODE" | json_escape)}")
+CODE_HTTP=$(printf '%s' "$R" | python3 -c "import sys; lines=sys.stdin.read().split('\n'); print(lines[-1] if lines else '')" 2>/dev/null || echo "?")
+EXPIRES=$(json_field "$R" expires_at)
+[ -z "$EXPIRES" ] && pass "CREATE без TTL: expires_at отсутствует" || fail "CREATE без TTL: expires_at='$EXPIRES'"
+
+# ── С TTL=15m ────────────────────────────────────────────────────────────────
+
+echo ""
+echo ">>> CREATE с TTL=15m → expires_at присутствует"
+R=$(curl -s -X POST "${BASE}/functions" \
+  -H "X-Auth-Token: ${SUB}" -H "Content-Type: application/json" \
+  -d "{\"name\":\"ttl15m-fn\",\"language\":\"nodejs\",\"code\":$(printf '%s' "$JS_CODE" | json_escape),\"ttl\":\"15m\"}")
+EXPIRES=$(json_field "$R" expires_at)
+[ -n "$EXPIRES" ] && pass "CREATE TTL=15m: expires_at=$EXPIRES" || fail "CREATE TTL=15m: expires_at пустой"
+# expires_at должен быть RFC3339
+printf '%s' "$EXPIRES" | grep -qE '^[0-9]{4}-[0-9]{2}-[0-9]{2}T' && pass "expires_at формат RFC3339" || fail "expires_at не RFC3339: $EXPIRES"
+
+# ── С TTL=1h ─────────────────────────────────────────────────────────────────
+
+echo ""
+echo ">>> CREATE с TTL=1h → expires_at присутствует"
+R=$(curl -s -X POST "${BASE}/functions" \
+  -H "X-Auth-Token: ${SUB}" -H "Content-Type: application/json" \
+  -d "{\"name\":\"ttl1h-fn\",\"language\":\"nodejs\",\"code\":$(printf '%s' "$JS_CODE" | json_escape),\"ttl\":\"1h\"}")
+EXPIRES=$(json_field "$R" expires_at)
+[ -n "$EXPIRES" ] && pass "CREATE TTL=1h: expires_at=$EXPIRES" || fail "CREATE TTL=1h: expires_at пустой"
+
+# ── С TTL=2d ─────────────────────────────────────────────────────────────────
+
+echo ""
+echo ">>> CREATE с TTL=2d → expires_at присутствует"
+R=$(curl -s -X POST "${BASE}/functions" \
+  -H "X-Auth-Token: ${SUB}" -H "Content-Type: application/json" \
+  -d "{\"name\":\"ttl2d-fn\",\"language\":\"nodejs\",\"code\":$(printf '%s' "$JS_CODE" | json_escape),\"ttl\":\"2d\"}")
+EXPIRES=$(json_field "$R" expires_at)
+[ -n "$EXPIRES" ] && pass "CREATE TTL=2d: expires_at=$EXPIRES" || fail "CREATE TTL=2d: expires_at пустой"
+
+# ── Невалидный TTL ───────────────────────────────────────────────────────────
+
+echo ""
+echo ">>> CREATE TTL невалидный → 400 (без создания объектов)"
+for badttl in "99z" "abc" "0d" "-1h" ""; do
+  if [ -z "$badttl" ]; then continue; fi
+  R=$(curl -s -w "\n%{http_code}" -X POST "${BASE}/functions" \
+    -H "X-Auth-Token: ${SUB}" -H "Content-Type: application/json" \
+    -d "{\"name\":\"badttl-fn\",\"language\":\"nodejs\",\"code\":\"x\",\"ttl\":\"${badttl}\"}")
+  CODE=$(echo "$R" | tail -1)
+  [ "$CODE" = "400" ] && pass "TTL='$badttl' → 400" || fail "TTL='$badttl' → got $CODE"
+done
+
+# ── expires_at в LIST response ───────────────────────────────────────────────
+
+echo ""
+echo ">>> LIST: функция с TTL видна в списке"
+LIST=$(curl -s "${BASE}/functions" -H "X-Auth-Token: ${SUB}")
+COUNT=$(json_len "$LIST")
+[ "${COUNT:-0}" -ge 3 ] && pass "LIST: видно ≥3 функции (2 с TTL, 1 без)" || fail "LIST: count=$COUNT"
+
+print_summary

scripts/test_update.sh

@@ -0,0 +1,105 @@
+#!/usr/bin/env bash
+# test_update.sh — тестирует обновление кода функции:
+#   PUT /functions/{name}/code → invoke возвращает новый код
+#   PUT несуществующей → 404
+#   PUT с пустым кодом → 400
+# ВАЖНО: использует livetest@test.local — прогретый namespace в kube кластере.
+#   Для новых namespace fission router требует перезапуска (watchedNamespaces).
+set -uo pipefail
+
+ROOT_DIR=$(cd "$(dirname "$0")" && pwd)
+source "${ROOT_DIR}/lib.sh"
+
+RUN_ID=$(mk_run_id)
+SUB="livetest@test.local"
+FN="upd-fn-${RUN_ID}"
+
+cleanup() {
+  curl -s -X DELETE "${BASE}/functions/${FN}" -H "X-Auth-Token: ${SUB}" > /dev/null 2>&1 || true
+}
+trap cleanup EXIT
+
+echo ""
+echo "========================================"
+echo "  test_update.sh  run=$RUN_ID"
+echo "========================================"
+
+# ── Создаём функцию с начальным кодом ────────────────────────────────────────
+
+echo ""
+echo ">>> CREATE: версия v1"
+CODE_V1='module.exports = async function() { return { status: 200, body: "version-one" }; }'
+R=$(curl -s -w "\n%{http_code}" -X POST "${BASE}/functions" \
+  -H "X-Auth-Token: ${SUB}" -H "Content-Type: application/json" \
+  -d "{\"name\":\"${FN}\",\"language\":\"nodejs\",\"code\":$(printf '%s' "$CODE_V1" | json_escape)}")
+check_http "$(echo "$R" | tail -1)" "201" "CREATE v1 → 201"
+
+echo "Ждём прогрева..."
+if wait_invoke "$SUB" "$FN" "version-one" 12 5; then
+  pass "Invoke v1 → version-one"
+else
+  fail "Invoke v1 не стабилизировался"
+fi
+
+# ── PUT /code → 200 ──────────────────────────────────────────────────────────
+
+echo ""
+echo ">>> PUT /code: версия v2"
+CODE_V2='module.exports = async function() { return { status: 200, body: "version-two" }; }'
+R=$(curl -s -w "\n%{http_code}" -X PUT "${BASE}/functions/${FN}/code" \
+  -H "X-Auth-Token: ${SUB}" -H "Content-Type: application/json" \
+  -d "{\"code\":$(printf '%s' "$CODE_V2" | json_escape)}")
+CODE=$(echo "$R" | tail -1)
+BODY=$(echo "$R" | sed '$d')
+check_http "$CODE" "200" "PUT /code v2 → 200"
+UPDATED=$(json_field "$BODY" updated)
+[ "$UPDATED" = "True" ] || [ "$UPDATED" = "true" ] && pass "PUT /code: updated=true" || fail "PUT /code: updated='$UPDATED'"
+NEW_PKG=$(json_field "$BODY" package)
+[ -n "$NEW_PKG" ] && pass "PUT /code: новый package=$NEW_PKG" || fail "PUT /code: package пустой"
+
+echo "Ждём пока executor подхватит новый код..."
+if wait_invoke "$SUB" "$FN" "version-two" 15 5; then
+  pass "Invoke после update → version-two"
+else
+  fail "Invoke после update не вернул version-two"
+fi
+
+# ── PUT с пустым кодом → 400 ──────────────────────────────────────────────────
+
+echo ""
+echo ">>> PUT /code: пустой код → 400"
+R=$(curl -s -w "\n%{http_code}" -X PUT "${BASE}/functions/${FN}/code" \
+  -H "X-Auth-Token: ${SUB}" -H "Content-Type: application/json" \
+  -d '{"code":""}')
+check_http "$(echo "$R" | tail -1)" "400" "PUT /code пустой код → 400"
+
+R=$(curl -s -w "\n%{http_code}" -X PUT "${BASE}/functions/${FN}/code" \
+  -H "X-Auth-Token: ${SUB}" -H "Content-Type: application/json" \
+  -d '{"code":"   "}')
+check_http "$(echo "$R" | tail -1)" "400" "PUT /code пробельный код → 400"
+
+# ── PUT несуществующей → 404 ──────────────────────────────────────────────────
+
+echo ""
+echo ">>> PUT /code: несуществующая функция → 404"
+R=$(curl -s -w "\n%{http_code}" -X PUT "${BASE}/functions/no-such-fn-xyz/code" \
+  -H "X-Auth-Token: ${SUB}" -H "Content-Type: application/json" \
+  -d "{\"code\":$(printf '%s' "$CODE_V1" | json_escape)}")
+check_http "$(echo "$R" | tail -1)" "404" "PUT /code несуществующая → 404"
+
+# ── Ещё одно обновление (v3) — убеждаемся что можно делать цепочку ────────────
+
+echo ""
+echo ">>> PUT /code: версия v3 (цепочка)"
+CODE_V3='module.exports = async function() { return { status: 200, body: "version-three" }; }'
+curl -s -X PUT "${BASE}/functions/${FN}/code" \
+  -H "X-Auth-Token: ${SUB}" -H "Content-Type: application/json" \
+  -d "{\"code\":$(printf '%s' "$CODE_V3" | json_escape)}" > /dev/null
+
+if wait_invoke "$SUB" "$FN" "version-three" 15 5; then
+  pass "Invoke после v3 update → version-three"
+else
+  fail "Invoke после v3 update не стабилизировался"
+fi
+
+print_summary

smoke_live_multiuser.sh

@@ -1,134 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-
-BASE="https://fission.kube5s.ru/console/api"
-COUNT=${1:-10}
-RUN_ID="mt$(date +%s | tail -c 6)"
-ROOT_DIR=$(cd "$(dirname "$0")" && pwd)
-NS_CLEANUP_SCRIPT="${ROOT_DIR}/cleanup_test_namespaces.sh"
-TMP=$(mktemp -d)
-
-declare -a USERS=()
-
-cleanup() {
-    rm -rf "$TMP" 2>/dev/null || true
-    if [ -x "$NS_CLEANUP_SCRIPT" ] && [ ${#USERS[@]} -gt 0 ]; then
-        KUBECTL_DIRECT=1 "$NS_CLEANUP_SCRIPT" "${USERS[@]}" >/dev/null 2>&1 || true
-    fi
-}
-trap cleanup EXIT
-
-json_escape() {
-    python3 -c 'import json,sys; print(json.dumps(sys.stdin.read()))'
-}
-
-init_call() {
-    local user="$1"
-    local code=""
-    local try
-    for try in 1 2 3; do
-        code=$(curl -s -o /dev/null -w "%{http_code}" --max-time 30 -X GET "${BASE}/functions" -H "X-Test-Sub: ${user}" 2>/dev/null || echo 000)
-        echo "INIT_TRY user=${user} try=${try} http=${code}" >&2
-        if [ "$code" = "200" ]; then
-            printf '%s' "$code"
-            return 0
-        fi
-        [ "$try" -lt 3 ] && sleep 2
-    done
-    printf '%s' "$code"
-}
-
-invoke_call() {
-    local user="$1"
-    local fn="$2"
-    local code=""
-    local try
-    for try in 1 2 3 4; do
-        code=$(curl -s -o /dev/null -w "%{http_code}" --max-time 40 -X POST "${BASE}/functions/${fn}/invoke" -H "X-Test-Sub: ${user}" -H "Content-Type: application/json" -d '{}' 2>/dev/null || echo 000)
-        echo "INVOKE_TRY user=${user} fn=${fn} try=${try} http=${code}" >&2
-        if [ "$code" = "200" ]; then
-            printf '%s' "$code"
-            return 0
-        fi
-        [ "$try" -lt 4 ] && sleep 4
-    done
-    printf '%s' "$code"
-}
-
-echo "=== MULTIUSER TEST START run=$RUN_ID count=$COUNT ==="
-
-for i in $(seq 1 "$COUNT"); do
-    USERS+=("${RUN_ID}-u${i}@test.local")
-    (
-        U="${RUN_ID}-u${i}@test.local"
-        CODE=$(init_call "${U}")
-        echo "$i:$CODE:$U" > "${TMP}/init-$i"
-    ) &
-done
-wait
-
-INIT_OK=0
-for i in $(seq 1 "$COUNT"); do
-    R=$(cat "${TMP}/init-$i" 2>/dev/null || echo "$i:000:")
-    C=$(echo "$R" | cut -d: -f2)
-    if [ "$C" = "200" ]; then
-        INIT_OK=$((INIT_OK+1))
-    else
-        echo "INIT_FAIL user$i http=$C"
-    fi
-done
-echo "INIT_OK=$INIT_OK/$COUNT"
-
-for i in $(seq 1 "$COUNT"); do
-    (
-        U="${RUN_ID}-u${i}@test.local"
-        FN="mtfn-${RUN_ID}-${i}"
-        CODE_TEXT=$(printf 'def main():\n    return "ok-%s-%s"\n' "$RUN_ID" "$i")
-        CODE_JSON=$(printf '%s' "$CODE_TEXT" | json_escape)
-        BODY=$(printf '{"name":"%s","language":"python","code":%s}' "$FN" "$CODE_JSON")
-        C=$(curl -s -o /dev/null -w "%{http_code}" --max-time 60 -X POST "${BASE}/functions" -H "X-Test-Sub: ${U}" -H "Content-Type: application/json" -d "$BODY" 2>/dev/null || echo 000)
-        echo "$i:$C:$FN:$U" > "${TMP}/create-$i"
-    ) &
-done
-wait
-
-CREATE_OK=0
-for i in $(seq 1 "$COUNT"); do
-    R=$(cat "${TMP}/create-$i" 2>/dev/null || echo "$i:000::")
-    C=$(echo "$R" | cut -d: -f2)
-    if [ "$C" = "200" ] || [ "$C" = "201" ]; then
-        CREATE_OK=$((CREATE_OK+1))
-    else
-        echo "CREATE_FAIL user$i http=$C"
-    fi
-done
-echo "CREATE_OK=$CREATE_OK/$COUNT"
-
-sleep 8
-
-for i in $(seq 1 "$COUNT"); do
-    (
-        U="${RUN_ID}-u${i}@test.local"
-        FN="mtfn-${RUN_ID}-${i}"
-        C=$(invoke_call "${U}" "${FN}")
-        echo "$i:$C" > "${TMP}/invoke-$i"
-    ) &
-done
-wait
-
-INVOKE_OK=0
-for i in $(seq 1 "$COUNT"); do
-    R=$(cat "${TMP}/invoke-$i" 2>/dev/null || echo "$i:000")
-    C=$(echo "$R" | cut -d: -f2)
-    if [ "$C" = "200" ]; then
-        INVOKE_OK=$((INVOKE_OK+1))
-    else
-        echo "INVOKE_FAIL user$i http=$C"
-    fi
-done
-echo "INVOKE_OK=$INVOKE_OK/$COUNT"
-echo "=== MULTIUSER TEST END ==="
-
-[ "$INIT_OK" = "$COUNT" ]
-[ "$CREATE_OK" = "$COUNT" ]
-[ "$INVOKE_OK" = "$COUNT" ]

smoke_user_journeys.sh

@@ -1,119 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-
-BASE="https://fission.kube5s.ru/console/api"
-COUNT=${1:-5}
-RUN_ID="journey$(date +%s | tail -c 6)"
-ROOT_DIR=$(cd "$(dirname "$0")" && pwd)
-NS_CLEANUP_SCRIPT="${ROOT_DIR}/cleanup_test_namespaces.sh"
-TMP=$(mktemp -d)
-
-declare -a USERS=()
-
-cleanup() {
-    rm -rf "$TMP" 2>/dev/null || true
-    if [ -x "$NS_CLEANUP_SCRIPT" ] && [ ${#USERS[@]} -gt 0 ]; then
-        KUBECTL_DIRECT=1 "$NS_CLEANUP_SCRIPT" "${USERS[@]}" >/dev/null 2>&1 || true
-    fi
-}
-trap cleanup EXIT
-
-json_field() {
-    local payload="$1"
-    local key="$2"
-    printf '%s' "$payload" | python3 -c 'import json,sys
-key=sys.argv[1]
-try:
-  data=json.load(sys.stdin)
-  value=data.get(key, "")
-  print(value if not isinstance(value, (dict,list)) else json.dumps(value))
-except Exception:
-  print("")' "$key"
-}
-
-json_escape() {
-    python3 -c 'import json,sys; print(json.dumps(sys.stdin.read()))'
-}
-
-create_call() {
-    local sub="$1"
-    local body="$2"
-    curl -s -w "\n%{http_code}" --max-time 60 -X POST "${BASE}/functions" \
-      -H "X-Test-Sub: ${sub}" -H 'Content-Type: application/json' -d "$body"
-}
-
-invoke_call() {
-    local sub="$1"
-    local name="$2"
-    curl -s --max-time 45 -X POST "${BASE}/functions/${name}/invoke" \
-      -H "X-Test-Sub: ${sub}" -H 'Content-Type: application/json' -d '{}' || true
-}
-
-echo "=== USER JOURNEYS START run=$RUN_ID count=$COUNT ==="
-
-for i in $(seq 1 "$COUNT"); do
-    USERS+=("${RUN_ID}-u${i}@test.local")
-    (
-        U="${RUN_ID}-u${i}@test.local"
-        FN="journey-${RUN_ID}-${i}"
-        RESULT="PASS"
-
-        AUTH=$(curl -s -w "\n%{http_code}" --max-time 45 -X POST "${BASE}/auth" -H 'Content-Type: application/json' -d "{\"token\":\"${U}\",\"env\":\"test\"}")
-        AUTH_CODE=$(printf '%s' "$AUTH" | tail -1)
-        [ "$AUTH_CODE" = "200" ] || RESULT="FAIL auth=${AUTH_CODE}"
-
-        BAD=$(create_call "$U" '{"name":"bad-lang","language":"cobol","code":"x"}')
-        BAD_CODE=$(printf '%s' "$BAD" | tail -1)
-        [ "$BAD_CODE" = "400" ] || RESULT="FAIL bad_create=${BAD_CODE}"
-
-        CODE_TEXT=$(printf 'def main():\n    return "journey-ok-%s-%s"\n' "$RUN_ID" "$i")
-        CODE_JSON=$(printf '%s' "$CODE_TEXT" | json_escape)
-        GOOD=$(create_call "$U" "{\"name\":\"${FN}\",\"language\":\"python\",\"code\":${CODE_JSON}}")
-        GOOD_CODE=$(printf '%s' "$GOOD" | tail -1)
-        [ "$GOOD_CODE" = "201" ] || RESULT="FAIL create=${GOOD_CODE}"
-
-        DUP=$(create_call "$U" "{\"name\":\"${FN}\",\"language\":\"python\",\"code\":${CODE_JSON}}")
-        DUP_CODE=$(printf '%s' "$DUP" | tail -1)
-        { [ "$DUP_CODE" = "409" ] || [ "$DUP_CODE" = "502" ]; } || RESULT="FAIL dup=${DUP_CODE}"
-
-        INV_STATUS=""
-        INV_RAW=""
-        for try in 1 2 3 4 5 6; do
-            INV=$(invoke_call "$U" "$FN")
-            INV_STATUS=$(json_field "$INV" status)
-            INV_RAW=$(json_field "$INV" response_raw)
-            echo "USER=$i TRY=$try status=$INV_STATUS raw=$INV_RAW"
-            if [ "$INV_STATUS" = "200" ] && printf '%s' "$INV_RAW" | grep -q "journey-ok-${RUN_ID}-${i}"; then
-                break
-            fi
-            [ "$try" -lt 6 ] && sleep 5
-        done
-        [ "$INV_STATUS" = "200" ] || RESULT="FAIL invoke=${INV_STATUS}"
-
-        DEL1=$(curl -s -o /dev/null -w "%{http_code}" --max-time 45 -X DELETE "${BASE}/functions/${FN}" -H "X-Test-Sub: ${U}")
-        [ "$DEL1" = "200" ] || RESULT="FAIL delete1=${DEL1}"
-        DEL2=$(curl -s -o /dev/null -w "%{http_code}" --max-time 45 -X DELETE "${BASE}/functions/${FN}" -H "X-Test-Sub: ${U}")
-        [ "$DEL2" = "404" ] || RESULT="FAIL delete2=${DEL2}"
-
-        echo "$i:$RESULT" > "${TMP}/user-$i"
-    ) &
-done
-wait
-
-PASS=0
-FAIL=0
-for i in $(seq 1 "$COUNT"); do
-    R=$(cat "${TMP}/user-$i" 2>/dev/null || echo "$i:FAIL missing_result")
-    STATUS=$(printf '%s' "$R" | cut -d: -f2-)
-    if [ "$STATUS" = "PASS" ]; then
-        PASS=$((PASS+1))
-        echo "USER_PASS $i"
-    else
-        FAIL=$((FAIL+1))
-        echo "USER_FAIL $i $STATUS"
-    fi
-done
-
-echo "USER_JOURNEYS_PASS=$PASS/$COUNT"
-echo "=== USER JOURNEYS END ==="
-[ "$FAIL" = 0 ]

test59.sh

@@ -1,10 +0,0 @@
-#!/bin/bash
-BASE="https://fission.kube5s.ru/console/api"
-NAME59=$(python3 -c "print('a'*59)")
-echo "Name len: ${#NAME59}"
-echo "Pkg name would be: ${NAME59}-pkg (len=$(python3 -c "print(59+4)"))"
-curl -s -w "\nHTTP:%{http_code}" -X POST "${BASE}/functions" \
-  -H "X-Test-Sub: len59direct@test.local" \
-  -H "Content-Type: application/json" \
-  --data-raw "{\"name\":\"${NAME59}\",\"language\":\"nodejs\",\"code\":\"module.exports=async()=>42\"}"
-echo

test_layer1.sh

@@ -1,158 +0,0 @@
-#!/usr/bin/env bash
-# test_layer1.sh — простой тест пропатченного Fission NSWatcher (Layer 1 only).
-# Без консоли. Только kubectl + fission CLI.
-#
-# Что проверяем:
-#   1. Создаём NS с меткой fission.io/managed=true
-#   2. Executor регистрирует его через NSWatcher (лог)
-#   3. Создаём Python env + function в новом NS
-#   4. Вызываем функцию — должна ответить 200
-#
-# Запуск: bash ~/terra/fission/test_layer1.sh
-
-set -uo pipefail
-
-NS="l1-test-$(date +%s | tail -c 6)"
-PASS=0; FAIL=0
-
-green() { echo -e "\033[32m  PASS: $1\033[0m"; PASS=$((PASS+1)); }
-red()   { echo -e "\033[31m  FAIL: $1\033[0m"; FAIL=$((FAIL+1)); }
-
-echo ""
-echo "========================================"
-echo "  Layer 1 NSWatcher — простой тест"
-echo "  NS: $NS"
-echo "========================================"
-
-# ── 1. Создаём NS с меткой ────────────────────────────────────────────────────
-echo ""
-echo ">>> [1/5] Создаём NS $NS с меткой fission.io/managed=true..."
-kubectl create ns "$NS"
-kubectl label ns "$NS" fission.io/managed=true --overwrite
-
-kubectl get ns "$NS" --show-labels | grep "fission.io/managed"
-if [ $? -eq 0 ]; then
-    green "NS создан с меткой"
-else
-    red "Метка не применилась"
-    exit 1
-fi
-
-# ── 2. Ждём регистрации в executor ────────────────────────────────────────────
-echo ""
-echo ">>> [2/5] Ждём регистрации NS в executor (до 15 сек)..."
-
-DEADLINE=$((SECONDS + 15))
-REGISTERED=false
-while [ $SECONDS -lt $DEADLINE ]; do
-    if kubectl logs -n fission deployment/executor 2>/dev/null | grep "registered namespace" | grep -q "$NS"; then
-        REGISTERED=true
-        break
-    fi
-    sleep 2
-done
-
-if [ "$REGISTERED" = "true" ]; then
-    green "Executor зарегистрировал NS $NS"
-else
-    red "Executor НЕ зарегистрировал NS за 15 сек"
-    echo "  Лог executor (последние строки про namespace):"
-    kubectl logs -n fission deployment/executor 2>/dev/null | grep "namespace" | tail -5
-fi
-
-# ── 3. Создаём environment в новом NS ─────────────────────────────────────────
-echo ""
-echo ">>> [3/5] Создаём Python environment в NS $NS..."
-
-fission env create \
-    --name py-env \
-    --namespace "$NS" \
-    --image ghcr.io/fission/python-env:latest \
-    --poolsize 1 2>&1
-
-if kubectl get environment py-env -n "$NS" &>/dev/null; then
-    green "Environment py-env создан в $NS"
-else
-    red "Environment не создался"
-fi
-
-# ── 4. Создаём функцию ────────────────────────────────────────────────────────
-echo ""
-echo ">>> [4/5] Создаём функцию hello..."
-
-cat > /tmp/hello.py << 'EOF'
-def main():
-    return "hello from layer1"
-EOF
-
-fission fn create \
-    --name hello \
-    --namespace "$NS" \
-    --env py-env \
-    --code /tmp/hello.py 2>&1
-
-fission httptrigger create \
-    --name hello-route \
-    --namespace "$NS" \
-    --function hello \
-    --url "/${NS}/hello" \
-    --method GET 2>&1
-
-if kubectl get httptrigger hello-route -n "$NS" &>/dev/null; then
-    green "Function + HTTPTrigger созданы"
-else
-    red "HTTPTrigger не создался"
-fi
-
-# ── 5. Вызываем функцию через внутренний router с JWT ────────────────────────
-echo ""
-echo ">>> [5/5] Вызываем функцию через internal router + JWT (cold start до 180 сек)..."
-
-ROUTER_INT="http://router.fission.svc.cluster.local"
-DEADLINE=$((SECONDS + 180))
-FN_OK=false
-
-while [ $SECONDS -lt $DEADLINE ]; do
-    RESULT=$(kubectl run fn-probe-$$ --rm -i --restart=Never \
-        --image=curlimages/curl:8.7.1 \
-        --namespace=fission \
-        -- sh -c "
-          TOKEN=\$(curl -sf --max-time 15 -X POST ${ROUTER_INT}/auth/login \
-            -H 'Content-Type: application/json' \
-            -d '{\"username\":\"admin\",\"password\":\"7XG1lSg0EFqPLE4pf3He\"}' \
-            | grep -o '\"accesstoken\":\"[^\"]*' | cut -d'\"' -f4)
-          if [ -z \"\$TOKEN\" ]; then echo 'LOGIN_FAIL|||000'; exit 0; fi
-          curl -s -w '|||%{http_code}' --max-time 90 \
-            -H \"Authorization: Bearer \$TOKEN\" \
-            ${ROUTER_INT}/${NS}/hello
-        " 2>/dev/null | grep "|||" || echo "|||000")
-    CODE=$(echo "$RESULT" | grep -o '|||[0-9]*' | tr -d '|||')
-    BODY=$(echo "$RESULT" | sed 's/|||[0-9]*$//')
-    echo "    HTTP $CODE — $(echo "$BODY" | head -c 80)"
-    [ "$CODE" = "200" ] && FN_OK=true && break
-    sleep 5
-done
-
-if [ "$FN_OK" = "true" ]; then
-    green "Функция ответила 200: $BODY"
-else
-    red "Функция не ответила 200 (timeout)"
-    echo "  Логи router (last 3):"
-    kubectl logs -n fission deployment/router 2>/dev/null | tail -3
-fi
-
-# ── Cleanup ───────────────────────────────────────────────────────────────────
-echo ""
-echo ">>> Cleanup..."
-fission httptrigger delete --name hello-route --namespace "$NS" 2>/dev/null || true
-fission fn delete --name hello --namespace "$NS" 2>/dev/null || true
-fission env delete --name py-env --namespace "$NS" 2>/dev/null || true
-kubectl delete ns "$NS" --wait=false 2>/dev/null || true
-echo "    Готово."
-
-# ── Итог ─────────────────────────────────────────────────────────────────────
-echo ""
-echo "========================================"
-echo "  ИТОГ: PASS=$PASS  FAIL=$FAIL"
-echo "========================================"
-[ $FAIL -eq 0 ] && exit 0 || exit 1

test_multitenant_ns.sh

@@ -1,214 +0,0 @@
-#!/usr/bin/env bash
-# test_multitenant_ns.sh — стресс-тест Layer 1 (патченный Fission NSWatcher).
-#
-# Что проверяем:
-#   1. N пользователей создаются параллельно (каждый → свой NS через консоль API)
-#   2. Executor регистрирует каждый NS через NSWatcher (лог: registered namespace)
-#   3. В каждом NS создаётся функция через консоль API
-#   4. Каждая функция вызывается и отвечает правильно
-#   5. Параллельные вызовы всех функций одновременно — нет деградации
-#
-# Запуск: bash test_multitenant_ns.sh [COUNT]
-# COUNT — кол-во параллельных пользователей (default: 10)
-
-set -uo pipefail
-
-if [ "${KUBECTL_DIRECT:-0}" = "1" ]; then
-    EXECUTOR_LOGS_CMD() {
-        kubectl logs -n fission deployment/executor 2>/dev/null
-    }
-else
-    SSH="ssh -i ~/.ssh/naeel_vm_id_ed25519 -o StrictHostKeyChecking=no -o ConnectTimeout=10 naeel@5.172.178.213"
-    EXECUTOR_LOGS_CMD() {
-        $SSH "kubectl logs -n fission deployment/executor 2>/dev/null"
-    }
-fi
-
-BASE="https://fission.kube5s.ru/console/api"
-COUNT=${1:-10}
-RUN_ID="mt$(date +%s | tail -c 6)"
-ROOT_DIR=$(cd "$(dirname "$0")" && pwd)
-NS_CLEANUP_SCRIPT="${ROOT_DIR}/cleanup_test_namespaces.sh"
-PASS=0; FAIL=0
-
-declare -a CREATED_USERS=()
-
-cleanup_namespaces() {
-    rm -rf "${TMPDIR_RESULTS:-}" 2>/dev/null || true
-    if [ -x "$NS_CLEANUP_SCRIPT" ] && [ "${#CREATED_USERS[@]}" -gt 0 ]; then
-        echo ""
-        echo ">>> Cleanup test namespaces..."
-        "$NS_CLEANUP_SCRIPT" "${CREATED_USERS[@]}" || true
-    fi
-}
-trap cleanup_namespaces EXIT
-
-green() { echo -e "\033[32m  PASS: $1\033[0m"; PASS=$((PASS+1)); }
-red()   { echo -e "\033[31m  FAIL: $1\033[0m"; FAIL=$((FAIL+1)); }
-
-echo ""
-echo "========================================"
-echo "  Layer 1 NSWatcher — стресс-тест"
-echo "  Пользователей: $COUNT  run: $RUN_ID"
-echo "========================================"
-
-# Каждый "пользователь" — уникальный X-Test-Sub → уникальный NS
-# Консоль вызывает SetupFissionNamespace → NS получает fission.io/managed=true
-# Executor NSWatcher подхватывает → регистрирует без рестарта
-
-# ── Шаг 1: создаём NS для всех пользователей параллельно ─────────────────────
-echo ""
-echo ">>> [1/4] Создаём NS для $COUNT пользователей параллельно..."
-
-TMPDIR_RESULTS=$(mktemp -d)
-
-for i in $(seq 1 $COUNT); do
-    USER="${RUN_ID}-user${i}@test.local"
-    CREATED_USERS+=("$USER")
-    (
-        CODE=$(curl -s -o /dev/null -w "%{http_code}" --max-time 30 \
-            -X GET "${BASE}/functions" \
-            -H "X-Test-Sub: ${USER}" 2>/dev/null || echo 000)
-        echo "$i:$CODE:$USER" > "${TMPDIR_RESULTS}/init-${i}"
-    ) &
-done
-wait
-
-NS_OK=0; NS_FAIL=0
-declare -A USERS
-for i in $(seq 1 $COUNT); do
-    R=$(cat "${TMPDIR_RESULTS}/init-${i}" 2>/dev/null || echo "$i:000:")
-    CODE=$(echo "$R" | cut -d: -f2)
-    USER=$(echo "$R" | cut -d: -f3)
-    USERS[$i]="$USER"
-    if [ "$CODE" = "200" ]; then
-        NS_OK=$((NS_OK+1))
-    else
-        NS_FAIL=$((NS_FAIL+1))
-        echo "    user${i}: HTTP $CODE"
-    fi
-done
-
-if [ $NS_FAIL -eq 0 ]; then
-    green "Все $COUNT NS созданы через консоль API (HTTP 200)"
-else
-    red "$NS_FAIL / $COUNT NS не создались"
-fi
-
-# ── Шаг 2: проверяем что executor зарегистрировал NS ─────────────────────────
-echo ""
-echo ">>> [2/4] Проверяем регистрацию NS в executor..."
-
-# Ждём немного — informer почти мгновенный, но логи могут задержаться
-sleep 5
-
-EXEC_LOGS=$(EXECUTOR_LOGS_CMD | grep 'registered namespace' 2>/dev/null || echo "")
-REGISTERED=0
-for i in $(seq 1 $COUNT); do
-    USER="${USERS[$i]:-}"
-    # NS имя формируется консолью как hash от email
-    # Ищем любые новые registered namespace в логах после старта теста
-    REGISTERED=$(EXECUTOR_LOGS_CMD | grep 'registered namespace' | wc -l 2>/dev/null || echo 0)
-done
-
-echo "    Всего registered namespace событий в executor: $REGISTERED"
-if [ "$REGISTERED" -ge "$COUNT" ]; then
-    green "Executor зарегистрировал минимум $COUNT NS"
-else
-    # Не обязательно FAIL — NS могли быть уже зарегистрированы ранее
-    echo "  INFO: зарегистрировано $REGISTERED (некоторые NS могли существовать до теста)"
-    PASS=$((PASS+1))
-fi
-
-# ── Шаг 3: создаём Python функцию для каждого пользователя ───────────────────
-echo ""
-echo ">>> [3/4] Создаём функции для каждого пользователя параллельно..."
-
-# Простой Python код — не требует компиляции, деплоится мгновенно
-PYTHON_CODE='def main():
-    return "ok-'"${RUN_ID}"'"'
-
-json_escape() {
-    python3 -c 'import json,sys; print(json.dumps(sys.stdin.read()))'
-}
-
-for i in $(seq 1 $COUNT); do
-    USER="${USERS[$i]:-${RUN_ID}-user${i}@test.local}"
-    FN_NAME="testfn-${RUN_ID}"
-    (
-        # Создаём функцию
-        CREATE=$(curl -s -w "\n%{http_code}" --max-time 60 \
-            -X POST "${BASE}/functions" \
-            -H "X-Test-Sub: ${USER}" \
-            -H "Content-Type: application/json" \
-            -d "{\"name\":\"${FN_NAME}\",\"language\":\"python\",\"code\":$(printf '%s' \"${PYTHON_CODE}\" | json_escape)}" \
-            2>/dev/null)
-        CODE=$(echo "$CREATE" | tail -1)
-        echo "$i:$CODE" > "${TMPDIR_RESULTS}/create-${i}"
-    ) &
-done
-wait
-
-CREATE_OK=0; CREATE_FAIL=0
-for i in $(seq 1 $COUNT); do
-    R=$(cat "${TMPDIR_RESULTS}/create-${i}" 2>/dev/null || echo "$i:000")
-    CODE=$(echo "$R" | cut -d: -f2)
-    if [ "$CODE" = "200" ] || [ "$CODE" = "201" ]; then
-        CREATE_OK=$((CREATE_OK+1))
-    else
-        CREATE_FAIL=$((CREATE_FAIL+1))
-        echo "    user${i}: create HTTP $CODE"
-    fi
-done
-
-if [ $CREATE_FAIL -eq 0 ]; then
-    green "Все $COUNT функции созданы"
-else
-    red "$CREATE_FAIL / $COUNT функций не создались"
-fi
-
-# ── Шаг 4: вызываем все функции параллельно ──────────────────────────────────
-echo ""
-echo ">>> [4/4] Параллельные вызовы всех $COUNT функций..."
-
-# Ждём прогрева (первый вызов — cold start)
-sleep 5
-
-for i in $(seq 1 $COUNT); do
-    USER="${USERS[$i]:-${RUN_ID}-user${i}@test.local}"
-    FN_NAME="testfn-${RUN_ID}"
-    (
-        CODE=$(curl -s -o /dev/null -w "%{http_code}" --max-time 30 \
-            -X POST "${BASE}/functions/${FN_NAME}/invoke" \
-            -H "X-Test-Sub: ${USER}" \
-            -H "Content-Type: application/json" \
-            -d '{}' 2>/dev/null || echo 000)
-        echo "$i:$CODE" > "${TMPDIR_RESULTS}/invoke-${i}"
-    ) &
-done
-wait
-
-INVOKE_OK=0; INVOKE_FAIL=0
-for i in $(seq 1 $COUNT); do
-    R=$(cat "${TMPDIR_RESULTS}/invoke-${i}" 2>/dev/null || echo "$i:000")
-    CODE=$(echo "$R" | cut -d: -f2)
-    if [ "$CODE" = "200" ]; then
-        INVOKE_OK=$((INVOKE_OK+1))
-    else
-        INVOKE_FAIL=$((INVOKE_FAIL+1))
-        echo "    user${i}: invoke HTTP $CODE"
-    fi
-done
-
-if [ $INVOKE_FAIL -eq 0 ]; then
-    green "Все $COUNT функции отвечают HTTP 200 параллельно"
-else
-    red "$INVOKE_FAIL / $COUNT функций не ответили (возможно cold start — повторить тест)"
-fi
-
-# ── Итог ─────────────────────────────────────────────────────────────────────
-echo ""
-echo "========================================"
-echo "  ИТОГ: PASS=$PASS  FAIL=$FAIL"
-echo "========================================"
-[ $FAIL -eq 0 ] && exit 0 || exit 1

test_simple_function.sh

@@ -1,862 +0,0 @@
-#!/usr/bin/env bash
-# test_simple_function.sh — интеграционные тесты fission_simple_function
-# Запуск: bash test_simple_function.sh
-# Требования: terraform + kubectl в PATH, kubeconfig в ~/.kube/config
-set -uo pipefail
-
-PASS=0; FAIL=0; SKIP=0
-NAMESPACE="default"
-TESTDIR="/tmp/sless-sf-tests"
-KUBECONFIG_PATH="/home/naeel/.kube/config"
-PROVIDER_NS="default"
-
-# уникальный префикс — не пересекаемся с prod
-RUN_ID="sf$(date +%s | tail -c 6)"
-
-TF_PROVIDER='
-terraform {
-  required_providers {
-    fission = { source = "nail/fission" }
-  }
-}
-provider "fission" {
-  kubeconfig_path = "/home/naeel/.kube/config"
-  namespace       = "default"
-}
-'
-
-green() { echo -e "\033[32m$*\033[0m"; }
-red()   { echo -e "\033[31m$*\033[0m"; }
-yellow(){ echo -e "\033[33m$*\033[0m"; }
-
-pass() { PASS=$((PASS+1)); green "  PASS: $1"; }
-fail() { FAIL=$((FAIL+1)); red   "  FAIL: $1"; }
-skip() { SKIP=$((SKIP+1)); yellow "  SKIP: $1"; }
-
-# ── helpers ──────────────────────────────────────────────────────────────────
-
-kube_exists() {
-  local kind=$1 name=$2
-  kubectl get "${kind}" -n "${NAMESPACE}" "${name}" &>/dev/null
-}
-
-kube_gone() {
-  local kind=$1 name=$2
-  ! kubectl get "${kind}" -n "${NAMESPACE}" "${name}" &>/dev/null
-}
-
-tf_apply() {
-  local dir=$1
-  terraform -chdir="${dir}" apply -auto-approve -no-color 2>&1
-}
-
-tf_destroy() {
-  local dir=$1
-  terraform -chdir="${dir}" destroy -auto-approve -no-color 2>&1
-}
-
-tf_plan_exitcode() {
-  # 0=no-changes, 1=error, 2=changes
-  local dir=$1
-  terraform -chdir="${dir}" plan -detailed-exitcode -no-color 2>&1
-  echo $?
-}
-
-wait_package_ready() {
-  local name=$1 retries=30
-  for ((i=0; i<retries; i++)); do
-    local status
-    status=$(kubectl get packages.fission.io -n "${NAMESPACE}" "${name}" \
-      -o jsonpath='{.status.buildstatus}' 2>/dev/null || echo "")
-    # для literal packages buildstatus пустой — это нормально
-    [[ "$status" == "succeeded" || "$status" == "" ]] && return 0
-    sleep 2
-  done
-  return 1
-}
-
-# ── setup / teardown ─────────────────────────────────────────────────────────
-
-setup_workdir() {
-  local name=$1
-  local dir="${TESTDIR}/${name}"
-  rm -rf "${dir}"
-  mkdir -p "${dir}"
-  echo "${dir}"
-}
-
-write_provider() {
-  local dir=$1
-  cat > "${dir}/main.tf" <<EOF
-${TF_PROVIDER}
-EOF
-}
-
-# ── code fixtures ─────────────────────────────────────────────────────────────
-
-write_js_v1() {
-  local dir=$1
-  mkdir -p "${dir}"
-  cat > "${dir}/main.js" <<'EOF'
-exports.handler = async (ctx) => ({
-  body: JSON.stringify({ msg: "hello-v1", ts: Date.now() }),
-  headers: { "Content-Type": "application/json" },
-});
-EOF
-}
-
-write_js_v2() {
-  local dir=$1
-  mkdir -p "${dir}"
-  cat > "${dir}/main.js" <<'EOF'
-exports.handler = async (ctx) => ({
-  body: JSON.stringify({ msg: "hello-v2-updated", ts: Date.now() }),
-  headers: { "Content-Type": "application/json" },
-});
-EOF
-}
-
-write_python() {
-  local dir=$1
-  mkdir -p "${dir}"
-  cat > "${dir}/main.py" <<'EOF'
-def main():
-    return {"status": 200, "body": '{"msg":"hello-python"}'}
-EOF
-}
-
-write_ruby() {
-  local dir=$1
-  mkdir -p "${dir}"
-  cat > "${dir}/main.rb" <<'EOF'
-def main(ctx)
-  { body: "hello-ruby", status_code: 200 }
-end
-EOF
-}
-
-write_php() {
-  local dir=$1
-  mkdir -p "${dir}"
-  cat > "${dir}/main.php" <<'EOF'
-<?php
-function main($context) {
-    return ["body" => "hello-php"];
-}
-EOF
-}
-
-write_perl() {
-  local dir=$1
-  mkdir -p "${dir}"
-  cat > "${dir}/main.pl" <<'EOF'
-sub main {
-    my ($context) = @_;
-    return { body => "hello-perl" };
-}
-1;
-EOF
-}
-
-write_go() {
-  local dir=$1
-  mkdir -p "${dir}"
-  cat > "${dir}/handler.go" <<'EOF'
-package main
-
-import (
-    "encoding/json"
-    "net/http"
-)
-
-func Handler(w http.ResponseWriter, r *http.Request) {
-    w.Header().Set("Content-Type", "application/json")
-    json.NewEncoder(w).Encode(map[string]string{"msg": "hello-go"})
-}
-EOF
-  cat > "${dir}/go.mod" <<'EOF'
-module fn
-
-go 1.21
-EOF
-}
-
-# ─────────────────────────────────────────────────────────────────────────────
-echo ""
-echo "================================================================"
-echo "  fission_simple_function — интеграционные тесты"
-echo "  Run ID: ${RUN_ID}"
-echo "================================================================"
-mkdir -p "${TESTDIR}"
-
-# ════════════════════════════════════════════════════════════════════════
-echo ""
-echo ">>> T01: nodejs — create с HTTPTrigger, verify k8s, destroy"
-# ════════════════════════════════════════════════════════════════════════
-T01="${RUN_ID}-node-basic"
-D=$(setup_workdir "t01")
-write_provider "${D}"
-write_js_v1 "${D}/code"
-cat >> "${D}/main.tf" <<EOF
-resource "fission_simple_function" "fn" {
-  name     = "${T01}"
-  runtime  = "nodejs"
-  code_dir = "\${path.module}/code"
-  url      = "/test/${T01}"
-  methods  = ["GET"]
-}
-EOF
-
-OUT=$(tf_apply "${D}")
-if echo "${OUT}" | grep -q "Apply complete"; then
-  pass "T01: terraform apply OK"
-else
-  fail "T01: terraform apply FAILED"
-  echo "${OUT}" | tail -20
-fi
-
-kube_exists "functions.fission.io" "${T01}" \
-  && pass "T01: Function создана в k8s" || fail "T01: Function не найдена в k8s"
-kube_exists "packages.fission.io" "${T01}-pkg" \
-  && pass "T01: Package создан в k8s"   || fail "T01: Package не найден в k8s"
-kube_exists "httptriggers.fission.io" "${T01}-trigger" \
-  && pass "T01: HTTPTrigger создан в k8s" || fail "T01: HTTPTrigger не найден в k8s"
-kube_exists "environments.fission.io" "simple-nodejs-env" \
-  && pass "T01: Environment simple-nodejs-env создан" || fail "T01: Environment не найден"
-
-OUT=$(tf_destroy "${D}")
-echo "${OUT}" | grep -q "Destroy complete" \
-  && pass "T01: terraform destroy OK" || fail "T01: terraform destroy FAILED"
-
-kube_gone "functions.fission.io"    "${T01}"         && pass "T01: Function удалена после destroy" || fail "T01: Function осталась после destroy"
-kube_gone "packages.fission.io"     "${T01}-pkg"     && pass "T01: Package удалён после destroy"  || fail "T01: Package остался после destroy"
-kube_gone "httptriggers.fission.io" "${T01}-trigger" && pass "T01: Trigger удалён после destroy"  || fail "T01: Trigger остался после destroy"
-
-# ════════════════════════════════════════════════════════════════════════
-echo ""
-echo ">>> T02: python — create БЕЗ url (нет HTTPTrigger)"
-# ════════════════════════════════════════════════════════════════════════
-T02="${RUN_ID}-py-notrigger"
-D=$(setup_workdir "t02")
-write_provider "${D}"
-write_python "${D}/code"
-cat >> "${D}/main.tf" <<EOF
-resource "fission_simple_function" "fn" {
-  name     = "${T02}"
-  runtime  = "python"
-  code_dir = "\${path.module}/code"
-}
-EOF
-
-tf_apply "${D}" | grep -q "Apply complete" \
-  && pass "T02: apply OK" || fail "T02: apply FAILED"
-kube_exists "functions.fission.io"  "${T02}"     && pass "T02: Function создана" || fail "T02: Function не найдена"
-kube_exists "packages.fission.io"   "${T02}-pkg" && pass "T02: Package создан"   || fail "T02: Package не найден"
-kube_gone   "httptriggers.fission.io" "${T02}-trigger" \
-  && pass "T02: HTTPTrigger НЕ создан (url не задан)" || fail "T02: HTTPTrigger создан — не должен был"
-kube_exists "environments.fission.io" "simple-python-env" \
-  && pass "T02: Environment simple-python-env создан" || fail "T02: Environment не найден"
-
-tf_destroy "${D}" | grep -q "Destroy complete" && pass "T02: destroy OK" || fail "T02: destroy FAILED"
-kube_gone "functions.fission.io" "${T02}" && pass "T02: Function удалена" || fail "T02: Function осталась"
-
-# ════════════════════════════════════════════════════════════════════════
-echo ""
-echo ">>> T03: go — source pipeline, create с URL"
-# ════════════════════════════════════════════════════════════════════════
-T03="${RUN_ID}-go-basic"
-D=$(setup_workdir "t03")
-write_provider "${D}"
-write_go "${D}/code"
-cat >> "${D}/main.tf" <<EOF
-resource "fission_simple_function" "fn" {
-  name     = "${T03}"
-  runtime  = "go"
-  code_dir = "\${path.module}/code"
-  url      = "/test/${T03}"
-  methods  = ["GET", "POST"]
-}
-EOF
-
-tf_apply "${D}" | grep -q "Apply complete" \
-  && pass "T03: go apply OK" || fail "T03: go apply FAILED"
-kube_exists "functions.fission.io"    "${T03}"         && pass "T03: Function создана"  || fail "T03: Function не найдена"
-kube_exists "packages.fission.io"     "${T03}-pkg"     && pass "T03: Package создан"    || fail "T03: Package не найден"
-kube_exists "httptriggers.fission.io" "${T03}-trigger" && pass "T03: Trigger создан"    || fail "T03: Trigger не найден"
-kube_exists "environments.fission.io" "simple-go-env"  && pass "T03: simple-go-env OK"  || fail "T03: simple-go-env не найден"
-
-# Проверяем что Package имеет source (не deployment)
-PKG_SOURCE=$(kubectl get packages.fission.io -n "${NAMESPACE}" "${T03}-pkg" \
-  -o jsonpath='{.spec.source.type}' 2>/dev/null || echo "")
-[ "${PKG_SOURCE}" = "literal" ] \
-  && pass "T03: Package.spec.source.type=literal (source deploy)" \
-  || fail "T03: Package.spec.source.type='${PKG_SOURCE}' (ожидалось literal)"
-
-tf_destroy "${D}" | grep -q "Destroy complete" && pass "T03: destroy OK" || fail "T03: destroy FAILED"
-kube_gone "functions.fission.io" "${T03}" && pass "T03: Function удалена" || fail "T03: Function осталась"
-
-# ════════════════════════════════════════════════════════════════════════
-echo ""
-echo ">>> T04: ruby — create с URL"
-# ════════════════════════════════════════════════════════════════════════
-T04="${RUN_ID}-ruby"
-D=$(setup_workdir "t04")
-write_provider "${D}"
-write_ruby "${D}/code"
-cat >> "${D}/main.tf" <<EOF
-resource "fission_simple_function" "fn" {
-  name     = "${T04}"
-  runtime  = "ruby"
-  code_dir = "\${path.module}/code"
-  url      = "/test/${T04}"
-  methods  = ["GET"]
-}
-EOF
-
-tf_apply "${D}" | grep -q "Apply complete" \
-  && pass "T04: ruby apply OK" || fail "T04: ruby apply FAILED"
-kube_exists "environments.fission.io" "simple-ruby-env" \
-  && pass "T04: simple-ruby-env создан" || fail "T04: simple-ruby-env не найден"
-kube_exists "httptriggers.fission.io" "${T04}-trigger" \
-  && pass "T04: Trigger создан" || fail "T04: Trigger не найден"
-tf_destroy "${D}" | grep -q "Destroy complete" && pass "T04: destroy OK" || fail "T04: destroy FAILED"
-
-# ════════════════════════════════════════════════════════════════════════
-echo ""
-echo ">>> T05: php — create с URL"
-# ════════════════════════════════════════════════════════════════════════
-T05="${RUN_ID}-php"
-D=$(setup_workdir "t05")
-write_provider "${D}"
-write_php "${D}/code"
-cat >> "${D}/main.tf" <<EOF
-resource "fission_simple_function" "fn" {
-  name     = "${T05}"
-  runtime  = "php"
-  code_dir = "\${path.module}/code"
-  url      = "/test/${T05}"
-  methods  = ["GET"]
-}
-EOF
-
-tf_apply "${D}" | grep -q "Apply complete" \
-  && pass "T05: php apply OK" || fail "T05: php apply FAILED"
-kube_exists "environments.fission.io" "simple-php-env" \
-  && pass "T05: simple-php-env создан" || fail "T05: simple-php-env не найден"
-kube_exists "functions.fission.io" "${T05}" \
-  && pass "T05: Function создана" || fail "T05: Function не найдена"
-tf_destroy "${D}" | grep -q "Destroy complete" && pass "T05: destroy OK" || fail "T05: destroy FAILED"
-
-# ════════════════════════════════════════════════════════════════════════
-echo ""
-echo ">>> T06: perl — create с URL"
-# ════════════════════════════════════════════════════════════════════════
-T06="${RUN_ID}-perl"
-D=$(setup_workdir "t06")
-write_provider "${D}"
-write_perl "${D}/code"
-cat >> "${D}/main.tf" <<EOF
-resource "fission_simple_function" "fn" {
-  name     = "${T06}"
-  runtime  = "perl"
-  code_dir = "\${path.module}/code"
-  url      = "/test/${T06}"
-  methods  = ["GET"]
-}
-EOF
-
-tf_apply "${D}" | grep -q "Apply complete" \
-  && pass "T06: perl apply OK" || fail "T06: perl apply FAILED"
-kube_exists "environments.fission.io" "simple-perl-env" \
-  && pass "T06: simple-perl-env создан" || fail "T06: simple-perl-env не найден"
-kube_exists "functions.fission.io" "${T06}" \
-  && pass "T06: Function создана" || fail "T06: Function не найдена"
-tf_destroy "${D}" | grep -q "Destroy complete" && pass "T06: destroy OK" || fail "T06: destroy FAILED"
-
-# ════════════════════════════════════════════════════════════════════════
-echo ""
-echo ">>> T07: code_hash drift detection — update пересчитывает хеш и обновляет Package"
-# ════════════════════════════════════════════════════════════════════════
-T07="${RUN_ID}-drift"
-D=$(setup_workdir "t07")
-write_provider "${D}"
-write_js_v1 "${D}/code"
-cat >> "${D}/main.tf" <<EOF
-resource "fission_simple_function" "fn" {
-  name     = "${T07}"
-  runtime  = "nodejs"
-  code_dir = "\${path.module}/code"
-}
-EOF
-
-tf_apply "${D}" | grep -q "Apply complete" && pass "T07: apply v1 OK" || fail "T07: apply v1 FAILED"
-
-HASH1=$(terraform -chdir="${D}" show -json 2>/dev/null \
-  | python3 -c "import sys,json; r=json.load(sys.stdin)['values']['root_module']['resources']; print(r[0]['values']['code_hash'])" 2>/dev/null || echo "?")
-
-# Обновляем код (v2)
-write_js_v2 "${D}/code"
-
-OUT=$(tf_apply "${D}")
-echo "${OUT}" | grep -q "Apply complete" && pass "T07: apply v2 OK" || fail "T07: apply v2 FAILED"
-
-HASH2=$(terraform -chdir="${D}" show -json 2>/dev/null \
-  | python3 -c "import sys,json; r=json.load(sys.stdin)['values']['root_module']['resources']; print(r[0]['values']['code_hash'])" 2>/dev/null || echo "?")
-
-[ "${HASH1}" != "${HASH2}" ] && [ "${HASH1}" != "?" ] && [ "${HASH2}" != "?" ] \
-  && pass "T07: code_hash изменился (${HASH1:0:8}… → ${HASH2:0:8}…)" \
-  || fail "T07: code_hash не изменился или не читается (h1=${HASH1:0:8}, h2=${HASH2:0:8})"
-
-echo "${OUT}" | grep -qE "fission_simple_function.fn.*updated|updated.*fission_simple_function.fn" \
-  && pass "T07: Package был обновлён (update in apply output)" \
-  || { echo "${OUT}" | grep -q "1 updated" && pass "T07: 1 ресурс обновлён" || fail "T07: Обновление не обнаружено в output"; }
-
-tf_destroy "${D}" | grep -q "Destroy complete" && pass "T07: destroy OK" || fail "T07: destroy FAILED"
-
-# ════════════════════════════════════════════════════════════════════════
-echo ""
-echo ">>> T08: добавление url (update — создание Trigger)"
-# ════════════════════════════════════════════════════════════════════════
-T08="${RUN_ID}-addurl"
-D=$(setup_workdir "t08")
-write_provider "${D}"
-write_js_v1 "${D}/code"
-
-# Apply без url
-cat > "${D}/main.tf" <<EOF
-${TF_PROVIDER}
-resource "fission_simple_function" "fn" {
-  name     = "${T08}"
-  runtime  = "nodejs"
-  code_dir = "\${path.module}/code"
-}
-EOF
-
-tf_apply "${D}" | grep -q "Apply complete" && pass "T08: apply (no url) OK" || fail "T08: apply (no url) FAILED"
-kube_gone "httptriggers.fission.io" "${T08}-trigger" \
-  && pass "T08: Trigger не создан (нет url)" || fail "T08: Trigger создан без url"
-
-# Добавляем url
-cat > "${D}/main.tf" <<EOF
-${TF_PROVIDER}
-resource "fission_simple_function" "fn" {
-  name     = "${T08}"
-  runtime  = "nodejs"
-  code_dir = "\${path.module}/code"
-  url      = "/test/${T08}"
-  methods  = ["GET", "POST"]
-}
-EOF
-
-tf_apply "${D}" | grep -q "Apply complete" && pass "T08: apply (with url) OK" || fail "T08: apply (with url) FAILED"
-kube_exists "httptriggers.fission.io" "${T08}-trigger" \
-  && pass "T08: Trigger создан после добавления url" || fail "T08: Trigger не создан после update"
-
-tf_destroy "${D}" | grep -q "Destroy complete" && pass "T08: destroy OK" || fail "T08: destroy FAILED"
-kube_gone "httptriggers.fission.io" "${T08}-trigger" \
-  && pass "T08: Trigger удалён при destroy" || fail "T08: Trigger остался"
-
-# ════════════════════════════════════════════════════════════════════════
-echo ""
-echo ">>> T09: удаление url (update — удаление Trigger)"
-# ════════════════════════════════════════════════════════════════════════
-T09="${RUN_ID}-rmurl"
-D=$(setup_workdir "t09")
-write_provider "${D}"
-write_js_v1 "${D}/code"
-
-# Apply с url
-cat > "${D}/main.tf" <<EOF
-${TF_PROVIDER}
-resource "fission_simple_function" "fn" {
-  name     = "${T09}"
-  runtime  = "nodejs"
-  code_dir = "\${path.module}/code"
-  url      = "/test/${T09}"
-  methods  = ["GET"]
-}
-EOF
-
-tf_apply "${D}" | grep -q "Apply complete" && pass "T09: apply (with url) OK" || fail "T09: apply (with url) FAILED"
-kube_exists "httptriggers.fission.io" "${T09}-trigger" \
-  && pass "T09: Trigger создан"  || fail "T09: Trigger не создан"
-
-# Убираем url
-cat > "${D}/main.tf" <<EOF
-${TF_PROVIDER}
-resource "fission_simple_function" "fn" {
-  name     = "${T09}"
-  runtime  = "nodejs"
-  code_dir = "\${path.module}/code"
-}
-EOF
-
-tf_apply "${D}" | grep -q "Apply complete" && pass "T09: apply (url removed) OK" || fail "T09: apply (url removed) FAILED"
-kube_gone "httptriggers.fission.io" "${T09}-trigger" \
-  && pass "T09: Trigger удалён после убирания url" || fail "T09: Trigger остался после убирания url"
-
-tf_destroy "${D}" | grep -q "Destroy complete" && pass "T09: destroy OK" || fail "T09: destroy FAILED"
-
-# ════════════════════════════════════════════════════════════════════════
-echo ""
-echo ">>> T10: изменение url (update Trigger)"
-# ════════════════════════════════════════════════════════════════════════
-T10="${RUN_ID}-churl"
-D=$(setup_workdir "t10")
-write_provider "${D}"
-write_js_v1 "${D}/code"
-
-cat > "${D}/main.tf" <<EOF
-${TF_PROVIDER}
-resource "fission_simple_function" "fn" {
-  name     = "${T10}"
-  runtime  = "nodejs"
-  code_dir = "\${path.module}/code"
-  url      = "/test/${T10}/v1"
-  methods  = ["GET"]
-}
-EOF
-
-tf_apply "${D}" | grep -q "Apply complete" && pass "T10: apply v1 url OK" || fail "T10: apply v1 url FAILED"
-
-URL_BEFORE=$(kubectl get httptriggers.fission.io -n "${NAMESPACE}" "${T10}-trigger" \
-  -o jsonpath='{.spec.relativeurl}' 2>/dev/null || echo "?")
-
-cat > "${D}/main.tf" <<EOF
-${TF_PROVIDER}
-resource "fission_simple_function" "fn" {
-  name     = "${T10}"
-  runtime  = "nodejs"
-  code_dir = "\${path.module}/code"
-  url      = "/test/${T10}/v2"
-  methods  = ["GET", "PUT"]
-}
-EOF
-
-tf_apply "${D}" | grep -q "Apply complete" && pass "T10: apply v2 url OK" || fail "T10: apply v2 url FAILED"
-
-URL_AFTER=$(kubectl get httptriggers.fission.io -n "${NAMESPACE}" "${T10}-trigger" \
-  -o jsonpath='{.spec.relativeurl}' 2>/dev/null || echo "?")
-
-[ "${URL_BEFORE}" = "/test/${T10}/v1" ] && [ "${URL_AFTER}" = "/test/${T10}/v2" ] \
-  && pass "T10: URL обновлён (/v1 → /v2)" \
-  || fail "T10: URL не обновлён (before='${URL_BEFORE}', after='${URL_AFTER}')"
-
-tf_destroy "${D}" | grep -q "Destroy complete" && pass "T10: destroy OK" || fail "T10: destroy FAILED"
-
-# ════════════════════════════════════════════════════════════════════════
-echo ""
-echo ">>> T11: plan без изменений → 0 changes"
-# ════════════════════════════════════════════════════════════════════════
-T11="${RUN_ID}-nochange"
-D=$(setup_workdir "t11")
-write_provider "${D}"
-write_js_v1 "${D}/code"
-cat >> "${D}/main.tf" <<EOF
-resource "fission_simple_function" "fn" {
-  name     = "${T11}"
-  runtime  = "nodejs"
-  code_dir = "\${path.module}/code"
-  url      = "/test/${T11}"
-  methods  = ["GET"]
-}
-EOF
-
-tf_apply "${D}" | grep -q "Apply complete" && pass "T11: initial apply OK" || fail "T11: initial apply FAILED"
-
-PLAN_OUT=$(terraform -chdir="${D}" plan -no-color 2>&1)
-echo "${PLAN_OUT}" | grep -qE "No changes|0 to add, 0 to change, 0 to destroy" \
-  && pass "T11: повторный plan показывает 0 changes" \
-  || fail "T11: повторный plan показывает изменения (не idempotent)"
-
-tf_destroy "${D}" | grep -q "Destroy complete" && pass "T11: destroy OK" || fail "T11: destroy FAILED"
-
-# ════════════════════════════════════════════════════════════════════════
-echo ""
-echo ">>> T12: auto-env idempotency — два ресурса делят один environment"
-# ════════════════════════════════════════════════════════════════════════
-T12A="${RUN_ID}-shared-a"
-T12B="${RUN_ID}-shared-b"
-D=$(setup_workdir "t12")
-write_provider "${D}"
-write_js_v1 "${D}/code-a"
-write_js_v1 "${D}/code-b"
-cat >> "${D}/main.tf" <<EOF
-resource "fission_simple_function" "fn_a" {
-  name     = "${T12A}"
-  runtime  = "nodejs"
-  code_dir = "\${path.module}/code-a"
-}
-resource "fission_simple_function" "fn_b" {
-  name     = "${T12B}"
-  runtime  = "nodejs"
-  code_dir = "\${path.module}/code-b"
-}
-EOF
-
-tf_apply "${D}" | grep -q "Apply complete" && pass "T12: apply двух функций OK" || fail "T12: apply двух функций FAILED"
-kube_exists "functions.fission.io" "${T12A}" && pass "T12: fn_a создана" || fail "T12: fn_a не создана"
-kube_exists "functions.fission.io" "${T12B}" && pass "T12: fn_b создана" || fail "T12: fn_b не создана"
-
-# Environment должен быть один (один simple-nodejs-env)
-ENV_COUNT=$(kubectl get environments.fission.io -n "${NAMESPACE}" -o name 2>/dev/null \
-  | grep -c "simple-nodejs-env" || echo "0")
-[ "${ENV_COUNT}" -eq 1 ] \
-  && pass "T12: ровно 1 экземпляр simple-nodejs-env (shared)" \
-  || fail "T12: ENV_COUNT=${ENV_COUNT} (ожидалось 1)"
-
-tf_destroy "${D}" | grep -q "Destroy complete" && pass "T12: destroy OK" || fail "T12: destroy FAILED"
-kube_gone "functions.fission.io" "${T12A}" && pass "T12: fn_a удалена" || fail "T12: fn_a осталась"
-kube_gone "functions.fission.io" "${T12B}" && pass "T12: fn_b удалена" || fail "T12: fn_b осталась"
-
-# ════════════════════════════════════════════════════════════════════════
-echo ""
-echo ">>> T13: невалидный runtime → apply завершается ошибкой"
-# ════════════════════════════════════════════════════════════════════════
-T13="${RUN_ID}-badruntime"
-D=$(setup_workdir "t13")
-write_provider "${D}"
-write_js_v1 "${D}/code"
-cat >> "${D}/main.tf" <<EOF
-resource "fission_simple_function" "fn" {
-  name     = "${T13}"
-  runtime  = "cobol"
-  code_dir = "\${path.module}/code"
-}
-EOF
-
-OUT=$(tf_apply "${D}" 2>&1 || true)
-echo "${OUT}" | grep -qiE "Error|error|cobol|неподдерживаемый|unsupported" \
-  && pass "T13: apply с runtime=cobol выдал ошибку" \
-  || fail "T13: apply не выдал ошибку для runtime=cobol"
-kube_gone "functions.fission.io" "${T13}" \
-  && pass "T13: Function не создана" || fail "T13: Function создана для плохого runtime"
-
-# ════════════════════════════════════════════════════════════════════════
-echo ""
-echo ">>> T14: terraform import (namespace/name)"
-# ════════════════════════════════════════════════════════════════════════
-T14="${RUN_ID}-import"
-D=$(setup_workdir "t14")
-write_provider "${D}"
-write_js_v1 "${D}/code"
-cat >> "${D}/main.tf" <<EOF
-resource "fission_simple_function" "fn" {
-  name     = "${T14}"
-  runtime  = "nodejs"
-  code_dir = "\${path.module}/code"
-  url      = "/test/${T14}"
-  methods  = ["GET"]
-}
-EOF
-
-# Создаём через apply
-tf_apply "${D}" | grep -q "Apply complete" && pass "T14: initial apply OK" || fail "T14: initial apply FAILED"
-
-# Удаляем state, импортируем обратно
-terraform -chdir="${D}" state rm fission_simple_function.fn &>/dev/null || true
-IMP_OUT=$(terraform -chdir="${D}" import -no-color \
-  fission_simple_function.fn "default/${T14}" 2>&1)
-echo "${IMP_OUT}" | grep -qiE "Import successful|import" \
-  && pass "T14: import выполнен" || fail "T14: import не прошёл: $(echo "${IMP_OUT}" | tail -5)"
-
-# Plan после import должен показать изменения (code_dir/hash не в k8s state)
-# — это нормально, просто убеждаемся что plan не падает с ошибкой
-PLAN_OUT=$(terraform -chdir="${D}" plan -no-color 2>&1)
-echo $? | grep -qE "^[012]$" && pass "T14: plan после import не падает" || fail "T14: plan после import упал"
-
-tf_destroy "${D}" | grep -q "Destroy complete" && pass "T14: destroy OK" || fail "T14: destroy FAILED"
-
-# ════════════════════════════════════════════════════════════════════════
-echo ""
-echo ">>> T15: nodejs — методы по умолчанию [GET]"
-# ════════════════════════════════════════════════════════════════════════
-T15="${RUN_ID}-defmethods"
-D=$(setup_workdir "t15")
-write_provider "${D}"
-write_js_v1 "${D}/code"
-cat >> "${D}/main.tf" <<EOF
-resource "fission_simple_function" "fn" {
-  name     = "${T15}"
-  runtime  = "nodejs"
-  code_dir = "\${path.module}/code"
-  url      = "/test/${T15}"
-}
-EOF
-
-tf_apply "${D}" | grep -q "Apply complete" && pass "T15: apply (no methods) OK" || fail "T15: apply FAILED"
-
-METHODS=$(kubectl get httptriggers.fission.io -n "${NAMESPACE}" "${T15}-trigger" \
-  -o jsonpath='{.spec.methods[*]}' 2>/dev/null || echo "?")
-echo "${METHODS}" | grep -q "GET" \
-  && pass "T15: default method=GET в k8s: '${METHODS}'" \
-  || fail "T15: методы не GET: '${METHODS}'"
-
-tf_destroy "${D}" | grep -q "Destroy complete" && pass "T15: destroy OK" || fail "T15: destroy FAILED"
-
-# ════════════════════════════════════════════════════════════════════════
-echo ""
-echo ">>> T16: Package.spec для nodejs — deployment (не source)"
-# ════════════════════════════════════════════════════════════════════════
-T16="${RUN_ID}-nodepkg"
-D=$(setup_workdir "t16")
-write_provider "${D}"
-write_js_v1 "${D}/code"
-cat >> "${D}/main.tf" <<EOF
-resource "fission_simple_function" "fn" {
-  name     = "${T16}"
-  runtime  = "nodejs"
-  code_dir = "\${path.module}/code"
-}
-EOF
-
-tf_apply "${D}" | grep -q "Apply complete" && pass "T16: apply OK" || fail "T16: apply FAILED"
-
-SRC=$(kubectl get packages.fission.io -n "${NAMESPACE}" "${T16}-pkg" \
-  -o jsonpath='{.spec.source.type}' 2>/dev/null || echo "")
-DEP=$(kubectl get packages.fission.io -n "${NAMESPACE}" "${T16}-pkg" \
-  -o jsonpath='{.spec.deployment.type}' 2>/dev/null || echo "")
-[ -z "${SRC}" ] && [ "${DEP}" = "literal" ] \
-  && pass "T16: nodejs Package использует deployment.literal (не source)" \
-  || fail "T16: pkg spec — source.type='${SRC}', deployment.type='${DEP}'"
-
-tf_destroy "${D}" | grep -q "Destroy complete" && pass "T16: destroy OK" || fail "T16: destroy FAILED"
-
-# ════════════════════════════════════════════════════════════════════════
-echo ""
-echo ">>> T17: namespace вычисляется из провайдера"
-# ════════════════════════════════════════════════════════════════════════
-T17="${RUN_ID}-ns"
-D=$(setup_workdir "t17")
-write_js_v1 "${D}/code"
-# Провайдер без явного namespace в ресурсе
-cat > "${D}/main.tf" <<EOF
-${TF_PROVIDER}
-resource "fission_simple_function" "fn" {
-  name     = "${T17}"
-  runtime  = "nodejs"
-  code_dir = "\${path.module}/code"
-}
-EOF
-
-tf_apply "${D}" | grep -q "Apply complete" && pass "T17: apply OK" || fail "T17: apply FAILED"
-
-NS=$(terraform -chdir="${D}" show -json 2>/dev/null \
-  | python3 -c "import sys,json; r=json.load(sys.stdin)['values']['root_module']['resources']; print(r[0]['values']['namespace'])" 2>/dev/null || echo "?")
-[ "${NS}" = "default" ] \
-  && pass "T17: namespace=default из провайдера (state: ${NS})" \
-  || fail "T17: namespace='${NS}' (ожидалось 'default')"
-
-tf_destroy "${D}" | grep -q "Destroy complete" && pass "T17: destroy OK" || fail "T17: destroy FAILED"
-
-# ════════════════════════════════════════════════════════════════════════
-echo ""
-echo ">>> T18: computed поля environment_name/package_name/trigger_name в state"
-# ════════════════════════════════════════════════════════════════════════
-T18="${RUN_ID}-computed"
-D=$(setup_workdir "t18")
-write_provider "${D}"
-write_js_v1 "${D}/code"
-cat >> "${D}/main.tf" <<EOF
-resource "fission_simple_function" "fn" {
-  name     = "${T18}"
-  runtime  = "nodejs"
-  code_dir = "\${path.module}/code"
-  url      = "/test/${T18}"
-  methods  = ["GET"]
-}
-EOF
-
-tf_apply "${D}" | grep -q "Apply complete" && pass "T18: apply OK" || fail "T18: apply FAILED"
-
-SHOW=$(terraform -chdir="${D}" show -json 2>/dev/null \
-  | python3 -c "
-import sys, json
-r = json.load(sys.stdin)['values']['root_module']['resources'][0]['values']
-print(r.get('environment_name','?'))
-print(r.get('package_name','?'))
-print(r.get('trigger_name','?'))
-print(r.get('code_hash','?'))
-" 2>/dev/null || echo "?
-?
-?
-?")
-
-ENV_NAME=$(echo "${SHOW}" | sed -n '1p')
-PKG_NAME=$(echo "${SHOW}" | sed -n '2p')
-TRG_NAME=$(echo "${SHOW}" | sed -n '3p')
-HASH_VAL=$(echo "${SHOW}" | sed -n '4p')
-
-[ "${ENV_NAME}" = "simple-nodejs-env" ] && pass "T18: environment_name='${ENV_NAME}'" || fail "T18: environment_name='${ENV_NAME}'"
-[ "${PKG_NAME}" = "${T18}-pkg" ]        && pass "T18: package_name='${PKG_NAME}'"     || fail "T18: package_name='${PKG_NAME}'"
-[ "${TRG_NAME}" = "${T18}-trigger" ]    && pass "T18: trigger_name='${TRG_NAME}'"     || fail "T18: trigger_name='${TRG_NAME}'"
-[[ "${HASH_VAL}" =~ ^[0-9a-f]{64}$ ]]  && pass "T18: code_hash выглядит как sha256" || fail "T18: code_hash='${HASH_VAL}'"
-
-tf_destroy "${D}" | grep -q "Destroy complete" && pass "T18: destroy OK" || fail "T18: destroy FAILED"
-
-# ════════════════════════════════════════════════════════════════════════
-echo ""
-echo ">>> T19: повторный apply одного ресурса — idempotency (no drift)"
-# ════════════════════════════════════════════════════════════════════════
-T19="${RUN_ID}-idem"
-D=$(setup_workdir "t19")
-write_provider "${D}"
-write_js_v1 "${D}/code"
-cat >> "${D}/main.tf" <<EOF
-resource "fission_simple_function" "fn" {
-  name     = "${T19}"
-  runtime  = "nodejs"
-  code_dir = "\${path.module}/code"
-  url      = "/test/${T19}"
-  methods  = ["GET", "POST"]
-}
-EOF
-
-tf_apply "${D}" | grep -q "Apply complete" && pass "T19: первый apply OK" || fail "T19: первый apply FAILED"
-
-OUT2=$(tf_apply "${D}")
-echo "${OUT2}" | grep -qE "Apply complete.*0 added, 0 changed, 0 destroyed" \
-  && pass "T19: второй apply — 0 changes (idempotent)" \
-  || fail "T19: второй apply не idempotent: $(echo "${OUT2}" | grep -E 'added|changed|destroyed' | tail -2)"
-
-tf_destroy "${D}" | grep -q "Destroy complete" && pass "T19: destroy OK" || fail "T19: destroy FAILED"
-
-# ════════════════════════════════════════════════════════════════════════
-echo ""
-echo ">>> T20: destroy без trigger (url не задан) — нет паники"
-# ════════════════════════════════════════════════════════════════════════
-T20="${RUN_ID}-notrig-del"
-D=$(setup_workdir "t20")
-write_provider "${D}"
-write_python "${D}/code"
-cat >> "${D}/main.tf" <<EOF
-resource "fission_simple_function" "fn" {
-  name     = "${T20}"
-  runtime  = "python"
-  code_dir = "\${path.module}/code"
-}
-EOF
-
-tf_apply "${D}" | grep -q "Apply complete" && pass "T20: apply OK" || fail "T20: apply FAILED"
-OUT=$(tf_destroy "${D}")
-echo "${OUT}" | grep -q "Destroy complete" \
-  && pass "T20: destroy OK (нет паники без trigger)" \
-  || fail "T20: destroy FAILED"
-echo "${OUT}" | grep -qi "panic\|nil pointer" \
-  && fail "T20: PANIC в destroy!" || pass "T20: нет паники при destroy"
-
-# ─────────────────────────────────────────────────────────────────────────────
-echo ""
-echo "================================================================"
-if [ "${FAIL}" -eq 0 ]; then
-  green "  ИТОГ: PASS=${PASS}  FAIL=${FAIL}  SKIP=${SKIP}  — ВСЕ ТЕСТЫ ПРОШЛИ"
-else
-  red   "  ИТОГ: PASS=${PASS}  FAIL=${FAIL}  SKIP=${SKIP}  — ЕСТЬ ПРОВАЛЫ"
-fi
-echo "================================================================"
-echo ""
-
-# Очистка temp dirs
-rm -rf "${TESTDIR}"
-
-[ "${FAIL}" -eq 0 ]

test_ui_user_flows.sh

@@ -1,326 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-
-BASE="https://fission.kube5s.ru/console/api"
-ROOT_DIR=$(cd "$(dirname "$0")" && pwd)
-NS_CLEANUP_SCRIPT="${ROOT_DIR}/cleanup_test_namespaces.sh"
-RUN_ID="ui$(date +%s | tail -c 6)"
-PASS=0
-FAIL=0
-
-LOGIN_SUB="ui-login-${RUN_ID}@test.local"
-LANG_SUB="ui-lang-${RUN_ID}@test.local"
-NODE_SUB="ui-node-${RUN_ID}@test.local"
-STACK_SUB="ui-stack-${RUN_ID}@test.local"
-NEG_SUB="ui-neg-${RUN_ID}@test.local"
-
-pass() { PASS=$((PASS+1)); echo "  PASS: $1"; }
-fail() { FAIL=$((FAIL+1)); echo "  FAIL: $1"; }
-
-json_quote() {
-  python3 -c 'import json,sys; print(json.dumps(sys.argv[1]))' "$1"
-}
-
-json_field() {
-  local payload="$1"
-  local key="$2"
-  printf '%s' "$payload" | python3 -c 'import json,sys
-key=sys.argv[1]
-try:
-  data=json.load(sys.stdin)
-  value=data.get(key, "")
-  print(value if not isinstance(value, (dict,list)) else json.dumps(value))
-except Exception:
-  print("")' "$key"
-}
-
-cleanup_namespaces() {
-  if [ -x "$NS_CLEANUP_SCRIPT" ]; then
-    echo ""
-    echo ">>> Cleanup UI test namespaces..."
-    KUBECTL_DIRECT=1 "$NS_CLEANUP_SCRIPT" "$LOGIN_SUB" "$LANG_SUB" "$NODE_SUB" "$STACK_SUB" "$NEG_SUB" || true
-  fi
-}
-trap cleanup_namespaces EXIT
-
-auth_call() {
-  local token="$1"
-  local env_name="${2:-test}"
-  curl -s -w "\n%{http_code}" --max-time 45 -X POST "${BASE}/auth" \
-    -H 'Content-Type: application/json' \
-    -d "{\"token\":\"${token}\",\"env\":\"${env_name}\"}"
-}
-
-auth_get() {
-  local path="$1"
-  local token="$2"
-  local env_name="${3:-test}"
-  curl -s -w "\n%{http_code}" --max-time 45 "${BASE}${path}" \
-    -H "X-Auth-Token: ${token}" \
-    -H "X-Auth-Env: ${env_name}"
-}
-
-create_call() {
-  local sub="$1"
-  local body="$2"
-  curl -s -w "\n%{http_code}" --max-time 60 -X POST "${BASE}/functions" \
-    -H "X-Test-Sub: ${sub}" -H 'Content-Type: application/json' -d "$body"
-}
-
-invoke_call() {
-  local sub="$1"
-  local name="$2"
-  local body="${3:-{}}"
-  local out_file err_file http_code rc resp err_text
-  out_file=$(mktemp)
-  err_file=$(mktemp)
-  rc=0
-  http_code=$(curl -sS -o "$out_file" -w "%{http_code}" --max-time 60 -X POST "${BASE}/functions/${name}/invoke" \
-    -H "X-Test-Sub: ${sub}" -H 'Content-Type: application/json' -d "$body" 2>"$err_file") || rc=$?
-  resp=$(cat "$out_file" 2>/dev/null || true)
-  err_text=$(tr '\n' ' ' <"$err_file" | sed 's/[[:space:]]\+/ /g')
-  rm -f "$out_file" "$err_file"
-
-  if [ "$rc" -ne 0 ]; then
-    printf '{"error":%s,"status":"","response_raw":"","http_status":"%s"}\n' \
-      "$(json_quote "curl rc=${rc} http=${http_code}: ${err_text}")" "$http_code"
-    return 0
-  fi
-
-  if printf '%s' "$resp" | python3 -c 'import json,sys; json.load(sys.stdin)' >/dev/null 2>&1; then
-    printf '%s' "$resp"
-    return 0
-  fi
-
-  printf '{"error":%s,"status":"","response_raw":%s,"http_status":"%s"}\n' \
-    "$(json_quote "non-json invoke response http=${http_code}")" "$(json_quote "$resp")" "$http_code"
-}
-
-wait_invoke_ok() {
-  local sub="$1"
-  local name="$2"
-  local expected="$3"
-  local tries="$4"
-  local delay="$5"
-  local try status raw err latency http_status
-  for try in $(seq 1 "$tries"); do
-    resp=$(invoke_call "$sub" "$name")
-    status=$(json_field "$resp" status)
-    raw=$(json_field "$resp" response_raw)
-    err=$(json_field "$resp" error)
-    latency=$(json_field "$resp" latency_ms)
-    http_status=$(json_field "$resp" http_status)
-    echo "    TRY=${try} fn=${name} status=${status} http=${http_status} latency_ms=${latency} raw=${raw} err=${err}"
-    if [ "$status" = "200" ] && printf '%s' "$raw" | grep -q "$expected"; then
-      return 0
-    fi
-    if [ "$try" -lt "$tries" ]; then
-      sleep "$delay"
-    fi
-  done
-  return 1
-}
-
-wait_init_ready() {
-  local token="$1"
-  local env_name="${2:-test}"
-  local tries="$3"
-  local delay="$4"
-  local try debug_raw debug_code debug_body status_raw status_code status_body ready done dbg_ready exec_ready exec_pods router_ready router_pods
-  for try in $(seq 1 "$tries"); do
-    debug_raw=$(auth_get "/ns/debug" "$token" "$env_name")
-    debug_code=$(printf '%s' "$debug_raw" | tail -1)
-    debug_body=$(printf '%s' "$debug_raw" | sed '$d')
-    status_raw=$(auth_get "/ns/status" "$token" "$env_name")
-    status_code=$(printf '%s' "$status_raw" | tail -1)
-    status_body=$(printf '%s' "$status_raw" | sed '$d')
-    ready=$(json_field "$status_body" ready)
-    done=$(printf '%s' "$status_body" | python3 -c 'import json,sys
-try:
-  data=json.load(sys.stdin)
-  print(sum(1 for s in data.get("stages", []) if s.get("done")))
-except Exception:
-  print(0)')
-    dbg_ready=$(printf '%s' "$debug_body" | python3 -c 'import json,sys
-try:
-  data=json.load(sys.stdin)
-  print(str(data.get("controlPlane", {}).get("ready", "")))
-except Exception:
-  print("")')
-    exec_ready=$(printf '%s' "$debug_body" | python3 -c 'import json,sys
-try:
-  data=json.load(sys.stdin)
-  print(str(data.get("controlPlane", {}).get("executor", {}).get("ready", "")))
-except Exception:
-  print("")')
-    exec_pods=$(printf '%s' "$debug_body" | python3 -c 'import json,sys
-try:
-  data=json.load(sys.stdin)
-  print(data.get("controlPlane", {}).get("executor", {}).get("podCount", ""))
-except Exception:
-  print("")')
-    router_ready=$(printf '%s' "$debug_body" | python3 -c 'import json,sys
-try:
-  data=json.load(sys.stdin)
-  print(str(data.get("controlPlane", {}).get("router", {}).get("ready", "")))
-except Exception:
-  print("")')
-    router_pods=$(printf '%s' "$debug_body" | python3 -c 'import json,sys
-try:
-  data=json.load(sys.stdin)
-  print(data.get("controlPlane", {}).get("router", {}).get("podCount", ""))
-except Exception:
-  print("")')
-    echo "    INIT_TRY=${try} status_http=${status_code} debug_http=${debug_code} ready=${ready} done=${done}/3 cp_ready=${dbg_ready} executor_ready=${exec_ready} executor_pods=${exec_pods} router_ready=${router_ready} router_pods=${router_pods}"
-    if [ "$status_code" = "200" ] && [ "$debug_code" = "200" ] && [ "$ready" = "True" -o "$ready" = "true" ]; then
-      return 0
-    fi
-    if [ "$try" -lt "$tries" ]; then
-      sleep "$delay"
-    fi
-  done
-  return 1
-}
-
-echo ""
-echo "========================================"
-echo "  UI-like user flow tests"
-echo "  Run ID: ${RUN_ID}"
-echo "========================================"
-
-echo ""
-echo ">>> T01: login с невалидным токеном"
-R=$(auth_call "not-an-email")
-CODE=$(printf '%s' "$R" | tail -1)
-[ "$CODE" = "401" ] && pass "login invalid token -> 401" || fail "login invalid token -> got $CODE"
-
-echo ""
-echo ">>> T02: login c валидным test token"
-R=$(auth_call "$LOGIN_SUB")
-CODE=$(printf '%s' "$R" | tail -1)
-BODY=$(printf '%s' "$R" | sed '$d')
-NS=$(json_field "$BODY" namespace)
-[ "$CODE" = "200" ] && pass "login valid token -> 200" || fail "login valid token -> got $CODE"
-printf '%s' "$NS" | grep -q '^fission-' && pass "login returns namespace" || fail "login namespace malformed: ${NS}"
-
-echo ""
-echo ">>> T02b: первый вход ждёт init overlay до 3/3"
-if wait_init_ready "$LOGIN_SUB" "test" 12 5; then
-  pass "init overlay path -> namespace ready 3/3"
-else
-  fail "init overlay path did not reach 3/3"
-fi
-
-echo ""
-echo ">>> T03: ошибки create, которые типичны для UI"
-R=$(create_call "$NEG_SUB" '{"name":"","language":"python","code":"def main():\n    return 1"}')
-CODE=$(printf '%s' "$R" | tail -1)
-[ "$CODE" = "400" ] && pass "empty name -> 400" || fail "empty name -> got $CODE"
-
-R=$(create_call "$NEG_SUB" '{"name":"empty-code","language":"python","code":"   "}')
-CODE=$(printf '%s' "$R" | tail -1)
-[ "$CODE" = "400" ] && pass "empty code -> 400" || fail "empty code -> got $CODE"
-
-R=$(create_call "$NEG_SUB" '{"name":"bad ttl","language":"python","code":"def main():\n    return 1","ttl":"99z"}')
-CODE=$(printf '%s' "$R" | tail -1)
-[ "$CODE" = "400" ] && pass "invalid ttl -> 400" || fail "invalid ttl -> got $CODE"
-
-R=$(create_call "$NEG_SUB" '{"name":"bad name fn","language":"python","code":"def main():\n    return 1"}')
-CODE=$(printf '%s' "$R" | tail -1)
-[ "$CODE" != "201" ] && [ "$CODE" != "200" ] && pass "invalid name with spaces rejected" || fail "invalid name unexpectedly created"
-
-R=$(create_call "$NEG_SUB" '{"name":"bad-lang","language":"cobol","code":"x"}')
-CODE=$(printf '%s' "$R" | tail -1)
-[ "$CODE" = "400" ] && pass "invalid language -> 400" || fail "invalid language -> got $CODE"
-
-echo ""
-echo ">>> T04: duplicate create и повторный delete"
-R=$(create_call "$NEG_SUB" '{"name":"dup-ui","language":"python","entrypoint":"main.main","code":"def main():\n    return \"dup-ui\""}')
-CODE=$(printf '%s' "$R" | tail -1)
-[ "$CODE" = "201" ] && pass "first create -> 201" || fail "first create -> got $CODE"
-
-R=$(create_call "$NEG_SUB" '{"name":"dup-ui","language":"python","entrypoint":"main.main","code":"def main():\n    return \"dup-ui-2\""}')
-CODE=$(printf '%s' "$R" | tail -1)
-([ "$CODE" = "409" ] || [ "$CODE" = "502" ]) && pass "duplicate create rejected" || fail "duplicate create -> got $CODE"
-
-DC=$(curl -s -o /dev/null -w "%{http_code}" --max-time 45 -X DELETE "${BASE}/functions/dup-ui" -H "X-Test-Sub: ${NEG_SUB}")
-[ "$DC" = "200" ] && pass "first delete -> 200" || fail "first delete -> got $DC"
-DC2=$(curl -s -o /dev/null -w "%{http_code}" --max-time 45 -X DELETE "${BASE}/functions/dup-ui" -H "X-Test-Sub: ${NEG_SUB}")
-[ "$DC2" = "404" ] && pass "second delete -> 404" || fail "second delete -> got $DC2"
-
-echo ""
-echo ">>> T05: Python create/invoke как из UI"
-R=$(create_call "$LANG_SUB" '{"name":"py-ui","language":"python","entrypoint":"main.main","code":"def main():\n    return \"py-ui-ok\""}')
-CODE=$(printf '%s' "$R" | tail -1)
-[ "$CODE" = "201" ] && pass "python create -> 201" || fail "python create -> got $CODE"
-if wait_invoke_ok "$LANG_SUB" "py-ui" "py-ui-ok" 8 5; then
-  pass "python invoke -> 200"
-else
-  fail "python invoke did not stabilize"
-fi
-
-PY_PAR1=$(invoke_call "$LANG_SUB" "py-ui")
-PY_PAR2=$(invoke_call "$LANG_SUB" "py-ui")
-[ "$(json_field "$PY_PAR1" status)" = "200" ] && [ "$(json_field "$PY_PAR2" status)" = "200" ] && pass "python double invoke -> both 200" || fail "python double invoke did not return two 200s"
-
-echo ""
-echo ">>> T06: NodeJS create/invoke и edit/update"
-R=$(create_call "$NODE_SUB" '{"name":"node-ui","language":"nodejs","entrypoint":"main","code":"module.exports = async function() { return { status: 200, body: \"node-ui-ok\" }; }"}')
-CODE=$(printf '%s' "$R" | tail -1)
-[ "$CODE" = "201" ] && pass "nodejs create -> 201" || fail "nodejs create -> got $CODE"
-if wait_invoke_ok "$NODE_SUB" "node-ui" "node-ui-ok" 16 5; then
-  pass "nodejs invoke -> 200"
-else
-  fail "nodejs invoke did not stabilize"
-fi
-UPD=$(curl -s -w "\n%{http_code}" --max-time 60 -X PUT "${BASE}/functions/node-ui/code" \
-  -H "X-Test-Sub: ${NODE_SUB}" -H 'Content-Type: application/json' \
-  -d '{"code":"module.exports = async function() { return { status: 200, body: \"node-ui-updated\" }; }"}')
-CODE=$(printf '%s' "$UPD" | tail -1)
-[ "$CODE" = "200" ] && pass "nodejs update -> 200" || fail "nodejs update -> got $CODE"
-if wait_invoke_ok "$NODE_SUB" "node-ui" "node-ui-updated" 16 5; then
-  pass "nodejs invoke after edit -> updated body"
-else
-  fail "nodejs invoke after edit did not return updated body"
-fi
-
-echo ""
-echo ">>> T07: PHP и Ruby в одном namespace"
-PHP_CODE=$(python3 -c 'import json; print(json.dumps("<?php\nfunction handler($context) {\n    $context[\"response\"]->getBody()->write(\"php-ui-ok\");\n}"))')
-RUBY_CODE=$(python3 -c 'import json; print(json.dumps("def handler\n  \"ruby-ui-ok\"\nend"))')
-
-R=$(create_call "$STACK_SUB" "{\"name\":\"php-ui\",\"language\":\"php\",\"entrypoint\":\"main.php::handler\",\"code\":${PHP_CODE}}")
-CODE=$(printf '%s' "$R" | tail -1)
-[ "$CODE" = "201" ] && pass "php create -> 201" || fail "php create -> got $CODE"
-if wait_invoke_ok "$STACK_SUB" "php-ui" "php-ui-ok" 24 10; then
-  pass "php invoke -> 200"
-else
-  fail "php invoke did not stabilize"
-fi
-
-R=$(create_call "$STACK_SUB" "{\"name\":\"ruby-ui\",\"language\":\"ruby\",\"entrypoint\":\"handler\",\"code\":${RUBY_CODE}}")
-CODE=$(printf '%s' "$R" | tail -1)
-[ "$CODE" = "201" ] && pass "ruby create -> 201" || fail "ruby create -> got $CODE"
-if wait_invoke_ok "$STACK_SUB" "ruby-ui" "ruby-ui-ok" 24 10; then
-  pass "ruby invoke -> 200"
-else
-  fail "ruby invoke did not stabilize"
-fi
-
-echo ""
-echo ">>> T08: плохой entrypoint как пользовательский промах"
-R=$(create_call "$NEG_SUB" '{"name":"node-bad-entry","language":"nodejs","entrypoint":"missing","code":"module.exports = async function() { return { status: 200, body: \"bad\" }; }"}')
-CODE=$(printf '%s' "$R" | tail -1)
-[ "$CODE" = "201" ] && pass "bad entrypoint function created" || fail "bad entrypoint create -> got $CODE"
-RESP=$(invoke_call "$NEG_SUB" "node-bad-entry")
-STATUS=$(json_field "$RESP" status)
-ERR=$(json_field "$RESP" error)
-[ "$STATUS" != "200" ] && pass "bad entrypoint invoke fails as expected" || fail "bad entrypoint unexpectedly invoked"
-printf '%s' "$ERR" | grep -Eiq 'timeout|specialization|error|not found' && pass "bad entrypoint error is visible" || fail "bad entrypoint error text weak: ${ERR}"
-
-echo ""
-echo "========================================"
-echo "  RESULT: PASS=${PASS} FAIL=${FAIL}"
-echo "========================================"
-
-[ "$FAIL" -eq 0 ]

tests_v2.sh

@@ -1,817 +0,0 @@
-#!/usr/bin/env bash
-set -uo pipefail
-
-BASE="https://fission.kube5s.ru/console/api"
-ROOT_DIR=$(cd "$(dirname "$0")" && pwd)
-NS_CLEANUP_SCRIPT="${ROOT_DIR}/cleanup_test_namespaces.sh"
-PASS=0; FAIL=0
-RUN_ID=$(date +%s%N 2>/dev/null || date +%s)$(od -An -N2 -tu2 /dev/urandom 2>/dev/null | tr -d ' ' || echo "$$")
-RUN_ID=$(echo "$RUN_ID" | sha256sum 2>/dev/null | head -c 8 || echo "${RUN_ID}" | cut -c1-8)
-
-cleanup_namespaces() {
-  local subs=()
-  subs+=("${GO_NS}")
-  subs+=("alice@test.local" "routetest-alice@test.local" "routetest-bob@test.local")
-  subs+=("val-user@test.local" "dup-user@test.local" "upd-user@test.local" "get-user@test.local")
-  subs+=("ns-u1@test.local" "ns-u2@test.local" "alice-del@test.local" "carol-del@test.local")
-  subs+=("py-user@test.local" "js-user@test.local" "ttl-user@test.local" "body-user@test.local")
-  subs+=("stress-user@test.local" "brand-new-empty-user-xyzqwerty@test.local" "chain-user@test.local")
-  subs+=("dup2-user-${RUN_ID}@test.local" "name-user-${RUN_ID}@test.local")
-  subs+=("len57-user-${RUN_ID}@test.local" "big-user-${RUN_ID}@test.local" "size-user-${RUN_ID}@test.local")
-  subs+=("ttl-exp-${RUN_ID}@test.local" "race-${RUN_ID}@test.local")
-  subs+=("mfunc-${RUN_ID}@test.local" "victim-${RUN_ID}@test.local" "attacker-${RUN_ID}@test.local")
-  subs+=("lang-multi-${RUN_ID}@test.local" "lang-inv-${RUN_ID}@test.local")
-
-  local uid
-  for uid in $(seq 1 10); do
-    subs+=("u${uid}-${RUN_ID}@test.local")
-  done
-  for uid in $(seq 1 3); do
-    subs+=("fullcycle-u${uid}-${RUN_ID}@test.local")
-  done
-
-  if [ -x "$NS_CLEANUP_SCRIPT" ]; then
-    echo ""
-    echo ">>> Cleanup test namespaces..."
-    "$NS_CLEANUP_SCRIPT" "${subs[@]}" || true
-  fi
-}
-trap cleanup_namespaces EXIT
-
-# GO_NS фиксированный — namespace создаётся один раз, Fission не рестартует при повторных прогонах.
-# Первый прогон занимает ~5 мин (rolling restart Fission), последующие — мгновенно.
-GO_NS="go-livetest@test.local"
-# Триггерим ensureUserNamespace заранее — Fission начнёт регистрировать NS пока идут остальные тесты.
-curl -s -o /dev/null -X GET ${BASE}/functions -H "X-Test-Sub: ${GO_NS}" || true
-
-pass() { PASS=$((PASS+1)); echo "  PASS: $1"; }
-fail() { FAIL=$((FAIL+1)); echo "  FAIL: $1"; }
-check_http() { local got=$1 want=$2 label=$3; [ "$got" = "$want" ] && pass "$label (HTTP $got)" || fail "$label --- got HTTP $got, want $want"; }
-
-echo ""
-echo "========================================"
-echo "  fission-console v0.6.8 — ТЕСТ v2"
-echo "========================================"
-
-# ──────────────────────────────────────────────
-echo ""
-echo ">>> БЛОК A: Фиксы v0.6.8 — регресс"
-
-R=$(curl -s -w "\n%{http_code}" -X POST ${BASE}/functions/nonexistent-xyz-abc/invoke \
-  -H "X-Test-Sub: alice@test.local" -H "Content-Type: application/json" -d '{}')
-CODE=$(echo "$R" | tail -1); BODY=$(echo "$R" | head -1)
-check_http "$CODE" "404" "INVOKE nonexistent → 404"
-echo "$BODY" | grep -q "not found" && pass "INVOKE nonexistent — тело содержит 'not found'" || fail "INVOKE nonexistent — тело: $BODY"
-
-R=$(curl -s -w "\n%{http_code}" -X DELETE ${BASE}/functions/nonexistent-xyz-abc \
-  -H "X-Test-Sub: alice@test.local")
-CODE=$(echo "$R" | tail -1)
-check_http "$CODE" "404" "DELETE nonexistent → 404"
-
-# Создаём изолированные функции и проверяем route isolation
-ISO_NAME="iso-${RUN_ID}"
-R_A=$(curl -s -X POST ${BASE}/functions \
-  -H "X-Test-Sub: routetest-alice@test.local" -H "Content-Type: application/json" \
-  -d "{\"name\":\"${ISO_NAME}\",\"language\":\"nodejs\",\"code\":\"module.exports=async(ctx)=>({body:\\\"alice-iso\\\"})\",\"ttl\":\"5m\"}")
-R_B=$(curl -s -X POST ${BASE}/functions \
-  -H "X-Test-Sub: routetest-bob@test.local" -H "Content-Type: application/json" \
-  -d "{\"name\":\"${ISO_NAME}\",\"language\":\"nodejs\",\"code\":\"module.exports=async(ctx)=>({body:\\\"bob-iso\\\"})\",\"ttl\":\"5m\"}")
-ROUTE_A=$(echo "$R_A" | python3 -c "import sys,json; print(json.load(sys.stdin).get('route','?'))" 2>/dev/null)
-ROUTE_B=$(echo "$R_B" | python3 -c "import sys,json; print(json.load(sys.stdin).get('route','?'))" 2>/dev/null)
-[ "$ROUTE_A" != "$ROUTE_B" ] && pass "Route isolation: маршруты различаются ($ROUTE_A vs $ROUTE_B)" || fail "Route collision: маршруты одинаковы: $ROUTE_A"
-
-sleep 10
-
-# Invoke после изоляции
-INV_A=$(curl -s -X POST ${BASE}/functions/${ISO_NAME}/invoke \
-  -H "X-Test-Sub: routetest-alice@test.local" -H "Content-Type: application/json" -d '{}')
-INV_B=$(curl -s -X POST ${BASE}/functions/${ISO_NAME}/invoke \
-  -H "X-Test-Sub: routetest-bob@test.local" -H "Content-Type: application/json" -d '{}')
-BODY_A=$(echo "$INV_A" | python3 -c "import sys,json; print(json.load(sys.stdin).get('response_raw','?'))" 2>/dev/null)
-BODY_B=$(echo "$INV_B" | python3 -c "import sys,json; print(json.load(sys.stdin).get('response_raw','?'))" 2>/dev/null)
-[ "$BODY_A" = "alice-iso" ] && pass "Route isolation invoke — alice получает alice" || fail "Route isolation — alice получила: $BODY_A"
-[ "$BODY_B" = "bob-iso" ] && pass "Route isolation invoke — bob получает bob" || fail "Route isolation — bob получил: $BODY_B"
-
-# ──────────────────────────────────────────────
-echo ""
-echo ">>> БЛОК B: Валидация входных данных"
-
-R=$(curl -s -w "\n%{http_code}" -X POST ${BASE}/functions \
-  -H "X-Test-Sub: val-user@test.local" -H "Content-Type: application/json" \
-  -d '{"language":"nodejs","code":"x"}')
-CODE=$(echo "$R" | tail -1); check_http "$CODE" "400" "Создание без name → 400"
-
-R=$(curl -s -w "\n%{http_code}" -X POST ${BASE}/functions \
-  -H "X-Test-Sub: val-user@test.local" -H "Content-Type: application/json" \
-  -d '{"name":"nocode-fn","language":"nodejs"}')
-CODE=$(echo "$R" | tail -1); check_http "$CODE" "400" "Создание без code → 400"
-
-R=$(curl -s -w "\n%{http_code}" -X POST ${BASE}/functions \
-  -H "X-Test-Sub: val-user@test.local" -H "Content-Type: application/json" \
-  -d '{"name":"nolang-fn","code":"x"}')
-CODE=$(echo "$R" | tail -1); check_http "$CODE" "400" "Создание без language → 400"
-
-R=$(curl -s -w "\n%{http_code}" -X POST ${BASE}/functions \
-  -H "X-Test-Sub: val-user@test.local" -H "Content-Type: application/json" \
-  -d '{"name":"","language":"nodejs","code":"x"}')
-CODE=$(echo "$R" | tail -1); check_http "$CODE" "400" "Создание с пустым name → 400"
-
-R=$(curl -s -w "\n%{http_code}" -X POST ${BASE}/functions \
-  -H "X-Test-Sub: val-user@test.local" -H "Content-Type: application/json" \
-  -d '{"name":"bad lang fn","language":"nodejs","code":"x"}')
-# Fission не позволяет пробелы в имени — ожидаем 4xx или 502
-CODE=$(echo "$R" | tail -1)
-( [ "$CODE" = "400" ] || [ "$CODE" = "422" ] || [ "$CODE" = "502" ] ) && pass "Имя с пробелами → не 201 (got $CODE)" || fail "Имя с пробелами → got $CODE"
-
-# ──────────────────────────────────────────────
-echo ""
-echo ">>> БЛОК C: Дублирующее создание"
-
-curl -s -X POST ${BASE}/functions \
-  -H "X-Test-Sub: dup-user@test.local" -H "Content-Type: application/json" \
-  -d '{"name":"dup-fn","language":"nodejs","code":"module.exports=async()=>({body:\"v1\"});","ttl":"5m"}' > /dev/null
-
-R=$(curl -s -w "\n%{http_code}" -X POST ${BASE}/functions \
-  -H "X-Test-Sub: dup-user@test.local" -H "Content-Type: application/json" \
-  -d '{"name":"dup-fn","language":"nodejs","code":"module.exports=async()=>({body:\"v2\"});","ttl":"5m"}')
-CODE=$(echo "$R" | tail -1)
-( [ "$CODE" = "409" ] || [ "$CODE" = "502" ] ) && pass "Дублирующее создание → конфликт (got $CODE)" || fail "Дублирующее создание → got $CODE"
-
-# ──────────────────────────────────────────────
-echo ""
-echo ">>> БЛОК D: UPDATE кода и повторный invoke"
-
-curl -s -X POST ${BASE}/functions \
-  -H "X-Test-Sub: upd-user@test.local" -H "Content-Type: application/json" \
-  -d '{"name":"upd-fn","language":"nodejs","code":"module.exports=async()=>({body:\"before\"});","ttl":"10m"}' > /dev/null
-
-sleep 3
-
-R=$(curl -s -w "\n%{http_code}" -X PUT ${BASE}/functions/upd-fn/code \
-  -H "X-Test-Sub: upd-user@test.local" -H "Content-Type: application/json" \
-  -d '{"code":"module.exports=async()=>({body:\"after\"});"}')
-CODE=$(echo "$R" | tail -1); check_http "$CODE" "200" "UPDATE code → 200"
-
-sleep 10
-
-INV=$(curl -s -X POST ${BASE}/functions/upd-fn/invoke \
-  -H "X-Test-Sub: upd-user@test.local" -H "Content-Type: application/json" -d '{}')
-BODY=$(echo "$INV" | python3 -c "import sys,json; print(json.load(sys.stdin).get('response_raw','?'))" 2>/dev/null)
-[ "$BODY" = "after" ] && pass "После UPDATE — invoke возвращает новый код" || fail "После UPDATE — invoke вернул: $BODY"
-
-# ──────────────────────────────────────────────
-echo ""
-echo ">>> БЛОК E: GET функции"
-
-curl -s -X POST ${BASE}/functions \
-  -H "X-Test-Sub: get-user@test.local" -H "Content-Type: application/json" \
-  -d '{"name":"get-fn","language":"nodejs","code":"x","ttl":"5m"}' > /dev/null
-
-R=$(curl -s -w "\n%{http_code}" ${BASE}/functions/get-fn \
-  -H "X-Test-Sub: get-user@test.local")
-CODE=$(echo "$R" | tail -1); BODY=$(echo "$R" | head -1)
-check_http "$CODE" "200" "GET существующей функции → 200"
-echo "$BODY" | python3 -c "import sys,json; d=json.load(sys.stdin); exit(0 if d.get('name')=='get-fn' else 1)" 2>/dev/null \
-  && pass "GET — имя функции в ответе" || fail "GET — имя не найдено: $BODY"
-
-R=$(curl -s -w "\n%{http_code}" ${BASE}/functions/nonexist-get-xyz \
-  -H "X-Test-Sub: get-user@test.local")
-CODE=$(echo "$R" | tail -1); check_http "$CODE" "404" "GET несуществующей → 404"
-
-# ──────────────────────────────────────────────
-echo ""
-echo ">>> БЛОК F: Namespace изоляция LIST"
-
-# u1 создаёт 3 функции, u2 — 1. LIST u1 должен вернуть только свои
-for i in 1 2 3; do
-  curl -s -X POST ${BASE}/functions \
-    -H "X-Test-Sub: ns-u1@test.local" -H "Content-Type: application/json" \
-    -d "{\"name\":\"ns-fn-$i\",\"language\":\"nodejs\",\"code\":\"x\",\"ttl\":\"5m\"}" > /dev/null
-done
-curl -s -X POST ${BASE}/functions \
-  -H "X-Test-Sub: ns-u2@test.local" -H "Content-Type: application/json" \
-  -d '{"name":"ns-fn-u2","language":"nodejs","code":"x","ttl":"5m"}' > /dev/null
-
-COUNT_U1=$(curl -s ${BASE}/functions -H "X-Test-Sub: ns-u1@test.local" \
-  | python3 -c "import sys,json; print(len(json.load(sys.stdin)))" 2>/dev/null)
-COUNT_U2=$(curl -s ${BASE}/functions -H "X-Test-Sub: ns-u2@test.local" \
-  | python3 -c "import sys,json; print(len(json.load(sys.stdin)))" 2>/dev/null)
-
-[ "$COUNT_U1" -ge 3 ] 2>/dev/null && pass "LIST изоляция: u1 видит $COUNT_U1 функций (>= 3)" || fail "LIST u1 — $COUNT_U1"
-[ "$COUNT_U2" -ge 1 ] && [ "$COUNT_U2" -lt "$COUNT_U1" ] 2>/dev/null && pass "LIST изоляция: u2 видит $COUNT_U2 (меньше чем u1)" || fail "LIST u2 — $COUNT_U2 (u1=$COUNT_U1)"
-
-# ──────────────────────────────────────────────
-echo ""
-echo ">>> БЛОК G: Namespace изоляция DELETE"
-
-# Carol пытается удалить функцию Alice
-curl -s -X POST ${BASE}/functions \
-  -H "X-Test-Sub: alice-del@test.local" -H "Content-Type: application/json" \
-  -d '{"name":"alice-secret","language":"nodejs","code":"x","ttl":"5m"}' > /dev/null
-
-R=$(curl -s -w "\n%{http_code}" -X DELETE ${BASE}/functions/alice-secret \
-  -H "X-Test-Sub: carol-del@test.local")
-CODE=$(echo "$R" | tail -1); check_http "$CODE" "404" "Carol DELETE alice функции → 404"
-
-# Alice сама удаляет — должно быть 200
-R=$(curl -s -w "\n%{http_code}" -X DELETE ${BASE}/functions/alice-secret \
-  -H "X-Test-Sub: alice-del@test.local")
-CODE=$(echo "$R" | tail -1); check_http "$CODE" "200" "Alice DELETE своей функции → 200"
-
-# Alice повторно удаляет — 404
-R=$(curl -s -w "\n%{http_code}" -X DELETE ${BASE}/functions/alice-secret \
-  -H "X-Test-Sub: alice-del@test.local")
-CODE=$(echo "$R" | tail -1); check_http "$CODE" "404" "Alice повторный DELETE → 404"
-
-# ──────────────────────────────────────────────
-echo ""
-echo ">>> БЛОК H: Python — разные форматы кода"
-
-# Формат 1: def main() без аргумента — Fission Python env вызывает main() без аргументов
-curl -s -X POST ${BASE}/functions \
-  -H "X-Test-Sub: py-user@test.local" -H "Content-Type: application/json" \
-  -d '{"name":"py-main-'${RUN_ID}'","language":"python","code":"def main():\n    return \"py-main\", 200","ttl":"10m"}' > /dev/null
-
-sleep 15
-
-INV=$(curl -s -X POST ${BASE}/functions/py-main-${RUN_ID}/invoke \
-  -H "X-Test-Sub: py-user@test.local" -H "Content-Type: application/json" -d '{}')
-STATUS=$(echo "$INV" | python3 -c "import sys,json; print(json.load(sys.stdin).get('status','?'))" 2>/dev/null)
-[ "$STATUS" = "200" ] && pass "Python def main() (no-arg) → invoke 200" || fail "Python def main → status=$STATUS body=$(echo $INV)"
-
-# ──────────────────────────────────────────────
-echo ""
-echo ">>> БЛОК I: NodeJS — несколько export-паттернов"
-
-# module.exports = async function
-curl -s -X POST ${BASE}/functions \
-  -H "X-Test-Sub: js-user@test.local" -H "Content-Type: application/json" \
-  -d '{"name":"js-anon","language":"nodejs","code":"module.exports=async function(ctx){return {body:\"anon\"};}","ttl":"10m"}' > /dev/null
-
-# exports.handler
-curl -s -X POST ${BASE}/functions \
-  -H "X-Test-Sub: js-user@test.local" -H "Content-Type: application/json" \
-  -d '{"name":"js-handler","language":"nodejs","code":"exports.handler=async(ctx)=>({body:\"handler\"});","ttl":"10m"}' > /dev/null
-
-# exports.default
-curl -s -X POST ${BASE}/functions \
-  -H "X-Test-Sub: js-user@test.local" -H "Content-Type: application/json" \
-  -d '{"name":"js-default","language":"nodejs","code":"exports.default=async(ctx)=>({body:\"default\"});","ttl":"10m"}' > /dev/null
-
-sleep 10
-
-for fn_name in js-anon js-handler js-default; do
-  INV=$(curl -s -X POST ${BASE}/functions/${fn_name}/invoke \
-    -H "X-Test-Sub: js-user@test.local" -H "Content-Type: application/json" -d '{}')
-  STATUS=$(echo "$INV" | python3 -c "import sys,json; print(json.load(sys.stdin).get('status','?'))" 2>/dev/null)
-  [ "$STATUS" = "200" ] && pass "NodeJS $fn_name → 200" || fail "NodeJS $fn_name → status=$STATUS / $(echo $INV)"
-done
-
-# ──────────────────────────────────────────────
-echo ""
-echo ">>> БЛОК J: TTL — создание и проверка"
-
-curl -s -X POST ${BASE}/functions \
-  -H "X-Test-Sub: ttl-user@test.local" -H "Content-Type: application/json" \
-  -d "{\"name\":\"ttl-has-${RUN_ID}\",\"language\":\"nodejs\",\"code\":\"x\",\"ttl\":\"15m\"}" \
-  | python3 -c "import sys,json; d=json.load(sys.stdin); exit(0 if d.get('expires_at') else 1)" 2>/dev/null \
-  && pass "TTL=15m — expires_at присутствует" || fail "TTL=15m — expires_at отсутствует"
-
-curl -s -X POST ${BASE}/functions \
-  -H "X-Test-Sub: ttl-user@test.local" -H "Content-Type: application/json" \
-  -d "{\"name\":\"ttl-noexp-${RUN_ID}\",\"language\":\"nodejs\",\"code\":\"x\"}" \
-  | python3 -c "import sys,json; d=json.load(sys.stdin); exit(0 if not d.get('expires_at') else 1)" 2>/dev/null \
-  && pass "Без TTL — expires_at отсутствует" || fail "Без TTL — expires_at присутствует (не ожидалось)"
-
-# Невалидный TTL
-R=$(curl -s -w "\n%{http_code}" -X POST ${BASE}/functions \
-  -H "X-Test-Sub: ttl-user@test.local" -H "Content-Type: application/json" \
-  -d "{\"name\":\"ttl-bad-${RUN_ID}\",\"language\":\"nodejs\",\"code\":\"x\",\"ttl\":\"99z\"}")
-CODE=$(echo "$R" | tail -1)
-[ "$CODE" = "400" ] && pass "Невалидный TTL=99z → 400" || fail "Невалидный TTL=99z → got $CODE"
-
-# ──────────────────────────────────────────────
-echo ""
-echo ">>> БЛОК K: Invoke — тело запроса передаётся в функцию"
-
-# ctx.request.body может быть undefined — тестируем через ctx.request.url (всегда доступен)
-curl -s -X POST ${BASE}/functions \
-  -H "X-Test-Sub: body-user@test.local" -H "Content-Type: application/json" \
-  -d '{"name":"echo-url","language":"nodejs","code":"module.exports=async(ctx)=>({body:\"got:\"+ctx.request.url});","ttl":"10m"}' > /dev/null
-
-sleep 12
-
-INV=$(curl -s -X POST ${BASE}/functions/echo-url/invoke \
-  -H "X-Test-Sub: body-user@test.local" -H "Content-Type: application/json" \
-  -d '{"hello":"world"}')
-RESP=$(echo "$INV" | python3 -c "import sys,json; print(json.load(sys.stdin).get('response_raw','?'))" 2>/dev/null)
-STATUS=$(echo "$INV" | python3 -c "import sys,json; print(json.load(sys.stdin).get('status','?'))" 2>/dev/null)
-[ "$STATUS" = "200" ] && pass "NodeJS ctx.request.url доступен — invoke 200" || fail "Echo url — status=$STATUS resp: $RESP"
-echo "$RESP" | grep -q "got:" && pass "NodeJS ctx.request.url содержит данные" || fail "ctx.request.url — ответ: $RESP"
-
-# ──────────────────────────────────────────────
-echo ""
-echo ">>> БЛОК L: Stress — 10 параллельных invoke"
-
-curl -s -X POST ${BASE}/functions \
-  -H "X-Test-Sub: stress-user@test.local" -H "Content-Type: application/json" \
-  -d '{"name":"stress-fn","language":"nodejs","code":"module.exports=async()=>({body:\"ok\"});","ttl":"10m"}' > /dev/null
-sleep 8
-
-STRESS_OK=0
-for i in $(seq 1 10); do
-  ST=$(curl -s -X POST ${BASE}/functions/stress-fn/invoke \
-    -H "X-Test-Sub: stress-user@test.local" -H "Content-Type: application/json" -d '{}' \
-    | python3 -c "import sys,json; print(json.load(sys.stdin).get('status','?'))" 2>/dev/null)
-  [ "$ST" = "200" ] && STRESS_OK=$((STRESS_OK+1))
-done &
-wait
-
-# Run them
-STRESS_OK=0
-PIDS=()
-TMPDIR_S=$(mktemp -d)
-for i in $(seq 1 10); do
-  ( curl -s -X POST ${BASE}/functions/stress-fn/invoke \
-    -H "X-Test-Sub: stress-user@test.local" -H "Content-Type: application/json" -d '{}' \
-    | python3 -c "import sys,json; d=json.load(sys.stdin); exit(0 if d.get('status')==200 else 1)" 2>/dev/null \
-    && touch "${TMPDIR_S}/ok_$i" || true ) &
-done
-wait
-STRESS_OK=$(ls ${TMPDIR_S}/ok_* 2>/dev/null | wc -l)
-rm -rf "${TMPDIR_S}"
-[ "$STRESS_OK" -ge 9 ] && pass "Stress 10 parallel: $STRESS_OK/10 OK" || fail "Stress 10 parallel: $STRESS_OK/10 OK"
-
-# ──────────────────────────────────────────────
-echo ""
-echo ">>> БЛОК M: LIST пустого namespace"
-
-COUNT=$(curl -s ${BASE}/functions -H "X-Test-Sub: brand-new-empty-user-xyzqwerty@test.local" \
-  | python3 -c "import sys,json; print(len(json.load(sys.stdin)))" 2>/dev/null)
-[ "$COUNT" = "0" ] && pass "LIST новый пользователь → пустой список" || fail "LIST новый пользователь → $COUNT"
-
-# ──────────────────────────────────────────────
-echo ""
-echo ">>> БЛОК N: DELETE полная цепочка (fn + pkg + trigger)"
-
-curl -s -X POST ${BASE}/functions \
-  -H "X-Test-Sub: chain-user@test.local" -H "Content-Type: application/json" \
-  -d '{"name":"chain-fn","language":"nodejs","code":"module.exports=async()=>({body:\"ok\"});","ttl":"5m"}' > /dev/null
-
-# Получаем NS для chain-user из LIST (до DELETE)
-NS_CHAIN=$(curl -s ${BASE}/functions -H "X-Test-Sub: chain-user@test.local" \
-  | python3 -c "import sys,json; items=json.load(sys.stdin); print(items[0]['metadata']['namespace'] if items else '')" 2>/dev/null)
-
-R=$(curl -s -w "\n%{http_code}" -X DELETE ${BASE}/functions/chain-fn \
-  -H "X-Test-Sub: chain-user@test.local")
-CODE=$(echo "$R" | tail -1); check_http "$CODE" "200" "DELETE chain-fn → 200"
-
-# Ждём propagation удаления в k8s
-sleep 3
-# k8s: проверяем через kubectl (или через API если kubectl недоступен)
-FN_RAW=$(kubectl get functions.fission.io chain-fn -n ${NS_CHAIN} 2>&1)
-if echo "$FN_RAW" | grep -q "not found"; then
-  pass "k8s: Function удалена после DELETE"
-elif echo "$FN_RAW" | grep -q "credentials\|logged in\|Unauthorized"; then
-  # kubectl недоступен — проверяем через API (GET должен давать 404)
-  FN_API=$(curl -s -o /dev/null -w "%{http_code}" ${BASE}/functions/chain-fn \
-    -H "X-Test-Sub: chain-user@test.local")
-  [ "$FN_API" = "404" ] && pass "k8s: Function удалена (подтверждено API, kubectl без прав)" || fail "k8s: Function не удалена, API=$FN_API"
-else
-  fail "k8s: Function ещё существует в $NS_CHAIN"
-fi
-TRG_EXISTS=$(kubectl get httptriggers.fission.io -n ${NS_CHAIN} 2>&1 | grep -c "chain-fn" || true)
-
-# После удаления GET должен вернуть 404
-R=$(curl -s -w "\n%{http_code}" ${BASE}/functions/chain-fn \
-  -H "X-Test-Sub: chain-user@test.local")
-CODE=$(echo "$R" | tail -1); check_http "$CODE" "404" "GET после DELETE → 404"
-
-# ──────────────────────────────────────────────
-echo ""
-echo ">>> БЛОК O: Auth — без заголовка"
-
-R=$(curl -s -w "\n%{http_code}" ${BASE}/functions)
-CODE=$(echo "$R" | tail -1)
-( [ "$CODE" = "401" ] || [ "$CODE" = "403" ] ) && pass "Без X-Test-Sub → 401/403 (got $CODE)" || fail "Без X-Test-Sub → got $CODE"
-
-# ──────────────────────────────────────────────
-echo ""
-echo ">>> БЛОК P: /console/api/auth"
-
-# POST /auth без токена → 400 bad request
-R=$(curl -s -w "\n%{http_code}" -X POST ${BASE}/auth \
-  -H "Content-Type: application/json" -d '{"token":""}')
-CODE=$(echo "$R" | tail -1); BODY=$(echo "$R" | head -1)
-check_http "$CODE" "400" "POST /auth без токена → 400"
-echo "$BODY" | grep -q "token\|required\|invalid" && pass "/auth — тело содержит ошибку токена" || fail "/auth — тело: $BODY"
-
-# POST /auth с невалидным токеном → 401
-R=$(curl -s -w "\n%{http_code}" -X POST ${BASE}/auth \
-  -H "Content-Type: application/json" -d '{"token":"not.a.real.jwt.token"}')
-CODE=$(echo "$R" | tail -1)
-check_http "$CODE" "401" "POST /auth с невалидным токеном → 401"
-
-# ──────────────────────────────────────────────
-echo ""
-echo ">>> БЛОК Q: Дубликат → 409, невалидное имя → 400"
-
-# Создаём функцию, потом снова с тем же именем → 409
-curl -s -X POST ${BASE}/functions \
-  -H "X-Test-Sub: dup2-user-${RUN_ID}@test.local" -H "Content-Type: application/json" \
-  -d "{\"name\":\"dup-q-${RUN_ID}\",\"language\":\"nodejs\",\"code\":\"module.exports=async()=>({body:'x'})\"}" > /dev/null
-sleep 3
-R=$(curl -s -w "\n%{http_code}" -X POST ${BASE}/functions \
-  -H "X-Test-Sub: dup2-user-${RUN_ID}@test.local" -H "Content-Type: application/json" \
-  -d "{\"name\":\"dup-q-${RUN_ID}\",\"language\":\"nodejs\",\"code\":\"module.exports=async()=>({body:'x'})\"}")
-CODE=$(echo "$R" | tail -1)
-check_http "$CODE" "409" "Дубликат → 409 Conflict"
-
-# Имя с заглавной буквой → 400
-R=$(curl -s -w "\n%{http_code}" -X POST ${BASE}/functions \
-  -H "X-Test-Sub: name-user-${RUN_ID}@test.local" -H "Content-Type: application/json" \
-  -d "{\"name\":\"BadName\",\"language\":\"nodejs\",\"code\":\"x\"}")
-CODE=$(echo "$R" | tail -1)
-check_http "$CODE" "400" "Имя с заглавной буквой → 400"
-
-# Имя начинается с дефиса → 400
-R=$(curl -s -w "\n%{http_code}" -X POST ${BASE}/functions \
-  -H "X-Test-Sub: name-user-${RUN_ID}@test.local" -H "Content-Type: application/json" \
-  -d "{\"name\":\"-badstart\",\"language\":\"nodejs\",\"code\":\"x\"}")
-CODE=$(echo "$R" | tail -1)
-check_http "$CODE" "400" "Имя с ведущим дефисом → 400"
-
-# Имя заканчивается дефисом → 400
-R=$(curl -s -w "\n%{http_code}" -X POST ${BASE}/functions \
-  -H "X-Test-Sub: name-user-${RUN_ID}@test.local" -H "Content-Type: application/json" \
-  -d "{\"name\":\"badend-\",\"language\":\"nodejs\",\"code\":\"x\"}")
-CODE=$(echo "$R" | tail -1)
-check_http "$CODE" "400" "Имя с завершающим дефисом → 400"
-
-# Имя с пробелами → 400 (было 502)
-R=$(curl -s -w "\n%{http_code}" -X POST ${BASE}/functions \
-  -H "X-Test-Sub: name-user-${RUN_ID}@test.local" -H "Content-Type: application/json" \
-  -d "{\"name\":\"bad name\",\"language\":\"nodejs\",\"code\":\"x\"}")
-CODE=$(echo "$R" | tail -1)
-check_http "$CODE" "400" "Имя с пробелом → 400 (не 502)"
-
-# Имя 64 символа → 400
-LONGNAME=$(python3 -c "print('a'*64)")
-R=$(curl -s -w "\n%{http_code}" -X POST ${BASE}/functions \
-  -H "X-Test-Sub: name-user-${RUN_ID}@test.local" -H "Content-Type: application/json" \
-  -d "{\"name\":\"${LONGNAME}\",\"language\":\"nodejs\",\"code\":\"x\"}")
-CODE=$(echo "$R" | tail -1)
-check_http "$CODE" "400" "Имя 64 символа → 400"
-
-# Имя 58 символов → 400 (route = 64 > 63, Fission webhook отклонит)
-NAME58=$(python3 -c "print('a'*58)")
-R=$(curl -s -w "\n%{http_code}" -X POST ${BASE}/functions \
-  -H "X-Test-Sub: name-user-${RUN_ID}@test.local" -H "Content-Type: application/json" \
-  -d "{\"name\":\"${NAME58}\",\"language\":\"nodejs\",\"code\":\"x\"}")
-CODE=$(echo "$R" | tail -1)
-check_http "$CODE" "400" "Имя 58 символов → 400 (route будет 64 символа)"
-
-# Имя 57 символов → принято (route = 63 символа, ровно лимит Fission)
-NAME57=$(python3 -c "print('a'*57)")
-# Первый прогрев namespace
-curl -s -X POST ${BASE}/functions \
-  -H "X-Test-Sub: len57-user-${RUN_ID}@test.local" -H "Content-Type: application/json" \
-  -d '{"name":"warmup","language":"nodejs","code":"module.exports=async()=>({body:\"w\"})"}' > /dev/null
-sleep 8
-R=$(curl -s -w "\n%{http_code}" -X POST ${BASE}/functions \
-  -H "X-Test-Sub: len57-user-${RUN_ID}@test.local" -H "Content-Type: application/json" \
-  -d "{\"name\":\"${NAME57}\",\"language\":\"nodejs\",\"code\":\"module.exports=async()=>({body:'ok'})\"}")
-CODE=$(echo "$R" | tail -1)
-check_http "$CODE" "201" "Имя 57 символов → принято (201)"
-
-# ──────────────────────────────────────────────
-echo ""
-echo ">>> БЛОК R: Лимит размера кода 1MB"
-
-# Код > 1MB → 400
-BIG_TMP=$(mktemp)
-python3 -c "
-import json, sys
-code = 'x' * (1024*1024 + 1)
-body = json.dumps({'name':'big-fn','language':'nodejs','code':code})
-sys.stdout.write(body)
-" > "$BIG_TMP"
-R=$(curl -s -w "\n%{http_code}" -X POST ${BASE}/functions \
-  -H "X-Test-Sub: big-user-${RUN_ID}@test.local" -H "Content-Type: application/json" \
-  --data @"$BIG_TMP")
-rm -f "$BIG_TMP"
-CODE=$(echo "$R" | tail -1)
-# 400 = наш код, 413 = nginx body limit, 000 = connection reset nginx — всё означает "отклонён"
-( [ "$CODE" = "400" ] || [ "$CODE" = "413" ] || [ "$CODE" = "000" ] ) \
-  && pass "Код > 1MB → отклонён (HTTP $CODE)" \
-  || fail "Код > 1MB → got HTTP $CODE (ожидался 400/413)"
-
-# Код ровно 1000 символов → не 400
-CODE1K=$(python3 -c "print('module.exports=async()=>({body:' + '\"x\"' + '});' + ' '*(1000-38))")
-R=$(curl -s -w "\n%{http_code}" -X POST ${BASE}/functions \
-  -H "X-Test-Sub: size-user-${RUN_ID}@test.local" -H "Content-Type: application/json" \
-  -d "{\"name\":\"size-fn-${RUN_ID}\",\"language\":\"nodejs\",\"code\":\"module.exports=async()=>({body:'ok'})\"}")
-CODE=$(echo "$R" | tail -1)
-[ "$CODE" = "201" ] && pass "Код 1000 байт → принят (201)" || fail "Код 1000 байт → got $CODE"
-
-# ──────────────────────────────────────────────
-echo ""
-echo ">>> БЛОК S: TTL expire + reaper очистка"
-
-# Создаём функцию с TTL=1m
-R=$(curl -s -X POST ${BASE}/functions \
-  -H "X-Test-Sub: ttl-exp-${RUN_ID}@test.local" -H "Content-Type: application/json" \
-  -d "{\"name\":\"expire-fn-${RUN_ID}\",\"language\":\"nodejs\",\"code\":\"module.exports=async()=>({body:'bye'})\",\"ttl\":\"1m\"}")
-CREATED=$(echo "$R" | python3 -c "import sys,json; d=json.load(sys.stdin); print(d.get('name',''))" 2>/dev/null)
-[ "$CREATED" = "expire-fn-${RUN_ID}" ] && pass "TTL=1m функция создана" || fail "TTL=1m создание: $R"
-
-# Сразу должна быть видна в LIST
-COUNT=$(curl -s ${BASE}/functions \
-  -H "X-Test-Sub: ttl-exp-${RUN_ID}@test.local" | python3 -c "import sys,json; print(len(json.load(sys.stdin)))" 2>/dev/null)
-[ "$COUNT" -ge 1 ] 2>/dev/null && pass "TTL=1m функция видна в LIST" || fail "TTL=1m LIST count=$COUNT"
-
-# ──────────────────────────────────────────────
-echo ""
-echo ">>> БЛОК T: Параллельное создание одного namespace (race condition)"
-
-# 5 одновременных запросов от одного пользователя (первый раз)
-NS_USER="race-${RUN_ID}@test.local"
-RACE_RESULTS=""
-for i in $(seq 1 5); do
-  RACE_CODE="module.exports=async()=>({body:'r${i}'})"
-  curl -s -X POST ${BASE}/functions \
-    -H "X-Test-Sub: ${NS_USER}" -H "Content-Type: application/json" \
-    -d "{\"name\":\"race-fn-${i}\",\"language\":\"nodejs\",\"code\":\"${RACE_CODE}\"}" &
-done
-wait
-# Проверяем что namespace создался и функции (хоть часть) прошли
-sleep 5
-COUNT=$(curl -s ${BASE}/functions \
-  -H "X-Test-Sub: ${NS_USER}" | python3 -c "import sys,json; print(len(json.load(sys.stdin)))" 2>/dev/null)
-[ "$COUNT" -ge 1 ] 2>/dev/null && pass "Race condition: namespace создан, функций: $COUNT" || fail "Race condition: functions=$COUNT"
-
-# ──────────────────────────────────────────────
-echo ""
-echo ">>> БЛОК U: 10 разных пользователей создают функции параллельно"
-
-for uid in $(seq 1 10); do
-  (
-    U="u${uid}-${RUN_ID}@test.local"
-    CODE="module.exports=async()=>({body:'user${uid}'})"
-    curl -s -X POST ${BASE}/functions \
-      -H "X-Test-Sub: ${U}" -H "Content-Type: application/json" \
-      -d "{\"name\":\"fn-${uid}\",\"language\":\"nodejs\",\"code\":\"${CODE}\"}" > /dev/null
-  ) &
-done
-wait
-sleep 3
-
-OK_USERS=0
-for uid in $(seq 1 10); do
-  U="u${uid}-${RUN_ID}@test.local"
-  C=$(curl -s ${BASE}/functions -H "X-Test-Sub: ${U}" | python3 -c "import sys,json; print(len(json.load(sys.stdin)))" 2>/dev/null)
-  [ "$C" -ge 1 ] 2>/dev/null && OK_USERS=$((OK_USERS+1))
-done
-[ "$OK_USERS" -ge 8 ] && pass "10 юзеров параллельно: ${OK_USERS}/10 создали функции" || fail "10 юзеров параллельно: только ${OK_USERS}/10"
-
-# ──────────────────────────────────────────────
-echo ""
-echo ">>> БЛОК V: Изоляция — 10 юзеров не видят чужих функций"
-
-ISOLATION_OK=0
-for uid in $(seq 1 10); do
-  U="u${uid}-${RUN_ID}@test.local"
-  LIST=$(curl -s ${BASE}/functions -H "X-Test-Sub: ${U}")
-  # Проверяем что НЕТ чужих функций (fn-X от других пользователей не попадают)
-  # Каждый видит ровно 1 свою (fn-{uid}) и ни одной fn-{other}
-  MY_COUNT=$(echo "$LIST" | python3 -c "import sys,json; fns=json.load(sys.stdin); print(sum(1 for f in fns if f['metadata']['name']=='fn-${uid}'))" 2>/dev/null)
-  OTHER_COUNT=$(echo "$LIST" | python3 -c "import sys,json; fns=json.load(sys.stdin); print(sum(1 for f in fns if f['metadata']['name'].startswith('fn-') and f['metadata']['name']!='fn-${uid}'))" 2>/dev/null)
-  if [ "${MY_COUNT:-0}" -ge 1 ] && [ "${OTHER_COUNT:-0}" -eq 0 ]; then
-    ISOLATION_OK=$((ISOLATION_OK+1))
-  fi
-done
-[ "$ISOLATION_OK" -ge 8 ] && pass "Изоляция 10 юзеров: ${ISOLATION_OK}/10 видят только своё" || fail "Изоляция 10 юзеров: только ${ISOLATION_OK}/10"
-
-# ──────────────────────────────────────────────
-echo ""
-echo ">>> БЛОК W: 5 юзеров одновременно вызывают свои функции"
-
-for uid in $(seq 1 5); do
-  (
-    U="u${uid}-${RUN_ID}@test.local"
-    NS12=$(curl -s ${BASE}/functions -H "X-Test-Sub: ${U}" \
-      | python3 -c "import sys,json; fns=json.load(sys.stdin); print(fns[0]['route'].split('/')[1] if fns else '')" 2>/dev/null)
-    if [ -n "$NS12" ]; then
-      INVOKE_CODE=$(curl -s -o /dev/null -w "%{http_code}" \
-        "https://fission.kube5s.ru/console/proxy/${NS12}/fn-${uid}")
-      echo "U${uid}:${INVOKE_CODE}"
-    else
-      echo "U${uid}:NO_ROUTE"
-    fi
-  ) &
-done
-INVOKE_RESULTS=$(wait; sleep 2)
-# Просто проверяем что invoke не упал совсем (ждём фоновые процессы)
-sleep 3
-pass "5 юзеров параллельный invoke — завершён без паники"
-
-# ──────────────────────────────────────────────
-echo ""
-echo ">>> БЛОК X: 3 юзера — полный цикл CREATE→LIST→INVOKE→DELETE"
-
-FULL_CYCLE_OK=0
-for uid in $(seq 1 3); do
-  U="fullcycle-u${uid}-${RUN_ID}@test.local"
-  FN="fc-fn-${uid}"
-  CODE="module.exports=async()=>({body:'cycle${uid}'})"
-
-  # CREATE
-  CR=$(curl -s -o /dev/null -w "%{http_code}" -X POST ${BASE}/functions \
-    -H "X-Test-Sub: ${U}" -H "Content-Type: application/json" \
-    -d "{\"name\":\"${FN}\",\"language\":\"nodejs\",\"code\":\"${CODE}\"}")
-
-  # LIST — функция есть (sleep чтобы k8s успел зарегистрировать)
-  sleep 1
-  LC=$(curl -s ${BASE}/functions -H "X-Test-Sub: ${U}" \
-    | python3 -c "import sys,json; fns=json.load(sys.stdin); print(sum(1 for f in fns if f['metadata']['name']=='${FN}'))" 2>/dev/null)
-
-  # DELETE
-  DC=$(curl -s -o /dev/null -w "%{http_code}" -X DELETE \
-    "${BASE}/functions/${FN}" -H "X-Test-Sub: ${U}")
-
-  # LIST после DELETE — функции нет
-  LC2=$(curl -s ${BASE}/functions -H "X-Test-Sub: ${U}" \
-    | python3 -c "import sys,json; fns=json.load(sys.stdin); print(sum(1 for f in fns if f['metadata']['name']=='${FN}'))" 2>/dev/null)
-
-  if [ "$CR" = "201" ] && [ "${LC:-0}" -ge 1 ] && [ "$DC" = "200" ] && [ "${LC2:-1}" -eq 0 ]; then
-    FULL_CYCLE_OK=$((FULL_CYCLE_OK+1))
-  else
-    echo "  [U${uid}] CR=$CR LC=$LC DC=$DC LC2=$LC2"
-  fi
-done
-[ "$FULL_CYCLE_OK" -eq 3 ] && pass "3 юзера полный цикл CREATE→LIST→DELETE: ${FULL_CYCLE_OK}/3" || fail "3 юзера полный цикл: только ${FULL_CYCLE_OK}/3"
-
-# ──────────────────────────────────────────────
-echo ""
-echo ">>> БЛОК Y: Один юзер создаёт 10 функций, проверяем LIST и DELETE all"
-
-MFUNC_USER="mfunc-${RUN_ID}@test.local"
-for i in $(seq 1 10); do
-  curl -s -X POST ${BASE}/functions \
-    -H "X-Test-Sub: ${MFUNC_USER}" -H "Content-Type: application/json" \
-    -d "{\"name\":\"mf-${i}\",\"language\":\"nodejs\",\"code\":\"module.exports=async()=>({body:${i}})\"}" > /dev/null &
-done
-wait
-sleep 3
-
-MFUNC_COUNT=$(curl -s ${BASE}/functions \
-  -H "X-Test-Sub: ${MFUNC_USER}" \
-  | python3 -c "import sys,json; print(len(json.load(sys.stdin)))" 2>/dev/null)
-[ "${MFUNC_COUNT:-0}" -ge 8 ] && pass "1 юзер создал 10 функций: видно ${MFUNC_COUNT}" || fail "1 юзер: создано только ${MFUNC_COUNT:-0}"
-
-# Удаляем все
-for i in $(seq 1 10); do
-  curl -s -X DELETE "${BASE}/functions/mf-${i}" \
-    -H "X-Test-Sub: ${MFUNC_USER}" > /dev/null &
-done
-wait
-sleep 3
-MFUNC_AFTER=$(curl -s ${BASE}/functions \
-  -H "X-Test-Sub: ${MFUNC_USER}" \
-  | python3 -c "import sys,json; print(len(json.load(sys.stdin)))" 2>/dev/null)
-[ "${MFUNC_AFTER:-1}" -eq 0 ] && pass "DELETE all: список пуст после удаления 10 функций" || fail "DELETE all: осталось ${MFUNC_AFTER:-?} функций"
-
-# ──────────────────────────────────────────────
-echo ""
-echo ">>> БЛОК Z: Cross-user attack — юзер пытается DELETE/UPDATE/GET чужую функцию"
-
-VICTIM_USER="victim-${RUN_ID}@test.local"
-ATTACKER_USER="attacker-${RUN_ID}@test.local"
-
-# Жертва создаёт функцию
-curl -s -X POST ${BASE}/functions \
-  -H "X-Test-Sub: ${VICTIM_USER}" -H "Content-Type: application/json" \
-  -d '{"name":"secret-fn","language":"nodejs","code":"module.exports=async()=>({body:42})"}'  > /dev/null
-sleep 2
-
-# Атакующий пытается GET чужой функции
-Z_GET=$(curl -s -o /dev/null -w "%{http_code}" \
-  "${BASE}/functions/secret-fn" -H "X-Test-Sub: ${ATTACKER_USER}")
-[ "$Z_GET" = "404" ] && pass "Cross-user GET чужой функции → 404" || fail "Cross-user GET → ожидали 404, got $Z_GET"
-
-# Атакующий пытается UPDATE чужой функции (PUT /functions/{name}/code)
-Z_PUT=$(curl -s -o /dev/null -w "%{http_code}" -X PUT \
-  "${BASE}/functions/secret-fn/code" \
-  -H "X-Test-Sub: ${ATTACKER_USER}" -H "Content-Type: application/json" \
-  -d '{"code":"module.exports=async()=>({body:\"hacked\"})"}')
-[ "$Z_PUT" = "404" ] && pass "Cross-user UPDATE чужой функции → 404" || fail "Cross-user UPDATE → ожидали 404, got $Z_PUT"
-
-# Атакующий пытается DELETE чужой функции
-Z_DEL=$(curl -s -o /dev/null -w "%{http_code}" -X DELETE \
-  "${BASE}/functions/secret-fn" -H "X-Test-Sub: ${ATTACKER_USER}")
-[ "$Z_DEL" = "404" ] && pass "Cross-user DELETE чужой функции → 404" || fail "Cross-user DELETE → ожидали 404, got $Z_DEL"
-
-# Жертва проверяет что функция цела
-Z_VICTIM_LIST=$(curl -s ${BASE}/functions -H "X-Test-Sub: ${VICTIM_USER}" \
-  | python3 -c "import sys,json; fns=json.load(sys.stdin); print(sum(1 for f in fns if f['metadata']['name']=='secret-fn'))" 2>/dev/null)
-[ "${Z_VICTIM_LIST:-0}" -eq 1 ] && pass "Cross-user: функция жертвы цела после атаки" || fail "Cross-user: функция жертвы исчезла!"
-
-# ──────────────────────────────────────────────
-echo ""
-echo ">>> БЛОК AA: PHP — создание и вызов"
-
-# Оба блока (AA/AB) используют ОДИН namespace, чтобы избежать повторных executor rollouts.
-# Первая функция (PHP) вызывает addNSToFission → executor rollout (~60s).
-# Ruby создаётся в том же namespace → rollout не нужен → пул стартует сразу.
-LANG_NS="lang-multi-${RUN_ID}@test.local"
-
-PHP_CODE=$(python3 -c "import json; print(json.dumps('<?php\nfunction handler(\$context) {\n    \$context[\"response\"]->getBody()->write(\"php-ok\");\n}'))")
-R=$(curl -s -w "\n%{http_code}" -X POST ${BASE}/functions \
-  -H "X-Test-Sub: ${LANG_NS}" -H "Content-Type: application/json" \
-  -d "{\"name\":\"php-fn\",\"language\":\"php\",\"code\":${PHP_CODE},\"ttl\":\"10m\"}")
-CODE=$(echo "$R" | tail -1)
-check_http "$CODE" "201" "PHP: create → 201"
-
-# Ждём пока poolmgr поднимет pod для нового env (retry до 200s).
-# После executor rollout (~60s) + startup pod (~30s) = ~90s до первого invoke.
-STATUS=""; RAW=""
-for _try in $(seq 1 20); do
-  sleep 10
-  INV=$(curl -s -X POST ${BASE}/functions/php-fn/invoke \
-    -H "X-Test-Sub: ${LANG_NS}")
-  STATUS=$(echo "$INV" | python3 -c "import sys,json; print(json.load(sys.stdin).get('status','?'))" 2>/dev/null)
-  RAW=$(echo "$INV" | python3 -c "import sys,json; print(json.load(sys.stdin).get('response_raw','?'))" 2>/dev/null)
-  [ "$STATUS" = "200" ] && break
-done
-[ "$STATUS" = "200" ] && pass "PHP: invoke → 200" || fail "PHP: invoke → got $STATUS (body: $RAW)"
-echo "$RAW" | grep -q "php-ok" && pass "PHP: тело содержит php-ok" || fail "PHP: тело не содержит php-ok (got: $RAW)"
-
-# ──────────────────────────────────────────────
-echo ""
-echo ">>> БЛОК AB: Ruby — создание и вызов"
-
-RUBY_CODE=$(python3 -c "import json; print(json.dumps('def handler\n  \"ruby-ok\"\nend'))")
-R=$(curl -s -w "\n%{http_code}" -X POST ${BASE}/functions \
-  -H "X-Test-Sub: ${LANG_NS}" -H "Content-Type: application/json" \
-  -d "{\"name\":\"ruby-fn\",\"language\":\"ruby\",\"code\":${RUBY_CODE},\"ttl\":\"10m\"}")
-CODE=$(echo "$R" | tail -1)
-check_http "$CODE" "201" "Ruby: create → 201"
-
-# Ждём пока poolmgr поднимет pod (retry до 200s).
-# Namespace уже известен executor после PHP-блока → rollout не нужен → пул стартует быстро.
-STATUS=""; RAW=""
-for _try in $(seq 1 20); do
-  sleep 10
-  INV=$(curl -s -X POST ${BASE}/functions/ruby-fn/invoke \
-    -H "X-Test-Sub: ${LANG_NS}")
-  STATUS=$(echo "$INV" | python3 -c "import sys,json; print(json.load(sys.stdin).get('status','?'))" 2>/dev/null)
-  RAW=$(echo "$INV" | python3 -c "import sys,json; print(json.load(sys.stdin).get('response_raw','?'))" 2>/dev/null)
-  [ "$STATUS" = "200" ] && break
-done
-[ "$STATUS" = "200" ] && pass "Ruby: invoke → 200" || fail "Ruby: invoke → got $STATUS (body: $RAW)"
-echo "$RAW" | grep -q "ruby-ok" && pass "Ruby: тело содержит ruby-ok" || fail "Ruby: тело не содержит ruby-ok (got: $RAW)"
-
-# ──────────────────────────────────────────────
-echo ""
-echo ">>> БЛОК AD: Невалидный язык → 400"
-
-R=$(curl -s -w "\n%{http_code}" -X POST ${BASE}/functions \
-  -H "X-Test-Sub: lang-inv-${RUN_ID}@test.local" -H "Content-Type: application/json" \
-  -d '{"name":"bad-lang-fn","language":"cobol","code":"x"}')
-CODE=$(echo "$R" | tail -1)
-check_http "$CODE" "400" "Невалидный язык cobol → 400"
-
-# ──────────────────────────────────────────────
-echo ""
-echo ">>> БЛОК AE: Go — создание и вызов"
-
-# Go: namespace GO_NS уже прогрет в начале теста (curl в самом верху).
-# При первом прогоне Fission делает rolling restart (~5 мин) — retry до 600s покрывает это.
-# При последующих прогонах NS уже зарегистрирован → invoke занимает ~10-15s.
-GO_CODE=$(python3 -c "import json; print(json.dumps('package main\n\nimport (\n\t\"fmt\"\n\t\"net/http\"\n)\n\nfunc Handler(w http.ResponseWriter, r *http.Request) {\n\tfmt.Fprintf(w, \"go-ok\")\n}'))")
-# Удаляем старую функцию если осталась от прошлого прогона (игнорируем ошибку)
-curl -s -o /dev/null -X DELETE ${BASE}/functions/go-fn -H "X-Test-Sub: ${GO_NS}" || true
-R=$(curl -s -w "\n%{http_code}" -X POST ${BASE}/functions \
-  -H "X-Test-Sub: ${GO_NS}" -H "Content-Type: application/json" \
-  -d "{\"name\":\"go-fn\",\"language\":\"go\",\"code\":${GO_CODE},\"ttl\":\"30m\"}")
-CODE=$(echo "$R" | tail -1)
-check_http "$CODE" "201" "Go: create → 201"
-
-# Retry до 600s (60 итераций × 10s): первый прогон — ждём Fission rolling restart + build + pool pod.
-STATUS=""; RAW=""
-for _try in $(seq 1 60); do
-  sleep 10
-  INV=$(curl -s -X POST ${BASE}/functions/go-fn/invoke \
-    -H "X-Test-Sub: ${GO_NS}")
-  STATUS=$(echo "$INV" | python3 -c "import sys,json; print(json.load(sys.stdin).get('status','?'))" 2>/dev/null)
-  RAW=$(echo "$INV" | python3 -c "import sys,json; print(json.load(sys.stdin).get('response_raw','?'))" 2>/dev/null)
-  [ "$STATUS" = "200" ] && break
-done
-[ "$STATUS" = "200" ] && pass "Go: invoke → 200" || fail "Go: invoke → got $STATUS (body: $RAW)"
-echo "$RAW" | grep -q "go-ok" && pass "Go: тело содержит go-ok" || fail "Go: тело не содержит go-ok (got: $RAW)"
-
-# ──────────────────────────────────────────────
-echo ""
-echo "========================================"
-printf "Итого: PASS=%d  FAIL=%d\n" $PASS $FAIL
-echo "========================================"

token.txt

@@ -1,10 +1,3 @@
-api_token = "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJhdXRoLWFwaSIsInN1YiI6IjAxOWNjMjY4LTZjNmEtNzgxZS04NjEzLTRiZWQ0ZWM3Y2QyMCIsImV4cCI6MTc4OTAxNTg2NywiaWF0IjoxNzczNDYzODY3LCJqdGkiOiJmYjRkMGFiNy1lYT>
-# s3_uid    = "332cdb0d-34bf-43bf-864d-4adcc3b556fc"
-s3_uid    = "332cdb0d-34bf-43bf-864d-4adcc3b556fb"
-# realm     = "k8s-5-sandbox-nubes-ru"
-realm     = "k8s-3-sandbox-nubes-ru"
-#realm     = "naeel-test-3"
+ntazetdinov@nubes.ru
 
-
-
-eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJhdXRoLWFwaSIsInN1YiI6IjAxOWNjMjY4LTZjNmEtNzgxZS04NjEzLTRiZWQ0ZWM3Y2QyMCIsImV4cCI6MTc4OTAxNTg2Nywia
+eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJhdXRoLWFwaSIsInN1YiI6IjAxOWQ3NmM1LTQyNGMtN2MyYy04OWI3LWUzZjA5OTQ5YTk4ZiIsImV4cCI6MTc5MzA3ODQzOSwiaWF0IjoxNzc3NTI2NDM5LCJqdGkiOiI4MTU1ODNkNy0xZTRkLTRiMmMtOGM5ZS0wZDZmMGU2NmJjNTciLCJhdXRoX3RpbWUiOjAsInR5cCI6IiIsImF6cCI6IiIsInNlc3Npb25fc3RhdGUiOiIiLCJhY3IiOiIiLCJhbGxvd2VkLW9yaWdpbnMiOm51bGwsInJlYWxtX2FjY2VzcyI6eyJyb2xlcyI6bnVsbH0sInJlc291cmNlX2FjY2VzcyI6eyJhY2NvdW50Ijp7InJvbGVzIjpudWxsfX0sInNjb3BlIjoiIiwic2lkIjoiIiwiZW1haWxfdmVyaWZpZWQiOmZhbHNlLCJuYW1lIjoiIiwiQ2xpZW50SUQiOiJXWjAxMTEyIiwiY29tcGFueV9pZCI6IjhlYzcwYWMwLTU0NmQtNDJhNy04Y2ZmLTMzOWM4ZmI1MWEyMyIsImNvbXBhbnlfbmFtZSI6ItCe0J7QniDCq9Cd0KPQkdCV0KHCuyIsImlkcF91c3JfdWlkIjoiMDE5ZDc2YzUtNDI0Yy03YzJjLTg5YjctZTNmMDk5NDlhOThmIiwibG9naW4iOiJudGF6ZXRkaW5vdkBudWJlcy5ydSIsImZpcnN0bmFtZSI6ItCd0LDQuNC70YwiLCJtaWRkbGVuYW1lIjoi0KTQsNGA0LjRgtC-0LLQuNGHIiwibGFzdG5hbWUiOiLQotCw0LfQtdGC0LTQuNC90L7QsiIsImdyb3VwcyI6bnVsbCwicHJlZmVycmVkX3VzZXJuYW1lIjoiIiwiZ2l2ZW5fbmFtZSI6IiIsImZhbWlseV9uYW1lIjoiIiwiZW1haWwiOiJudGF6ZXRkaW5vdkBudWJlcy5ydSJ9.SaZsKAha45-fvKuJkLHUe_09AFsbH5QpzBVdPnjiEDQGIhl1A3ThgnM-oEh_H6CBXXfnOs2QDczzgCD8K8_tYzZKU1Wgk5lj04YW_fbTI89kHTO5wLtrAht9tFEjzBQZ-kmnG8mUK5tgqyNEjsngdQcfqVWRvneF366TiiRXk_76poUPpXWQmqdgCCKb3wq1rRgWcKDZcUC3JvDpOaqYL40zITZlM855drlJhMut4Gkg-EEk7ZGykl6YCsTRWVjFKGQ-7C-BDU2dkmIWhxzBAkvzzM2kBwvtlczCEDiUin7bXE-F_io89oJUYDzY4yPeHzwREwxCp6x9eD1NAIKKuA