refactor: split main.go into packages (internal/api, internal/fission, internal/runtime, cmd/server)

console/internal/api/ai_check.go

@@ -0,0 +1,219 @@
+package api
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"go/parser"
+	"go/token"
+	"io"
+	"net/http"
+	"os"
+	"os/exec"
+	"strings"
+	"time"
+)
+
+// handleAICheck проверяет синтаксис кода через реальный линтер языка.
+// POST /console/api/ai/check
+// Body: {"language":"python","code":"..."}
+// Response: {"ok":true,"result":"..."}
+//
+// Почему реальные линтеры, а не LLM:
+// LLM часто "исправляет" валидный код и врёт о наличии ошибок.
+// node --check / python3 -m py_compile / ruby -c / php -l / perl -c — детерминированы и надёжны.
+// Go использует go/parser прямо в процессе — без внешних команд, быстро.
+func (s *Server) handleAICheck(w http.ResponseWriter, r *http.Request) {
+	if r.Method != http.MethodPost {
+		writeJSONError(w, http.StatusMethodNotAllowed, "method not allowed")
+		return
+	}
+
+	var req struct {
+		Language string `json:"language"`
+		Code     string `json:"code"`
+	}
+	if err := json.NewDecoder(io.LimitReader(r.Body, 64*1024)).Decode(&req); err != nil {
+		writeJSONError(w, http.StatusBadRequest, "invalid JSON: "+err.Error())
+		return
+	}
+	if strings.TrimSpace(req.Code) == "" {
+		w.Header().Set("Content-Type", "application/json")
+		json.NewEncoder(w).Encode(map[string]any{"ok": false, "result": "Код пустой."})
+		return
+	}
+
+	// Конфигурация линтера для каждого языка
+	type linterCfg struct {
+		ext string
+		cmd []string
+	}
+	langs := map[string]linterCfg{
+		"nodejs": {ext: ".js", cmd: []string{"node", "--check"}},
+		"python": {ext: ".py", cmd: []string{"python3", "-m", "py_compile"}},
+		"ruby":   {ext: ".rb", cmd: []string{"ruby", "-c"}},
+		"php":    {ext: ".php", cmd: []string{"php", "-l"}},
+		"perl":   {ext: ".pl", cmd: []string{"perl", "-c"}},
+		"go":     {ext: ".go", cmd: nil}, // go проверяется через go/parser в процессе
+	}
+
+	cfg, ok := langs[req.Language]
+	if !ok {
+		writeJSONError(w, http.StatusBadRequest, "unsupported language: "+req.Language)
+		return
+	}
+
+	var isOK bool
+	var result string
+
+	if req.Language == "go" {
+		// Go: используем go/parser прямо в процессе — без внешних команд и temp файлов
+		fset := token.NewFileSet()
+		_, parseErr := parser.ParseFile(fset, "code.go", req.Code, parser.AllErrors)
+		if parseErr == nil {
+			isOK = true
+			result = "✅ Синтаксис корректен."
+		} else {
+			isOK = false
+			result = parseErr.Error()
+		}
+	} else {
+		// Записываем код во временный файл с нужным расширением
+		// (линтеры ruby/php определяют режим проверки по расширению)
+		tmpf, err := os.CreateTemp("", "fission-lint-*"+cfg.ext)
+		if err != nil {
+			writeJSONError(w, http.StatusInternalServerError, "tmp file: "+err.Error())
+			return
+		}
+		defer os.Remove(tmpf.Name()) // очищаем независимо от результата
+
+		if _, err := tmpf.WriteString(req.Code); err != nil {
+			tmpf.Close()
+			writeJSONError(w, http.StatusInternalServerError, "write tmp: "+err.Error())
+			return
+		}
+		tmpf.Close()
+
+		args := append(cfg.cmd, tmpf.Name())
+		ctx, cancel := context.WithTimeout(r.Context(), 10*time.Second)
+		defer cancel()
+
+		//nolint:gosec — cfg.cmd содержит только захардкоженные команды из langs (не user input)
+		out, err := exec.CommandContext(ctx, args[0], args[1:]...).CombinedOutput()
+		outStr := strings.TrimSpace(string(out))
+		// Убираем путь к tmp-файлу из вывода — пользователю незачем его видеть
+		outStr = strings.ReplaceAll(outStr, tmpf.Name(), "<code>")
+
+		if err == nil {
+			isOK = true
+			result = "✅ Синтаксис корректен."
+		} else {
+			isOK = false
+			if outStr != "" {
+				result = outStr
+			} else {
+				result = "Ошибка синтаксиса (линтер вернул код " + fmt.Sprintf("%v", err) + ")"
+			}
+		}
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(map[string]any{
+		"ok":     isOK,
+		"result": result,
+	})
+}
+
+// =============================================================================
+// ai/ask feature — удалить весь блок до "end ai/ask feature" чтобы выкосить
+// =============================================================================
+
+// handleAIAsk отвечает на произвольный вопрос пользователя через LLM.
+// POST /console/api/ai/ask
+// Body: {"question":"..."}
+// Response: {"answer":"..."}
+func (s *Server) handleAIAsk(w http.ResponseWriter, r *http.Request) {
+	if r.Method != http.MethodPost {
+		writeJSONError(w, http.StatusMethodNotAllowed, "method not allowed")
+		return
+	}
+	if s.llmKey == "" {
+		writeJSONError(w, http.StatusServiceUnavailable, "AI-ассистент не настроен (FISSION_LLM_KEY не задан)")
+		return
+	}
+
+	var req struct {
+		Question string `json:"question"`
+	}
+	if err := json.NewDecoder(io.LimitReader(r.Body, 4*1024)).Decode(&req); err != nil {
+		writeJSONError(w, http.StatusBadRequest, "invalid JSON: "+err.Error())
+		return
+	}
+	if strings.TrimSpace(req.Question) == "" {
+		writeJSONError(w, http.StatusBadRequest, "question is required")
+		return
+	}
+
+	body, _ := json.Marshal(map[string]any{
+		"model": "gpt-oss-120b",
+		"messages": []map[string]string{
+			{"role": "system", "content": "Ты умный ассистент. Отвечай кратко и по делу."},
+			{"role": "user", "content": req.Question},
+		},
+		"max_tokens": 1024,
+	})
+
+	ctx, cancel := context.WithTimeout(r.Context(), 30*time.Second)
+	defer cancel()
+
+	llmReq, err := http.NewRequestWithContext(ctx, http.MethodPost,
+		strings.TrimRight(s.llmURL, "/")+"/chat/completions",
+		bytes.NewReader(body),
+	)
+	if err != nil {
+		writeJSONError(w, http.StatusInternalServerError, err.Error())
+		return
+	}
+	llmReq.Header.Set("Content-Type", "application/json")
+	llmReq.Header.Set("Authorization", "Bearer "+s.llmKey)
+
+	resp, err := s.http.Do(llmReq)
+	if err != nil {
+		writeJSONError(w, http.StatusBadGateway, "LLM недоступен: "+err.Error())
+		return
+	}
+	defer resp.Body.Close()
+
+	var llmResp struct {
+		Choices []struct {
+			Message struct {
+				Content string `json:"content"`
+			} `json:"message"`
+		} `json:"choices"`
+		Error *struct {
+			Message string `json:"message"`
+		} `json:"error"`
+	}
+	if err := json.NewDecoder(io.LimitReader(resp.Body, 64*1024)).Decode(&llmResp); err != nil {
+		writeJSONError(w, http.StatusBadGateway, "parse error: "+err.Error())
+		return
+	}
+	if llmResp.Error != nil {
+		writeJSONError(w, http.StatusBadGateway, llmResp.Error.Message)
+		return
+	}
+	if len(llmResp.Choices) == 0 {
+		writeJSONError(w, http.StatusBadGateway, "empty response from LLM")
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(map[string]any{
+		"answer": strings.TrimSpace(llmResp.Choices[0].Message.Content),
+	})
+}
+
+// =============================================================================
+// end ai/ask feature
+// =============================================================================

console/internal/api/auth.go

@@ -0,0 +1,125 @@
+package api
+
+import (
+	"context"
+	"crypto/sha256"
+	"encoding/base64"
+	"encoding/hex"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"strings"
+)
+
+// ctxKeyNS — ключ для хранения namespace пользователя в context.Context.
+// Использует приватный тип чтобы избежать коллизий с ключами из других пакетов.
+type ctxKeyNS struct{}
+
+// 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"
+func (s *Server) authMiddleware(h http.HandlerFunc) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		var ns string
+
+		if s.testMode {
+			sub := strings.TrimSpace(r.Header.Get("X-Test-Sub"))
+			if sub == "" {
+				sub = strings.TrimSpace(r.Header.Get("X-Auth-Token"))
+			}
+			if sub == "" {
+				writeJSONError(w, http.StatusUnauthorized, "test mode: X-Test-Sub required")
+				return
+			}
+			h32 := sha256.Sum256([]byte(sub))
+			ns = "fission-" + hex.EncodeToString(h32[:8])
+		} else {
+			token := strings.TrimSpace(r.Header.Get("X-Auth-Token"))
+			env := strings.TrimSpace(strings.ToLower(r.Header.Get("X-Auth-Env")))
+			if _, ok := deckAPIs[env]; !ok {
+				env = "test"
+			}
+			if token == "" {
+				writeJSONError(w, http.StatusUnauthorized, "unauthorized")
+				return
+			}
+			if err := s.validateDeckToken(token, env); err != nil {
+				writeJSONError(w, http.StatusUnauthorized, "unauthorized")
+				return
+			}
+			var err error
+			ns, err = namespaceFromJWT(token)
+			if err != nil {
+				ns = s.ns
+			}
+		}
+
+		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))
+			return
+		}
+
+		h(w, r.WithContext(ctx))
+	}
+}
+
+// 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
+}

console/internal/api/doc.go

@@ -0,0 +1,2 @@
+// Package api содержит HTTP сервер, роутинг, handlers и middleware.
+package api

console/internal/api/handlers.go

@@ -0,0 +1,739 @@
+package api
+
+import (
+	"bytes"
+	"context"
+	"crypto/sha256"
+	"encoding/base64"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"log"
+	"net"
+	"net/http"
+	"regexp"
+	"strconv"
+	"strings"
+	"time"
+
+	"fission-console/internal/fission"
+	"fission-console/internal/model"
+	"fission-console/internal/runtime"
+
+	apierrors "k8s.io/apimachinery/pkg/api/errors"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
+)
+
+// validFuncName — RFC 1123 subdomain label: строчные буквы+цифры+дефис, без дефиса в начале/конце.
+// Максимум 57 символов (не 63): самый длинный суффикс "-route" (HTTPTrigger) = 6 символов.
+// 63 - 6 = 57. Fission webhook требует все связанные объекты <= 63 символов.
+var validFuncName = regexp.MustCompile(`^[a-z0-9]([a-z0-9-]*[a-z0-9])?$`)
+
+// maxCodeSize — максимальный размер кода функции (1 MB).
+// Выше — не имеет смысла для inline функции; лучше использовать Package с URL.
+const maxCodeSize = 1 << 20
+
+// handleFunctionsRoot обрабатывает запросы к /console/api/functions без имени функции.
+// GET → список всех функций, POST → создать новую.
+func (s *Server) handleFunctionsRoot(w http.ResponseWriter, r *http.Request) {
+	switch r.Method {
+	case http.MethodGet:
+		s.handleList(fission.FunctionGVR)(w, r)
+	case http.MethodPost:
+		s.handleCreateFunction(w, r)
+	default:
+		http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
+	}
+}
+
+// handleFunctionsAction обрабатывает запросы к /console/api/functions/:name[/action].
+// Парсит имя функции и опциональный sub-path ("code", "invoke").
+func (s *Server) handleFunctionsAction(w http.ResponseWriter, r *http.Request) {
+	// Убираем оба возможных префикса (legacy /api/ и основной /console/api/)
+	path := strings.TrimPrefix(r.URL.Path, "/api/functions/")
+	if path == r.URL.Path {
+		path = strings.TrimPrefix(r.URL.Path, "/console/api/functions/")
+	}
+	path = strings.Trim(path, "/")
+	if path == "" {
+		http.NotFound(w, r)
+		return
+	}
+
+	parts := strings.Split(path, "/")
+	name := strings.TrimSpace(parts[0])
+	if name == "" {
+		writeJSONError(w, http.StatusBadRequest, "function name is required")
+		return
+	}
+
+	if len(parts) == 1 {
+		// /functions/:name — CRUD операции с конкретной функцией
+		switch r.Method {
+		case http.MethodGet:
+			s.handleGetFunction(w, r, name)
+		case http.MethodDelete:
+			s.handleDeleteFunction(w, r, name)
+		default:
+			http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
+		}
+		return
+	}
+
+	// /functions/:name/code — обновление кода
+	if len(parts) == 2 && parts[1] == "code" && r.Method == http.MethodPut {
+		s.handleUpdateFunctionCode(w, r, name)
+		return
+	}
+
+	// /functions/:name/invoke — вызов функции
+	if len(parts) == 2 && parts[1] == "invoke" && r.Method == http.MethodPost {
+		s.handleInvokeFunction(w, r, name)
+		return
+	}
+
+	http.NotFound(w, r)
+}
+
+// handleCreateFunction создаёт новую функцию: Package + Function + HTTPTrigger.
+//
+// Порядок создания: Package → Function → HTTPTrigger.
+// При ошибке на любом шаге откатываем уже созданные объекты (best-effort).
+// TTL парсится ДО создания объектов — невалидный TTL не оставляет мусор.
+func (s *Server) handleCreateFunction(w http.ResponseWriter, r *http.Request) {
+	ns := s.userNS(r)
+
+	var req model.CreateFunctionRequest
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		writeJSONError(w, http.StatusBadRequest, fmt.Sprintf("decode request: %v", err))
+		return
+	}
+
+	// Гарантируем namespace — на случай прямого вызова API без handleAuth
+	nsCtx, nsCancel := context.WithTimeout(r.Context(), 60*time.Second)
+	defer nsCancel()
+	if err := s.nsManager.EnsureUserNS(nsCtx, ns); err != nil {
+		writeJSONError(w, http.StatusBadGateway, fmt.Sprintf("ensure namespace: %v", err))
+		return
+	}
+
+	req.Name = strings.TrimSpace(req.Name)
+	req.Language = strings.TrimSpace(req.Language)
+	req.Environment = strings.TrimSpace(req.Environment)
+	req.Code = strings.TrimSpace(req.Code)
+	req.Entrypoint = strings.TrimSpace(req.Entrypoint)
+	req.Route = strings.TrimSpace(req.Route)
+
+	// Валидация имени
+	if req.Name != "" && (!validFuncName.MatchString(req.Name) || len(req.Name) > 57) {
+		writeJSONError(w, http.StatusBadRequest, "invalid function name: must match ^[a-z0-9]([a-z0-9-]*[a-z0-9])?$ and be <= 57 chars")
+		return
+	}
+	if len(req.Code) > maxCodeSize {
+		writeJSONError(w, http.StatusBadRequest, "code exceeds 1MB limit")
+		return
+	}
+
+	// Lazy создание Environment по языку (если язык указан явно)
+	if req.Language != "" {
+		envCtx, envCancel := context.WithTimeout(r.Context(), 15*time.Second)
+		defer envCancel()
+		envName, err := fission.EnsureEnvironment(envCtx, s.dyn, ns, req.Language)
+		if err != nil {
+			if strings.Contains(err.Error(), "unsupported language") {
+				writeJSONError(w, http.StatusBadRequest, err.Error())
+			} else {
+				writeJSONError(w, http.StatusBadGateway, fmt.Sprintf("ensure environment: %v", err))
+			}
+			return
+		}
+		req.Environment = envName
+	}
+
+	if req.Name == "" || req.Environment == "" || req.Code == "" {
+		writeJSONError(w, http.StatusBadRequest, "name, environment/language and code are required")
+		return
+	}
+	if req.Entrypoint == "" {
+		req.Entrypoint = runtime.DefaultEntrypoint(req.Language)
+	}
+	if req.Route == "" {
+		// Namespace-prefix route: избегаем коллизий между пользователями
+		// (разные пользователи могут создать функцию с одинаковым именем)
+		nsShort := ns
+		if len(nsShort) > 12 {
+			nsShort = nsShort[len(nsShort)-12:]
+		}
+		req.Route = "/" + nsShort + "/" + req.Name
+	}
+	if !strings.HasPrefix(req.Route, "/") {
+		req.Route = "/" + req.Route
+	}
+	req.Methods = normalizeMethods(req.Methods)
+
+	ctx, cancel := context.WithTimeout(r.Context(), 20*time.Second)
+	defer cancel()
+
+	// Проверяем что environment существует (мог быть задан явно без language)
+	if _, err := s.dyn.Resource(fission.EnvironmentGVR).Namespace(ns).Get(ctx, req.Environment, metav1.GetOptions{}); err != nil {
+		writeJSONError(w, http.StatusBadRequest, fmt.Sprintf("environment %q not found: %v", req.Environment, err))
+		return
+	}
+
+	pkgName := req.Name + "-pkg"
+	triggerName := req.Name + "-route"
+
+	methodValues := make([]any, 0, len(req.Methods))
+	for _, method := range req.Methods {
+		methodValues = append(methodValues, method)
+	}
+
+	// Строим Package spec в зависимости от языка:
+	// - Go: source package → builder job компилирует в .so плагин
+	// - Node.js: deployment zip с ESM wrapper (package.json + main.js)
+	// - Остальные: deployment literal с кодом напрямую
+	var pkgSpec map[string]any
+	if req.Language == "go" {
+		srcZip, err := runtime.BuildGoSourceZip(req.Code)
+		if err != nil {
+			writeJSONError(w, http.StatusBadRequest, fmt.Sprintf("build go source archive: %v", err))
+			return
+		}
+		literal := base64.StdEncoding.EncodeToString(srcZip)
+		pkgSpec = map[string]any{
+			"source": map[string]any{
+				"type":    "literal",
+				"literal": literal,
+			},
+			"deployment":   map[string]any{},
+			"environment":  map[string]any{"name": req.Environment, "namespace": ns},
+			"buildcommand": "build",
+		}
+	} else {
+		var deployBytes []byte
+		if req.Language == "nodejs" {
+			zipBytes, zipErr := runtime.BuildJSDeployZip(req.Code)
+			if zipErr != nil {
+				writeJSONError(w, http.StatusInternalServerError, fmt.Sprintf("build nodejs archive: %v", zipErr))
+				return
+			}
+			deployBytes = zipBytes
+		} else {
+			// Python, PHP, Ruby, Perl — код передаётся как есть в deployment.literal
+			deployBytes = []byte(req.Code)
+		}
+		pkgSpec = map[string]any{
+			"deployment":  map[string]any{"type": "literal", "literal": base64.StdEncoding.EncodeToString(deployBytes)},
+			"environment": map[string]any{"name": req.Environment, "namespace": ns},
+			"source":      map[string]any{},
+		}
+	}
+
+	pkg := &unstructured.Unstructured{Object: map[string]any{
+		"apiVersion": "fission.io/v1",
+		"kind":       "Package",
+		"metadata":   map[string]any{"name": pkgName, "namespace": ns},
+		"spec":       pkgSpec,
+	}}
+
+	// Парсим TTL ДО создания K8s ресурсов — невалидный TTL не оставляет мусор
+	fnAnnotations := map[string]any{
+		"fission-console/language": req.Language,
+	}
+	if req.TTL != "" {
+		expiresAt, ttlErr := parseTTL(req.TTL)
+		if ttlErr != nil {
+			writeJSONError(w, http.StatusBadRequest, fmt.Sprintf("invalid ttl %q: %v", req.TTL, ttlErr))
+			return
+		}
+		fnAnnotations["fission-console/expires-at"] = expiresAt.UTC().Format(time.RFC3339)
+	}
+
+	if _, err := s.dyn.Resource(fission.PackageGVR).Namespace(ns).Create(ctx, pkg, metav1.CreateOptions{}); err != nil {
+		if apierrors.IsAlreadyExists(err) {
+			writeJSONError(w, http.StatusConflict, fmt.Sprintf("function %q already exists", req.Name))
+			return
+		}
+		if apierrors.IsInvalid(err) {
+			writeJSONError(w, http.StatusBadRequest, fmt.Sprintf("invalid function spec: %v", err))
+			return
+		}
+		writeJSONError(w, http.StatusBadGateway, fmt.Sprintf("create package: %v", err))
+		return
+	}
+
+	fn := &unstructured.Unstructured{Object: map[string]any{
+		"apiVersion": "fission.io/v1",
+		"kind":       "Function",
+		"metadata":   map[string]any{"name": req.Name, "namespace": ns, "annotations": fnAnnotations},
+		"spec": map[string]any{
+			"environment": map[string]any{"name": req.Environment, "namespace": ns},
+			"InvokeStrategy": map[string]any{
+				"ExecutionStrategy": map[string]any{"ExecutorType": "poolmgr"},
+				"StrategyType":      "execution",
+			},
+			"package": map[string]any{
+				"packageref":   map[string]any{"name": pkgName, "namespace": ns},
+				"functionName": req.Entrypoint,
+			},
+		},
+	}}
+
+	if _, err := s.dyn.Resource(fission.FunctionGVR).Namespace(ns).Create(ctx, fn, metav1.CreateOptions{}); err != nil {
+		// Откатываем Package если Function не создалась
+		_ = s.dyn.Resource(fission.PackageGVR).Namespace(ns).Delete(ctx, pkgName, metav1.DeleteOptions{})
+		if apierrors.IsAlreadyExists(err) {
+			writeJSONError(w, http.StatusConflict, fmt.Sprintf("function %q already exists", req.Name))
+			return
+		}
+		writeJSONError(w, http.StatusBadGateway, fmt.Sprintf("create function: %v", err))
+		return
+	}
+
+	httpTrigger := &unstructured.Unstructured{Object: map[string]any{
+		"apiVersion": "fission.io/v1",
+		"kind":       "HTTPTrigger",
+		"metadata":   map[string]any{"name": triggerName, "namespace": ns},
+		"spec": map[string]any{
+			"relativeurl":   req.Route,
+			"methods":       methodValues,
+			"createingress": true,
+			"functionref":   map[string]any{"type": "name", "name": req.Name},
+		},
+	}}
+
+	if _, err := s.dyn.Resource(fission.HTTPTrigGVR).Namespace(ns).Create(ctx, httpTrigger, metav1.CreateOptions{}); err != nil {
+		// Откатываем Function и Package
+		_ = s.dyn.Resource(fission.FunctionGVR).Namespace(ns).Delete(ctx, req.Name, metav1.DeleteOptions{})
+		_ = s.dyn.Resource(fission.PackageGVR).Namespace(ns).Delete(ctx, pkgName, metav1.DeleteOptions{})
+		writeJSONError(w, http.StatusBadGateway, fmt.Sprintf("create httptrigger: %v", err))
+		return
+	}
+
+	writeAnyJSON(w, http.StatusCreated, map[string]any{
+		"name":        req.Name,
+		"package":     pkgName,
+		"httptrigger": triggerName,
+		"route":       req.Route,
+		"expires_at":  fnAnnotations["fission-console/expires-at"],
+	})
+}
+
+// handleGetFunction возвращает детали функции: код, environment, route, methods.
+func (s *Server) handleGetFunction(w http.ResponseWriter, r *http.Request, name string) {
+	ctx, cancel := context.WithTimeout(r.Context(), 10*time.Second)
+	defer cancel()
+	ns := s.userNS(r)
+
+	fn, err := s.dyn.Resource(fission.FunctionGVR).Namespace(ns).Get(ctx, name, metav1.GetOptions{})
+	if err != nil {
+		status := http.StatusBadGateway
+		if apierrors.IsNotFound(err) {
+			status = http.StatusNotFound
+		}
+		writeJSONError(w, status, fmt.Sprintf("get function %q: %v", name, err))
+		return
+	}
+
+	packageName, _, _ := unstructured.NestedString(fn.Object, "spec", "package", "packageref", "name")
+	environment, _, _ := unstructured.NestedString(fn.Object, "spec", "environment", "name")
+	entrypoint, _, _ := unstructured.NestedString(fn.Object, "spec", "package", "functionName")
+
+	// Извлекаем исходный код из Package (пробуем source.literal, потом deployment.literal, потом url)
+	code := ""
+	if packageName != "" {
+		pkg, pkgErr := s.dyn.Resource(fission.PackageGVR).Namespace(ns).Get(ctx, packageName, metav1.GetOptions{})
+		if pkgErr == nil {
+			code = extractPackageSourceCode(ctx, s, pkg)
+		}
+	}
+
+	// Ищем HTTPTrigger для получения route и methods
+	route := ""
+	methods := []string{}
+	triggers, trigErr := s.dyn.Resource(fission.HTTPTrigGVR).Namespace(ns).List(ctx, metav1.ListOptions{})
+	if trigErr == nil {
+		for _, trig := range triggers.Items {
+			refName, _, _ := unstructured.NestedString(trig.Object, "spec", "functionref", "name")
+			if refName != name {
+				continue
+			}
+			route, _, _ = unstructured.NestedString(trig.Object, "spec", "relativeurl")
+			methods, _, _ = unstructured.NestedStringSlice(trig.Object, "spec", "methods")
+			break
+		}
+	}
+
+	writeAnyJSON(w, http.StatusOK, map[string]any{
+		"name":        name,
+		"namespace":   ns,
+		"environment": environment,
+		"package":     packageName,
+		"entrypoint":  entrypoint,
+		"code":        code,
+		"route":       route,
+		"methods":     methods,
+		"raw":         fn.Object,
+	})
+}
+
+// handleUpdateFunctionCode обновляет код уже существующей функции.
+// Обновляет Package.spec.deployment.literal и синхронизирует resourceVersion в Function.
+//
+// Почему нужно обновлять resourceVersion в Function:
+// Fission executor кэширует Package по resourceVersion. Без обновления в Function
+// executor будет использовать старый код до перезапуска pod.
+func (s *Server) handleUpdateFunctionCode(w http.ResponseWriter, r *http.Request, name string) {
+	var req model.UpdateCodeRequest
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		writeJSONError(w, http.StatusBadRequest, fmt.Sprintf("decode request: %v", err))
+		return
+	}
+	req.Code = strings.TrimSpace(req.Code)
+	if req.Code == "" {
+		writeJSONError(w, http.StatusBadRequest, "code is required")
+		return
+	}
+
+	ctx, cancel := context.WithTimeout(r.Context(), 20*time.Second)
+	defer cancel()
+	ns := s.userNS(r)
+
+	fn, err := s.dyn.Resource(fission.FunctionGVR).Namespace(ns).Get(ctx, name, metav1.GetOptions{})
+	if err != nil {
+		status := http.StatusBadGateway
+		if apierrors.IsNotFound(err) {
+			status = http.StatusNotFound
+		}
+		writeJSONError(w, status, fmt.Sprintf("get function %q: %v", name, err))
+		return
+	}
+
+	pkgName, _, _ := unstructured.NestedString(fn.Object, "spec", "package", "packageref", "name")
+	if pkgName == "" {
+		writeJSONError(w, http.StatusBadGateway, "function has no package reference")
+		return
+	}
+
+	pkg, err := s.dyn.Resource(fission.PackageGVR).Namespace(ns).Get(ctx, pkgName, metav1.GetOptions{})
+	if err != nil {
+		status := http.StatusBadGateway
+		if apierrors.IsNotFound(err) {
+			status = http.StatusNotFound
+		}
+		writeJSONError(w, status, fmt.Sprintf("get package %q: %v", pkgName, err))
+		return
+	}
+
+	// Определяем язык из аннотации — нужен для правильной упаковки
+	lang, _, _ := unstructured.NestedString(fn.Object, "metadata", "annotations", "fission-console/language")
+	var deployBytes []byte
+	if lang == "nodejs" {
+		zipBytes, zipErr := runtime.BuildJSDeployZip(req.Code)
+		if zipErr != nil {
+			writeJSONError(w, http.StatusInternalServerError, fmt.Sprintf("build nodejs archive: %v", zipErr))
+			return
+		}
+		deployBytes = zipBytes
+	} else {
+		deployBytes = []byte(req.Code)
+	}
+
+	literal := base64.StdEncoding.EncodeToString(deployBytes)
+	if err := unstructured.SetNestedField(pkg.Object, literal, "spec", "deployment", "literal"); err != nil {
+		writeJSONError(w, http.StatusInternalServerError, fmt.Sprintf("set package literal: %v", err))
+		return
+	}
+
+	updatedPkg, err := s.dyn.Resource(fission.PackageGVR).Namespace(ns).Update(ctx, pkg, metav1.UpdateOptions{})
+	if err != nil {
+		writeJSONError(w, http.StatusBadGateway, fmt.Sprintf("update package %q: %v", pkgName, err))
+		return
+	}
+
+	// Синхронизируем resourceVersion в Function.spec.package.packageref
+	// Это триггерит executor перезагрузить код в pool pod
+	if err := unstructured.SetNestedField(fn.Object, updatedPkg.GetResourceVersion(), "spec", "package", "packageref", "resourceversion"); err != nil {
+		writeJSONError(w, http.StatusInternalServerError, fmt.Sprintf("set function package resourceversion: %v", err))
+		return
+	}
+	if _, err := s.dyn.Resource(fission.FunctionGVR).Namespace(ns).Update(ctx, fn, metav1.UpdateOptions{}); err != nil {
+		writeJSONError(w, http.StatusBadGateway, fmt.Sprintf("update function %q package ref: %v", name, err))
+		return
+	}
+
+	writeAnyJSON(w, http.StatusOK, map[string]any{
+		"updated":                 true,
+		"package":                 pkgName,
+		"package_resourceversion": updatedPkg.GetResourceVersion(),
+	})
+}
+
+// handleInvokeFunction вызывает функцию через Fission router.
+// Определяет реальный URL из HTTPTrigger, выбирает метод (POST/GET).
+func (s *Server) handleInvokeFunction(w http.ResponseWriter, r *http.Request, name string) {
+	bodyBytes, err := io.ReadAll(r.Body)
+	if err != nil {
+		writeJSONError(w, http.StatusBadRequest, fmt.Sprintf("read request body: %v", err))
+		return
+	}
+	if len(bytes.TrimSpace(bodyBytes)) == 0 {
+		bodyBytes = []byte("{}")
+	}
+
+	invokeTimeout := s.invokeTimeout
+	if invokeTimeout <= 0 {
+		invokeTimeout = 20 * time.Second
+	}
+
+	ctx, cancel := context.WithTimeout(r.Context(), invokeTimeout)
+	defer cancel()
+	ns := s.userNS(r)
+
+	// Проверяем существование функции до вызова — лучше 404 чем непонятный timeout
+	if _, err2 := s.dyn.Resource(fission.FunctionGVR).Namespace(ns).Get(ctx, name, metav1.GetOptions{}); err2 != nil {
+		if apierrors.IsNotFound(err2) {
+			writeJSONError(w, http.StatusNotFound, fmt.Sprintf("function %q not found", name))
+			return
+		}
+		writeJSONError(w, http.StatusBadGateway, fmt.Sprintf("get function %q: %v", name, err2))
+		return
+	}
+
+	// Ищем HTTPTrigger чтобы получить реальный URL и метод
+	invokeURL := fmt.Sprintf("%s/fission-function/v2/functions/%s", s.routerURL, name)
+	invokeMethod := http.MethodPost
+	triggers, err := s.dyn.Resource(fission.HTTPTrigGVR).Namespace(ns).List(ctx, metav1.ListOptions{})
+	if err == nil {
+		for _, trig := range triggers.Items {
+			refName, _, _ := unstructured.NestedString(trig.Object, "spec", "functionref", "name")
+			if refName != name {
+				continue
+			}
+			route, _, _ := unstructured.NestedString(trig.Object, "spec", "relativeurl")
+			methods, _, _ := unstructured.NestedStringSlice(trig.Object, "spec", "methods")
+			hasPost, hasGet := false, false
+			for _, m := range methods {
+				switch strings.ToUpper(strings.TrimSpace(m)) {
+				case http.MethodPost:
+					hasPost = true
+				case http.MethodGet:
+					hasGet = true
+				}
+			}
+			if route != "" {
+				if !strings.HasPrefix(route, "/") {
+					route = "/" + route
+				}
+				invokeURL = s.routerURL + route
+				// Если функция поддерживает только GET — используем GET
+				if !hasPost && hasGet {
+					invokeMethod = http.MethodGet
+				}
+				break
+			}
+		}
+	}
+
+	start := time.Now()
+	var invokeBody io.Reader
+	if invokeMethod == http.MethodPost {
+		invokeBody = bytes.NewReader(bodyBytes)
+	}
+
+	req, err := http.NewRequestWithContext(ctx, invokeMethod, invokeURL, invokeBody)
+	if err != nil {
+		writeJSONError(w, http.StatusInternalServerError, fmt.Sprintf("build invoke request: %v", err))
+		return
+	}
+	if invokeMethod == http.MethodPost {
+		req.Header.Set("Content-Type", "application/json")
+	}
+	if token := s.getRouterToken(); token != "" {
+		req.Header.Set("Authorization", "Bearer "+token)
+	}
+
+	resp, err := s.http.Do(req)
+	if err != nil {
+		// Отличаем timeout от сетевой ошибки — timeout часто означает что функция не специализировалась
+		if errors.Is(err, context.DeadlineExceeded) {
+			writeJSONError(w, http.StatusBadGateway, fmt.Sprintf("invoke %q timeout after %s: function specialization likely failed (for example, syntax error)", name, invokeTimeout))
+			return
+		}
+		var netErr net.Error
+		if errors.As(err, &netErr) && netErr.Timeout() {
+			writeJSONError(w, http.StatusBadGateway, fmt.Sprintf("invoke %q timeout after %s: function specialization likely failed (for example, syntax error)", name, invokeTimeout))
+			return
+		}
+		writeJSONError(w, http.StatusBadGateway, fmt.Sprintf("invoke %q: %v", name, err))
+		return
+	}
+	defer resp.Body.Close()
+
+	respBody, _ := io.ReadAll(resp.Body)
+	writeAnyJSON(w, http.StatusOK, map[string]any{
+		"status":       resp.StatusCode,
+		"latency_ms":   time.Since(start).Milliseconds(),
+		"invoke_url":   invokeURL,
+		"response_raw": string(respBody),
+	})
+}
+
+// handleDeleteFunction удаляет функцию и связанные объекты: HTTPTrigger, Package.
+// После удаления вызывает CleanupEnvironmentIfUnused — убирает environment если язык больше не используется.
+func (s *Server) handleDeleteFunction(w http.ResponseWriter, r *http.Request, name string) {
+	ctx, cancel := context.WithTimeout(r.Context(), 20*time.Second)
+	defer cancel()
+	ns := s.userNS(r)
+
+	// Получаем Function чтобы знать pkgName и envName для cleanup
+	var pkgName, envName string
+	fn, err := s.dyn.Resource(fission.FunctionGVR).Namespace(ns).Get(ctx, name, metav1.GetOptions{})
+	if err != nil {
+		if apierrors.IsNotFound(err) {
+			writeJSONError(w, http.StatusNotFound, fmt.Sprintf("function %q not found", name))
+			return
+		}
+		writeJSONError(w, http.StatusBadGateway, fmt.Sprintf("get function %q: %v", name, err))
+		return
+	}
+	pkgName, _, _ = unstructured.NestedString(fn.Object, "spec", "package", "packageref", "name")
+	envName, _, _ = unstructured.NestedString(fn.Object, "spec", "environment", "name")
+
+	// Удаляем связанные HTTPTrigger-ы
+	triggers, err := s.dyn.Resource(fission.HTTPTrigGVR).Namespace(ns).List(ctx, metav1.ListOptions{})
+	if err == nil {
+		for _, trig := range triggers.Items {
+			refName, _, _ := unstructured.NestedString(trig.Object, "spec", "functionref", "name")
+			if refName == name {
+				_ = s.dyn.Resource(fission.HTTPTrigGVR).Namespace(ns).Delete(ctx, trig.GetName(), metav1.DeleteOptions{})
+			}
+		}
+	}
+
+	if err := s.dyn.Resource(fission.FunctionGVR).Namespace(ns).Delete(ctx, name, metav1.DeleteOptions{}); err != nil && !apierrors.IsNotFound(err) {
+		writeJSONError(w, http.StatusBadGateway, fmt.Sprintf("delete function %q: %v", name, err))
+		return
+	}
+
+	if pkgName != "" {
+		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
+		}
+	}
+
+	// Убираем environment pool pods если язык больше не используется (best-effort)
+	if envName != "" {
+		cleanupCtx, cleanupCancel := context.WithTimeout(context.Background(), 15*time.Second)
+		defer cleanupCancel()
+		fission.CleanupEnvironmentIfUnused(cleanupCtx, s.dyn, ns, envName)
+	}
+
+	// Сигналим reconciler: батчит изменения без race condition и rolling restarts
+	select {
+	case s.nsManager.NSReconcileCh <- struct{}{}:
+	default:
+	}
+
+	writeAnyJSON(w, http.StatusOK, map[string]any{"deleted": true, "name": name, "package": pkgName})
+}
+
+// handleAuth обрабатывает POST /console/api/auth.
+// Валидирует токен, создаёт namespace, возвращает namespace пользователя.
+func (s *Server) handleAuth(w http.ResponseWriter, r *http.Request) {
+	if r.Method != http.MethodPost {
+		writeJSONError(w, http.StatusMethodNotAllowed, "method not allowed")
+		return
+	}
+
+	var body struct {
+		Token string `json:"token"`
+		Env   string `json:"env"`
+	}
+	if err := json.NewDecoder(r.Body).Decode(&body); err != nil || strings.TrimSpace(body.Token) == "" {
+		writeJSONError(w, http.StatusBadRequest, "token required")
+		return
+	}
+
+	env := strings.TrimSpace(strings.ToLower(body.Env))
+	if _, ok := deckAPIs[env]; !ok {
+		env = "test"
+	}
+
+	var ns string
+	if s.testMode {
+		// testMode: токен — это email (sub), Deck не вызывается
+		if !strings.Contains(body.Token, "@") {
+			writeJSONError(w, http.StatusUnauthorized, "invalid token")
+			return
+		}
+		h32 := sha256.Sum256([]byte(body.Token))
+		ns = "fission-" + fmt.Sprintf("%x", h32[:8])
+	} else {
+		if err := s.validateDeckToken(body.Token, env); err != nil {
+			writeJSONError(w, http.StatusUnauthorized, "invalid token")
+			return
+		}
+		var err error
+		ns, err = namespaceFromJWT(body.Token)
+		if err != nil {
+			log.Printf("handleAuth: namespaceFromJWT: %v", err)
+			ns = s.ns
+		}
+	}
+
+	ctx, cancel := context.WithTimeout(r.Context(), 60*time.Second)
+	defer cancel()
+	if ensureErr := s.nsManager.EnsureUserNS(ctx, ns); ensureErr != nil {
+		log.Printf("handleAuth: ensureUserNS %s: %v", ns, ensureErr)
+	}
+
+	w.Header().Set("Content-Type", "application/json; charset=utf-8")
+	_ = json.NewEncoder(w).Encode(map[string]any{"ok": true, "env": env, "namespace": ns})
+}
+
+// parseTTL парсит строку TTL и возвращает время истечения.
+// Поддерживаемые форматы: Go duration (1h, 30m, 24h) и дни (1d, 7d, 30d).
+// Суффикс "d" не поддерживается стандартным time.ParseDuration — обрабатываем отдельно.
+func parseTTL(ttl string) (time.Time, error) {
+	if strings.HasSuffix(ttl, "d") {
+		days, err := strconv.Atoi(strings.TrimSuffix(ttl, "d"))
+		if err != nil || days <= 0 {
+			return time.Time{}, fmt.Errorf("invalid days value: %q", ttl)
+		}
+		return time.Now().Add(time.Duration(days) * 24 * time.Hour), nil
+	}
+	d, err := time.ParseDuration(ttl)
+	if err != nil {
+		return time.Time{}, err
+	}
+	if d <= 0 {
+		return time.Time{}, fmt.Errorf("ttl must be positive")
+	}
+	return time.Now().Add(d), nil
+}
+
+// normalizeMethods приводит список HTTP методов к верхнему регистру, убирает дубли.
+// Если список пустой или все элементы пустые — возвращает ["GET"].
+func normalizeMethods(in []string) []string {
+	if len(in) == 0 {
+		return []string{"GET"}
+	}
+	out := make([]string, 0, len(in))
+	seen := map[string]bool{}
+	for _, method := range in {
+		m := strings.ToUpper(strings.TrimSpace(method))
+		if m == "" || seen[m] {
+			continue
+		}
+		seen[m] = true
+		out = append(out, m)
+	}
+	if len(out) == 0 {
+		return []string{"GET"}
+	}
+	return out
+}

console/internal/api/middleware.go

@@ -0,0 +1,56 @@
+package api
+
+import (
+	"log"
+	"net/http"
+)
+
+// logRequests логирует метод и путь каждого входящего запроса.
+// Middleware-обёртка: оборачивает любой http.Handler.
+func logRequests(next http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		log.Printf("%s %s", r.Method, r.URL.Path)
+		next.ServeHTTP(w, r)
+	})
+}
+
+// withCORS добавляет CORS заголовки для разрешения cross-origin запросов.
+//
+// Почему Access-Control-Allow-Origin: *:
+// Console — одностраничное приложение, может обслуживаться с любого домена.
+// Строгий CORS с конкретным Origin потребовал бы конфигурации при деплое.
+// Все чувствительные операции защищены X-Auth-Token — не cookie, не ambient credentials.
+func withCORS(next http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Access-Control-Allow-Origin", "*")
+		w.Header().Set("Access-Control-Allow-Methods", "GET,POST,PUT,PATCH,DELETE,OPTIONS")
+		w.Header().Set("Access-Control-Allow-Headers", "Content-Type, Authorization, X-Auth-Token, X-Auth-Env")
+		// Preflight OPTIONS — отвечаем сразу без передачи в handler
+		if r.Method == http.MethodOptions {
+			w.WriteHeader(http.StatusNoContent)
+			return
+		}
+		next.ServeHTTP(w, r)
+	})
+}
+
+// withSecurityHeaders добавляет стандартные HTTP security заголовки.
+// Снижает риск XSS, clickjacking и утечки Referer.
+func withSecurityHeaders(next http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		// nosniff: браузер не должен угадывать MIME тип — только то что в Content-Type
+		w.Header().Set("X-Content-Type-Options", "nosniff")
+		// DENY: запрещаем отображение страницы в iframe (clickjacking protection)
+		w.Header().Set("X-Frame-Options", "DENY")
+		// strict-origin-when-cross-origin: скрываем полный URL при cross-origin запросах
+		w.Header().Set("Referrer-Policy", "strict-origin-when-cross-origin")
+		// Отключаем браузерные API которые не нужны console
+		w.Header().Set("Permissions-Policy", "camera=(), microphone=(), geolocation=()")
+		// CSP: разрешаем только ресурсы с того же origin + inline scripts/styles (нужны для embedded UI)
+		w.Header().Set("Content-Security-Policy",
+			"default-src 'self'; script-src 'self' 'unsafe-inline'; style-src 'self' 'unsafe-inline'; "+
+				"img-src 'self' data:; connect-src 'self'; font-src 'self' data:; object-src 'none'; "+
+				"frame-ancestors 'none'; base-uri 'self'; form-action 'self'; upgrade-insecure-requests; block-all-mixed-content")
+		next.ServeHTTP(w, r)
+	})
+}

console/internal/api/ns_status.go

@@ -0,0 +1,120 @@
+package api
+
+import (
+	"context"
+	"net/http"
+	"os"
+	"strings"
+	"time"
+
+	"fission-console/internal/fission"
+
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+)
+
+// handleNSStatus возвращает статус инициализации пользовательского namespace.
+// Используется UI для отображения прогресса при первом входе нового пользователя.
+//
+// Три стадии:
+//  1. Namespace существует и Active
+//  2. Namespace добавлен в FISSION_RESOURCE_NAMESPACES executor deployment
+//  3. Executor pod Running + Ready (готов принимать функции)
+func (s *Server) handleNSStatus(w http.ResponseWriter, r *http.Request) {
+	ns := s.userNS(r)
+	ctx, cancel := context.WithTimeout(r.Context(), 15*time.Second)
+	defer cancel()
+
+	fissionNS := os.Getenv("FISSION_SYSTEM_NAMESPACE")
+	if fissionNS == "" {
+		fissionNS = "fission"
+	}
+
+	type stageInfo struct {
+		Name string `json:"name"`
+		Done bool   `json:"done"`
+	}
+	stages := []stageInfo{
+		{Name: "Создание пространства имён"},
+		{Name: "Регистрация в Fission"},
+		{Name: "Прогрев окружений"},
+	}
+
+	// Stage 1: namespace существует и Active
+	nsObj, err := s.dyn.Resource(fission.NamespaceGVR).Get(ctx, ns, metav1.GetOptions{})
+	if err == nil {
+		phase, _, _ := unstructured.NestedString(nsObj.Object, "status", "phase")
+		stages[0].Done = phase == "Active"
+	}
+
+	// Stage 2: namespace в FISSION_RESOURCE_NAMESPACES executor deployment
+	if stages[0].Done {
+		execDep, err2 := s.dyn.Resource(fission.DeploymentGVR).Namespace(fissionNS).Get(ctx, "executor", metav1.GetOptions{})
+		if err2 == nil {
+			stages[1].Done = nsInFissionEnv(execDep, ns)
+		}
+	}
+
+	// Stage 3: executor pod Running + Ready
+	if stages[1].Done {
+		podGVR := schema.GroupVersionResource{Group: "", Version: "v1", Resource: "pods"}
+		podList, err3 := s.dyn.Resource(podGVR).Namespace(fissionNS).List(ctx, metav1.ListOptions{
+			LabelSelector: "svc=executor",
+		})
+		if err3 == nil {
+			for _, pod := range podList.Items {
+				phase, _, _ := unstructured.NestedString(pod.Object, "status", "phase")
+				if phase != "Running" {
+					continue
+				}
+				conditions, _, _ := unstructured.NestedSlice(pod.Object, "status", "conditions")
+				for _, c := range conditions {
+					cond, ok := c.(map[string]any)
+					if !ok {
+						continue
+					}
+					if cond["type"] == "Ready" && cond["status"] == "True" {
+						stages[2].Done = true
+					}
+				}
+			}
+		}
+	}
+
+	ready := stages[0].Done && stages[1].Done && stages[2].Done
+	writeAnyJSON(w, http.StatusOK, map[string]any{
+		"ready":  ready,
+		"stages": stages,
+	})
+}
+
+// nsInFissionEnv проверяет что namespace ns содержится в FISSION_RESOURCE_NAMESPACES
+// первого контейнера данного deployment.
+func nsInFissionEnv(dep *unstructured.Unstructured, ns string) bool {
+	containers, _, _ := unstructured.NestedSlice(dep.Object, "spec", "template", "spec", "containers")
+	for _, c := range containers {
+		cont, ok := c.(map[string]any)
+		if !ok {
+			continue
+		}
+		envs, _, _ := unstructured.NestedSlice(cont, "env")
+		for _, e := range envs {
+			env, ok := e.(map[string]any)
+			if !ok {
+				continue
+			}
+			if env["name"] == "FISSION_RESOURCE_NAMESPACES" {
+				if v, ok := env["value"].(string); ok {
+					for _, p := range strings.Split(v, ",") {
+						if strings.TrimSpace(p) == ns {
+							return true
+						}
+					}
+				}
+			}
+		}
+		break // только первый контейнер
+	}
+	return false
+}

console/internal/api/package.go

@@ -0,0 +1,156 @@
+package api
+
+import (
+	"archive/zip"
+	"bytes"
+	"context"
+	"encoding/base64"
+	"io"
+	"net/http"
+	"sort"
+	"strings"
+	"unicode/utf8"
+
+	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
+)
+
+// extractPackageSourceCode пытается извлечь исходный код из Fission Package.
+// Порядок попыток:
+//  1. spec.source.literal (base64) — Go функции (source package)
+//  2. spec.deployment.literal (base64) — интерпретируемые языки
+//  3. spec.source.url / spec.deployment.url — скачиваем архив по URL
+//
+// Декодирование: если данные — валидный UTF-8, возвращаем как есть.
+// Если это zip — ищем известные файлы (main.py, handler.rb и т.д.).
+func extractPackageSourceCode(ctx context.Context, s *Server, pkg *unstructured.Unstructured) string {
+	literalPaths := [][]string{
+		{"spec", "source", "literal"},
+		{"spec", "deployment", "literal"},
+	}
+	for _, p := range literalPaths {
+		literal, found, _ := unstructured.NestedString(pkg.Object, p...)
+		if !found || strings.TrimSpace(literal) == "" {
+			continue
+		}
+		if code, err := decodeLiteralToSource(literal); err == nil && strings.TrimSpace(code) != "" {
+			return code
+		}
+	}
+
+	// Fallback: скачиваем по URL
+	urlPaths := [][]string{
+		{"spec", "source", "url"},
+		{"spec", "deployment", "url"},
+	}
+	for _, p := range urlPaths {
+		urlValue, found, _ := unstructured.NestedString(pkg.Object, p...)
+		if !found || strings.TrimSpace(urlValue) == "" {
+			continue
+		}
+		archiveBytes, err := fetchPackageArchive(ctx, s, urlValue)
+		if err != nil {
+			continue
+		}
+		if code, err := decodeArchiveBytesToSource(archiveBytes); err == nil && strings.TrimSpace(code) != "" {
+			return code
+		}
+	}
+
+	return ""
+}
+
+// fetchPackageArchive скачивает архив функции по URL из Fission storage.
+func fetchPackageArchive(ctx context.Context, s *Server, archiveURL string) ([]byte, error) {
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, archiveURL, nil)
+	if err != nil {
+		return nil, err
+	}
+	resp, err := s.http.Do(req)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
+		return nil, io.ErrUnexpectedEOF
+	}
+	return io.ReadAll(resp.Body)
+}
+
+// decodeLiteralToSource декодирует base64-строку из Package.spec.*.literal в исходный код.
+func decodeLiteralToSource(literal string) (string, error) {
+	decoded, err := base64.StdEncoding.DecodeString(literal)
+	if err != nil {
+		return "", err
+	}
+	return decodeArchiveBytesToSource(decoded)
+}
+
+// decodeArchiveBytesToSource преобразует байты (utf-8 строка или zip архив) в исходный код.
+func decodeArchiveBytesToSource(decoded []byte) (string, error) {
+	if len(decoded) == 0 {
+		return "", io.ErrUnexpectedEOF
+	}
+	// Если байты — валидный UTF-8, возвращаем напрямую (python, ruby, perl, php)
+	if utf8.Valid(decoded) {
+		return string(decoded), nil
+	}
+	// PK signature: zip архив (nodejs, go source)
+	if len(decoded) >= 4 && bytes.Equal(decoded[:4], []byte{'P', 'K', 3, 4}) {
+		if src, zipErr := decodeZipSource(decoded); zipErr == nil {
+			return src, nil
+		}
+	}
+	return "", io.ErrUnexpectedEOF
+}
+
+// decodeZipSource извлекает исходный UTF-8 файл из zip архива.
+// Предпочитает хорошо известные имена файлов (main.py, handler.go и т.д.).
+func decodeZipSource(zipBytes []byte) (string, error) {
+	reader, err := zip.NewReader(bytes.NewReader(zipBytes), int64(len(zipBytes)))
+	if err != nil {
+		return "", err
+	}
+
+	// Сначала ищем по приоритетным именам
+	preferred := []string{"main.py", "main.js", "main.go", "handler.go", "handler.js", "handler.py"}
+	for _, name := range preferred {
+		for _, file := range reader.File {
+			if strings.EqualFold(file.Name, name) {
+				content, readErr := readZipFile(file)
+				if readErr == nil && utf8.Valid(content) {
+					return string(content), nil
+				}
+			}
+		}
+	}
+
+	// Fallback: первый UTF-8 файл по алфавиту (не директория)
+	files := make([]*zip.File, 0, len(reader.File))
+	for _, file := range reader.File {
+		if !file.FileInfo().IsDir() {
+			files = append(files, file)
+		}
+	}
+	sort.Slice(files, func(i, j int) bool { return files[i].Name < files[j].Name })
+
+	for _, file := range files {
+		content, readErr := readZipFile(file)
+		if readErr == nil && utf8.Valid(content) {
+			return string(content), nil
+		}
+	}
+
+	return "", io.ErrUnexpectedEOF
+}
+
+// readZipFile открывает и читает содержимое файла из zip архива.
+func readZipFile(file *zip.File) ([]byte, error) {
+	rc, err := file.Open()
+	if err != nil {
+		return nil, err
+	}
+	defer rc.Close()
+	return io.ReadAll(rc)
+}
+
+// decodeZipSource извлекает исходный UTF-8 файл из zip архива.

console/internal/api/server.go

@@ -0,0 +1,295 @@
+package api
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"os"
+	"strings"
+	"sync"
+	"time"
+
+	"fission-console/internal/fission"
+	"fission-console/ui"
+
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+	"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, конфиги, кэши токенов.
+type Server struct {
+	dyn       dynamic.Interface
+	ns        string // системный namespace (fallback, обычно "fission")
+	routerURL string
+	http      *http.Client
+
+	saTokenPath   string
+	invokeTimeout time.Duration
+	testMode      bool // FISSION_TEST_MODE=true — пропускает deck auth
+
+	authUser string
+	authPass string
+
+	// --- ai/ask feature (удалить блок целиком чтобы выкосить) ---
+	llmURL string // FISSION_LLM_URL
+	llmKey string // FISSION_LLM_KEY
+	// --- end ai/ask feature ---
+
+	// tokenMu защищает кэш JWT токена для аутентификации в Fission router.
+	tokenMu    sync.Mutex
+	cachedJWT  string
+	tokenExpAt time.Time
+
+	// tokenCache кэширует результаты валидации Deck токенов.
+	// Ключ: "env:token", значение: time.Time — когда кэш истекает.
+	tokenCache sync.Map
+
+	// nsManager управляет жизненным циклом пользовательских namespace-ов.
+	nsManager *fission.NSManager
+}
+
+// Config содержит все параметры для создания Server.
+type Config struct {
+	Dyn           dynamic.Interface
+	Namespace     string
+	RouterURL     string
+	HTTPTimeout   time.Duration
+	InvokeTimeout time.Duration
+	SATokenPath   string
+	AuthUser      string
+	AuthPass      string
+	TestMode      bool
+	LLMUrl        string
+	LLMKey        string
+}
+
+// NewServer создаёт и настраивает HTTP Server со всеми зависимостями.
+func NewServer(cfg Config) *Server {
+	return &Server{
+		dyn:           cfg.Dyn,
+		ns:            cfg.Namespace,
+		routerURL:     cfg.RouterURL,
+		http:          &http.Client{Timeout: cfg.HTTPTimeout},
+		saTokenPath:   cfg.SATokenPath,
+		invokeTimeout: cfg.InvokeTimeout,
+		authUser:      cfg.AuthUser,
+		authPass:      cfg.AuthPass,
+		testMode:      cfg.TestMode,
+		llmURL:        cfg.LLMUrl,
+		llmKey:        cfg.LLMKey,
+		nsManager:     fission.NewNSManager(cfg.Dyn),
+	}
+}
+
+// RegisterRoutes регистрирует все HTTP маршруты на mux.
+// Разделено на публичные (без auth) и приватные (с authMiddleware).
+func (s *Server) RegisterRoutes(mux *http.ServeMux) {
+	// Публичные: health checks, UI, auth endpoint
+	mux.HandleFunc("/health", func(w http.ResponseWriter, _ *http.Request) {
+		w.Header().Set("Content-Type", "text/plain; charset=utf-8")
+		_, _ = w.Write([]byte("ok\n"))
+	})
+	mux.HandleFunc("/console/health", func(w http.ResponseWriter, _ *http.Request) {
+		w.Header().Set("Content-Type", "text/plain; charset=utf-8")
+		_, _ = w.Write([]byte("ok\n"))
+	})
+
+	// UI: embedded single-page app
+	uiHandler := http.StripPrefix("/console", ui.Handler())
+	mux.Handle("/console", uiHandler)
+	mux.Handle("/console/", uiHandler)
+
+	// Auth: не требует токена — сам проверяет и возвращает namespace
+	mux.HandleFunc("/console/api/auth", s.handleAuth)
+
+	// Приватные: требуют X-Auth-Token / X-Test-Sub
+	auth := s.authMiddleware
+
+	// Legacy /api/* (без /console префикса) — для обратной совместимости
+	mux.HandleFunc("/api/environments", s.handleList(fission.EnvironmentGVR))
+	mux.HandleFunc("/api/packages", s.handleList(fission.PackageGVR))
+	mux.HandleFunc("/api/functions", s.handleFunctionsRoot)
+	mux.HandleFunc("/api/functions/", s.handleFunctionsAction)
+	mux.HandleFunc("/api/httptriggers", s.handleList(fission.HTTPTrigGVR))
+	mux.HandleFunc("/api/timetriggers", s.handleList(fission.TimeTrigGVR))
+
+	// Основные /console/api/* маршруты
+	mux.HandleFunc("/console/api/environments", auth(s.handleList(fission.EnvironmentGVR)))
+	mux.HandleFunc("/console/api/packages", auth(s.handleList(fission.PackageGVR)))
+	mux.HandleFunc("/console/api/functions", auth(s.handleFunctionsRoot))
+	mux.HandleFunc("/console/api/functions/", auth(s.handleFunctionsAction))
+	mux.HandleFunc("/console/api/httptriggers", auth(s.handleList(fission.HTTPTrigGVR)))
+	mux.HandleFunc("/console/api/timetriggers", auth(s.handleList(fission.TimeTrigGVR)))
+	mux.HandleFunc("/console/api/ns/status", auth(s.handleNSStatus))
+	mux.HandleFunc("/console/api/ai/check", auth(s.handleAICheck))
+	// --- ai/ask feature (удалить строку чтобы выкосить роут) ---
+	mux.HandleFunc("/console/api/ai/ask", auth(s.handleAIAsk))
+	// --- end ai/ask feature ---
+}
+
+// Handler возвращает http.Handler со всеми middleware: CORS, security headers, логирование.
+func (s *Server) Handler() http.Handler {
+	mux := http.NewServeMux()
+	s.RegisterRoutes(mux)
+	return withSecurityHeaders(withCORS(logRequests(mux)))
+}
+
+// NSManager возвращает указатель на NSManager для запуска фоновых горутин из main.
+func (s *Server) NSManager() *fission.NSManager {
+	return s.nsManager
+}
+
+// handleList возвращает handler который читает список ресурсов из namespace пользователя.
+// Общий для environments, packages, functions, httptriggers, timetriggers.
+func (s *Server) handleList(gvr schema.GroupVersionResource) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		if r.Method != http.MethodGet {
+			http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
+			return
+		}
+
+		ctx, cancel := context.WithTimeout(r.Context(), 10*time.Second)
+		defer cancel()
+
+		list, err := s.dyn.Resource(gvr).Namespace(s.userNS(r)).List(ctx, metav1.ListOptions{})
+		if err != nil {
+			writeJSONError(w, http.StatusBadGateway, fmt.Sprintf("list %s: %v", gvr.Resource, err))
+			return
+		}
+
+		writeJSON(w, http.StatusOK, list.Items)
+	}
+}
+
+// writeJSON сериализует список unstructured объектов в JSON response.
+func writeJSON(w http.ResponseWriter, status int, data []unstructured.Unstructured) {
+	w.Header().Set("Content-Type", "application/json; charset=utf-8")
+	w.WriteHeader(status)
+	_ = json.NewEncoder(w).Encode(data)
+}
+
+// writeAnyJSON сериализует любое значение в JSON response.
+func writeAnyJSON(w http.ResponseWriter, status int, data any) {
+	w.Header().Set("Content-Type", "application/json; charset=utf-8")
+	w.WriteHeader(status)
+	_ = json.NewEncoder(w).Encode(data)
+}
+
+// writeJSONError возвращает JSON с ключом "error" и заданным HTTP статусом.
+func writeJSONError(w http.ResponseWriter, status int, msg string) {
+	w.Header().Set("Content-Type", "application/json; charset=utf-8")
+	w.WriteHeader(status)
+	_ = json.NewEncoder(w).Encode(map[string]any{"error": msg})
+}
+
+// readSAToken читает service account JWT токен из файла.
+// Используется как fallback аутентификация для запросов к Fission router
+// когда authUser/authPass не заданы.
+func (s *Server) readSAToken() string {
+	if s.saTokenPath == "" {
+		return ""
+	}
+	data, err := os.ReadFile(s.saTokenPath)
+	if err != nil {
+		return ""
+	}
+	return strings.TrimSpace(string(data))
+}
+
+// getRouterToken возвращает Bearer токен для запросов к Fission router.
+// Если authUser+authPass заданы — получает JWT через login endpoint (с кэшем).
+// Иначе — использует SA токен из pod filesystem.
+func (s *Server) getRouterToken() string {
+	if s.authUser == "" || s.authPass == "" {
+		return s.readSAToken()
+	}
+
+	s.tokenMu.Lock()
+	defer s.tokenMu.Unlock()
+
+	if s.cachedJWT != "" && time.Now().Before(s.tokenExpAt) {
+		return s.cachedJWT // кэш ещё актуален
+	}
+
+	loginURL := s.routerURL + "/auth/login"
+	body, _ := json.Marshal(map[string]string{"username": s.authUser, "password": s.authPass})
+	resp, err := s.http.Post(loginURL, "application/json", bytes.NewReader(body))
+	if err != nil {
+		return s.readSAToken()
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK && resp.StatusCode != http.StatusCreated {
+		return s.readSAToken()
+	}
+
+	var result struct {
+		AccessToken string `json:"accesstoken"`
+	}
+	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil || result.AccessToken == "" {
+		return s.readSAToken()
+	}
+
+	s.cachedJWT = result.AccessToken
+	// Fission JWT живёт ~120s; кэшируем на 100s чтобы не использовать просроченный
+	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
+}