admin-console: bump to v0.1.1

RUNID=9251970 (S3 ngcloud msk-1):
- PASS=20/20 — все тесты прошли
- Upload: мелкие файлы медленнее (+1-3s), крупные — сопоставимо
- Cold start: S3 ≈ PV (python быстрее, ruby small медленнее, PHP одинаково)
- Hot avg: практически идентично на обоих бэкендах

ruby/medium cold=80568ms — аномалия воспроизвелась 4-й раз подряд на S3.
Подтверждено: не связана с типом хранилища, это поведение poolmgr.

Вердикт: S3 == PV по производительности. S3 предпочтительнее.

.github/copilot-instructions.md

@@ -1,18 +1,73 @@
 # Правила
 
 ## ⛔ ОТВЕЧАТЬ КРАТКО — АБСОЛЮТНОЕ ПРАВИЛО
-- Вопрос → короткий ответ → СТОП. Не рассуждать, не исследовать без команды.
-- НЕ делать ничего "попутно" без явной просьбы. Сделал — стоп — ждёшь команды.
-- Без приветствий и лишних рассуждений. Код — только по запросу. Не бормотать.
+- Вопрос → короткий ответ → СТОП.
+- Ничего лишнего.
+- Код — только по запросу.
 
-> Подробные правила: [`.github/pravila.md`](pravila.md)
+## ⛔⛔⛔ ВОПРОС = СТОП
+
+**Если в сообщении есть вопрос в ЛЮБОЙ форме** ("так ?", "верно ?", "почему ?", "как ?", "так же ?" и т.д.):
+1. ТОЛЬКО ответить на вопрос
+2. ОСТАНОВИТЬСЯ
+3. ЖДАТЬ следующей команды
+**ЗАПРЕЩЕНО** начинать работу, писать код, запускать команды — без явного "делай".
+
+## ⛔⛔⛔ НЕ ТРОГАТЬ РАБОЧИЙ КОД — АБСОЛЮТНЫЙ ЗАПРЕТ НАВСЕГДА
+
+**НИКАКИХ самодеятельных изменений рабочего кода:**
+- Никаких "оптимизаций", "улучшений", "рефакторинга" без команды
+- Никаких новых фич без явного разрешения
+- Никаких helm upgrade, kubectl patch и прочих инфраструктурных изменений без команды
+- Перед ЛЮБЫМ изменением рабочего кода — объяснить ЗАЧЕМ и ждать "делай"
+
+**ПРЕЦЕДЕНТЫ:**
+- v1.3.49: убрали mode toggle в edit modal "для улучшения" → сломали рабочий редактор
+- helm upgrade попытка → сломал JWT secret router → 401 у всех функций пользователей
 
 1. Не трогать рабочий код без явного указания.
-2. Файлы редактировать локально — `~/remote_dev/` = `~/terra/` на ВМ (sshfs), SCP не нужен.
-   Перед любым запуском команд проверять, что локальные файлы и содержимое на ВМ синхронизированы; при сомнении ориентироваться на состояние файлов на ВМ.
-3. Все команды — **только через SSH**, никогда локально:
-   ```bash
+
+2. Файлы редактируются локально:
+   ~/fission-console
+
+    После ЛЮБЫХ изменений ОБЯЗАТЕЛЬНО синхронизировать на ВМ командой:
+    rsync -az \
+       -e "ssh -i ~/.ssh/naeel_vm_id_ed25519 -o StrictHostKeyChecking=no -o ConnectTimeout=10" \
+       ~/fission-console/ \
+       naeel@5.172.178.213:~/terra/fission/
+
+
+3. Git (add/commit/push) выполнять ЛОКАЛЬНО в ~/fission-console
+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-console`
+2. После любых изменений — обязательно rsync на ВМ:
+   rsync -az \
+     -e "ssh -i ~/.ssh/naeel_vm_id_ed25519 -o StrictHostKeyChecking=no -o ConnectTimeout=10" \
+     ~/fission-console/ \
+     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-console
+4. Docker, kubectl и другие инфраструктурные команды — только через SSH на ВМ
+5. Перед запуском любой команды на ВМ обязательно убедиться, что синхронизация (rsync) выполнена
+6. SCP, sshfs, remote_dev и маунты больше НЕ используются
+7. Только rsync для синхронизации
+
+Пример:
+1. Редактируешь локально
+2. rsync на ВМ
+3. Выполняешь команды через SSH на ВМ
 
 ## SSH
 
@@ -39,7 +49,11 @@ ssh -i ~/.ssh/naeel_vm_id_ed25519 -o StrictHostKeyChecking=no -o ConnectTimeout=
 
 ## Git
 
-Коммитить и пушить через SSH после каждого завершённого этапа.
+⛔⛔⛔ АБСОЛЮТНОЕ ПРАВИЛО:
+- Git — ТОЛЬКО ЛОКАЛЬНО в `~/fission-console`. НИКОГДА через SSH на VM.
+- Разрешены ТОЛЬКО две операции: `git commit` и `git push`.
+- ЗАПРЕЩЕНО: git pull, git fetch, git rebase, git merge, git reset, git stash, git checkout — что угодно кроме commit и push.
+- Если push отклонён — СТОП, доложить пользователю. Не лезть в pull/merge/rebase самостоятельно.
 
 Версионирование тегами: `vMAJOR.MINOR.PATCH`
 - Patch — любое изменение кода
@@ -50,9 +64,44 @@ 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-console/test-results/
+```
+
+**Никогда не разбираться с результатами по памяти / буферу / чату. Только лог.**
+
+## ⛔ РУЧНЫЕ ПАТЧИ — ЗАПРЕЩЕНЫ
+
+- НИКОГДА не применять ручные патчи (`kubectl patch`, `kubectl apply` отдельных полей, `python -c` замены в yaml и т.д.) без явного указания.
+- Все изменения — только через код (Helm chart, YAML, Go-код) + сборка + деплой.
+- Ручной патч слетает при следующем helm upgrade/redeploy → регрессия.
+- Исключение: только если пользователь явно написал "примени ручной патч".
+
 ## Поведение агента
 
 - Не трогать рабочий код без явного указания
-- Не делать ничего сверх того, о чём явно попросили
+- Не делать НИЧЕГО сверх того, о чём явно приказали — ни git-команд, ни rebase, ни дополнительных шагов
+- Если для продолжения нужен выбор — СПРОСИТЬ разрешения, не делать самостоятельно
 - Деструктивные операции (`kubectl delete`, `rm -rf`, `terraform destroy` и др.) — только после явного подтверждения с указанием конкретных объектов
 - Отвечать кратко, без вступлений, извинений, благодарностей и прочей воды

.gitignore

@@ -2,6 +2,7 @@
 .terraform/
 *.tfstate
 *.tfstate.*
+*.tfvars
 
 # Go
 bin/
@@ -15,3 +16,11 @@ examples/*/dist/
 terraform-provider-fission
 terraform-provider-fission_*
 console/fission-console
+
+# Secrets / tokens
+token.txt
+helm/fission-s3-secret.yaml
+
+# Test logs
+test-results/
+scripts/test_layer1.sh

LLM/LLM_PROMPT_TRAINING_2026-04-28.md

@@ -235,3 +235,59 @@
 ### Вывод
 - Текущий prompt уже работает на коротких и простых кейсах.
 - Следующий шаг — проверить его на более разнообразных задачах, чтобы убедиться, что шаблон не ломается за пределами приветствий.
+
+---
+
+## Итерация 9 (2026-05-19) — RUNTIME BUG DISCOVERY
+
+### Источник
+Реальный прогон `test_heavy.sh` на кластере. Обнаружены критические баги в PHP и Node.js runtime-контракте.
+
+### БАГ C: PHP `return array` → пустой response
+
+**Задача LLM:** написать PHP-функцию.  
+**Сгенерированный код (типичный):**
+```php
+<?php
+function handler(array $ctx): array {
+    return ['statusCode' => 200, 'body' => json_encode(['tag' => 'ok'])];
+}
+```
+**Результат invoke:** `{"status":200,"response_raw":""}` — тело пустое.
+
+**Причина:** PHP env (`ghcr.io/fission/php-env:latest`, server.php) создаёт `$response = new Response()`,
+вызывает функцию и возвращает оригинальный объект. Return value функции игнорируется.
+
+**Правильный код:**
+```php
+<?php
+function handler($ctx) {
+    $ctx["response"]->getBody()->write(json_encode(['tag' => 'ok']));
+}
+```
+
+**Что изменено в промпте:**
+- PHP секция переписана: запрет на `return array`, требование писать через `$ctx["response"]->getBody()->write(...)`.
+- Добавлен пример с JSON-ответом и PSR-7 объектами.
+
+---
+
+### БАГ B: Node.js entrypoint `"main.js"` — split на точке → funcname="js"
+
+**Проблема консоли, не пользовательского кода.**
+
+Node-env `specializeV2` (строка 160 server.js) интерпретирует functionName через `split(".")`:
+- `"main.js"` → `{filename:"main", funcname:"js"}` → ищет `module["js"]` → undefined → specialize 500.
+- `"main"` → `{filename:"main", funcname:undefined}` → берёт `default export` → работает.
+
+**Fix в консоли:** `console/internal/runtime/entrypoint.go`, `DefaultEntrypoint("nodejs")` = `"main"`.
+
+**Влияние на промпт:** никакого — это внутренняя проблема консоли. Пользовательский Node.js код пишется как обычно.
+
+---
+
+### Итог итерации 9
+- PHP промпт обновлён: PSR-7 `getBody()->write()` вместо `return array`.
+- Node.js промпт уточнён: `module.exports = async function(ctx) {...}`, CJS стиль.
+- Документация: `doc/RUNTIME_FUNCTION_GUIDE.md` — полный справочник контрактов.
+

LLM/LLM_PROMPT_UNIVERSAL_DRAFT_2026-04-28.md

@@ -54,9 +54,31 @@
 - Не ломай контракт функции выдуманными обертками или неподходящими типами.
 
 ### PHP
-- Возвращай корректный PHP-код функции.
-- Следи за открывающим тегом и синтаксисом массива/строк.
-- Не выдумывай несуществующие `Fission\\Contract` классы или SDK, если задача про обычную функцию.
+- **КРИТИЧНО:** PHP env НЕ читает return value функции. `return ['statusCode'=>200,'body'=>...]` — тело ответа будет ПУСТЫМ.
+- Запись в ответ — ТОЛЬКО через `$ctx["response"]->getBody()->write(...)`:
+  ```php
+  <?php
+  function handler($ctx) {
+      $ctx["response"]->getBody()->write(json_encode(['key' => 'value']));
+  }
+  ```
+- Сигнатура: `function handler($ctx)` — без type hint `array` и без `: array` return type.
+- Доступ к запросу: `$ctx["request"]`, к логгеру: `$ctx["logger"]`.
+- Открывающий тег `<?php` обязателен.
+- Не выдумывай несуществующие `Fission\\Contract` классы или SDK.
+- Альтернатива (только если нет доступа к request): простой `echo` без объявления функции handler:
+  ```php
+  <?php
+  echo json_encode(['key' => 'value']);
+  ```
+
+### Node.js
+- Пользовательский код оборачивается консолью в CJS wrapper. Писать как обычный CommonJS.
+- Экспорт: `module.exports = async function(ctx) { return { status: 200, body: "..." }; }`
+- Формат ответа: объект `{ status: число, body: строка }`.
+- **НЕ** использовать `export default` — код запускается в CJS контексте.
+- **НЕ** указывать `.js` в entrypoint — это внутренняя настройка консоли, не пользовательский код.
+- Не вставляй ESM import/export обвязку в пользовательский код.
 
 ### Ruby
 - Возвращай корректный Ruby-код функции.

LLM/explain-archive-batch/README.md

@@ -0,0 +1,21 @@
+# Batch LLM Explain Archive — тесты
+
+## Методика
+- Для каждого архива из examples/ создаём .zip с кодом.
+- Отправляем на endpoint /console/api/ai/explain-archive.
+- Сохраняем prompt, ответ LLM, замечания.
+- Итеративно улучшаем prompt по результатам.
+
+## Пример: hello-python
+
+**main.py:**
+```
+def main():
+    return "hello from fission via terraform"
+```
+
+**Ответ LLM:**
+> Эта серверless‑функция состоит из единственной функции `main`, которая при вызове сразу возвращает строку `"hello from fission via terraform"`. По сути, она только выводит приветственное сообщение.
+
+**Комментарий:**
+- Ответ корректный, краткий, по делу.

LLM/explain-archive-batch/go-hello.md

@@ -0,0 +1,25 @@
+# go-hello.zip
+
+**handler.go:**
+```go
+package main
+
+import (
+	"fmt"
+	"net/http"
+)
+
+// Handler — точка входа для Fission go-env.
+// Go builder компилирует этот файл в .so плагин,
+// go-env загружает его через plugin.Open().
+func Handler(w http.ResponseWriter, r *http.Request) {
+	w.Header().Set("Content-Type", "text/plain")
+	fmt.Fprintf(w, "Hello from real Go in Fission (builder pipeline)")
+}
+```
+
+**Ответ LLM:**
+> Эта функция — HTTP‑обработчик для серверлесс‑платформы Fission, написанный на Go. При получении любого запроса она отвечает простым текстом «Hello from real Go in Fission (builder pipeline)», устанавливая заголовок `Content-Type: text/plain`. Файл компилируется в плагин *.so, который затем загружается и вызывается Fission.
+
+**Комментарий:**
+- Ответ корректный, упомянута специфика Fission (плагин .so), описание поведения точное.

LLM/explain-archive-batch/php-hello.md

@@ -0,0 +1,18 @@
+# php-hello.zip
+
+**main.php:**
+```php
+<?php
+function handler($context)
+{
+    /** @var \Psr\Http\Message\ResponseInterface $response */
+    $response = $context["response"];
+    $response->getBody()->write("Hello from PHP in Fission");
+}
+```
+
+**Ответ LLM:**
+> Эта PHP‑функция выступает в роли обработчика запросов в Fission. Она получает объект ответа из контекста и записывает в его тело строку `Hello from PHP in Fission`. Таким образом при вызове функции клиент получает именно это приветственное сообщение.
+
+**Комментарий:**
+- Ответ корректный, кратко и по делу, специфика Fission отражена.

LLM/explain-archive-batch/python-cart.md

@@ -0,0 +1,20 @@
+# python-cart.zip
+
+**main.py:**
+```python
+import json
+import time
+from flask import request
+
+# In-memory корзина (живёт пока жив под poolmgr)
+_CARTS: dict = {}
+
+... (см. полный код в архиве)
+```
+
+**Ответ LLM:**
+> Эта сервер‑лес функция реализует простую корзину покупок, хранящуюся в оперативной памяти под ключом `user_id`. При `GET` возвращает текущее содержимое корзины, подсчитанный итог и количество товаров. `POST` принимает JSON с данными товара (id, название, цена, количество) и добавляет его в корзину, увеличивая количество, если такой товар уже есть. `DELETE` удаляет из корзины товар по `product_id`. Для остальных HTTP‑методов возвращается ошибка 405.
+
+**Комментарий:**
+- Ответ LLM очень точный, описывает все основные ветки логики, даже не видя весь код (ограничение по длине prompt).
+- LLM корректно понял in-memory storage и работу с методами.

LLM/explain-archive-batch/ruby-hello.md

@@ -0,0 +1,16 @@
+# ruby-hello.zip
+
+**main.rb:**
+```ruby
+# frozen_string_literal: true
+
+def handler
+  "Hello from Ruby in Fission"
+end
+```
+
+**Ответ LLM:**
+> Функция `handler` просто возвращает строку `"Hello from Ruby in Fission"`. Она не принимает входных параметров и не выполняет никакой логики, кроме возврата фиксированного сообщения. Таким образом, её цель – продемонстрировать работу простого Ruby‑обработчика в среде Fission.
+
+**Комментарий:**
+- Ответ корректный, кратко и по делу, специфика Fission отражена.

README.md

@@ -102,6 +102,58 @@ Backend сервис для управления serverless-функциями
 
 ## Деплой
 
+### Хранилище архивов функций (storagesvc)
+
+Fission хранит ZIP-архивы функций через `storagesvc`. Поддерживается два бэкенда:
+
+#### S3 (рекомендуется)
+
+```bash
+# 1. Создать файл с credentials (НЕ коммитить в git):
+cat > helm/fission-s3-secret.yaml << 'EOF'
+persistence:
+  s3:
+    accessKeyId: <ACCESS_KEY>
+    secretAccessKey: <SECRET_KEY>
+EOF
+
+# 2. Применить:
+kubectl delete deploy executor router storagesvc -n fission  # убрать field manager конфликты
+helm upgrade fission fission-charts/fission-all --version 1.22.1 \
+  -n fission \
+  -f helm/fission-values.yaml \
+  -f helm/fission-s3-secret.yaml \
+  --no-hooks --timeout 180s
+```
+
+Параметры S3 (bucket, endpoint, region) — в `helm/fission-values.yaml`.  
+Credentials — только в `helm/fission-s3-secret.yaml` (файл в `.gitignore`).
+
+#### PV (возврат/альтернатива)
+
+```bash
+kubectl delete deploy executor router storagesvc -n fission
+helm upgrade fission fission-charts/fission-all --version 1.22.1 \
+  -n fission \
+  -f helm/fission-values-pv.yaml \
+  --no-hooks --timeout 180s
+```
+
+Никаких секретов не нужно. StorageClass `vcd-disk-ext4` (VMware VCD), 2Gi.
+
+#### Сравнение
+
+| | S3 | PV |
+|---|---|---|
+| Upload скорость | ~1-3s (сеть) | ~0.3-2s (кэш) |
+| Cold start | ≈ одинаково | ≈ одинаково |
+| Hot (основная нагрузка) | идентично | идентично |
+| Масштабирование storagesvc | ✅ N реплик | ❌ ReadWriteOnce |
+| Переезд кластера | ✅ просто бакет | ❌ надо мигрировать PV |
+| Backup | ✅ встроен в S3 | ручной |
+
+---
+
 | Параметр | Значение |
 |---|---|
 | Кластер | `kube5s.ru` |

admin-console/DEEPSEEK_HANDOFF.md

@@ -0,0 +1,164 @@
+# Handoff: admin-console — задание для DeepSeek
+
+## Контекст
+
+Репозиторий `fission-console`, ветка `restructure/repo-layout`.
+
+Это **Fission Serverless Platform** — кастомная установка. Клиентская консоль (`client-console/`) уже готова и работает в проде. Нужно реализовать **admin-console** (`admin-console/`) — панель для оператора платформы (просмотр всех клиентов, использование ресурсов, данные для бухгалтерии).
+
+---
+
+## Что уже сделано (скелет)
+
+```
+admin-console/
+  cmd/server/main.go          — точка входа, порт 8091, требует ADMIN_TOKEN
+  internal/api/server.go      — роуты: /admin/api/namespaces, /usage, /users
+  internal/metrics/k8s.go     — k8s-клиент (in-cluster), заглушки для реальных данных
+  internal/model/types.go     — типы NamespaceInfo, UsageEntry, UserInfo
+  deploy/admin.yaml           — K8s Deployment + ClusterRole (read-only всё)
+  ui/index.html               — базовый UI (тёмная тема, 3 вкладки)
+  go.mod                      — module admin-console, зависит от k8s.io/client-go v0.31.0
+```
+
+---
+
+## Что нужно реализовать
+
+### 1. `internal/metrics/k8s.go` — подсчёт Fission CRD
+
+Метод `ListClientNamespaces` должен для каждого namespace считать объекты через Dynamic client:
+
+```go
+import (
+    "k8s.io/client-go/dynamic"
+    "k8s.io/apimachinery/pkg/runtime/schema"
+)
+
+dynamicClient, _ := dynamic.NewForConfig(cfg)
+
+gvr := schema.GroupVersionResource{Group: "fission.io", Version: "v1", Resource: "functions"}
+list, err := dynamicClient.Resource(gvr).Namespace(ns).List(ctx, metav1.ListOptions{})
+info.Functions = len(list.Items)
+```
+
+Аналогично для: `packages`, `environments`, `httptriggers`, `timetriggers`.
+
+Сохрани `dynamicClient` в структуру `K8sClient` и используй его в обоих методах.
+
+### 2. `internal/metrics/k8s.go` — S3-хранилище в `CollectUsage`
+
+Поле `StorageGB` — читать из S3. Конфигурация через env:
+- `S3_ENDPOINT` = `https://s3.msk-1.ngcloud.ru`
+- `S3_BUCKET` = `sless-functions`
+- `S3_ACCESS_KEY`, `S3_SECRET_KEY`
+
+Использовать `github.com/aws/aws-sdk-go-v2`. Для каждого namespace prefix = `{namespace}/`, суммировать размер всех объектов.
+
+```go
+import (
+    "github.com/aws/aws-sdk-go-v2/aws"
+    "github.com/aws/aws-sdk-go-v2/credentials"
+    "github.com/aws/aws-sdk-go-v2/service/s3"
+    awscfg "github.com/aws/aws-sdk-go-v2/config"
+)
+
+cfg, _ := awscfg.LoadDefaultConfig(ctx,
+    awscfg.WithRegion("ru-msk-1"),
+    awscfg.WithCredentialsProvider(credentials.NewStaticCredentialsProvider(accessKey, secretKey, "")),
+    awscfg.WithEndpointResolverWithOptions(...), // custom endpoint
+)
+client := s3.NewFromConfig(cfg, func(o *s3.Options) { o.UsePathStyle = true })
+
+paginator := s3.NewListObjectsV2Paginator(client, &s3.ListObjectsV2Input{
+    Bucket: aws.String(bucket),
+    Prefix: aws.String(namespace + "/"),
+})
+var totalBytes int64
+for paginator.HasMorePages() {
+    page, _ := paginator.NextPage(ctx)
+    for _, obj := range page.Contents {
+        totalBytes += aws.ToInt64(obj.Size)
+    }
+}
+entry.StorageGB = float64(totalBytes) / (1024 * 1024 * 1024)
+```
+
+Поля `Invocations`, `CPUMilliCores`, `MemoryMB` — оставить 0 (TODO).
+
+### 3. `go.mod` — добавить зависимости
+
+```
+github.com/aws/aws-sdk-go-v2 v1.30.0
+github.com/aws/aws-sdk-go-v2/config v1.27.0
+github.com/aws/aws-sdk-go-v2/service/s3 v1.58.0
+github.com/aws/aws-sdk-go-v2/credentials v1.17.0
+```
+
+Запустить `go mod tidy` после добавления.
+
+### 4. `deploy/admin.yaml` — добавить env в контейнер
+
+```yaml
+env:
+  - name: ADMIN_TOKEN
+    valueFrom:
+      secretKeyRef:
+        name: fission-admin-token
+        key: token
+  - name: S3_ENDPOINT
+    value: "https://s3.msk-1.ngcloud.ru"
+  - name: S3_BUCKET
+    value: "sless-functions"
+  - name: S3_ACCESS_KEY
+    valueFrom:
+      secretKeyRef:
+        name: fission-s3-credentials
+        key: access_key
+  - name: S3_SECRET_KEY
+    valueFrom:
+      secretKeyRef:
+        name: fission-s3-credentials
+        key: secret_key
+```
+
+### 5. `ui/index.html` — доработать UI
+
+- В таблице "Использование" показывать реальное поле `storage_gb` (уже есть в шаблоне).
+- Добавить кнопку **"Экспорт CSV"** над таблицей Usage — генерировать CSV из текущих данных и скачивать через `Blob`:
+
+```js
+function exportCSV(rows) {
+    const header = 'Namespace,Email,Функции,Вызовы,Хранилище GB,Период\n';
+    const body = rows.map(u =>
+        [u.namespace, u.user_email, u.functions, u.invocations_total,
+         u.storage_gb.toFixed(3), `${u.period_start} — ${u.period_end}`].join(',')
+    ).join('\n');
+    const blob = new Blob([header + body], { type: 'text/csv;charset=utf-8;' });
+    const a = document.createElement('a');
+    a.href = URL.createObjectURL(blob);
+    a.download = `usage-${new Date().toISOString().slice(0,10)}.csv`;
+    a.click();
+}
+```
+
+---
+
+## Правила среды
+
+- **Go version**: `1.25.0` (не менять в go.mod)
+- **Образ**: `naeel/fission-admin-console:v0.1.0`
+- **Build + push**: только через SSH на ВМ `naeel@5.172.178.213` (ключ у оператора)
+- **Namespace деплоя**: `fission`
+- **S3-секрет** `fission-s3-credentials` уже существует в namespace `fission`
+- **Admin-токен** создать вручную перед деплоем:
+  ```bash
+  kubectl create secret generic fission-admin-token -n fission --from-literal=token=<случайная_строка>
+  ```
+- Деплой: `kubectl apply -f ~/terra/fission/admin-console/deploy/admin.yaml`
+
+## Что НЕ трогать
+
+- `client-console/` — рабочий код в проде, **не трогать вообще**
+- `helm/`, `terraform/`, `scripts/` — не трогать
+- Любой файл вне `admin-console/` — без явного разрешения не трогать

admin-console/Dockerfile

@@ -0,0 +1,12 @@
+FROM golang:1.26-alpine AS builder
+WORKDIR /build
+COPY . .
+RUN go mod tidy
+RUN CGO_ENABLED=0 GOOS=linux go build -trimpath -ldflags="-s -w" -o admin-console ./cmd/server/
+
+FROM alpine:3.20
+RUN apk add --no-cache ca-certificates
+COPY --from=builder /build/admin-console /admin-console
+COPY ui/ /ui/
+EXPOSE 8091
+ENTRYPOINT ["/admin-console"]

admin-console/cmd/server/main.go

@@ -0,0 +1,27 @@
+package main
+
+import (
+	"log"
+	"net/http"
+	"os"
+
+	"admin-console/internal/api"
+)
+
+func main() {
+	adminToken := os.Getenv("ADMIN_TOKEN")
+	if adminToken == "" {
+		log.Fatal("ADMIN_TOKEN env variable is required")
+	}
+
+	srv := api.NewServer(adminToken)
+
+	mux := http.NewServeMux()
+	srv.RegisterRoutes(mux)
+
+	addr := ":8091"
+	log.Printf("admin-console starting on %s", addr)
+	if err := http.ListenAndServe(addr, mux); err != nil {
+		log.Fatalf("server error: %v", err)
+	}
+}

admin-console/deploy/admin.yaml

@@ -0,0 +1,120 @@
+apiVersion: v1
+kind: ServiceAccount
+metadata:
+  name: fission-admin-console
+  namespace: fission
+---
+apiVersion: rbac.authorization.k8s.io/v1
+kind: ClusterRole
+metadata:
+  name: fission-admin-console
+rules:
+  # читать ВСЕ namespaces (для отображения клиентов)
+  - apiGroups: [""]
+    resources: ["namespaces"]
+    verbs: ["get", "list"]
+  # читать секреты в клиентских namespaces (для списка пользователей)
+  - apiGroups: [""]
+    resources: ["secrets"]
+    verbs: ["get", "list"]
+  # читать pods (для метрик потребления)
+  - apiGroups: [""]
+    resources: ["pods"]
+    verbs: ["get", "list"]
+  # читать Fission CRD
+  - apiGroups: ["fission.io"]
+    resources: ["environments", "packages", "functions", "httptriggers", "timetriggers"]
+    verbs: ["get", "list"]
+---
+apiVersion: rbac.authorization.k8s.io/v1
+kind: ClusterRoleBinding
+metadata:
+  name: fission-admin-console
+roleRef:
+  apiGroup: rbac.authorization.k8s.io
+  kind: ClusterRole
+  name: fission-admin-console
+subjects:
+  - kind: ServiceAccount
+    name: fission-admin-console
+    namespace: fission
+---
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: fission-admin-console
+  namespace: fission
+spec:
+  replicas: 1
+  selector:
+    matchLabels:
+      app: fission-admin-console
+  template:
+    metadata:
+      labels:
+        app: fission-admin-console
+    spec:
+      serviceAccountName: fission-admin-console
+      containers:
+        - name: fission-admin-console
+          image: naeel/fission-admin-console:v0.1.1
+          imagePullPolicy: Always
+          ports:
+            - containerPort: 8091
+          env:
+            - name: ADMIN_TOKEN
+              valueFrom:
+                secretKeyRef:
+                  name: fission-admin-token
+                  key: token
+            - name: S3_ENDPOINT
+              value: "https://s3.msk-1.ngcloud.ru"
+            - name: S3_BUCKET
+              value: "sless-functions"
+            - name: S3_ACCESS_KEY
+              valueFrom:
+                secretKeyRef:
+                  name: fission-s3-credentials
+                  key: access_key
+            - name: S3_SECRET_KEY
+              valueFrom:
+                secretKeyRef:
+                  name: fission-s3-credentials
+                  key: secret_key
+---
+apiVersion: v1
+kind: Service
+metadata:
+  name: fission-admin-console
+  namespace: fission
+spec:
+  selector:
+    app: fission-admin-console
+  ports:
+    - port: 8091
+      targetPort: 8091
+---
+apiVersion: networking.k8s.io/v1
+kind: Ingress
+metadata:
+  name: fission-admin-console
+  namespace: fission
+  annotations:
+    nginx.ingress.kubernetes.io/force-ssl-redirect: "true"
+spec:
+  ingressClassName: nginx
+  rules:
+    - host: fission.kube5s.ru
+      http:
+        paths:
+          - backend:
+              service:
+                name: fission-admin-console
+                port:
+                  number: 8091
+            path: /admin
+            pathType: Prefix
+  tls:
+    - hosts:
+        - fission.kube5s.ru
+      secretName: fission-tls

admin-console/go.mod

@@ -0,0 +1,15 @@
+module admin-console
+
+go 1.25.0
+
+require (
+	github.com/aws/aws-sdk-go-v2 v1.30.0
+	github.com/aws/aws-sdk-go-v2/config v1.27.0
+	github.com/aws/aws-sdk-go-v2/credentials v1.17.0
+	github.com/aws/aws-sdk-go-v2/service/s3 v1.58.0
+	k8s.io/api v0.31.0
+	k8s.io/apimachinery v0.31.0
+	k8s.io/client-go v0.31.0
+)
+
+

admin-console/internal/api/server.go

@@ -0,0 +1,129 @@
+package api
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+	"strings"
+	"time"
+
+	"admin-console/internal/metrics"
+	"admin-console/internal/model"
+)
+
+// Server — HTTP-сервер admin-console.
+type Server struct {
+	adminToken string
+	k8s        *metrics.K8sClient
+}
+
+func NewServer(adminToken string) *Server {
+	k8s, err := metrics.NewK8sClient()
+	if err != nil {
+		// вне кластера — работаем без k8s (для локальной разработки)
+		k8s = nil
+	}
+	return &Server{adminToken: adminToken, k8s: k8s}
+}
+
+func (s *Server) RegisterRoutes(mux *http.ServeMux) {
+	// статика UI
+	mux.Handle("/admin/", http.StripPrefix("/admin/", http.FileServer(http.Dir("ui"))))
+
+	// API
+	mux.HandleFunc("/admin/api/health", s.handleHealth)
+	mux.HandleFunc("/admin/api/namespaces", s.authMiddleware(s.handleNamespaces))
+	mux.HandleFunc("/admin/api/namespaces/", s.authMiddleware(s.handleNamespaceDetail))
+	mux.HandleFunc("/admin/api/usage", s.authMiddleware(s.handleUsage))
+	mux.HandleFunc("/admin/api/users", s.authMiddleware(s.handleUsers))
+}
+
+// authMiddleware проверяет Bearer-токен из заголовка Authorization.
+func (s *Server) authMiddleware(next http.HandlerFunc) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		auth := r.Header.Get("Authorization")
+		if !strings.HasPrefix(auth, "Bearer ") || strings.TrimPrefix(auth, "Bearer ") != s.adminToken {
+			writeJSON(w, http.StatusUnauthorized, model.ErrResp("unauthorized"))
+			return
+		}
+		next(w, r)
+	}
+}
+
+func (s *Server) handleHealth(w http.ResponseWriter, r *http.Request) {
+	writeJSON(w, http.StatusOK, map[string]string{"status": "ok"})
+}
+
+// handleNamespaces возвращает список клиентских namespace-ов (быстро, без счётчиков).
+func (s *Server) handleNamespaces(w http.ResponseWriter, r *http.Request) {
+	if s.k8s == nil {
+		writeJSON(w, http.StatusServiceUnavailable, model.ErrResp("k8s unavailable"))
+		return
+	}
+	ns, err := s.k8s.ListClientNamespaces(r.Context())
+	if err != nil {
+		writeJSON(w, http.StatusInternalServerError, model.ErrResp(err.Error()))
+		return
+	}
+	writeJSON(w, http.StatusOK, map[string]any{"namespaces": ns})
+}
+
+// handleNamespaceDetail возвращает детальную информацию об одном namespace (с CRD-счётчиками).
+func (s *Server) handleNamespaceDetail(w http.ResponseWriter, r *http.Request) {
+	if s.k8s == nil {
+		writeJSON(w, http.StatusServiceUnavailable, model.ErrResp("k8s unavailable"))
+		return
+	}
+	// URL: /admin/api/namespaces/{name}
+	name := strings.TrimPrefix(r.URL.Path, "/admin/api/namespaces/")
+	if name == "" {
+		writeJSON(w, http.StatusBadRequest, model.ErrResp("missing namespace name"))
+		return
+	}
+	ctx, cancel := context.WithTimeout(r.Context(), 15*time.Second)
+	defer cancel()
+	info, err := s.k8s.GetNamespaceDetail(ctx, name)
+	if err != nil {
+		writeJSON(w, http.StatusNotFound, model.ErrResp(err.Error()))
+		return
+	}
+	writeJSON(w, http.StatusOK, info)
+}
+
+// handleUsage возвращает агрегированные метрики использования для бухгалтерии.
+func (s *Server) handleUsage(w http.ResponseWriter, r *http.Request) {
+	if s.k8s == nil {
+		writeJSON(w, http.StatusServiceUnavailable, model.ErrResp("k8s unavailable"))
+		return
+	}
+	ctx, cancel := context.WithTimeout(r.Context(), 60*time.Second)
+	defer cancel()
+	usage, err := s.k8s.CollectUsage(ctx)
+	if err != nil {
+		writeJSON(w, http.StatusInternalServerError, model.ErrResp(err.Error()))
+		return
+	}
+	writeJSON(w, http.StatusOK, map[string]any{"usage": usage})
+}
+
+// handleUsers возвращает список пользователей из secrets в клиентских namespace-ах.
+func (s *Server) handleUsers(w http.ResponseWriter, r *http.Request) {
+	if s.k8s == nil {
+		writeJSON(w, http.StatusServiceUnavailable, model.ErrResp("k8s unavailable"))
+		return
+	}
+	ctx, cancel := context.WithTimeout(r.Context(), 30*time.Second)
+	defer cancel()
+	users, err := s.k8s.ListUsers(ctx)
+	if err != nil {
+		writeJSON(w, http.StatusInternalServerError, model.ErrResp(err.Error()))
+		return
+	}
+	writeJSON(w, http.StatusOK, map[string]any{"users": users})
+}
+
+func writeJSON(w http.ResponseWriter, status int, v any) {
+	w.Header().Set("Content-Type", "application/json")
+	w.WriteHeader(status)
+	json.NewEncoder(w).Encode(v)
+}

admin-console/internal/metrics/k8s.go

@@ -0,0 +1,254 @@
+package metrics
+
+import (
+	"context"
+	"fmt"
+	"log"
+	"os"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/config"
+	"github.com/aws/aws-sdk-go-v2/credentials"
+	"github.com/aws/aws-sdk-go-v2/service/s3"
+
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+	"k8s.io/client-go/dynamic"
+	"k8s.io/client-go/kubernetes"
+	"k8s.io/client-go/rest"
+	"k8s.io/client-go/tools/clientcmd"
+
+	"admin-console/internal/model"
+)
+
+// fission CRD group-version-resources.
+var (
+	gvrFunctions    = schema.GroupVersionResource{Group: "fission.io", Version: "v1", Resource: "functions"}
+	gvrPackages     = schema.GroupVersionResource{Group: "fission.io", Version: "v1", Resource: "packages"}
+	gvrEnvironments = schema.GroupVersionResource{Group: "fission.io", Version: "v1", Resource: "environments"}
+	gvrHTTPTriggers = schema.GroupVersionResource{Group: "fission.io", Version: "v1", Resource: "httptriggers"}
+	gvrTimeTriggers = schema.GroupVersionResource{Group: "fission.io", Version: "v1", Resource: "timetriggers"}
+)
+
+// K8sClient — обёртка над kubernetes.Clientset для нужд admin-console.
+type K8sClient struct {
+	cs       *kubernetes.Clientset
+	dc       dynamic.Interface
+	s3       *s3.Client
+	s3Bucket string
+}
+
+// NewK8sClient создаёт клиента из in-cluster конфига, с fallback на ~/.kube/config.
+func NewK8sClient() (*K8sClient, error) {
+	cfg, err := rest.InClusterConfig()
+	if err != nil {
+		cfg, err = clientcmd.BuildConfigFromFlags("", clientcmd.RecommendedHomeFile)
+		if err != nil {
+			return nil, fmt.Errorf("no k8s config: %w", err)
+		}
+	}
+	cs, err := kubernetes.NewForConfig(cfg)
+	if err != nil {
+		return nil, err
+	}
+	dc, err := dynamic.NewForConfig(cfg)
+	if err != nil {
+		return nil, fmt.Errorf("dynamic client: %w", err)
+	}
+
+	k := &K8sClient{cs: cs, dc: dc}
+
+	// S3 — опционально (не падаем если нет кредов)
+	k.initS3()
+
+	return k, nil
+}
+
+// initS3 создаёт S3-клиент из переменных окружения.
+func (k *K8sClient) initS3() {
+	endpoint := os.Getenv("S3_ENDPOINT")
+	bucket := os.Getenv("S3_BUCKET")
+	accessKey := os.Getenv("S3_ACCESS_KEY")
+	secretKey := os.Getenv("S3_SECRET_KEY")
+
+	if endpoint == "" || bucket == "" || accessKey == "" || secretKey == "" {
+		log.Println("[admin-console] S3 env vars not set — storage metrics disabled")
+		return
+	}
+
+	cfg, err := config.LoadDefaultConfig(context.Background(),
+		config.WithRegion("ru-msk-1"),
+		config.WithCredentialsProvider(credentials.NewStaticCredentialsProvider(accessKey, secretKey, "")),
+	)
+	if err != nil {
+		log.Printf("[admin-console] S3 config error: %v", err)
+		return
+	}
+
+	k.s3 = s3.NewFromConfig(cfg, func(o *s3.Options) {
+		o.BaseEndpoint = aws.String(endpoint)
+		o.UsePathStyle = true
+	})
+	k.s3Bucket = bucket
+	log.Printf("[admin-console] S3 client ready, bucket=%s", bucket)
+}
+
+// ListClientNamespaces возвращает список namespace-ов БЕЗ CRD-счётчиков (быстро).
+func (k *K8sClient) ListClientNamespaces(ctx context.Context) ([]model.NamespaceInfo, error) {
+	nsList, err := k.cs.CoreV1().Namespaces().List(ctx, metav1.ListOptions{
+		LabelSelector: "managed-by=fission-console",
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	result := make([]model.NamespaceInfo, 0, len(nsList.Items))
+	for _, ns := range nsList.Items {
+		result = append(result, model.NamespaceInfo{
+			Name:      ns.Name,
+			UserEmail: ns.Labels["user"],
+			CreatedAt: ns.CreationTimestamp.Format(time.RFC3339),
+		})
+	}
+	return result, nil
+}
+
+// GetNamespaceDetail возвращает информацию об одном namespace с CRD-счётчиками.
+func (k *K8sClient) GetNamespaceDetail(ctx context.Context, nsName string) (*model.NamespaceInfo, error) {
+	ns, err := k.cs.CoreV1().Namespaces().Get(ctx, nsName, metav1.GetOptions{})
+	if err != nil {
+		return nil, err
+	}
+	info := &model.NamespaceInfo{
+		Name:      ns.Name,
+		UserEmail: ns.Labels["user"],
+		CreatedAt: ns.CreationTimestamp.Format(time.RFC3339),
+	}
+	k.fillCRDCounts(ctx, nsName, info)
+	return info, nil
+}
+
+// fillCRDCounts заполняет счётчики Fission-ресурсов для одного namespace.
+func (k *K8sClient) fillCRDCounts(ctx context.Context, ns string, info *model.NamespaceInfo) {
+	count := func(gvr schema.GroupVersionResource) int {
+		list, err := k.dc.Resource(gvr).Namespace(ns).List(ctx, metav1.ListOptions{Limit: 1})
+		if err != nil {
+			return 0
+		}
+		if rem := list.GetRemainingItemCount(); rem != nil {
+			return int(*rem) + len(list.Items)
+		}
+		return len(list.Items)
+	}
+
+	var wg sync.WaitGroup
+	wg.Add(5)
+	go func() { defer wg.Done(); info.Functions = count(gvrFunctions) }()
+	go func() { defer wg.Done(); info.Packages = count(gvrPackages) }()
+	go func() { defer wg.Done(); info.Environments = count(gvrEnvironments) }()
+	go func() { defer wg.Done(); info.HTTPTriggers = count(gvrHTTPTriggers) }()
+	go func() { defer wg.Done(); info.TimeTriggers = count(gvrTimeTriggers) }()
+	wg.Wait()
+}
+
+// CollectUsage возвращает агрегированную статистику по всем клиентским namespace-ам.
+func (k *K8sClient) CollectUsage(ctx context.Context) ([]model.UsageEntry, error) {
+	nsList, err := k.cs.CoreV1().Namespaces().List(ctx, metav1.ListOptions{
+		LabelSelector: "managed-by=fission-console",
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	now := time.Now().UTC()
+	startOfMonth := time.Date(now.Year(), now.Month(), 1, 0, 0, 0, 0, time.UTC)
+
+	result := make([]model.UsageEntry, 0, len(nsList.Items))
+	for _, ns := range nsList.Items {
+		entry := model.UsageEntry{
+			Namespace:   ns.Name,
+			UserEmail:   ns.Labels["user"],
+			PeriodStart: startOfMonth.Format("2006-01-02"),
+			PeriodEnd:   now.Format("2006-01-02"),
+		}
+
+		// Считаем функции через Dynamic client.
+		if list, err := k.dc.Resource(gvrFunctions).Namespace(ns.Name).List(ctx, metav1.ListOptions{Limit: 1}); err == nil {
+			entry.Functions = len(list.Items)
+			if rem := list.GetRemainingItemCount(); rem != nil {
+				entry.Functions += int(*rem)
+			}
+		}
+
+		// Считаем S3-хранилище.
+		entry.StorageGB = k.namespaceStorage(ctx, ns.Name)
+
+		// Invocations / CPU / Memory — TODO.
+		result = append(result, entry)
+	}
+	return result, nil
+}
+
+// namespaceStorage возвращает суммарный размер объектов S3 с префиксом "{ns}/".
+func (k *K8sClient) namespaceStorage(ctx context.Context, ns string) float64 {
+	if k.s3 == nil {
+		return 0
+	}
+
+	var totalBytes int64
+	paginator := s3.NewListObjectsV2Paginator(k.s3, &s3.ListObjectsV2Input{
+		Bucket: aws.String(k.s3Bucket),
+		Prefix: aws.String(ns + "/"),
+	})
+
+	for paginator.HasMorePages() {
+		page, err := paginator.NextPage(ctx)
+		if err != nil {
+			log.Printf("[admin-console] S3 list error ns=%s: %v", ns, err)
+			return 0
+		}
+		for _, obj := range page.Contents {
+			if obj.Size != nil {
+				totalBytes += *obj.Size
+			}
+		}
+	}
+
+	return float64(totalBytes) / (1024 * 1024 * 1024)
+}
+
+// ListUsers собирает пользователей из secret fission-console-users в каждом
+// клиентском namespace.
+func (k *K8sClient) ListUsers(ctx context.Context) ([]model.UserInfo, error) {
+	nsList, err := k.cs.CoreV1().Namespaces().List(ctx, metav1.ListOptions{
+		LabelSelector: "managed-by=fission-console",
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	var users []model.UserInfo
+	for _, ns := range nsList.Items {
+		email := ns.Labels["user"]
+		if email == "" {
+			secret, err := k.cs.CoreV1().Secrets(ns.Name).Get(ctx, "fission-console-users", metav1.GetOptions{})
+			if err == nil {
+				for key := range secret.Data {
+					if strings.Contains(key, "@") {
+						email = key
+						break
+					}
+				}
+			}
+		}
+		users = append(users, model.UserInfo{
+			Email:     email,
+			Namespace: ns.Name,
+			CreatedAt: ns.CreationTimestamp.Format(time.RFC3339),
+		})
+	}
+	return users, nil
+}

admin-console/internal/model/types.go

@@ -0,0 +1,40 @@
+package model
+
+// ErrResp — стандартный ответ с ошибкой.
+func ErrResp(msg string) map[string]string {
+	return map[string]string{"error": msg}
+}
+
+// NamespaceInfo — информация об одном клиентском namespace.
+type NamespaceInfo struct {
+	Name      string `json:"name"`
+	UserEmail string `json:"user_email,omitempty"`
+	CreatedAt string `json:"created_at,omitempty"`
+
+	// счётчики ресурсов Fission
+	Functions    int `json:"functions"`
+	Packages     int `json:"packages"`
+	Environments int `json:"environments"`
+	HTTPTriggers int `json:"http_triggers"`
+	TimeTriggers int `json:"time_triggers"`
+}
+
+// UsageEntry — строка использования для одного namespace (для бухгалтерии).
+type UsageEntry struct {
+	Namespace     string  `json:"namespace"`
+	UserEmail     string  `json:"user_email,omitempty"`
+	Functions     int     `json:"functions"`
+	Invocations   int64   `json:"invocations_total"` // TODO: из Prometheus/logs
+	StorageGB     float64 `json:"storage_gb"`        // TODO: из storagesvc/S3
+	CPUMilliCores int64   `json:"cpu_millicores"`    // TODO: из metrics-server
+	MemoryMB      int64   `json:"memory_mb"`         // TODO: из metrics-server
+	PeriodStart   string  `json:"period_start"`
+	PeriodEnd     string  `json:"period_end"`
+}
+
+// UserInfo — пользователь из secret fission-console-users.
+type UserInfo struct {
+	Email     string `json:"email"`
+	Namespace string `json:"namespace"`
+	CreatedAt string `json:"created_at,omitempty"`
+}

admin-console/ui/index.html

@@ -0,0 +1,219 @@
+<!DOCTYPE html>
+<html lang="ru">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Fission Admin Console v0.1.1</title>
+  <style>
+    * { box-sizing: border-box; margin: 0; padding: 0; }
+    body { font-family: system-ui, sans-serif; background: #0f1117; color: #e0e0e0; }
+    header { background: #1a1d27; padding: 16px 24px; border-bottom: 1px solid #2a2d3a;
+             display: flex; align-items: center; gap: 12px; }
+    header h1 { font-size: 18px; font-weight: 600; color: #fff; }
+    header .badge { background: #e53e3e; color: #fff; font-size: 10px; font-weight: 700;
+                    padding: 2px 6px; border-radius: 4px; letter-spacing: .5px; }
+    #login { display: flex; align-items: center; justify-content: center; height: calc(100vh - 57px); }
+    #login form { background: #1a1d27; border: 1px solid #2a2d3a; border-radius: 8px;
+                  padding: 32px; display: flex; flex-direction: column; gap: 12px; width: 320px; }
+    #login h2 { font-size: 16px; color: #fff; margin-bottom: 4px; }
+    input { background: #0f1117; border: 1px solid #2a2d3a; border-radius: 6px;
+            color: #e0e0e0; padding: 10px 12px; font-size: 14px; outline: none; }
+    input:focus { border-color: #4a90d9; }
+    button { background: #2563eb; color: #fff; border: none; border-radius: 6px;
+             padding: 10px; font-size: 14px; cursor: pointer; font-weight: 600; }
+    button:hover { background: #1d4ed8; }
+    #app { display: none; }
+    nav { background: #1a1d27; border-bottom: 1px solid #2a2d3a;
+          display: flex; gap: 4px; padding: 0 24px; }
+    nav button { background: none; border: none; color: #9ca3af; font-size: 14px;
+                 padding: 12px 16px; cursor: pointer; border-bottom: 2px solid transparent; }
+    nav button.active { color: #fff; border-bottom-color: #2563eb; }
+    main { padding: 24px; }
+    table { width: 100%; border-collapse: collapse; font-size: 13px; }
+    th { color: #6b7280; font-weight: 500; text-align: left; padding: 8px 12px;
+         border-bottom: 1px solid #2a2d3a; }
+    td { padding: 10px 12px; border-bottom: 1px solid #1a1d27; }
+    tr:hover td { background: #1a1d27; }
+    .pill { display: inline-block; padding: 2px 8px; border-radius: 12px; font-size: 11px; }
+    .pill-blue { background: #1e3a5f; color: #60a5fa; }
+    .err { color: #f87171; font-size: 13px; padding: 16px 0; }
+    .loader { color: #6b7280; font-size: 13px; padding: 16px 0; }
+    .cnt { color: #6b7280; font-size: 12px; }
+    .cnt.loading { animation: pulse 1.5s infinite; }
+    @keyframes pulse { 0%,100%{opacity:.3} 50%{opacity:1} }
+  </style>
+</head>
+<body>
+<header>
+  <h1>Fission Admin Console</h1>
+  <span class="badge">ADMIN</span>
+</header>
+
+<div id="login">
+  <form id="loginForm">
+    <h2>Вход в Admin Console</h2>
+    <input type="password" id="tokenInput" placeholder="Admin token" autocomplete="current-password">
+    <button type="submit">Войти</button>
+    <div id="loginErr" class="err" style="display:none"></div>
+  </form>
+</div>
+
+<div id="app">
+  <nav>
+    <button class="active" onclick="showTab('namespaces', this)">Клиенты</button>
+    <button onclick="showTab('usage', this)">Использование</button>
+    <button onclick="showTab('users', this)">Пользователи</button>
+  </nav>
+  <main id="content"></main>
+</div>
+
+<script>
+  const API = '/admin/api';
+  let TOKEN = '';
+  let NS_LIST = [];
+
+  document.getElementById('loginForm').addEventListener('submit', async e => {
+    e.preventDefault();
+    TOKEN = document.getElementById('tokenInput').value.trim();
+    try {
+      const r = await fetch(`${API}/namespaces`, { headers: { Authorization: `Bearer ${TOKEN}` } });
+      if (r.ok) {
+        const data = await r.json();
+        NS_LIST = data.namespaces || [];
+        document.getElementById('login').style.display = 'none';
+        document.getElementById('app').style.display = 'block';
+        showTab('namespaces', document.querySelector('nav button'));
+      } else {
+        const err = document.getElementById('loginErr');
+        err.style.display = 'block';
+        err.textContent = 'Неверный токен';
+      }
+    } catch(e) {
+      const err = document.getElementById('loginErr');
+      err.style.display = 'block';
+      err.textContent = 'Ошибка соединения: ' + e.message;
+    }
+  });
+
+  function showTab(tab, btn) {
+    document.querySelectorAll('nav button').forEach(b => b.classList.remove('active'));
+    btn.classList.add('active');
+    loadTab(tab);
+  }
+
+  async function loadTab(tab) {
+    const content = document.getElementById('content');
+    if (tab === 'namespaces') {
+      content.innerHTML = renderNamespaces(NS_LIST);
+      // загружаем CRD-счётчики асинхронно
+      loadAllDetails();
+      return;
+    }
+    content.innerHTML = '<p class="loader">Загрузка…</p>';
+    try {
+      const r = await fetch(`${API}/${tab}`, { headers: { Authorization: `Bearer ${TOKEN}` } });
+      const data = await r.json();
+      if (!r.ok) { content.innerHTML = `<p class="err">${data.error}</p>`; return; }
+      content.innerHTML = renderTab(tab, data);
+    } catch(e) {
+      content.innerHTML = `<p class="err">Ошибка: ${e.message}</p>`;
+    }
+  }
+
+  function renderTab(tab, data) {
+    if (tab === 'usage') return renderUsage(data.usage);
+    if (tab === 'users')  return renderUsers(data.users);
+    return '';
+  }
+
+  function renderNamespaces(rows) {
+    if (!rows?.length) return '<p class="loader">Нет namespace-ов</p>';
+    return `<table>
+      <tr><th>Namespace</th><th>Email</th><th>Fn</th><th>Pkg</th><th>Env</th><th>HTTP</th><th>Time</th><th>Создан</th></tr>
+      ${rows.map((n,i) => `<tr>
+        <td><span class="pill pill-blue">${n.name}</span></td>
+        <td>${n.user_email || '—'}</td>
+        <td class="cnt loading" id="ns${i}-fn">…</td>
+        <td class="cnt loading" id="ns${i}-pkg">…</td>
+        <td class="cnt loading" id="ns${i}-env">…</td>
+        <td class="cnt loading" id="ns${i}-http">…</td>
+        <td class="cnt loading" id="ns${i}-time">…</td>
+        <td>${n.created_at ? n.created_at.slice(0,10) : '—'}</td>
+      </tr>`).join('')}
+    </table>`;
+  }
+
+  async function loadAllDetails() {
+    for (let i = 0; i < NS_LIST.length; i++) {
+      loadDetail(i, NS_LIST[i].name);
+    }
+  }
+
+  async function loadDetail(idx, name) {
+    try {
+      const r = await fetch(`${API}/namespaces/${encodeURIComponent(name)}`, {
+        headers: { Authorization: `Bearer ${TOKEN}` }
+      });
+      if (!r.ok) return;
+      const d = await r.json();
+      setCnt(idx, 'fn', d.functions);
+      setCnt(idx, 'pkg', d.packages);
+      setCnt(idx, 'env', d.environments);
+      setCnt(idx, 'http', d.http_triggers);
+      setCnt(idx, 'time', d.time_triggers);
+    } catch(e) {}
+  }
+
+  function setCnt(idx, type, val) {
+    const el = document.getElementById(`ns${idx}-${type}`);
+    if (el) { el.textContent = val ?? 0; el.classList.remove('loading'); }
+  }
+
+  function renderUsage(rows) {
+    if (!rows?.length) return '<p class="loader">Нет данных</p>';
+    const btn = `<div style="margin-bottom:12px">
+      <button onclick="exportCSV()">📥 Экспорт CSV</button>
+    </div>`;
+    return btn + `<table>
+      <tr><th>Namespace</th><th>Email</th><th>Функции</th><th>Вызовы</th><th>Хранилище GB</th><th>Период</th></tr>
+      ${rows.map(u => `<tr>
+        <td><span class="pill pill-blue">${u.namespace}</span></td>
+        <td>${u.user_email || '—'}</td>
+        <td>${u.functions}</td>
+        <td>${u.invocations_total}</td>
+        <td>${(u.storage_gb || 0).toFixed(3)}</td>
+        <td>${u.period_start} — ${u.period_end}</td>
+      </tr>`).join('')}
+    </table>`;
+  }
+
+  function exportCSV() {
+    const table = document.querySelector('table');
+    if (!table) return;
+    let csv = '\uFEFF';
+    table.querySelectorAll('tr').forEach(row => {
+      const cells = [];
+      row.querySelectorAll('th,td').forEach(c => cells.push('"' + c.textContent.replace(/"/g, '""') + '"'));
+      csv += cells.join(',') + '\n';
+    });
+    const blob = new Blob([csv], { type: 'text/csv;charset=utf-8;' });
+    const a = document.createElement('a');
+    a.href = URL.createObjectURL(blob);
+    a.download = `usage-${new Date().toISOString().slice(0,10)}.csv`;
+    a.click();
+  }
+
+  function renderUsers(rows) {
+    if (!rows?.length) return '<p class="loader">Нет пользователей</p>';
+    return `<table>
+      <tr><th>Email</th><th>Namespace</th><th>Создан</th></tr>
+      ${rows.map(u => `<tr>
+        <td>${u.email || '—'}</td>
+        <td><span class="pill pill-blue">${u.namespace}</span></td>
+        <td>${u.created_at ? u.created_at.slice(0,10) : '—'}</td>
+      </tr>`).join('')}
+    </table>`;
+  }
+</script>
+</body>
+</html>

bench-func/bench_func_test.sh

@@ -0,0 +1,114 @@
+#!/bin/bash
+# Бенчмарк: upload, deploy, cold/hot start для простой функции
+# Все результаты пишутся в test-results/bench-func
+
+set -e
+RESULTS_DIR="$(dirname "$0")/../test-results/bench-func"
+FUNC_DIR="$(dirname "$0")"
+FUNC_NAME="bench-hello"
+ENV_NAME="bench-python-env"
+NS="bench-func-$(date +%s)"
+# Donor namespace с готовым RBAC
+DONOR_NS=$(kubectl get ns --no-headers | awk '{print $1}' | grep -E '^fission-[a-f0-9]{16}$' | head -1)
+LOGFILE="$RESULTS_DIR/bench_func_$(date +%Y-%m-%d_%H-%M-%S).log"
+
+mkdir -p "$RESULTS_DIR"
+{
+  echo "# Bench: $(date)"
+  echo "Namespace: $NS"
+  echo "Donor NS: $DONOR_NS"
+} | tee "$LOGFILE"
+
+# 1. Create namespace + copy RBAC from donor
+echo -n "[1] Create namespace + RBAC... " | tee -a "$LOGFILE"
+START_NS=$(date +%s%3N)
+kubectl create ns "$NS" >/dev/null
+
+# Копируем ServiceAccount-ы
+for sa in fission-builder fission-fetcher; do
+  kubectl get sa "$sa" -n "$DONOR_NS" -o json 2>/dev/null \
+    | jq 'del(.metadata.resourceVersion,.metadata.uid,.metadata.creationTimestamp,.metadata.annotations,.metadata.ownerReferences) | .metadata.namespace = $ns' --arg ns "$NS" \
+    | kubectl apply -f - >/dev/null 2>&1 || true
+done
+
+# Копируем RoleBindings из donor
+kubectl get rolebinding -n "$DONOR_NS" -o json 2>/dev/null \
+  | jq -r '.items[] | select(.roleRef.kind=="ClusterRole") | del(.metadata.resourceVersion,.metadata.uid,.metadata.creationTimestamp,.metadata.annotations,.metadata.ownerReferences) | .metadata.namespace = $ns' --arg ns "$NS" \
+  | kubectl apply -f - >/dev/null 2>&1 || true
+
+END_NS=$(date +%s%3N)
+echo "$((END_NS-START_NS)) ms" | tee -a "$LOGFILE"
+
+# 2. Create environment
+echo -n "[2] Create environment... " | tee -a "$LOGFILE"
+START_ENV=$(date +%s%3N)
+fission env create --name "$ENV_NAME" --image naeel/fission-python-env:v1.1 --namespace "$NS" >/dev/null 2>&1
+END_ENV=$(date +%s%3N)
+echo "$((END_ENV-START_ENV)) ms" | tee -a "$LOGFILE"
+
+# 3. Upload function
+echo -n "[3] Upload function... " | tee -a "$LOGFILE"
+START_UP=$(date +%s%3N)
+fission fn create --name "$FUNC_NAME" --env "$ENV_NAME" --code "$FUNC_DIR/hello.py" --namespace "$NS" >/dev/null 2>&1
+END_UP=$(date +%s%3N)
+echo "$((END_UP-START_UP)) ms" | tee -a "$LOGFILE"
+
+# 4. Cold start invoke (retry до 60 раз по 2 сек = 2 мин максимум)
+echo -n "[4] Cold start invoke... " | tee -a "$LOGFILE"
+START_COLD=$(date +%s%3N)
+COLD_OK=0
+for i in {1..60}; do
+  RESULT=$(fission fn test --name "$FUNC_NAME" --namespace "$NS" 2>&1 || true)
+  if echo "$RESULT" | grep -qE "hello|200|statusCode"; then
+    COLD_OK=1
+    break
+  fi
+  sleep 2
+done
+END_COLD=$(date +%s%3N)
+if [[ $COLD_OK -eq 1 ]]; then
+  echo "$((END_COLD-START_COLD)) ms" | tee -a "$LOGFILE"
+else
+  echo "FAILED" | tee -a "$LOGFILE"
+  {
+    echo "[DEBUG] pods in $NS:"
+    kubectl get pods -n "$NS" 2>&1
+    echo "[DEBUG] events in $NS:"
+    kubectl get events -n "$NS" --sort-by=.metadata.creationTimestamp 2>&1 | tail -20
+  } >> "$LOGFILE"
+  exit 1
+fi
+
+# 5. Hot start invoke (pod уже прогрет, retry до 5 раз)
+echo -n "[5] Hot start invoke... " | tee -a "$LOGFILE"
+START_HOT=$(date +%s%3N)
+HOT_OK=0
+for i in {1..5}; do
+  RESULT=$(fission fn test --name "$FUNC_NAME" --namespace "$NS" 2>&1 || true)
+  if echo "$RESULT" | grep -qE "hello|200|statusCode"; then
+    HOT_OK=1; break
+  fi
+  sleep 2
+done
+END_HOT=$(date +%s%3N)
+if [[ $HOT_OK -eq 1 ]]; then
+  echo "$((END_HOT-START_HOT)) ms" | tee -a "$LOGFILE"
+else
+  echo "FAILED (pod не ответил)" | tee -a "$LOGFILE"
+fi
+
+# 6. Hot x5
+echo "[6] Hot start x5:" | tee -a "$LOGFILE"
+for i in {1..5}; do
+  START_H=$(date +%s%3N)
+  RESULT=$(fission fn test --name "$FUNC_NAME" --namespace "$NS" 2>&1 || true)
+  END_H=$(date +%s%3N)
+  if echo "$RESULT" | grep -qE "hello|200|statusCode"; then
+    echo "  invoke #$i: $((END_H-START_H)) ms" | tee -a "$LOGFILE"
+  else
+    echo "  invoke #$i: FAILED" | tee -a "$LOGFILE"
+  fi
+done
+
+echo "---" | tee -a "$LOGFILE"
+echo "DONE. Log: $LOGFILE"

bench-func/diag_bugs.sh

@@ -0,0 +1,263 @@
+#!/usr/bin/env bash
+# diag_bugs.sh — диагностика двух аномалий из bench_full run=9248232
+#   BUG-1: php/medium + php/large COLD-TIMEOUT (гипотеза: arrow functions PHP 7.4+)
+#   BUG-2: ruby/medium cold=80451ms (гипотеза: poolmgr eviction — проверяем воспроизводимость)
+
+set -uo pipefail
+
+SCRIPT_DIR=$(cd "$(dirname "$0")" && pwd)
+ROOT_DIR=$(cd "${SCRIPT_DIR}/.." && pwd)
+source "${ROOT_DIR}/scripts/lib.sh"
+
+SUB="bench@bench.local"
+RUNID="diag$(date +%s | tail -c 6)"
+TMP=$(mktemp -d)
+
+TIMESTAMP=$(date +%Y-%m-%d_%H-%M-%S)
+RESULTS_DIR="${ROOT_DIR}/test-results/bench-func"
+LOGFILE="${RESULTS_DIR}/diag_bugs_${TIMESTAMP}.log"
+mkdir -p "$RESULTS_DIR"
+
+declare -a ALL_FNS=()
+PASS_CNT=0
+FAIL_CNT=0
+
+cleanup() {
+  rm -rf "$TMP" 2>/dev/null || true
+  for fn in "${ALL_FNS[@]:-}"; do
+    curl -s -X DELETE "${BASE}/functions/${fn}" \
+      -H "X-Auth-Token: ${SUB}" >/dev/null 2>&1 || true
+  done
+}
+trap cleanup EXIT
+
+log() { echo "$@" | tee -a "$LOGFILE"; }
+escape_code() { python3 -c 'import json,sys; print(json.dumps(sys.stdin.read()))'; }
+get_status() {
+  python3 -c "import json,sys
+try: d=json.load(sys.stdin); print(d.get('status',''))
+except: print('')" 2>/dev/null
+}
+get_field() {
+  local f="$1"
+  python3 -c "import json,sys
+try: d=json.load(sys.stdin); print(d.get('$f',''))
+except: print('')" 2>/dev/null
+}
+
+log "════════════════════════════════════════════════════════════════"
+log "  diag_bugs.sh  run=${RUNID}  $(date)"
+log "  API: ${BASE}  SUB: ${SUB}"
+log "════════════════════════════════════════════════════════════════"
+
+# ═══════════════════════════════════════════════════════════════════
+# Вспомогательная: загрузить функцию, сделать cold+hot invoke, вернуть результат
+# bench_one LABEL LANG CODEFILE [EXPECTED_STR]
+# ═══════════════════════════════════════════════════════════════════
+bench_one() {
+  local label="$1" lang="$2" codefile="$3" expected="${4:-}"
+  local fn="bench-${label}-${RUNID}"
+  ALL_FNS+=("$fn")
+
+  # Upload
+  local code_esc t0 t1 R CODE BODY UPLOAD_MS
+  code_esc=$(cat "$codefile" | escape_code)
+  t0=$(date +%s%3N)
+  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\":\"${lang}\",\"code\":${code_esc}}" 2>/dev/null)
+  t1=$(date +%s%3N)
+  CODE=$(echo "$R" | tail -1)
+  BODY=$(echo "$R" | head -n -1)
+  UPLOAD_MS=$((t1-t0))
+
+  if [ "$CODE" != "201" ]; then
+    log "  [${label}] UPLOAD FAIL HTTP=${CODE}: $(echo "$BODY" | head -c 200)"
+    FAIL_CNT=$((FAIL_CNT+1))
+    return 1
+  fi
+  log "  [${label}] upload OK ${UPLOAD_MS}ms"
+
+  # Cold start (retry 20×5s)
+  local tc0 COLD_MS=0 cold_ok=0 cold_body=""
+  tc0=$(date +%s%3N)
+  for i in $(seq 1 20); do
+    local resp s raw
+    resp=$(curl -s --max-time 35 -X POST "${BASE}/functions/${fn}/invoke" \
+      -H "X-Auth-Token: ${SUB}" -H "Content-Type: application/json" -d '{}' 2>/dev/null)
+    s=$(echo "$resp" | get_status)
+    raw=$(echo "$resp" | get_field "response_raw")
+    if [ "$s" = "200" ]; then
+      if [ -z "$expected" ] || echo "$raw" | grep -qF "$expected"; then
+        local tc1; tc1=$(date +%s%3N)
+        COLD_MS=$((tc1-tc0))
+        cold_ok=1
+        cold_body="$raw"
+        break
+      fi
+    fi
+    sleep 5
+  done
+
+  if [ $cold_ok -eq 0 ]; then
+    log "  [${label}] COLD TIMEOUT"
+    FAIL_CNT=$((FAIL_CNT+1))
+    return 1
+  fi
+
+  # Hot ×3
+  local HOT_TOTAL=0 hot_ok=0
+  for i in 1 2 3; do
+    local th0 th1 resp s
+    th0=$(date +%s%3N)
+    resp=$(curl -s --max-time 35 -X POST "${BASE}/functions/${fn}/invoke" \
+      -H "X-Auth-Token: ${SUB}" -H "Content-Type: application/json" -d '{}' 2>/dev/null)
+    th1=$(date +%s%3N)
+    s=$(echo "$resp" | get_status)
+    [ "$s" = "200" ] && { HOT_TOTAL=$((HOT_TOTAL+th1-th0)); hot_ok=$((hot_ok+1)); }
+  done
+  local HOT_AVG=0; [ $hot_ok -gt 0 ] && HOT_AVG=$((HOT_TOTAL/hot_ok))
+
+  log "  [${label}] OK  cold=${COLD_MS}ms  hot_avg=${HOT_AVG}ms (${hot_ok}/3)"
+  [ -n "$cold_body" ] && log "  [${label}] body=$(echo "$cold_body" | head -c 120)"
+  PASS_CNT=$((PASS_CNT+1))
+}
+
+# ═══════════════════════════════════════════════════════════════════
+# BUG-1: PHP arrow functions
+# ═══════════════════════════════════════════════════════════════════
+log ""
+log "┌─────────────────────────────────────────────────────────────────┐"
+log "│ BUG-1: PHP arrow functions (fn()=> требует PHP 7.4+)           │"
+log "└─────────────────────────────────────────────────────────────────┘"
+
+# Тест 1а: минимальный PHP с arrow function — поддерживается?
+cat > "${TMP}/php_arrow_min.php" << 'EOF'
+<?php
+function main($event, $context) {
+    $nums = [1,2,3,4,5];
+    $doubled = array_map(fn($x) => $x * 2, $nums);
+    return "arrow-ok:" . implode(",", $doubled);
+}
+EOF
+log ""
+log "  [php-arrow-min] Тест: arrow function fn(\$x)=>\$x*2 (PHP 7.4+)"
+bench_one "php-arrow-min" "php" "${TMP}/php_arrow_min.php" "arrow-ok"
+
+# Тест 1б: PHP version info через phpinfo-like
+cat > "${TMP}/php_version.php" << 'EOF'
+<?php
+function main($event, $context) {
+    return "php-version:" . PHP_VERSION . " php-major:" . PHP_MAJOR_VERSION . "." . PHP_MINOR_VERSION;
+}
+EOF
+log ""
+log "  [php-version] Тест: получить версию PHP runtime"
+bench_one "php-version" "php" "${TMP}/php_version.php" "php-version"
+
+# Тест 1в: PHP medium без arrow functions (обычные function)
+cat > "${TMP}/php_medium_noarrow.php" << 'EOF'
+<?php
+function fib($n){$a=0;$b=1;for($i=0;$i<$n;$i++)[$a,$b]=[$b,$a+$b];return $a;}
+function sieve($n){$s=array_fill(0,$n+1,true);$s[0]=$s[1]=false;for($i=2;$i*$i<=$n;$i++)if($s[$i])for($j=$i*$i;$j<=$n;$j+=$i)$s[$j]=false;return array_keys(array_filter($s));}
+function sqrtSum($n){$s=0;for($i=1;$i<=$n;$i++)$s+=sqrt($i);return $s;}
+function bubbleSort($arr){$n=count($arr);for($i=0;$i<$n;$i++)for($j=0;$j<$n-$i-1;$j++)if($arr[$j]>$arr[$j+1]){$t=$arr[$j];$arr[$j]=$arr[$j+1];$arr[$j+1]=$t;}return $arr;}
+function matMul($a,$b){$ra=count($a);$ca=count($a[0]);$cb=count($b[0]);$c=array_fill(0,$ra,array_fill(0,$cb,0));for($i=0;$i<$ra;$i++)for($j=0;$j<$cb;$j++)for($k=0;$k<$ca;$k++)$c[$i][$j]+=$a[$i][$k]*$b[$k][$j];return $c;}
+function processWordsNoArrow($words){
+    $out=[];
+    foreach($words as $s){
+        if(strlen($s)>3) $out[]=strrev(strtoupper($s));
+    }
+    return $out;
+}
+function statsArrNoArrow($arr){
+    $n=count($arr);$m=array_sum($arr)/$n;
+    $v=0; foreach($arr as $x) $v+=($x-$m)*($x-$m); $v/=$n;
+    return['n'=>$n,'mean'=>round($m,4),'std'=>round(sqrt($v),4)];
+}
+
+function main($event,$context){
+    $t0=microtime(true);
+    $words=["alpha","beta","gamma","delta","epsilon","zeta","eta","theta","iota","kappa","lambda","mu"];
+    $f=fib(35);$primes=sieve(500);$s=sqrtSum(1000);
+    $nums=range(50,1);$sorted=bubbleSort($nums);
+    $a=[[1,2,3],[4,5,6]];$b=[[7,8],[9,10],[11,12]];$c=matMul($a,$b);
+    $pw=processWordsNoArrow($words);$st=statsArrNoArrow($primes);
+    $h=substr(hash('sha256','bench-medium-php'),0,16);
+    $elapsed=microtime(true)-$t0;
+    return json_encode(['tag'=>'bench-php-medium-noarrow-ok','fib35'=>$f,'primes'=>count($primes),
+        'sqrt'=>round($s,1),'sorted0'=>$sorted[0],'mat_c00'=>$c[0][0],
+        'words'=>count($pw),'stats'=>$st,'hash'=>$h,'elapsed'=>round($elapsed,5)]);
+}
+EOF
+log ""
+log "  [php-medium-noarrow] PHP medium логика без arrow functions (foreach вместо fn()=>)"
+bench_one "php-med-noarr" "php" "${TMP}/php_medium_noarrow.php" "bench-php-medium-noarrow-ok"
+
+# ═══════════════════════════════════════════════════════════════════
+# BUG-2: ruby/medium cold=80451ms — воспроизводимость
+# ═══════════════════════════════════════════════════════════════════
+log ""
+log "┌─────────────────────────────────────────────────────────────────┐"
+log "│ BUG-2: ruby/medium cold=80451ms — воспроизводимость (×3)      │"
+log "└─────────────────────────────────────────────────────────────────┘"
+
+cat > "${TMP}/ruby_medium_diag.rb" << 'EOF'
+require 'json'
+require 'digest'
+
+WORDS=%w[alpha beta gamma delta epsilon zeta eta theta iota kappa lambda mu nu xi omicron pi rho sigma tau upsilon phi chi psi omega]
+
+def fib(n); a,b=0,1; n.times{a,b=b,a+b}; a; end
+def sieve(n)
+  s=Array.new(n+1,true); s[0]=s[1]=false
+  (2..Math.sqrt(n).to_i).each{|i|(i*i..n).step(i){|j|s[j]=false} if s[i]}
+  (0..n).select{|i|s[i]}
+end
+def sqrt_sum(n); (1..n).sum{|i|Math.sqrt(i)}; end
+def bubble_sort(arr)
+  arr=arr.dup; n=arr.length
+  n.times{(n-1).times{|j|arr[j],arr[j+1]=arr[j+1],arr[j] if arr[j]>arr[j+1]}}
+  arr
+end
+def mat_mul(a,b)
+  ra,ca,cb=a.length,a[0].length,b[0].length
+  Array.new(ra){|i|Array.new(cb){|j|(0...ca).sum{|k|a[i][k]*b[k][j]}}}
+end
+def process_words(w); w.select{|s|s.length>3}.map{|s|s.upcase.reverse}; end
+def get_stats(arr)
+  n=arr.length; m=arr.sum.to_f/n; v=arr.sum{|x|(x-m)**2}/n
+  {n:n, mean:m.round(4), std:Math.sqrt(v).round(4)}
+end
+
+def handler(ctx)
+  t0=Time.now
+  f=fib(35); primes=sieve(500); s=sqrt_sum(1000)
+  nums=(1..50).to_a.reverse; sorted=bubble_sort(nums)
+  a=[[1,2,3],[4,5,6]]; b=[[7,8],[9,10],[11,12]]; c=mat_mul(a,b)
+  pw=process_words(WORDS); st=get_stats(primes)
+  h=Digest::SHA256.hexdigest('bench-medium-ruby')[0,16]
+  elapsed=Time.now-t0
+  { statusCode: 200, body: JSON.generate({tag:"bench-ruby-medium-ok", fib35:f, primes:primes.length,
+    sqrt:s.round(1), sorted0:sorted[0], mat_c00:c[0][0],
+    words:pw.length, stats:st, hash:h, elapsed:elapsed.round(5)}) }
+end
+EOF
+
+log ""
+log "  ruby/medium × 3 независимых функции (разные имена → чистый cold start каждый раз)"
+for attempt in 1 2 3; do
+  log ""
+  log "  --- Попытка ${attempt}/3 ---"
+  bench_one "ruby-med-${attempt}" "ruby" "${TMP}/ruby_medium_diag.rb" "bench-ruby-medium-ok"
+done
+
+# ═══════════════════════════════════════════════════════════════════
+# ИТОГ
+# ═══════════════════════════════════════════════════════════════════
+log ""
+log "════════════════════════════════════════════════════════════════"
+log "  ИТОГ: PASS=${PASS_CNT}  FAIL=${FAIL_CNT}  TOTAL=$((PASS_CNT+FAIL_CNT))"
+log "  Лог: ${LOGFILE}"
+log "  Готово: $(date)"
+log "════════════════════════════════════════════════════════════════"

bench-func/hello.py

@@ -0,0 +1,5 @@
+def main(event, context):
+    return {
+        "statusCode": 200,
+        "body": "hello, world!"
+    }

client-console/cmd/server/main.go

@@ -11,8 +11,12 @@ import (
 	"time"
 
 	"fission-console/internal/api"
+	"fission-console/internal/auth"
+	"fission-console/internal/billing"
+	"fission-console/internal/stats"
 
 	"k8s.io/client-go/dynamic"
+	"k8s.io/client-go/kubernetes"
 	"k8s.io/client-go/rest"
 	"k8s.io/client-go/tools/clientcmd"
 )
@@ -36,8 +40,22 @@ func main() {
 		log.Fatalf("create dynamic client: %v", err)
 	}
 
+	kube, err := kubernetes.NewForConfig(cfg)
+	if err != nil {
+		log.Fatalf("create kubernetes client: %v", err)
+	}
+
+	authenticator := &auth.MultiAuthenticator{
+		JWT:  auth.NewDeckAuthenticator(auth.DefaultDeckAPIs, nil),
+		Demo: &auth.DemoAuthenticator{},
+	}
+
+	billingStore := billing.NewStore()
+	statsProvider := stats.NewProvider()
+
 	srv := api.NewServer(api.Config{
 		Dyn:           dyn,
+		Kube:          kube,
 		Namespace:     namespace,
 		RouterURL:     routerURL,
 		HTTPTimeout:   httpTimeout,
@@ -45,17 +63,20 @@ 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"),
 		// --- end ai/ask feature ---
+		Billing: billingStore,
+		Stats:   statsProvider,
 	})
 
 	// Запускаем фоновые горутины: reaper истёкших функций
 	nsm := srv.NSManager()
 	nsm.StartExpiryReaper(envDurationDefault("REAPER_INTERVAL", 5*time.Minute))
-	// StartNSReconciler удалён — за FISSION_RESOURCE_NAMESPACES теперь отвечает Layer 1 NSWatcher
+	nsm.StartNSReconciler(envDurationDefault("NS_RECONCILE_INTERVAL", 30*time.Second))
 
 	httpServer := &http.Server{
 		Addr:    ":" + port,

client-console/deploy/console.yaml

@@ -12,9 +12,15 @@ rules:
   - apiGroups: [""]
     resources: ["pods"]
     verbs: ["get", "list"]
+  - apiGroups: [""]
+    resources: ["pods/log"]
+    verbs: ["get"]
+  - apiGroups: [""]
+    resources: ["secrets"]
+    verbs: ["get", "list", "create", "delete"]
   - apiGroups: ["apps"]
     resources: ["deployments"]
-    verbs: ["get", "list", "update", "patch"]
+    verbs: ["get", "list", "create", "update", "patch", "delete"]
   - apiGroups: ["fission.io"]
     resources: ["environments", "packages", "functions", "httptriggers", "timetriggers"]
     verbs: ["get", "list", "create", "update", "patch", "delete"]
@@ -52,7 +58,8 @@ spec:
       serviceAccountName: fission-console
       containers:
         - name: console
-          image: naeel/fission-console:v1.3.12
+          image: naeel/fission-console:v1.3.96
+          imagePullPolicy: Always
           ports:
             - containerPort: 8090
           env:
@@ -76,6 +83,18 @@ spec:
                 secretKeyRef:
                   name: router
                   key: password
+            - name: FISSION_STORAGESVC_URL
+              value: "http://storagesvc.fission.svc.cluster.local"
+            - name: BILLING_DSN
+              value: "postgres://super:BQUF5ruECa1ZFlq4wYt3gPJUEmtBMkA9QNK4MM5Sd8al4ArMDlmT16DIKHYBPyif@postgresqlk8s-master.dc5db45d-f8b4-4fd0-ad33-ec4dd017f2d5.svc.cluster.local:5432/sqsdb"
+            - name: GRAFANA_INTERNAL_URL
+              value: "http://grafana.grafana.svc.cluster.local:3000"
+            - name: GRAFANA_PUBLIC_URL
+              value: "https://fission.kube5s.ru/grafana"
+            - name: GRAFANA_ADMIN_USER
+              value: "admin"
+            - name: GRAFANA_ADMIN_PASS
+              value: "GrafanaAdmin2026!"
           livenessProbe:
             httpGet:
               path: /health
@@ -143,13 +162,8 @@ spec:
                 name: fission-console
                 port:
                   number: 8090
-          - path: /cron
-            pathType: Prefix
-            backend:
-              service:
-                name: fission-console
-                port:
-                  number: 8090
+          # ⛔ /cron НЕ ПРИНАДЛЕЖИТ console. Ingress /cron → metrics-collector:8091 (metrics-collector/deploy/metrics-collector.yaml)
+          # ⛔ НЕ ДОБАВЛЯТЬ /cron сюда — это сломает независимость сервисов.
   tls:
     - hosts:
         - fission.kube5s.ru

client-console/go.mod

@@ -3,12 +3,15 @@ module fission-console
 go 1.25.0
 
 require (
+	golang.org/x/net v0.47.0
+	k8s.io/api v0.34.1
 	k8s.io/apimachinery v0.34.1
 	k8s.io/client-go v0.34.1
 )
 
 require (
 	github.com/davecgh/go-spew v1.1.1 // indirect
+	github.com/emicklei/go-restful/v3 v3.12.2 // indirect
 	github.com/fxamacker/cbor/v2 v2.9.0 // indirect
 	github.com/go-logr/logr v1.4.3 // indirect
 	github.com/go-openapi/jsonpointer v0.21.0 // indirect
@@ -16,6 +19,11 @@ require (
 	github.com/go-openapi/swag v0.23.0 // indirect
 	github.com/gogo/protobuf v1.3.2 // indirect
 	github.com/google/gnostic-models v0.7.0 // indirect
+	github.com/google/uuid v1.6.0 // indirect
+	github.com/jackc/pgpassfile v1.0.0 // indirect
+	github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 // indirect
+	github.com/jackc/pgx/v5 v5.9.2 // indirect
+	github.com/jackc/puddle/v2 v2.2.2 // indirect
 	github.com/josharian/intern v1.0.0 // indirect
 	github.com/json-iterator/go v1.1.12 // indirect
 	github.com/mailru/easyjson v0.7.7 // indirect
@@ -27,8 +35,8 @@ require (
 	github.com/x448/float16 v0.8.4 // indirect
 	go.yaml.in/yaml/v2 v2.4.3 // indirect
 	go.yaml.in/yaml/v3 v3.0.4 // indirect
-	golang.org/x/net v0.47.0 // indirect
 	golang.org/x/oauth2 v0.30.0 // indirect
+	golang.org/x/sync v0.18.0 // indirect
 	golang.org/x/sys v0.38.0 // indirect
 	golang.org/x/term v0.37.0 // indirect
 	golang.org/x/text v0.31.0 // indirect

client-console/go.sum

@@ -29,6 +29,14 @@ github.com/google/pprof v0.0.0-20241029153458-d1b30febd7db h1:097atOisP2aRj7vFgY
 github.com/google/pprof v0.0.0-20241029153458-d1b30febd7db/go.mod h1:vavhavw2zAxS5dIdcRluK6cSGGPlZynqzFM8NdvU144=
 github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
 github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/jackc/pgpassfile v1.0.0 h1:/6Hmqy13Ss2zCq62VdNG8tM1wchn8zjSGOBJ6icpsIM=
+github.com/jackc/pgpassfile v1.0.0/go.mod h1:CEx0iS5ambNFdcRtxPj5JhEz+xB6uRky5eyVu/W2HEg=
+github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 h1:iCEnooe7UlwOQYpKFhBabPMi4aNAfoODPEFNiAnClxo=
+github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761/go.mod h1:5TJZWKEWniPve33vlWYSoGYefn3gLQRzjfDlhSJ9ZKM=
+github.com/jackc/pgx/v5 v5.9.2 h1:3ZhOzMWnR4yJ+RW1XImIPsD1aNSz4T4fyP7zlQb56hw=
+github.com/jackc/pgx/v5 v5.9.2/go.mod h1:mal1tBGAFfLHvZzaYh77YS/eC6IX9OWbRV1QIIM0Jn4=
+github.com/jackc/puddle/v2 v2.2.2 h1:PR8nw+E/1w0GLuRFSmiioY6UooMp6KJv0/61nB7icHo=
+github.com/jackc/puddle/v2 v2.2.2/go.mod h1:vriiEXHvEE654aYKXXjOvZM39qJ0q+azkZFrfEOc3H4=
 github.com/josharian/intern v1.0.0 h1:vlS4z54oSdjm0bgjRigI+G1HpF+tI+9rE5LLzOg8HmY=
 github.com/josharian/intern v1.0.0/go.mod h1:5DoeVV0s6jJacbCEi61lwdGj/aVlrQvzHFFd8Hwg//Y=
 github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM=
@@ -70,6 +78,7 @@ github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpE
 github.com/stretchr/objx v0.5.2 h1:xuMeJ0Sdp5ZMRXx/aWO6RZxdr3beISkG5/G/aIRr3pY=
 github.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/8L+MA=
 github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
+github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
 github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
 github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
 github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
@@ -99,6 +108,8 @@ golang.org/x/oauth2 v0.30.0/go.mod h1:B++QgG3ZKulg6sRPGD/mqlHQs5rB3Ml9erfeDY7xKl
 golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.18.0 h1:kr88TuHDroi+UVf+0hZnirlk8o8T+4MrK6mr60WkH/I=
+golang.org/x/sync v0.18.0/go.mod h1:9KTHXmSnoGruLpwFjVSX0lNNA75CykiMECbovNTZqGI=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=

client-console/internal/api/ai_prompts.go

@@ -194,7 +194,133 @@ func buildExplainUserPrompt(lang, code string) string {
 }
 
 func buildChatSystemPrompt() string {
-	return "Ты краткий и полезный ассистент для Fission Console. Отвечай по делу и без лишней болтовни."
+	return strings.TrimSpace(`Ты ассистент платформы NUBES Fission Console — веб-интерфейса для запуска serverless-функций.
+Отвечай кратко, по делу, понятным языком без технического жаргона.
+
+## Что такое Fission Console
+Веб-интерфейс по адресу https://fission.kube5s.ru/console/
+Позволяет создавать, редактировать, вызывать и удалять функции без знания инфраструктуры.
+
+## Вход в систему
+- Токен из Личного кабинета (Профиль → Токены) — рекомендуется
+- Демо-логин — любая строка не менее 6 символов. Один и тот же логин всегда даёт одно и то же окружение (namespace).
+
+## Кнопки верхней панели
+- **Refresh** — обновить список функций
+- **✏️ Из кода** — создать новую функцию, написав код прямо в браузере
+- **📦 Из архива** — создать новую функцию из zip-архива с файлами
+- **Help** — справка по консоли
+- **Выход** — выйти из системы
+
+## Таблица функций — что означают столбцы
+- **Имя** — уникальное имя функции
+- **Окружение** — язык выполнения (python, nodejs, go, php, ruby и др.)
+- **Пакет** — имя внутреннего объекта с кодом функции (технический, менять не нужно)
+- **Создана / Изменена** — дата и время создания и последнего изменения
+- **Маршрут** — HTTP-путь через который вызывается функция (например /my-fn)
+- **Методы** — разрешённые HTTP методы (GET, POST и др.)
+- **Cron** — расписание автозапуска (например ` + "`*/5 * * * *`" + ` = каждые 5 минут). Если пусто — cron не задан.
+- **Действия** — кнопки управления функцией (см. ниже)
+
+## Кнопки действий в строке функции
+- **Ред.** — открыть редактор: изменить код, timeout, cron
+- **Вызов** — вызвать функцию прямо из браузера, увидеть ответ и время выполнения
+- **Логи** — посмотреть вывод функции (то что она пишет через print/console.log/log.Printf и т.д.)
+- **Удалить** — удалить функцию (необратимо)
+
+## Создание функции "Из кода"
+Поля формы:
+- **Name** — имя функции (строчные буквы, цифры, дефис; напр. my-func)
+- **Language** — язык (Python, Node.js, Go, PHP, Ruby)
+- **Entrypoint** — точка входа. По умолчанию подставляется автоматически. Для Python: main.main, для Node.js: main, для Go: main, для PHP: main.php::handler, для Ruby: handler
+- **Route** — URL-путь (напр. /my-func). Именно по этому пути функция доступна снаружи
+- **Методы** — HTTP методы через запятую (GET, POST, GET,POST и т.д.)
+- **Timeout** — максимальное время выполнения в секундах
+- **Cron** — расписание в формате cron (необязательно). Включается переключателем.
+- **Код** — редактор кода прямо в браузере
+
+Кнопки в редакторе кода:
+- **🔍 Проверить синтаксис линтером** — проверяет код на синтаксические ошибки
+- **✨ Сгенерировать код LLM** — описать задачу текстом, получить готовый код
+- **📖 LLM: Что делает?** — объяснение что делает текущий код
+
+## Создание функции "Из архива"
+Аналогично "Из кода", но вместо редактора кода — загрузка zip-файла.
+- **🔍 Проверка архива линтером** — проверяет архив на ошибки и совместимость
+- **📖 LLM: Что делает?** — объяснение содержимого архива
+
+## Редактирование функции (кнопка Ред.)
+- **Name, Environment, Entrypoint** — только для просмотра, не редактируются
+- **Timeout** — можно изменить
+- **Cron** — можно включить/выключить и изменить расписание
+- **Код** — редактируется (для функций созданных из кода)
+- **Заменить архив** — загрузить новый zip (для функций из архива)
+- **Переменные окружения** — раздел в конце редактора. Кнопка "+ Добавить" добавляет переменную (имя + значение). Кнопка "Сохранить env vars" применяет изменения. Переменные сразу доступны в поде функции через os.environ (Python), process.env (Node.js), os.Getenv (Go) и т.д.
+- **📋 Клон** — кнопка в нижней панели. Позволяет создать копию функции с новым именем. Клон наследует код, язык, entrypoint, timeout. Маршрут назначается автоматически.
+
+## Вызов функции (кнопка Вызов)
+Открывается модальное окно. Можно указать тело запроса (JSON) и нажать "Вызвать".
+Показывается ответ функции, HTTP статус и время выполнения.
+Если функция долго не отвечает — это нормально при первом вызове (cold start, прогрев 5-15 секунд).
+
+## Логи (кнопка Логи)
+Показывает вывод функции: всё что она пишет через print(), console.log(), fmt.Println() и т.д.
+Кнопка "Обновить" — перезагрузить логи.
+Логи видны пока функция активна (обрабатывает запросы или работает по cron).
+
+## Вызов функции снаружи (через API)
+Функции доступны по адресу: https://fission.kube5s.ru/fn/ВАШ_ROUTE
+Нужен заголовок: Authorization: Bearer ВАШ_ТОКЕН
+
+Пример curl:
+  curl -skL -X POST https://fission.kube5s.ru/fn/ВАШ_ROUTE \
+    -H "Authorization: Bearer $TOKEN" \
+    -H "Content-Type: application/json" \
+    -d '{"key":"value"}'
+
+Пример Python:
+  import requests
+  response = requests.post(
+    "https://fission.kube5s.ru/fn/ВАШ_ROUTE",
+    headers={"Authorization": "Bearer ВАШ_ТОКЕН"},
+    json={"key": "value"}, timeout=60
+  )
+
+## Форматы функций по языкам
+Python (entrypoint: main.main):
+  def main():
+      return "Hello"
+
+Node.js (entrypoint: main):
+  module.exports = async function(context) {
+      return { status: 200, body: "Hello" }
+  }
+
+Go (entrypoint: main):
+  func Handler(w http.ResponseWriter, r *http.Request) {
+      w.Write([]byte("Hello"))
+  }
+
+PHP (entrypoint: main.php::handler):
+  function handler($context) {
+      return ["status" => 200, "body" => "Hello"];
+  }
+
+Ruby (entrypoint: handler):
+  def handler(context)
+    "Hello"
+  end
+
+## Cron расписание — формат
+Формат: минута час день_месяца месяц день_недели
+Примеры:
+- ` + "`*/5 * * * *`" + ` — каждые 5 минут
+- ` + "`0 * * * *`" + ` — каждый час
+- ` + "`0 9 * * 1-5`" + ` — в 9:00 по будням
+- ` + "`@hourly`" + `, ` + "`@daily`" + `, ` + "`@weekly`" + ` — стандартные псевдонимы
+
+## ESC и закрытие окон
+Нажатие ESC закрывает любое открытое окно (модалку).`)
 }
 
 func prettyLanguageName(lang string) string {

client-console/internal/api/auth.go

@@ -0,0 +1,85 @@
+package api
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+	"strings"
+
+	"fission-console/internal/auth"
+)
+
+// 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 != "" {
+		return token
+	}
+	authz := strings.TrimSpace(r.Header.Get("Authorization"))
+	if authz == "" {
+		return ""
+	}
+	const bearerPrefix = "Bearer "
+	if len(authz) >= len(bearerPrefix) && strings.EqualFold(authz[:len(bearerPrefix)], bearerPrefix) {
+		return strings.TrimSpace(authz[len(bearerPrefix):])
+	}
+	return ""
+}
+
+// userNS возвращает namespace пользователя из контекста запроса.
+func (s *Server) userNS(r *http.Request) string {
+	if ns, ok := r.Context().Value(ctxKeyNS{}).(string); ok && ns != "" {
+		return ns
+	}
+	return s.ns
+}
+
+// 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 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
+		}
+
+		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
+		}
+
+		h(w, r.WithContext(ctx))
+	}
+}
+
+// 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
+}

client-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
+	}
+}

client-console/internal/api/explain_archive.go

@@ -0,0 +1,180 @@
+package api
+
+import (
+	"archive/zip"
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"strings"
+	"time"
+)
+
+const (
+	// maxExplainCodeBytes — суммарный лимит кода из архива для отправки в LLM.
+	// LLM бесплатный и слабый — не перегружаем контекст.
+	maxExplainCodeBytes = 20 * 1024
+)
+
+// handleExplainArchive — POST /console/api/ai/explain-archive
+// Принимает zip-архив, извлекает код, отправляет в LLM с вопросом "что делает?".
+func (s *Server) handleExplainArchive(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
+	}
+
+	r.Body = http.MaxBytesReader(w, r.Body, 10*1024*1024)
+	if err := r.ParseMultipartForm(maxArchiveBytes); err != nil {
+		writeJSONError(w, http.StatusBadRequest, "ошибка разбора multipart: "+err.Error())
+		return
+	}
+
+	f, _, err := r.FormFile("archive")
+	if err != nil {
+		writeJSONError(w, http.StatusBadRequest, "поле 'archive' обязательно")
+		return
+	}
+	defer f.Close()
+
+	var buf bytes.Buffer
+	if _, err := buf.ReadFrom(f); err != nil {
+		writeJSONError(w, http.StatusBadRequest, "ошибка чтения архива: "+err.Error())
+		return
+	}
+	if buf.Len() > maxArchiveBytes {
+		writeJSONError(w, http.StatusRequestEntityTooLarge,
+			fmt.Sprintf("архив слишком большой: максимум %d KB", maxArchiveBytes/1024))
+		return
+	}
+
+	zr, err := zip.NewReader(bytes.NewReader(buf.Bytes()), int64(buf.Len()))
+	if err != nil {
+		writeJSONError(w, http.StatusBadRequest, "не удалось открыть zip: "+err.Error())
+		return
+	}
+
+	// Поддерживаемые расширения
+	supported := map[string]bool{".py": true, ".js": true, ".rb": true, ".php": true, ".go": true}
+
+	type fileChunk struct {
+		name string
+		code string
+	}
+	var chunks []fileChunk
+	var totalBytes int
+
+	for _, zf := range zr.File {
+		if zf.FileInfo().IsDir() {
+			continue
+		}
+		ext := strings.ToLower(archiveFileExt(zf.Name))
+		if !supported[ext] {
+			continue
+		}
+		if totalBytes >= maxExplainCodeBytes {
+			break
+		}
+		rc, err := zf.Open()
+		if err != nil {
+			continue
+		}
+		limit := maxExplainCodeBytes - totalBytes
+		content, err := io.ReadAll(io.LimitReader(rc, int64(limit)))
+		rc.Close()
+		if err != nil || len(content) == 0 {
+			continue
+		}
+		chunks = append(chunks, fileChunk{name: zf.Name, code: string(content)})
+		totalBytes += len(content)
+	}
+
+	if len(chunks) == 0 {
+		writeJSONError(w, http.StatusBadRequest, "нет поддерживаемых файлов (.py, .js, .rb, .php, .go)")
+		return
+	}
+
+	// Собираем текст для LLM
+	var sb strings.Builder
+	sb.WriteString("Ниже приведены файлы из архива serverless-функции. Опиши КРАТКО (2-5 предложений) что делает эта функция.\n\n")
+	for _, c := range chunks {
+		sb.WriteString(fmt.Sprintf("=== %s ===\n%s\n\n", c.name, c.code))
+	}
+	prompt := sb.String()
+
+	llmReqBody := llmChatRequest{
+		Model: "gpt-oss-120b",
+		Messages: []llmMessage{
+			{Role: "system", Content: "Ты ассистент для анализа serverless-функций. Отвечай кратко, на русском языке."},
+			{Role: "user", Content: prompt},
+		},
+		MaxTokens: 512,
+	}
+
+	body, _ := json.Marshal(llmReqBody)
+
+	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, "пустой ответ от LLM")
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(map[string]any{
+		"answer": strings.TrimSpace(llmResp.Choices[0].Message.Content),
+	})
+}
+
+// archiveFileExt возвращает расширение файла из пути внутри zip (включая точку).
+func archiveFileExt(name string) string {
+	for i := len(name) - 1; i >= 0 && name[i] != '/'; i-- {
+		if name[i] == '.' {
+			return name[i:]
+		}
+	}
+	return ""
+}

client-console/internal/api/function_archive.go

@@ -0,0 +1,342 @@
+// Package api — создание и обновление функций из zip-архива (multipart/form-data).
+//
+// Этот файл отвечает за два сценария:
+//  1. handleCreateFunctionFromArchive — создание новой функции из загруженного .zip файла.
+//  2. handleUpdateFunctionArchive     — обновление существующей функции новым .zip файлом.
+//
+// Архив загружается пользователем через форму с полем "archive".
+// Содержимое архива передаётся в storagesvc → S3 без модификации.
+// В отличие от function_code.go, здесь нет трансформации кода — архив идёт как есть.
+//
+// Связанная аннотация: fission-console/source-type = "archive"
+// позволяет UI определить режим редактирования при открытии функции.
+package api
+
+import (
+	"context"
+	"fmt"
+	"io"
+	"net/http"
+	"strconv"
+	"strings"
+	"time"
+
+	"fission-console/internal/fission"
+	"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"
+)
+
+// handleCreateFunctionFromArchive создаёт функцию из загруженного zip-архива (multipart/form-data).
+// Поля формы: name, language (или environment), entrypoint, route, methods, timeout, ttl.
+// Файловое поле: archive (.zip).
+func (s *Server) handleCreateFunctionFromArchive(w http.ResponseWriter, r *http.Request, ns string) {
+	if err := r.ParseMultipartForm(maxArchiveUploadSize); err != nil {
+		writeJSONError(w, http.StatusBadRequest, fmt.Sprintf("parse multipart form: %v", err))
+		return
+	}
+
+	name := strings.TrimSpace(r.FormValue("name"))
+	if name == "" || (!validFuncName.MatchString(name) || len(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
+	}
+
+	lang := strings.TrimSpace(r.FormValue("language"))
+	envName := strings.TrimSpace(r.FormValue("environment"))
+
+	f, fhCreate, err := r.FormFile("archive")
+	if err != nil {
+		writeJSONError(w, http.StatusBadRequest, fmt.Sprintf("archive file required: %v", err))
+		return
+	}
+	defer f.Close()
+	archiveBytes, err := io.ReadAll(io.LimitReader(f, maxArchiveUploadSize))
+	if err != nil {
+		writeJSONError(w, http.StatusBadRequest, fmt.Sprintf("read archive: %v", err))
+		return
+	}
+	archiveFilenameCreate := ""
+	if fhCreate != nil {
+		archiveFilenameCreate = fhCreate.Filename
+	}
+
+	// Проверяем magic bytes: zip должен начинаться с PK (0x50 0x4B)
+	if len(archiveBytes) < 4 || archiveBytes[0] != 0x50 || archiveBytes[1] != 0x4B {
+		writeJSONError(w, http.StatusBadRequest, "загруженный файл не является zip-архивом (ожидается .zip)")
+		return
+	}
+
+	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
+	}
+
+	ctx, cancel := context.WithTimeout(r.Context(), 20*time.Second)
+	defer cancel()
+
+	// Определяем environment: по языку или явно
+	if lang != "" {
+		envCtx, envCancel := context.WithTimeout(r.Context(), 15*time.Second)
+		defer envCancel()
+		resolved, envErr := fission.EnsureEnvironment(envCtx, s.dyn, ns, lang)
+		if envErr != nil {
+			if strings.Contains(envErr.Error(), "unsupported language") {
+				writeJSONError(w, http.StatusBadRequest, envErr.Error())
+			} else {
+				writeJSONError(w, http.StatusBadGateway, fmt.Sprintf("ensure environment: %v", envErr))
+			}
+			return
+		}
+		envName = resolved
+	}
+	if envName == "" {
+		writeJSONError(w, http.StatusBadRequest, "language or environment is required")
+		return
+	}
+	if _, err := s.dyn.Resource(fission.EnvironmentGVR).Namespace(ns).Get(ctx, envName, metav1.GetOptions{}); err != nil {
+		writeJSONError(w, http.StatusBadRequest, fmt.Sprintf("environment %q not found: %v", envName, err))
+		return
+	}
+
+	entrypoint := strings.TrimSpace(r.FormValue("entrypoint"))
+	if entrypoint == "" {
+		entrypoint = runtime.DefaultEntrypoint(lang)
+	}
+	route := strings.TrimSpace(r.FormValue("route"))
+	if route == "" {
+		nsShort := ns
+		if len(nsShort) > 12 {
+			nsShort = nsShort[len(nsShort)-12:]
+		}
+		route = "/" + nsShort + "/" + name
+	}
+	if !strings.HasPrefix(route, "/") {
+		route = "/" + route
+	}
+	methods := normalizeMethods(strings.Split(r.FormValue("methods"), ","))
+	timeout := normalizeFunctionTimeout(0)
+	if tv := r.FormValue("timeout"); tv != "" {
+		if n, err := strconv.ParseInt(tv, 10, 64); err == nil {
+			timeout = normalizeFunctionTimeout(n)
+		}
+	}
+
+	// Загружаем архив в storagesvc
+	deploySpec, uploadErr := s.buildDeploySpec(ctx, archiveBytes)
+	if uploadErr != nil {
+		writeJSONError(w, http.StatusInternalServerError, fmt.Sprintf("upload archive: %v", uploadErr))
+		return
+	}
+
+	pkgName := name + "-pkg"
+	triggerName := name + "-route"
+
+	pkg := &unstructured.Unstructured{Object: map[string]any{
+		"apiVersion": "fission.io/v1",
+		"kind":       "Package",
+		"metadata":   map[string]any{"name": pkgName, "namespace": ns},
+		"spec": map[string]any{
+			"deployment":  deploySpec,
+			"environment": map[string]any{"name": envName, "namespace": ns},
+			"source":      map[string]any{},
+		},
+	}}
+
+	now := time.Now().UTC()
+	fnAnnotations := map[string]any{
+		"fission-console/language":  lang,
+		fissionSourceTypeAnnotation: "archive",
+		functionCreatedAtAnnotation: now.Format(time.RFC3339),
+		functionUpdatedAtAnnotation: now.Format(time.RFC3339),
+	}
+	if archiveFilenameCreate != "" {
+		fnAnnotations["fission-console/archive-filename"] = archiveFilenameCreate
+	}
+	if ttl := r.FormValue("ttl"); ttl != "" {
+		if expiresAt, ttlErr := parseTTL(ttl); ttlErr == nil {
+			fnAnnotations["fission-console/expires-at"] = expiresAt.UTC().Format(time.RFC3339)
+		}
+	}
+
+	methodValues := make([]any, 0, len(methods))
+	for _, m := range methods {
+		methodValues = append(methodValues, m)
+	}
+
+	fn := &unstructured.Unstructured{Object: map[string]any{
+		"apiVersion": "fission.io/v1",
+		"kind":       "Function",
+		"metadata":   map[string]any{"name": name, "namespace": ns, "annotations": fnAnnotations},
+		"spec": map[string]any{
+			"environment": map[string]any{"name": envName, "namespace": ns},
+			"package":     map[string]any{"packageref": map[string]any{"name": pkgName, "namespace": ns}},
+			"InvokeStrategy": map[string]any{
+				"ExecutionStrategy": map[string]any{"ExecutorType": "poolmgr"},
+				"StrategyType":      "execution",
+			},
+			"functionTimeout": timeout,
+		},
+	}}
+	if entrypoint != "" {
+		_ = unstructured.SetNestedField(fn.Object, entrypoint, "spec", "package", "functionName")
+	}
+
+	trigger := &unstructured.Unstructured{Object: map[string]any{
+		"apiVersion": "fission.io/v1",
+		"kind":       "HTTPTrigger",
+		"metadata":   map[string]any{"name": triggerName, "namespace": ns},
+		"spec": map[string]any{
+			"functionref": map[string]any{"name": name, "type": "name"},
+			"relativeurl": route,
+			"methods":     methodValues,
+		},
+	}}
+
+	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", name))
+			return
+		}
+		writeJSONError(w, http.StatusBadGateway, fmt.Sprintf("create package: %v", err))
+		return
+	}
+	if _, err := s.dyn.Resource(fission.FunctionGVR).Namespace(ns).Create(ctx, fn, metav1.CreateOptions{}); err != nil {
+		_ = s.dyn.Resource(fission.PackageGVR).Namespace(ns).Delete(ctx, pkgName, metav1.DeleteOptions{})
+		writeJSONError(w, http.StatusBadGateway, fmt.Sprintf("create function: %v", err))
+		return
+	}
+	if _, err := s.dyn.Resource(fission.HTTPTrigGVR).Namespace(ns).Create(ctx, trigger, metav1.CreateOptions{}); err != nil {
+		_ = s.dyn.Resource(fission.FunctionGVR).Namespace(ns).Delete(ctx, name, metav1.DeleteOptions{})
+		_ = s.dyn.Resource(fission.PackageGVR).Namespace(ns).Delete(ctx, pkgName, metav1.DeleteOptions{})
+		writeJSONError(w, http.StatusBadGateway, fmt.Sprintf("create trigger: %v", err))
+		return
+	}
+
+	writeAnyJSON(w, http.StatusCreated, map[string]any{
+		"name":        name,
+		"namespace":   ns,
+		"environment": envName,
+		"route":       route,
+		"source_type": "archive",
+	})
+}
+
+// handleUpdateFunctionArchive обновляет функцию из загруженного zip-архива (multipart/form-data).
+// Поля формы: timeout (optional), entrypoint (optional). Файловое поле: archive (.zip).
+// Создаёт новый Package (новое имя) — чтобы executor сбросил кэш function service.
+func (s *Server) handleUpdateFunctionArchive(w http.ResponseWriter, r *http.Request, name string) {
+	if err := r.ParseMultipartForm(maxArchiveUploadSize); err != nil {
+		writeJSONError(w, http.StatusBadRequest, fmt.Sprintf("parse multipart form: %v", err))
+		return
+	}
+
+	f, _, err := r.FormFile("archive")
+	if err != nil {
+		writeJSONError(w, http.StatusBadRequest, fmt.Sprintf("archive file required: %v", err))
+		return
+	}
+	defer f.Close()
+	archiveBytes, err := io.ReadAll(io.LimitReader(f, maxArchiveUploadSize))
+	if err != nil {
+		writeJSONError(w, http.StatusBadRequest, fmt.Sprintf("read archive: %v", err))
+		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
+	}
+
+	oldPkgName, _, _ := unstructured.NestedString(fn.Object, "spec", "package", "packageref", "name")
+	envName, _, _ := unstructured.NestedString(fn.Object, "spec", "environment", "name")
+
+	newPkgName := name + "-pkg-" + strconv.FormatInt(time.Now().UnixMilli(), 36)
+	deploySpec, uploadErr := s.buildDeploySpec(ctx, archiveBytes)
+	if uploadErr != nil {
+		writeJSONError(w, http.StatusInternalServerError, fmt.Sprintf("upload archive: %v", 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":  deploySpec,
+			"environment": map[string]any{"name": envName, "namespace": ns},
+			"source":      map[string]any{},
+		},
+	}}
+
+	createdPkg, err := s.dyn.Resource(fission.PackageGVR).Namespace(ns).Create(ctx, newPkg, metav1.CreateOptions{})
+	if err != nil {
+		writeJSONError(w, http.StatusBadGateway, fmt.Sprintf("create new package: %v", err))
+		return
+	}
+
+	// Обновляем timeout если задан
+	timeout := normalizeFunctionTimeout(0)
+	if tv := r.FormValue("timeout"); tv != "" {
+		if n, err := strconv.ParseInt(tv, 10, 64); err == nil {
+			timeout = normalizeFunctionTimeout(n)
+		}
+	}
+	_ = unstructured.SetNestedField(fn.Object, timeout, "spec", "functionTimeout")
+
+	// Обновляем entrypoint если передан
+	if ep := strings.TrimSpace(r.FormValue("entrypoint")); ep != "" {
+		_ = unstructured.SetNestedField(fn.Object, ep, "spec", "package", "functionName")
+	}
+
+	fnAnnotations := fn.GetAnnotations()
+	if fnAnnotations == nil {
+		fnAnnotations = map[string]string{}
+	}
+	fnAnnotations[fissionSourceTypeAnnotation] = "archive"
+	fnAnnotations[functionUpdatedAtAnnotation] = time.Now().UTC().Format(time.RFC3339)
+	if fh, fhErr := r.MultipartForm.File["archive"]; fhErr == false || len(fh) > 0 {
+		if files := r.MultipartForm.File["archive"]; len(files) > 0 && files[0].Filename != "" {
+			fnAnnotations["fission-console/archive-filename"] = files[0].Filename
+		}
+	}
+	fn.SetAnnotations(fnAnnotations)
+
+	if err := unstructured.SetNestedField(fn.Object, map[string]any{
+		"name":            newPkgName,
+		"namespace":       ns,
+		"resourceversion": createdPkg.GetResourceVersion(),
+	}, "spec", "package", "packageref"); err != nil {
+		_ = s.dyn.Resource(fission.PackageGVR).Namespace(ns).Delete(ctx, newPkgName, metav1.DeleteOptions{})
+		writeJSONError(w, http.StatusInternalServerError, fmt.Sprintf("set packageref: %v", err))
+		return
+	}
+	if _, err := s.dyn.Resource(fission.FunctionGVR).Namespace(ns).Update(ctx, fn, metav1.UpdateOptions{}); err != nil {
+		_ = s.dyn.Resource(fission.PackageGVR).Namespace(ns).Delete(ctx, newPkgName, metav1.DeleteOptions{})
+		writeJSONError(w, http.StatusBadGateway, fmt.Sprintf("update function: %v", err))
+		return
+	}
+
+	if oldPkgName != "" && oldPkgName != newPkgName {
+		_ = s.dyn.Resource(fission.PackageGVR).Namespace(ns).Delete(ctx, oldPkgName, metav1.DeleteOptions{})
+	}
+
+	writeAnyJSON(w, http.StatusOK, map[string]any{
+		"updated":     true,
+		"package":     newPkgName,
+		"source_type": "archive",
+	})
+}

client-console/internal/api/function_clone.go

@@ -0,0 +1,333 @@
+// Package api — клонирование функций.
+//
+// handleCloneFunction создаёт полную копию функции с новым именем:
+//   - скачивает архив из storagesvc (или копирует literal)
+//   - заливает новый архив (отдельный объект в S3)
+//   - создаёт новый Package, Function и HTTPTrigger
+//
+// Архив переливается заново, чтобы удаление оригинала не сломало клон.
+package api
+
+import (
+	"context"
+	"encoding/base64"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"regexp"
+	"strings"
+	"time"
+
+	"fission-console/internal/billing"
+	"fission-console/internal/fission"
+	"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"
+)
+
+// handleCloneFunction — POST /functions/:name/clone
+// Body: {"new_name": "my-clone", "route": "/my-clone"}  (route необязателен)
+func (s *Server) handleCloneFunction(w http.ResponseWriter, r *http.Request, srcName string) {
+	ctx, cancel := context.WithTimeout(r.Context(), 60*time.Second)
+	defer cancel()
+	ns := s.userNS(r)
+
+	var req struct {
+		NewName string `json:"new_name"`
+		Route   string `json:"route"`
+	}
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		writeJSONError(w, http.StatusBadRequest, fmt.Sprintf("decode request: %v", err))
+		return
+	}
+	req.NewName = strings.TrimSpace(req.NewName)
+	req.Route = strings.TrimSpace(req.Route)
+
+	// Валидация нового имени
+	if req.NewName == "" {
+		writeJSONError(w, http.StatusBadRequest, "new_name is required")
+		return
+	}
+	validName := regexp.MustCompile(`^[a-z0-9]([a-z0-9-]*[a-z0-9])?$`)
+	if !validName.MatchString(req.NewName) || len(req.NewName) > 57 {
+		writeJSONError(w, http.StatusBadRequest, "invalid new_name: must match ^[a-z0-9]([a-z0-9-]*[a-z0-9])?$ and be <= 57 chars")
+		return
+	}
+
+	// Получаем исходную функцию
+	srcFn, err := s.dyn.Resource(fission.FunctionGVR).Namespace(ns).Get(ctx, srcName, metav1.GetOptions{})
+	if err != nil {
+		if apierrors.IsNotFound(err) {
+			writeJSONError(w, http.StatusNotFound, fmt.Sprintf("function %q not found", srcName))
+			return
+		}
+		writeJSONError(w, http.StatusBadGateway, fmt.Sprintf("get function: %v", err))
+		return
+	}
+
+	// Получаем имя пакета исходной функции
+	srcPkgName, _, _ := unstructured.NestedString(srcFn.Object, "spec", "package", "packageref", "name")
+	if srcPkgName == "" {
+		writeJSONError(w, http.StatusBadGateway, "source function has no package reference")
+		return
+	}
+
+	// Получаем исходный Package
+	srcPkg, err := s.dyn.Resource(fission.PackageGVR).Namespace(ns).Get(ctx, srcPkgName, metav1.GetOptions{})
+	if err != nil {
+		writeJSONError(w, http.StatusBadGateway, fmt.Sprintf("get source package: %v", err))
+		return
+	}
+
+	// Скачиваем байты архива из Package
+	archiveBytes, err := s.downloadPackageBytes(ctx, srcPkg)
+	if err != nil {
+		writeJSONError(w, http.StatusBadGateway, fmt.Sprintf("download archive: %v", err))
+		return
+	}
+
+	// Загружаем как новый архив
+	newDeploySpec, err := s.buildDeploySpec(ctx, archiveBytes)
+	if err != nil {
+		writeJSONError(w, http.StatusBadGateway, fmt.Sprintf("upload clone archive: %v", err))
+		return
+	}
+
+	// Параметры для нового пакета (берём spec из оригинала)
+	now := time.Now().UTC()
+	newPkgName := req.NewName + "-" + now.Format("20060102150405")
+
+	// Определяем environment из исходной функции
+	envName, _, _ := unstructured.NestedString(srcFn.Object, "spec", "environment", "name")
+
+	// Собираем spec пакета (аналогично оригиналу, но с новыми байтами)
+	// Если у оригинала есть source (Go) — копируем source spec
+	srcSourceSpec, _, _ := unstructured.NestedMap(srcPkg.Object, "spec", "source")
+	hasBuildCmd, _, _ := unstructured.NestedString(srcPkg.Object, "spec", "buildcommand")
+
+	var newPkgSpec map[string]any
+	if hasBuildCmd != "" {
+		// Go: source package
+		newPkgSpec = map[string]any{
+			"source":       newDeploySpec, // перезаливаем source
+			"deployment":   map[string]any{},
+			"environment":  map[string]any{"name": envName, "namespace": ns},
+			"buildcommand": hasBuildCmd,
+		}
+		_ = srcSourceSpec
+	} else {
+		newPkgSpec = map[string]any{
+			"deployment":  newDeploySpec,
+			"environment": map[string]any{"name": envName, "namespace": ns},
+			"source":      map[string]any{},
+		}
+	}
+
+	newPkg := &unstructured.Unstructured{Object: map[string]any{
+		"apiVersion": "fission.io/v1",
+		"kind":       "Package",
+		"metadata":   map[string]any{"name": newPkgName, "namespace": ns},
+		"spec":       newPkgSpec,
+	}}
+	if _, err := s.dyn.Resource(fission.PackageGVR).Namespace(ns).Create(ctx, newPkg, metav1.CreateOptions{}); err != nil {
+		writeJSONError(w, http.StatusBadGateway, fmt.Sprintf("create clone package: %v", err))
+		return
+	}
+
+	// Копируем аннотации из исходной функции
+	srcAnnotations := srcFn.GetAnnotations()
+	newAnnotations := map[string]any{
+		functionCreatedAtAnnotation: now.Format(time.RFC3339),
+		functionUpdatedAtAnnotation: now.Format(time.RFC3339),
+	}
+	for _, k := range []string{
+		"fission-console/language",
+		fissionSourceTypeAnnotation,
+		"fission-console/env-vars",
+		"fission-console/archive-filename",
+	} {
+		if v, ok := srcAnnotations[k]; ok && v != "" {
+			newAnnotations[k] = v
+		}
+	}
+	newAnnotations["fission-console/cloned-from"] = srcName
+
+	// Копируем entrypoint
+	entrypoint, _, _ := unstructured.NestedString(srcFn.Object, "spec", "package", "functionName")
+	timeout, _, _ := unstructured.NestedInt64(srcFn.Object, "spec", "functionTimeout")
+	if timeout == 0 {
+		timeout = 60
+	}
+
+	// Копируем InvokeStrategy и podspec
+	invokeStrategy, _, _ := unstructured.NestedMap(srcFn.Object, "spec", "InvokeStrategy")
+	if invokeStrategy == nil {
+		invokeStrategy = map[string]any{
+			"ExecutionStrategy": map[string]any{"ExecutorType": "poolmgr"},
+			"StrategyType":      "execution",
+		}
+	}
+	podspec, _, _ := unstructured.NestedMap(srcFn.Object, "spec", "podspec")
+
+	newFnSpec := map[string]any{
+		"environment":     map[string]any{"name": envName, "namespace": ns},
+		"functionTimeout": timeout,
+		"InvokeStrategy":  invokeStrategy,
+		"package": map[string]any{
+			"packageref":   map[string]any{"name": newPkgName, "namespace": ns},
+			"functionName": entrypoint,
+		},
+	}
+	if len(podspec) > 0 {
+		newFnSpec["podspec"] = podspec
+	}
+
+	newFn := &unstructured.Unstructured{Object: map[string]any{
+		"apiVersion": "fission.io/v1",
+		"kind":       "Function",
+		"metadata": map[string]any{
+			"name":        req.NewName,
+			"namespace":   ns,
+			"annotations": newAnnotations,
+		},
+		"spec": newFnSpec,
+	}}
+	if _, err := s.dyn.Resource(fission.FunctionGVR).Namespace(ns).Create(ctx, newFn, metav1.CreateOptions{}); err != nil {
+		_ = s.dyn.Resource(fission.PackageGVR).Namespace(ns).Delete(ctx, newPkgName, metav1.DeleteOptions{})
+		if apierrors.IsAlreadyExists(err) {
+			writeJSONError(w, http.StatusConflict, fmt.Sprintf("function %q already exists", req.NewName))
+			return
+		}
+		writeJSONError(w, http.StatusBadGateway, fmt.Sprintf("create clone function: %v", err))
+		return
+	}
+
+	// Маршрут для нового триггера
+	if req.Route == "" {
+		nsShort := ns
+		if len(nsShort) > 12 {
+			nsShort = nsShort[len(nsShort)-12:]
+		}
+		req.Route = "/" + nsShort + "/" + req.NewName
+	}
+	if !strings.HasPrefix(req.Route, "/") {
+		req.Route = "/" + req.Route
+	}
+	triggerName := req.NewName + "-route"
+
+	// Определяем методы из существующего триггера оригинала
+	methods := s.getTriggerMethods(ctx, ns, srcName)
+	if len(methods) == 0 {
+		methods = []any{"GET"}
+	}
+
+	newTrigger := &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":       methods,
+			"createingress": true,
+			"functionref":   map[string]any{"type": "name", "name": req.NewName},
+		},
+	}}
+	if _, err := s.dyn.Resource(fission.HTTPTrigGVR).Namespace(ns).Create(ctx, newTrigger, metav1.CreateOptions{}); err != nil {
+		_ = s.dyn.Resource(fission.FunctionGVR).Namespace(ns).Delete(ctx, req.NewName, metav1.DeleteOptions{})
+		_ = s.dyn.Resource(fission.PackageGVR).Namespace(ns).Delete(ctx, newPkgName, metav1.DeleteOptions{})
+		writeJSONError(w, http.StatusBadGateway, fmt.Sprintf("create httptrigger: %v", err))
+		return
+	}
+
+	s.billing.RecordInvocation(billing.Invocation{
+		Namespace:    ns,
+		FunctionName: req.NewName,
+		TriggerType:  billing.TriggerEvent,
+		StartedAt:    now,
+		StatusCode:   http.StatusCreated,
+		RecordedBy:   "console",
+		EventType:    "clone",
+	})
+
+	writeAnyJSON(w, http.StatusCreated, map[string]any{
+		"name":        req.NewName,
+		"cloned_from": srcName,
+		"package":     newPkgName,
+		"route":       req.Route,
+	})
+}
+
+// downloadPackageBytes извлекает байты архива из Package CRD.
+// Поддерживает type:url (скачивает из storagesvc) и type:literal (base64).
+func (s *Server) downloadPackageBytes(ctx context.Context, pkg *unstructured.Unstructured) ([]byte, error) {
+	// Пробуем deployment сначала, потом source (для Go)
+	for _, field := range [][]string{{"spec", "deployment"}, {"spec", "source"}} {
+		spec, _, _ := unstructured.NestedMap(pkg.Object, field...)
+		if len(spec) == 0 {
+			continue
+		}
+		archiveType, _ := spec["type"].(string)
+		switch archiveType {
+		case "url":
+			archiveURL, _ := spec["url"].(string)
+			if archiveURL == "" {
+				continue
+			}
+			return s.downloadFromStoragesvc(ctx, archiveURL)
+		case "literal":
+			lit, _ := spec["literal"].(string)
+			if lit == "" {
+				continue
+			}
+			return base64.StdEncoding.DecodeString(lit)
+		}
+	}
+	// Последний шанс: если функция Python с простым кодом — возвращаем заглушку
+	return nil, fmt.Errorf("no downloadable archive found in package (empty deployment and source spec)")
+}
+
+// downloadFromStoragesvc скачивает архив по URL из storagesvc.
+func (s *Server) downloadFromStoragesvc(ctx context.Context, archiveURL string) ([]byte, error) {
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, archiveURL, nil)
+	if err != nil {
+		return nil, fmt.Errorf("build download request: %w", err)
+	}
+	resp, err := s.http.Do(req)
+	if err != nil {
+		return nil, fmt.Errorf("download archive: %w", err)
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode != http.StatusOK {
+		return nil, fmt.Errorf("download archive status %d", resp.StatusCode)
+	}
+	data, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return nil, fmt.Errorf("read archive body: %w", err)
+	}
+	return data, nil
+}
+
+// getTriggerMethods возвращает методы HTTP из триггера функции (для копирования в клон).
+func (s *Server) getTriggerMethods(ctx context.Context, ns, fnName string) []any {
+	triggers, err := s.dyn.Resource(fission.HTTPTrigGVR).Namespace(ns).List(ctx, metav1.ListOptions{})
+	if err != nil {
+		return nil
+	}
+	for _, t := range triggers.Items {
+		ref, _, _ := unstructured.NestedString(t.Object, "spec", "functionref", "name")
+		if ref != fnName {
+			continue
+		}
+		methods, _, _ := unstructured.NestedSlice(t.Object, "spec", "methods")
+		if len(methods) > 0 {
+			return methods
+		}
+	}
+	return nil
+}
+
+// Ссылка на runtime.DefaultEntrypoint для возможного использования в будущем
+var _ = runtime.DefaultEntrypoint

client-console/internal/api/function_clone_test.go

@@ -0,0 +1,631 @@
+package api
+
+import (
+	"archive/zip"
+	"bytes"
+	"context"
+	"encoding/base64"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+
+	"fission-console/internal/billing"
+	"fission-console/internal/fission"
+
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
+	k8sruntime "k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+	dynamicfake "k8s.io/client-go/dynamic/fake"
+)
+
+// ─── helpers ────────────────────────────────────────────────────────────────
+
+// newCloneTestServer создаёт Server с фиктивным k8s-клиентом и
+// опциональным HTTP-сервером, имитирующим storagesvc.
+func newCloneTestServer(t *testing.T, storagesvcHandler http.HandlerFunc, objs ...*unstructured.Unstructured) (*Server, *httptest.Server) {
+	t.Helper()
+	scheme := k8sruntime.NewScheme()
+	listKinds := map[schema.GroupVersionResource]string{
+		fission.FunctionGVR: "FunctionList",
+		fission.PackageGVR:  "PackageList",
+		fission.HTTPTrigGVR: "HTTPTriggerList",
+	}
+	runtimeObjs := make([]k8sruntime.Object, len(objs))
+	for i, o := range objs {
+		runtimeObjs[i] = o
+	}
+	dynClient := dynamicfake.NewSimpleDynamicClientWithCustomListKinds(scheme, listKinds, runtimeObjs...)
+
+	var storagesvc *httptest.Server
+	httpClient := &http.Client{}
+	if storagesvcHandler != nil {
+		storagesvc = httptest.NewServer(storagesvcHandler)
+		httpClient = storagesvc.Client()
+	}
+
+	s := &Server{
+		dyn:     dynClient,
+		ns:      "fission-test",
+		http:    httpClient,
+		billing: billing.NoopStore{},
+	}
+	return s, storagesvc
+}
+
+// cloneRequest выполняет POST /functions/:srcName/clone с телом body.
+func cloneRequest(t *testing.T, s *Server, srcName, body string) *httptest.ResponseRecorder {
+	t.Helper()
+	req := httptest.NewRequest(http.MethodPost,
+		"/console/api/functions/"+srcName+"/clone",
+		strings.NewReader(body))
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("X-Auth-Token", "test-token")
+	rec := httptest.NewRecorder()
+	s.handleCloneFunction(rec, req, srcName)
+	return rec
+}
+
+// makeZip возвращает минимальный zip-архив с одним файлом filename/content.
+func makeZip(t *testing.T, filename, content string) []byte {
+	t.Helper()
+	var buf bytes.Buffer
+	w := zip.NewWriter(&buf)
+	f, err := w.Create(filename)
+	if err != nil {
+		t.Fatalf("zip.Create: %v", err)
+	}
+	if _, err := io.WriteString(f, content); err != nil {
+		t.Fatalf("zip.Write: %v", err)
+	}
+	if err := w.Close(); err != nil {
+		t.Fatalf("zip.Close: %v", err)
+	}
+	return buf.Bytes()
+}
+
+// packageWithLiteral создаёт Package CRD с type:literal (base64-encoded bytes).
+func packageWithLiteral(ns, name, fnName string, data []byte) *unstructured.Unstructured {
+	return &unstructured.Unstructured{Object: map[string]any{
+		"apiVersion": "fission.io/v1",
+		"kind":       "Package",
+		"metadata":   map[string]any{"name": name, "namespace": ns},
+		"spec": map[string]any{
+			"deployment": map[string]any{
+				"type":    "literal",
+				"literal": base64.StdEncoding.EncodeToString(data),
+			},
+			"environment": map[string]any{"name": fnName, "namespace": ns},
+			"source":      map[string]any{},
+		},
+	}}
+}
+
+// packageWithURL создаёт Package CRD с type:url.
+func packageWithURL(ns, pkgName, envName, archiveURL string) *unstructured.Unstructured {
+	return &unstructured.Unstructured{Object: map[string]any{
+		"apiVersion": "fission.io/v1",
+		"kind":       "Package",
+		"metadata":   map[string]any{"name": pkgName, "namespace": ns},
+		"spec": map[string]any{
+			"deployment": map[string]any{
+				"type": "url",
+				"url":  archiveURL,
+			},
+			"environment": map[string]any{"name": envName, "namespace": ns},
+			"source":      map[string]any{},
+		},
+	}}
+}
+
+// functionWithPkg создаёт Function CRD, ссылающуюся на pkgName.
+func functionWithPkg(ns, fnName, pkgName, envName, entrypoint string) *unstructured.Unstructured {
+	return &unstructured.Unstructured{Object: map[string]any{
+		"apiVersion": "fission.io/v1",
+		"kind":       "Function",
+		"metadata": map[string]any{
+			"name":      fnName,
+			"namespace": ns,
+			"annotations": map[string]any{
+				"fission-console/language":    envName,
+				"fission-console/source-type": "code",
+				"fission-console/created-at":  "2026-05-09T00:00:00Z",
+				"fission-console/updated-at":  "2026-05-09T00:00:00Z",
+			},
+		},
+		"spec": map[string]any{
+			"environment":     map[string]any{"name": envName, "namespace": ns},
+			"functionTimeout": int64(120),
+			"package": map[string]any{
+				"packageref":   map[string]any{"name": pkgName, "namespace": ns},
+				"functionName": entrypoint,
+			},
+			"InvokeStrategy": map[string]any{
+				"ExecutionStrategy": map[string]any{"ExecutorType": "poolmgr"},
+				"StrategyType":      "execution",
+			},
+		},
+	}}
+}
+
+// httpTriggerObject создаёт HTTPTrigger CRD для функции fnName.
+func httpTriggerObject(ns, trigName, fnName, route string, methods []any) *unstructured.Unstructured {
+	return &unstructured.Unstructured{Object: map[string]any{
+		"apiVersion": "fission.io/v1",
+		"kind":       "HTTPTrigger",
+		"metadata":   map[string]any{"name": trigName, "namespace": ns},
+		"spec": map[string]any{
+			"relativeurl":   route,
+			"methods":       methods,
+			"createingress": true,
+			"functionref":   map[string]any{"type": "name", "name": fnName},
+		},
+	}}
+}
+
+// ─── Тесты валидации имени ───────────────────────────────────────────────────
+
+func TestHandleCloneFunction_InvalidName_EmptyName(t *testing.T) {
+	s, _ := newCloneTestServer(t, nil)
+	rec := cloneRequest(t, s, "src", `{"new_name":""}`)
+	if rec.Code != http.StatusBadRequest {
+		t.Fatalf("status = %d, want 400; body=%s", rec.Code, rec.Body)
+	}
+	if !strings.Contains(rec.Body.String(), "new_name is required") {
+		t.Fatalf("body should mention 'new_name is required', got: %s", rec.Body)
+	}
+}
+
+func TestHandleCloneFunction_InvalidName_UpperCase(t *testing.T) {
+	s, _ := newCloneTestServer(t, nil)
+	rec := cloneRequest(t, s, "src", `{"new_name":"MyFunc"}`)
+	if rec.Code != http.StatusBadRequest {
+		t.Fatalf("status = %d, want 400; body=%s", rec.Code, rec.Body)
+	}
+}
+
+func TestHandleCloneFunction_InvalidName_StartsWithDash(t *testing.T) {
+	s, _ := newCloneTestServer(t, nil)
+	rec := cloneRequest(t, s, "src", `{"new_name":"-bad"}`)
+	if rec.Code != http.StatusBadRequest {
+		t.Fatalf("status = %d, want 400; body=%s", rec.Code, rec.Body)
+	}
+}
+
+func TestHandleCloneFunction_InvalidName_EndsWithDash(t *testing.T) {
+	s, _ := newCloneTestServer(t, nil)
+	rec := cloneRequest(t, s, "src", `{"new_name":"bad-"}`)
+	if rec.Code != http.StatusBadRequest {
+		t.Fatalf("status = %d, want 400; body=%s", rec.Code, rec.Body)
+	}
+}
+
+func TestHandleCloneFunction_InvalidName_TooLong(t *testing.T) {
+	s, _ := newCloneTestServer(t, nil)
+	longName := strings.Repeat("a", 58)
+	rec := cloneRequest(t, s, "src", fmt.Sprintf(`{"new_name":%q}`, longName))
+	if rec.Code != http.StatusBadRequest {
+		t.Fatalf("status = %d, want 400; body=%s", rec.Code, rec.Body)
+	}
+}
+
+func TestHandleCloneFunction_ValidName_MaxLength(t *testing.T) {
+	// 57 символов — допустимо; но функция src не существует → 404
+	s, _ := newCloneTestServer(t, nil)
+	name57 := strings.Repeat("a", 57)
+	rec := cloneRequest(t, s, "src", fmt.Sprintf(`{"new_name":%q}`, name57))
+	// Ожидаем не 400 (прошло валидацию), а 404 (src не найден)
+	if rec.Code == http.StatusBadRequest {
+		t.Fatalf("57-char name should pass validation, got 400; body=%s", rec.Body)
+	}
+	if rec.Code != http.StatusNotFound {
+		t.Fatalf("status = %d, want 404; body=%s", rec.Code, rec.Body)
+	}
+}
+
+func TestHandleCloneFunction_ValidName_WithDashes(t *testing.T) {
+	// Имя вида "a-b-c" — допустимо
+	s, _ := newCloneTestServer(t, nil)
+	rec := cloneRequest(t, s, "nonexist", `{"new_name":"a-b-c"}`)
+	if rec.Code == http.StatusBadRequest {
+		t.Fatalf("'a-b-c' should pass validation, got 400; body=%s", rec.Body)
+	}
+}
+
+// ─── Тест: источник не существует ────────────────────────────────────────────
+
+func TestHandleCloneFunction_SourceNotFound(t *testing.T) {
+	s, _ := newCloneTestServer(t, nil)
+	rec := cloneRequest(t, s, "ghost", `{"new_name":"ghost-copy"}`)
+	if rec.Code != http.StatusNotFound {
+		t.Fatalf("status = %d, want 404; body=%s", rec.Code, rec.Body)
+	}
+	if !strings.Contains(rec.Body.String(), "ghost") {
+		t.Fatalf("body should mention 'ghost', got: %s", rec.Body)
+	}
+}
+
+// ─── Тест: успешный клон с type:literal ──────────────────────────────────────
+
+func TestHandleCloneFunction_Success_Literal(t *testing.T) {
+	const ns = "fission-test"
+	zipData := makeZip(t, "main.py", "def main():\n    return 'hello'\n")
+
+	pkg := packageWithLiteral(ns, "src-pkg", "python", zipData)
+	fn := functionWithPkg(ns, "src", "src-pkg", "python", "main.main")
+	trig := httpTriggerObject(ns, "src-route", "src", "/test-ns/src", []any{"GET", "POST"})
+
+	// storagesvc принимает загрузку и возвращает URL
+	storagesvc := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.Method == http.MethodPost {
+			// Имитируем загрузку — возвращаем ID архива
+			w.Header().Set("Content-Type", "application/json")
+			fmt.Fprint(w, `{"id":"fission/new-archive-id-123"}`)
+			return
+		}
+		http.NotFound(w, r)
+	}))
+	defer storagesvc.Close()
+
+	s, _ := newCloneTestServer(t, nil, pkg, fn, trig)
+	s.storagesvcURL = storagesvc.URL
+	s.http = storagesvc.Client()
+
+	rec := cloneRequest(t, s, "src", `{"new_name":"src-copy"}`)
+	if rec.Code != http.StatusCreated {
+		t.Fatalf("status = %d, want 201; body=%s", rec.Code, rec.Body)
+	}
+
+	var resp map[string]any
+	if err := json.NewDecoder(rec.Body).Decode(&resp); err != nil {
+		t.Fatalf("decode response: %v", err)
+	}
+	if resp["name"] != "src-copy" {
+		t.Fatalf("response.name = %v, want 'src-copy'", resp["name"])
+	}
+	if resp["cloned_from"] != "src" {
+		t.Fatalf("response.cloned_from = %v, want 'src'", resp["cloned_from"])
+	}
+	if resp["package"] == "" || resp["package"] == nil {
+		t.Fatalf("response.package is empty")
+	}
+
+	ctx := context.Background()
+
+	// Проверяем что Function создана
+	cloneFn, err := s.dyn.Resource(fission.FunctionGVR).Namespace(ns).Get(ctx, "src-copy", metav1.GetOptions{})
+	if err != nil {
+		t.Fatalf("clone Function not found: %v", err)
+	}
+
+	// Аннотация cloned-from
+	ann := cloneFn.GetAnnotations()
+	if ann["fission-console/cloned-from"] != "src" {
+		t.Fatalf("annotation cloned-from = %q, want 'src'", ann["fission-console/cloned-from"])
+	}
+	// Аннотации language и source-type скопированы
+	if ann["fission-console/language"] != "python" {
+		t.Fatalf("annotation language = %q, want 'python'", ann["fission-console/language"])
+	}
+	if ann["fission-console/source-type"] != "code" {
+		t.Fatalf("annotation source-type = %q, want 'code'", ann["fission-console/source-type"])
+	}
+
+	// Entrypoint скопирован
+	ep, _, _ := unstructured.NestedString(cloneFn.Object, "spec", "package", "functionName")
+	if ep != "main.main" {
+		t.Fatalf("entrypoint = %q, want 'main.main'", ep)
+	}
+
+	// Timeout скопирован
+	timeout, _, _ := unstructured.NestedInt64(cloneFn.Object, "spec", "functionTimeout")
+	if timeout != 120 {
+		t.Fatalf("timeout = %d, want 120", timeout)
+	}
+
+	// Проверяем что HTTPTrigger создан
+	trigName := "src-copy-route"
+	cloneTrig, err := s.dyn.Resource(fission.HTTPTrigGVR).Namespace(ns).Get(ctx, trigName, metav1.GetOptions{})
+	if err != nil {
+		t.Fatalf("clone HTTPTrigger not found: %v", err)
+	}
+
+	// Методы скопированы из оригинального триггера
+	methods, _, _ := unstructured.NestedStringSlice(cloneTrig.Object, "spec", "methods")
+	if len(methods) != 2 {
+		t.Fatalf("methods = %v, want [GET POST]", methods)
+	}
+
+	// Маршрут сгенерирован автоматически (содержит new_name)
+	route, _, _ := unstructured.NestedString(cloneTrig.Object, "spec", "relativeurl")
+	if !strings.HasSuffix(route, "/src-copy") {
+		t.Fatalf("route = %q, should end with '/src-copy'", route)
+	}
+}
+
+// ─── Тест: маршрут задан явно ────────────────────────────────────────────────
+
+func TestHandleCloneFunction_CustomRoute(t *testing.T) {
+	const ns = "fission-test"
+	zipData := makeZip(t, "main.py", "def main():\n    return 'hi'\n")
+
+	pkg := packageWithLiteral(ns, "fn-pkg", "python", zipData)
+	fn := functionWithPkg(ns, "fn", "fn-pkg", "python", "main.main")
+
+	storagesvc := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		fmt.Fprint(w, `{"id":"fission/arc-456"}`)
+	}))
+	defer storagesvc.Close()
+
+	s, _ := newCloneTestServer(t, nil, pkg, fn)
+	s.storagesvcURL = storagesvc.URL
+	s.http = storagesvc.Client()
+
+	rec := cloneRequest(t, s, "fn", `{"new_name":"fn-clone","route":"/custom/path"}`)
+	if rec.Code != http.StatusCreated {
+		t.Fatalf("status = %d, want 201; body=%s", rec.Code, rec.Body)
+	}
+
+	ctx := context.Background()
+	trig, err := s.dyn.Resource(fission.HTTPTrigGVR).Namespace(ns).Get(ctx, "fn-clone-route", metav1.GetOptions{})
+	if err != nil {
+		t.Fatalf("HTTPTrigger not found: %v", err)
+	}
+	route, _, _ := unstructured.NestedString(trig.Object, "spec", "relativeurl")
+	if route != "/custom/path" {
+		t.Fatalf("route = %q, want '/custom/path'", route)
+	}
+}
+
+// ─── Тест: маршрут без слеша — добавляется автоматически ─────────────────────
+
+func TestHandleCloneFunction_RouteWithoutLeadingSlash(t *testing.T) {
+	const ns = "fission-test"
+	zipData := makeZip(t, "main.py", "def main():\n    return 'hi'\n")
+
+	pkg := packageWithLiteral(ns, "fn2-pkg", "python", zipData)
+	fn := functionWithPkg(ns, "fn2", "fn2-pkg", "python", "main.main")
+
+	storagesvc := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		fmt.Fprint(w, `{"id":"fission/arc-789"}`)
+	}))
+	defer storagesvc.Close()
+
+	s, _ := newCloneTestServer(t, nil, pkg, fn)
+	s.storagesvcURL = storagesvc.URL
+	s.http = storagesvc.Client()
+
+	rec := cloneRequest(t, s, "fn2", `{"new_name":"fn2-clone","route":"no-leading-slash"}`)
+	if rec.Code != http.StatusCreated {
+		t.Fatalf("status = %d, want 201; body=%s", rec.Code, rec.Body)
+	}
+
+	ctx := context.Background()
+	trig, err := s.dyn.Resource(fission.HTTPTrigGVR).Namespace(ns).Get(ctx, "fn2-clone-route", metav1.GetOptions{})
+	if err != nil {
+		t.Fatalf("HTTPTrigger not found: %v", err)
+	}
+	route, _, _ := unstructured.NestedString(trig.Object, "spec", "relativeurl")
+	if !strings.HasPrefix(route, "/") {
+		t.Fatalf("route = %q, should start with '/'", route)
+	}
+}
+
+// ─── Тест: дублирующее имя → 409 ─────────────────────────────────────────────
+
+func TestHandleCloneFunction_DuplicateName_Conflict(t *testing.T) {
+	const ns = "fission-test"
+	zipData := makeZip(t, "main.py", "def main():\n    return 'a'\n")
+
+	pkg := packageWithLiteral(ns, "dup-pkg", "python", zipData)
+	fn := functionWithPkg(ns, "dup-src", "dup-pkg", "python", "main.main")
+	// Уже существующая функция с именем "dup-copy"
+	existingFn := functionWithPkg(ns, "dup-copy", "other-pkg", "python", "main.main")
+
+	storagesvc := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		fmt.Fprint(w, `{"id":"fission/arc-dup"}`)
+	}))
+	defer storagesvc.Close()
+
+	s, _ := newCloneTestServer(t, nil, pkg, fn, existingFn)
+	s.storagesvcURL = storagesvc.URL
+	s.http = storagesvc.Client()
+
+	rec := cloneRequest(t, s, "dup-src", `{"new_name":"dup-copy"}`)
+	if rec.Code != http.StatusConflict {
+		t.Fatalf("status = %d, want 409; body=%s", rec.Code, rec.Body)
+	}
+	if !strings.Contains(rec.Body.String(), "dup-copy") {
+		t.Fatalf("body should mention 'dup-copy', got: %s", rec.Body)
+	}
+}
+
+// ─── Тест: откат при ошибке создания Function ────────────────────────────────
+
+func TestHandleCloneFunction_Rollback_OnFunctionConflict(t *testing.T) {
+	const ns = "fission-test"
+	zipData := makeZip(t, "main.py", "def main():\n    return 'rb'\n")
+
+	pkg := packageWithLiteral(ns, "rb-pkg", "python", zipData)
+	fn := functionWithPkg(ns, "rb-src", "rb-pkg", "python", "main.main")
+	// Уже существующая функция с именем клона
+	existingFn := functionWithPkg(ns, "rb-clone", "other-pkg", "python", "main.main")
+
+	storagesvc := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		fmt.Fprint(w, `{"id":"fission/arc-rb"}`)
+	}))
+	defer storagesvc.Close()
+
+	s, _ := newCloneTestServer(t, nil, pkg, fn, existingFn)
+	s.storagesvcURL = storagesvc.URL
+	s.http = storagesvc.Client()
+
+	rec := cloneRequest(t, s, "rb-src", `{"new_name":"rb-clone"}`)
+	if rec.Code != http.StatusConflict {
+		t.Fatalf("status = %d, want 409; body=%s", rec.Code, rec.Body)
+	}
+
+	// После rollback Package с именем "rb-clone-*" не должен остаться
+	ctx := context.Background()
+	pkgs, err := s.dyn.Resource(fission.PackageGVR).Namespace(ns).List(ctx, metav1.ListOptions{})
+	if err != nil {
+		t.Fatalf("list packages: %v", err)
+	}
+	for _, p := range pkgs.Items {
+		if strings.HasPrefix(p.GetName(), "rb-clone-") {
+			t.Fatalf("rollback failed: package %q still exists", p.GetName())
+		}
+	}
+}
+
+// ─── Тест: downloadPackageBytes — type:literal ────────────────────────────────
+
+func TestDownloadPackageBytes_Literal(t *testing.T) {
+	s, _ := newCloneTestServer(t, nil)
+
+	original := []byte("hello from literal")
+	pkg := packageWithLiteral("fission-test", "lit-pkg", "python", original)
+
+	got, err := s.downloadPackageBytes(context.Background(), pkg)
+	if err != nil {
+		t.Fatalf("downloadPackageBytes error: %v", err)
+	}
+	if !bytes.Equal(got, original) {
+		t.Fatalf("got %q, want %q", got, original)
+	}
+}
+
+// ─── Тест: downloadPackageBytes — type:url ────────────────────────────────────
+
+func TestDownloadPackageBytes_URL(t *testing.T) {
+	const content = "archive-content-from-storagesvc"
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		fmt.Fprint(w, content)
+	}))
+	defer srv.Close()
+
+	pkg := packageWithURL("fission-test", "url-pkg", "python", srv.URL+"/v1/archive?id=abc")
+	s := &Server{http: srv.Client()}
+
+	got, err := s.downloadPackageBytes(context.Background(), pkg)
+	if err != nil {
+		t.Fatalf("downloadPackageBytes error: %v", err)
+	}
+	if string(got) != content {
+		t.Fatalf("got %q, want %q", got, content)
+	}
+}
+
+// ─── Тест: downloadPackageBytes — пустой Package → ошибка ────────────────────
+
+func TestDownloadPackageBytes_EmptyPackage_Error(t *testing.T) {
+	s, _ := newCloneTestServer(t, nil)
+	emptyPkg := &unstructured.Unstructured{Object: map[string]any{
+		"apiVersion": "fission.io/v1",
+		"kind":       "Package",
+		"metadata":   map[string]any{"name": "empty", "namespace": "fission-test"},
+		"spec":       map[string]any{},
+	}}
+	_, err := s.downloadPackageBytes(context.Background(), emptyPkg)
+	if err == nil {
+		t.Fatal("expected error for empty package, got nil")
+	}
+}
+
+// ─── Тест: downloadFromStoragesvc — non-200 → ошибка ────────────────────────
+
+func TestDownloadFromStoragesvc_Non200(t *testing.T) {
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(http.StatusNotFound)
+	}))
+	defer srv.Close()
+
+	s := &Server{http: srv.Client()}
+	_, err := s.downloadFromStoragesvc(context.Background(), srv.URL+"/v1/archive?id=gone")
+	if err == nil {
+		t.Fatal("expected error for 404 response, got nil")
+	}
+	if !strings.Contains(err.Error(), "404") {
+		t.Fatalf("error should mention 404, got: %v", err)
+	}
+}
+
+// ─── Тест: getTriggerMethods — триггер существует ────────────────────────────
+
+func TestGetTriggerMethods_Found(t *testing.T) {
+	const ns = "fission-test"
+	trig := httpTriggerObject(ns, "my-trig", "my-fn", "/my", []any{"GET", "POST"})
+	s, _ := newCloneTestServer(t, nil, trig)
+
+	methods := s.getTriggerMethods(context.Background(), ns, "my-fn")
+	if len(methods) != 2 {
+		t.Fatalf("methods = %v, want 2 elements", methods)
+	}
+}
+
+// ─── Тест: getTriggerMethods — триггера нет → nil ────────────────────────────
+
+func TestGetTriggerMethods_NotFound(t *testing.T) {
+	s, _ := newCloneTestServer(t, nil)
+	methods := s.getTriggerMethods(context.Background(), "fission-test", "no-such-fn")
+	if methods != nil {
+		t.Fatalf("expected nil, got %v", methods)
+	}
+}
+
+// ─── Тест: невалидный JSON body → 400 ────────────────────────────────────────
+
+func TestHandleCloneFunction_InvalidJSON(t *testing.T) {
+	s, _ := newCloneTestServer(t, nil)
+	req := httptest.NewRequest(http.MethodPost, "/console/api/functions/src/clone",
+		strings.NewReader(`not-json`))
+	rec := httptest.NewRecorder()
+	s.handleCloneFunction(rec, req, "src")
+	if rec.Code != http.StatusBadRequest {
+		t.Fatalf("status = %d, want 400; body=%s", rec.Code, rec.Body)
+	}
+}
+
+// ─── Тест: успешный клон — Package содержит ссылку на Function ───────────────
+
+func TestHandleCloneFunction_PackageRefsCloneFunction(t *testing.T) {
+	const ns = "fission-test"
+	zipData := makeZip(t, "main.py", "def main():\n    return 'ref'\n")
+	pkg := packageWithLiteral(ns, "ref-pkg", "python", zipData)
+	fn := functionWithPkg(ns, "ref-src", "ref-pkg", "python", "main.main")
+
+	storagesvc := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		fmt.Fprint(w, `{"id":"fission/arc-ref"}`)
+	}))
+	defer storagesvc.Close()
+
+	s, _ := newCloneTestServer(t, nil, pkg, fn)
+	s.storagesvcURL = storagesvc.URL
+	s.http = storagesvc.Client()
+
+	rec := cloneRequest(t, s, "ref-src", `{"new_name":"ref-clone"}`)
+	if rec.Code != http.StatusCreated {
+		t.Fatalf("status = %d, want 201; body=%s", rec.Code, rec.Body)
+	}
+
+	ctx := context.Background()
+	cloneFn, err := s.dyn.Resource(fission.FunctionGVR).Namespace(ns).Get(ctx, "ref-clone", metav1.GetOptions{})
+	if err != nil {
+		t.Fatalf("clone function not found: %v", err)
+	}
+
+	pkgRef, _, _ := unstructured.NestedString(cloneFn.Object, "spec", "package", "packageref", "name")
+	if !strings.HasPrefix(pkgRef, "ref-clone-") {
+		t.Fatalf("clone Function.spec.package.packageref.name = %q, should start with 'ref-clone-'", pkgRef)
+	}
+
+	// Package с этим именем должен существовать
+	_, err = s.dyn.Resource(fission.PackageGVR).Namespace(ns).Get(ctx, pkgRef, metav1.GetOptions{})
+	if err != nil {
+		t.Fatalf("clone Package %q not found: %v", pkgRef, err)
+	}
+}

client-console/internal/api/function_code.go

@@ -0,0 +1,438 @@
+// Package api — создание и обновление функций из исходного кода (inline code).
+//
+// Этот файл отвечает за два сценария:
+//  1. handleCreateFunction    — создание новой функции из кода (JSON body).
+//  2. handleUpdateFunctionCode — обновление существующей функции: новый код → новый Package.
+//
+// Поддерживаемые языки: python, nodejs, php, ruby, go.
+// Для Go создаётся source package (builder компилирует .so плагин).
+// Для остальных языков — deployment archive (zip загружается в storagesvc или как literal).
+//
+// Почему новый Package при обновлении:
+// Fission executor кэширует function service по functionUid и не видит изменений
+// в существующем Package. Новое имя пакета гарантирует cache miss в executor.
+package api
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"strconv"
+	"strings"
+	"time"
+
+	"fission-console/internal/billing"
+	"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"
+)
+
+// buildDeployArchive упаковывает исходный код в байты для deployment Package.
+// Для nodejs — ESM-обёртка (package.json + main.js).
+// Для php/ruby — zip с одним файлом скрипта.
+// Для остальных (python) — raw bytes кода (или zip если есть deps).
+// deps — содержимое файла зависимостей (requirements.txt, Gemfile, composer.json).
+// Если deps пустой — поведение как раньше.
+func buildDeployArchive(lang, code, deps string) ([]byte, error) {
+	switch lang {
+	case "nodejs":
+		// TODO: поддержка package.json с deps для nodejs — пока игнорируем deps
+		return runtime.BuildJSDeployZip(code)
+	case "php":
+		if deps != "" {
+			return runtime.BuildScriptZipWithDeps(code, "main.php", deps, "composer.json")
+		}
+		return runtime.BuildScriptZip(code, "main.php")
+	case "ruby":
+		if deps != "" {
+			return runtime.BuildScriptZipWithDeps(code, "handler.rb", deps, "Gemfile")
+		}
+		return runtime.BuildScriptZip(code, "handler.rb")
+	default: // python
+		return runtime.BuildPythonZip(code, deps)
+	}
+}
+
+// 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)
+
+	// Поддерживаем два формата: JSON (код) и multipart/form-data (архив).
+	isArchiveUpload := strings.HasPrefix(r.Header.Get("Content-Type"), "multipart/form-data")
+	if isArchiveUpload {
+		s.handleCreateFunctionFromArchive(w, r, ns)
+		return
+	}
+
+	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)
+	req.Timeout = normalizeFunctionTimeout(req.Timeout)
+
+	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 archive с кодом (S3 или literal fallback)
+	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
+		}
+		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":       srcSpec,
+			"deployment":   map[string]any{},
+			"environment":  map[string]any{"name": req.Environment, "namespace": ns},
+			"buildcommand": "build",
+		}
+	} else {
+		deployBytes, archiveErr := buildDeployArchive(req.Language, req.Code, req.Deps)
+		if archiveErr != nil {
+			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":  deploySpec,
+			"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,
+		fissionSourceTypeAnnotation: "code",
+	}
+	now := time.Now().UTC()
+	fnAnnotations[functionCreatedAtAnnotation] = now.Format(time.RFC3339)
+	fnAnnotations[functionUpdatedAtAnnotation] = now.Format(time.RFC3339)
+	if req.Deps != "" {
+		fnAnnotations["fission-console/deps"] = req.Deps
+	}
+	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},
+			"functionTimeout": req.Timeout,
+			"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
+	}
+
+	s.billing.RecordInvocation(billing.Invocation{
+		Namespace:    ns,
+		FunctionName: req.Name,
+		TriggerType:  billing.TriggerEvent,
+		StartedAt:    now,
+		StatusCode:   http.StatusCreated,
+		RecordedBy:   "console",
+		EventType:    "create",
+	})
+
+	writeAnyJSON(w, http.StatusCreated, map[string]any{
+		"name":        req.Name,
+		"package":     pkgName,
+		"httptrigger": triggerName,
+		"route":       req.Route,
+		"expires_at":  fnAnnotations["fission-console/expires-at"],
+	})
+}
+
+// handleUpdateFunctionCode обновляет код уже существующей функции.
+// Создаёт НОВЫЙ Package (вместо обновления старого) чтобы executor сбросил кэш:
+// executor кэширует function service по functionUid и не видит изменений в том же Package.
+// Новое имя пакета гарантирует cache miss в executor.
+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
+	}
+
+	oldPkgName, _, _ := unstructured.NestedString(fn.Object, "spec", "package", "packageref", "name")
+
+	// Определяем язык из аннотации — нужен для правильной упаковки
+	lang, _, _ := unstructured.NestedString(fn.Object, "metadata", "annotations", "fission-console/language")
+	deployBytes, archiveErr := buildDeployArchive(lang, req.Code, req.Deps)
+	if archiveErr != nil {
+		writeJSONError(w, http.StatusInternalServerError, fmt.Sprintf("build %s archive: %v", lang, archiveErr))
+		return
+	}
+
+	// Создаём новый Package с уникальным именем.
+	// Это единственный способ сбросить кэш executor: он кэширует по functionUid и
+	// не замечает изменений в существующем Package.
+	envName, _, _ := unstructured.NestedString(fn.Object, "spec", "environment", "name")
+	createdAt := func() time.Time {
+		ann := fn.GetAnnotations()
+		if ann != nil {
+			if v := strings.TrimSpace(ann[functionCreatedAtAnnotation]); v != "" {
+				if ts, err := parseRFC3339(v); err == nil {
+					return ts.UTC()
+				}
+			}
+		}
+		if ts := fn.GetCreationTimestamp(); !ts.IsZero() {
+			return ts.UTC()
+		}
+		return time.Time{}
+	}()
+	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":  deploySpec,
+			"environment": map[string]any{"name": envName, "namespace": ns},
+			"source":      map[string]any{},
+		},
+	}}
+
+	createdPkg, err := s.dyn.Resource(fission.PackageGVR).Namespace(ns).Create(ctx, newPkg, metav1.CreateOptions{})
+	if err != nil {
+		writeJSONError(w, http.StatusBadGateway, fmt.Sprintf("create new package: %v", err))
+		return
+	}
+
+	// Обновляем Function на новый Package
+	if err := unstructured.SetNestedField(fn.Object, normalizeFunctionTimeout(req.Timeout), "spec", "functionTimeout"); err != nil {
+		writeJSONError(w, http.StatusInternalServerError, fmt.Sprintf("set function timeout: %v", err))
+		_ = s.dyn.Resource(fission.PackageGVR).Namespace(ns).Delete(ctx, newPkgName, metav1.DeleteOptions{})
+		return
+	}
+	ensureFunctionTimestamps(fn, now)
+	if createdAt.IsZero() {
+		createdAt = now
+	}
+	fnAnnotations := fn.GetAnnotations()
+	if fnAnnotations == nil {
+		fnAnnotations = map[string]string{}
+	}
+	fnAnnotations[functionCreatedAtAnnotation] = createdAt.UTC().Format(time.RFC3339)
+	fnAnnotations[functionUpdatedAtAnnotation] = now.Format(time.RFC3339)
+	if req.Deps != "" {
+		fnAnnotations["fission-console/deps"] = req.Deps
+	} else {
+		delete(fnAnnotations, "fission-console/deps")
+	}
+	fn.SetAnnotations(fnAnnotations)
+	if err := unstructured.SetNestedField(fn.Object, map[string]any{
+		"name":            newPkgName,
+		"namespace":       ns,
+		"resourceversion": createdPkg.GetResourceVersion(),
+	}, "spec", "package", "packageref"); err != nil {
+		writeJSONError(w, http.StatusInternalServerError, fmt.Sprintf("set function packageref: %v", err))
+		_ = s.dyn.Resource(fission.PackageGVR).Namespace(ns).Delete(ctx, newPkgName, metav1.DeleteOptions{})
+		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: %v", name, err))
+		_ = s.dyn.Resource(fission.PackageGVR).Namespace(ns).Delete(ctx, newPkgName, metav1.DeleteOptions{})
+		return
+	}
+
+	// Удаляем старый Package (best effort)
+	if oldPkgName != "" && oldPkgName != newPkgName {
+		_ = s.dyn.Resource(fission.PackageGVR).Namespace(ns).Delete(ctx, oldPkgName, metav1.DeleteOptions{})
+	}
+
+	writeAnyJSON(w, http.StatusOK, map[string]any{
+		"updated": true,
+		"package": newPkgName,
+	})
+}

client-console/internal/api/function_crud.go

@@ -0,0 +1,529 @@
+// Package api — CRUD операции с функциями: чтение, удаление, обновление таймаута, логи, env vars.
+//
+// Этот файл содержит операции, не связанные с заменой кода/архива:
+//   - handleGetFunction           — GET /functions/:name (детали: код, route, environment, source_type)
+//   - handleDeleteFunction        — DELETE /functions/:name (каскадное удаление: триггеры, Package, S3)
+//   - handleUpdateFunctionTimeout — PUT /functions/:name/timeout (только таймаут, без замены кода)
+//   - handleGetFunctionLogs       — GET /functions/:name/logs (логи пода через Kubernetes API)
+//   - handleGetFunctionEnvVars    — GET /functions/:name/envvars (переменные окружения из CRD)
+//   - handlePutFunctionEnvVars    — PUT /functions/:name/envvars (обновить env vars в CRD)
+//
+// Операции с кодом и архивом — в function_code.go и function_archive.go соответственно.
+// Вызов функции — в function_invoke.go.
+package api
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"strings"
+	"time"
+
+	"fission-console/internal/billing"
+	"fission-console/internal/fission"
+
+	corev1 "k8s.io/api/core/v1"
+	apierrors "k8s.io/apimachinery/pkg/api/errors"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
+	k8stypes "k8s.io/apimachinery/pkg/types"
+)
+
+// 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")
+	functionTimeout, foundTimeout, _ := unstructured.NestedInt64(fn.Object, "spec", "functionTimeout")
+	if !foundTimeout || functionTimeout <= 0 {
+		functionTimeout = int64(defaultFunctionInvokeTimeout / time.Second)
+	}
+
+	// Извлекаем исходный код из 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
+		}
+	}
+
+	// Читаем source-type аннотацию (code / archive)
+	sourceType := "code"
+	archiveFilename := ""
+	deps := ""
+	if ann := fn.GetAnnotations(); ann != nil {
+		if v := ann[fissionSourceTypeAnnotation]; v != "" {
+			sourceType = v
+		}
+		if v := ann["fission-console/archive-filename"]; v != "" {
+			archiveFilename = v
+		}
+		if v := ann["fission-console/deps"]; v != "" {
+			deps = v
+		}
+	}
+
+	writeAnyJSON(w, http.StatusOK, map[string]any{
+		"name":             name,
+		"namespace":        ns,
+		"environment":      environment,
+		"package":          packageName,
+		"entrypoint":       entrypoint,
+		"timeout":          functionTimeout,
+		"created_at":       functionTimestampResponse(fn)["created_at"],
+		"updated_at":       functionTimestampResponse(fn)["updated_at"],
+		"code":             code,
+		"deps":             deps,
+		"source_type":      sourceType,
+		"archive_filename": archiveFilename,
+		"route":            route,
+		"methods":          methods,
+		"env_vars":         extractEnvVars(fn),
+		"raw":              fn.Object,
+	})
+}
+
+// handleUpdateFunctionTimeout обновляет только spec.functionTimeout функции (без замены кода/архива).
+func (s *Server) handleUpdateFunctionTimeout(w http.ResponseWriter, r *http.Request, name string) {
+	ctx, cancel := context.WithTimeout(r.Context(), 10*time.Second)
+	defer cancel()
+	ns := s.userNS(r)
+
+	var req struct {
+		Timeout    int64  `json:"timeout"`
+		Entrypoint string `json:"entrypoint"`
+	}
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		writeJSONError(w, http.StatusBadRequest, fmt.Sprintf("decode request: %v", err))
+		return
+	}
+	timeout := normalizeFunctionTimeout(req.Timeout)
+
+	fn, err := s.dyn.Resource(fission.FunctionGVR).Namespace(ns).Get(ctx, name, metav1.GetOptions{})
+	if err != nil {
+		writeJSONError(w, http.StatusBadGateway, fmt.Sprintf("get function %q: %v", name, err))
+		return
+	}
+	if err := unstructured.SetNestedField(fn.Object, timeout, "spec", "functionTimeout"); err != nil {
+		writeJSONError(w, http.StatusInternalServerError, fmt.Sprintf("set timeout: %v", err))
+		return
+	}
+	if req.Entrypoint != "" {
+		_ = unstructured.SetNestedField(fn.Object, req.Entrypoint, "spec", "package", "functionName")
+	}
+	now := time.Now().UTC().Format(time.RFC3339)
+	ann := fn.GetAnnotations()
+	if ann == nil {
+		ann = map[string]string{}
+	}
+	ann[functionUpdatedAtAnnotation] = now
+	fn.SetAnnotations(ann)
+
+	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: %v", name, err))
+		return
+	}
+	writeAnyJSON(w, http.StatusOK, map[string]any{"updated": true, "timeout": timeout})
+}
+
+// handleDeleteFunction удаляет функцию и связанные объекты: HTTPTrigger, TimeTrigger, 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{})
+			}
+		}
+	}
+
+	// Удаляем связанные TimeTrigger-ы
+	if triggers, err := s.dyn.Resource(fission.TimeTrigGVR).Namespace(ns).List(ctx, metav1.ListOptions{}); err == nil {
+		for _, trig := range triggers.Items {
+			refName, _, _ := unstructured.NestedString(trig.Object, "spec", "functionref", "name")
+			if refName == name {
+				_ = s.dyn.Resource(fission.TimeTrigGVR).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 != "" {
+		// Получаем 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)
+	if envName != "" {
+		cleanupCtx, cleanupCancel := context.WithTimeout(context.Background(), 15*time.Second)
+		defer cleanupCancel()
+		fission.CleanupEnvironmentIfUnused(cleanupCtx, s.dyn, ns, envName)
+	}
+
+	// (reconciler NS удалён — за FISSION_RESOURCE_NAMESPACES теперь отвечает Layer 1 NSWatcher)
+
+	s.billing.RecordInvocation(billing.Invocation{
+		Namespace:    ns,
+		FunctionName: name,
+		TriggerType:  billing.TriggerEvent,
+		StartedAt:    time.Now(),
+		StatusCode:   http.StatusOK,
+		RecordedBy:   "console",
+		EventType:    "delete",
+	})
+
+	writeAnyJSON(w, http.StatusOK, map[string]any{"deleted": true, "name": name, "package": pkgName})
+}
+
+// handleGetFunctionLogs возвращает логи пода функции (последние 100 строк).
+// Ищет под по лейблу functionName=<name> в namespace пользователя.
+func (s *Server) handleGetFunctionLogs(w http.ResponseWriter, r *http.Request, name string) {
+	ns := s.userNS(r)
+	ctx := r.Context()
+
+	if s.kube == nil {
+		writeJSONError(w, http.StatusServiceUnavailable, "kubernetes client not available")
+		return
+	}
+
+	labelSelector := "functionName=" + name
+	pods, err := s.kube.CoreV1().Pods(ns).List(ctx, metav1.ListOptions{
+		LabelSelector: labelSelector,
+	})
+	if err != nil {
+		writeJSONError(w, http.StatusInternalServerError, "list pods: "+err.Error())
+		return
+	}
+
+	if len(pods.Items) == 0 {
+		writeAnyJSON(w, http.StatusOK, map[string]any{
+			"logs": "(нет запущенных подов для функции " + name + ")",
+		})
+		return
+	}
+
+	var allLogs strings.Builder
+	tailLines := int64(100)
+	for _, pod := range pods.Items {
+		containerName := ""
+		if len(pod.Spec.Containers) > 0 {
+			containerName = pod.Spec.Containers[0].Name
+		}
+		req := s.kube.CoreV1().Pods(ns).GetLogs(pod.Name, &corev1.PodLogOptions{
+			Container: containerName,
+			TailLines: &tailLines,
+		})
+		rc, err := req.Stream(ctx)
+		if err != nil {
+			allLogs.WriteString("[" + pod.Name + ": ошибка чтения логов: " + err.Error() + "]\n")
+			continue
+		}
+		data, _ := io.ReadAll(rc)
+		rc.Close()
+		if allLogs.Len() > 0 {
+			allLogs.WriteString("\n--- " + pod.Name + " ---\n")
+		} else {
+			allLogs.WriteString("--- " + pod.Name + " ---\n")
+		}
+		allLogs.Write(data)
+	}
+
+	writeAnyJSON(w, http.StatusOK, map[string]any{
+		"logs": allLogs.String(),
+	})
+}
+
+// handleGetFunctionEnvVars возвращает переменные окружения функции из .spec.runtime.container.env
+func (s *Server) handleGetFunctionEnvVars(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
+	}
+
+	envVars := extractEnvVars(fn)
+	writeAnyJSON(w, http.StatusOK, map[string]any{"env_vars": envVars})
+}
+
+// handlePutFunctionEnvVars обновляет переменные окружения функции.
+//
+// Логика переключения ExecutorType:
+//   - Если env vars непустые → ExecutorType: newdeploy + spec.podspec.containers[0].env
+//     (newdeploy создаёт dedicated Deployment, Kubernetes ставит env vars на уровне ОС)
+//   - Если env vars пустые → ExecutorType: poolmgr, podspec удаляется
+//     (poolmgr использует warm pool, быстрый cold start)
+//
+// Это единственный универсальный способ передать env vars в pod для всех языков
+// (Python, Go, Ruby, PHP, Node.js) без изменений в env-серверах.
+func (s *Server) handlePutFunctionEnvVars(w http.ResponseWriter, r *http.Request, name string) {
+	ctx, cancel := context.WithTimeout(r.Context(), 10*time.Second)
+	defer cancel()
+	ns := s.userNS(r)
+
+	var req struct {
+		EnvVars []map[string]string `json:"env_vars"` // [{name: "KEY", value: "VAL"}, ...]
+	}
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		writeJSONError(w, http.StatusBadRequest, fmt.Sprintf("decode request: %v", err))
+		return
+	}
+
+	// Валидация: имена переменных
+	for _, ev := range req.EnvVars {
+		k := ev["name"]
+		if k == "" {
+			writeJSONError(w, http.StatusBadRequest, "env var name cannot be empty")
+			return
+		}
+	}
+
+	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
+	}
+
+	// Сериализуем в JSON для аннотации (для UI)
+	envJSON, err := json.Marshal(req.EnvVars)
+	if err != nil {
+		writeJSONError(w, http.StatusInternalServerError, fmt.Sprintf("marshal env vars: %v", err))
+		return
+	}
+
+	// Обновляем аннотации
+	now := time.Now().UTC().Format(time.RFC3339)
+	ann := fn.GetAnnotations()
+	if ann == nil {
+		ann = map[string]string{}
+	}
+	ann[functionUpdatedAtAnnotation] = now
+	ann["fission-console/env-vars"] = string(envJSON)
+	fn.SetAnnotations(ann)
+
+	if len(req.EnvVars) > 0 {
+		// Есть env vars → newdeploy + podspec с env vars
+		envName, _, _ := unstructured.NestedString(fn.Object, "spec", "environment", "name")
+
+		// Строим список env vars для Kubernetes
+		envList := make([]any, 0, len(req.EnvVars))
+		for _, ev := range req.EnvVars {
+			envList = append(envList, map[string]any{
+				"name":  ev["name"],
+				"value": ev["value"],
+			})
+		}
+
+		// Устанавливаем podspec.containers[0] с env vars
+		// Имя контейнера = имя environment (стандарт Fission)
+		if err := unstructured.SetNestedSlice(fn.Object, []any{
+			map[string]any{
+				"name": envName,
+				"env":  envList,
+			},
+		}, "spec", "podspec", "containers"); err != nil {
+			writeJSONError(w, http.StatusInternalServerError, fmt.Sprintf("set podspec: %v", err))
+			return
+		}
+
+		// Переключаем на newdeploy (только он поддерживает podspec env)
+		if err := unstructured.SetNestedField(fn.Object, map[string]any{
+			"ExecutionStrategy": map[string]any{
+				"ExecutorType":          "newdeploy",
+				"MinScale":              int64(0),
+				"MaxScale":              int64(1),
+				"SpecializationTimeout": int64(120),
+			},
+			"StrategyType": "execution",
+		}, "spec", "InvokeStrategy"); err != nil {
+			writeJSONError(w, http.StatusInternalServerError, fmt.Sprintf("set invoke strategy: %v", err))
+			return
+		}
+	} else {
+		// Нет env vars → poolmgr, убираем podspec
+		unstructured.RemoveNestedField(fn.Object, "spec", "podspec")
+
+		if err := unstructured.SetNestedField(fn.Object, map[string]any{
+			"ExecutionStrategy": map[string]any{
+				"ExecutorType":          "poolmgr",
+				"SpecializationTimeout": int64(120),
+			},
+			"StrategyType": "execution",
+		}, "spec", "InvokeStrategy"); err != nil {
+			writeJSONError(w, http.StatusInternalServerError, fmt.Sprintf("set invoke strategy: %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: %v", name, err))
+		return
+	}
+
+	// Fission newdeploy НЕ применяет fn.Spec.PodSpec при построении Deployment.
+	// Поэтому напрямую патчим существующий Deployment через Kubernetes API.
+	if len(req.EnvVars) > 0 && s.kube != nil {
+		envName, _, _ := unstructured.NestedString(fn.Object, "spec", "environment", "name")
+		if envName != "" {
+			if err := s.patchDeploymentEnvVars(ctx, ns, name, envName, req.EnvVars); err != nil {
+				// Не фатальная ошибка — CRD обновлён, Deployment будет обновлён позже
+				_ = err // warn only
+			}
+		}
+	}
+
+	executor := "poolmgr"
+	if len(req.EnvVars) > 0 {
+		executor = "newdeploy"
+	}
+	writeAnyJSON(w, http.StatusOK, map[string]any{"updated": true, "count": len(req.EnvVars), "executor": executor})
+}
+
+// extractEnvVars читает аннотацию fission-console/env-vars (JSON) из Function CRD
+// Возвращает [{name, value}, ...]
+func extractEnvVars(fn *unstructured.Unstructured) []map[string]string {
+	ann := fn.GetAnnotations()
+	if ann == nil {
+		return []map[string]string{}
+	}
+	raw := ann["fission-console/env-vars"]
+	if raw == "" {
+		return []map[string]string{}
+	}
+	var result []map[string]string
+	if err := json.Unmarshal([]byte(raw), &result); err != nil {
+		return []map[string]string{}
+	}
+	return result
+}
+
+// patchDeploymentEnvVars находит Deployment newdeploy для функции и патчит его env vars.
+// Fission не применяет fn.Spec.PodSpec при построении Deployment, поэтому патчим напрямую.
+// Поиск по labels: functionName=<name>, functionNamespace=<ns>, executorType=newdeploy
+func (s *Server) patchDeploymentEnvVars(ctx context.Context, ns, fnName, envContainerName string, envVars []map[string]string) error {
+	selector := fmt.Sprintf("functionName=%s,functionNamespace=%s,executorType=newdeploy", fnName, ns)
+	deplList, err := s.kube.AppsV1().Deployments(ns).List(ctx, metav1.ListOptions{LabelSelector: selector})
+	if err != nil {
+		return fmt.Errorf("list deployments: %w", err)
+	}
+	if len(deplList.Items) == 0 {
+		return nil // Deployment ещё не создан Fission — ничего страшного
+	}
+
+	// Строим env vars для patch (StrategicMergePatch мержит по "name")
+	envItems := make([]map[string]string, 0, len(envVars))
+	for _, ev := range envVars {
+		envItems = append(envItems, map[string]string{"name": ev["name"], "value": ev["value"]})
+	}
+
+	patch := map[string]any{
+		"spec": map[string]any{
+			"template": map[string]any{
+				"spec": map[string]any{
+					"containers": []any{
+						map[string]any{
+							"name": envContainerName,
+							"env":  envItems,
+						},
+					},
+				},
+			},
+		},
+	}
+	patchBytes, err := json.Marshal(patch)
+	if err != nil {
+		return fmt.Errorf("marshal patch: %w", err)
+	}
+
+	for _, depl := range deplList.Items {
+		if _, err := s.kube.AppsV1().Deployments(ns).Patch(
+			ctx, depl.Name, k8stypes.StrategicMergePatchType, patchBytes, metav1.PatchOptions{},
+		); err != nil {
+			return fmt.Errorf("patch deployment %s: %w", depl.Name, err)
+		}
+	}
+	return nil
+}

client-console/internal/api/function_invoke.go

@@ -0,0 +1,458 @@
+// Package api — вызов функций через Fission router.
+//
+// Этот файл содержит три способа вызова функций:
+//   - handleInvokeFunction        — POST /functions/:name/invoke (через консоль, для тестирования)
+//   - handleInvokeRoute           — /fn/<route> (публичный gateway, пользователь вызывает по своему маршруту)
+//   - handleFissionFunctionGateway — /fission-function/<ns>/<name> (внутренний gateway для cron/timer)
+//
+// Все три варианта проксируют запрос к Fission router с JWT-токеном router.
+// Таймаут вызова берётся из spec.functionTimeout функции (или из конфига если не задан).
+//
+// Вспомогательные утилиты (buildInternalInvokeURL, copyProxyRequestHeaders и др.) — в этом же файле.
+package api
+
+import (
+	"bytes"
+	"context"
+	"errors"
+	"fmt"
+	"io"
+	"net"
+	"net/http"
+	"strings"
+	"time"
+
+	"fission-console/internal/billing"
+	"fission-console/internal/fission"
+
+	apierrors "k8s.io/apimachinery/pkg/api/errors"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
+)
+
+// resolveInvokeTimeout возвращает таймаут вызова функции.
+// Приоритет: spec.functionTimeout функции → конфиг сервера → defaultFunctionInvokeTimeout.
+func (s *Server) resolveInvokeTimeout(fn *unstructured.Unstructured) time.Duration {
+	if fn != nil {
+		seconds, found, err := unstructured.NestedInt64(fn.Object, "spec", "functionTimeout")
+		if err == nil && found && seconds > 0 {
+			return time.Duration(seconds) * time.Second
+		}
+	}
+	if s.invokeTimeout > 0 {
+		return s.invokeTimeout
+	}
+	return defaultFunctionInvokeTimeout
+}
+
+// buildInternalInvokeURL строит URL для вызова функции через Fission router.
+// Для namespace "default" — /fission-function/<name>.
+// Для остальных — /fission-function/<namespace>/<name>.
+func buildInternalInvokeURL(routerURL, namespace, functionName string) string {
+	if namespace == "default" || namespace == "" {
+		return fmt.Sprintf("%s/fission-function/%s", routerURL, functionName)
+	}
+	return fmt.Sprintf("%s/fission-function/%s/%s", routerURL, namespace, functionName)
+}
+
+// shouldForwardRequestBody возвращает true если метод подразумевает тело запроса.
+// GET и HEAD не имеют тела — тело не проксируется.
+func shouldForwardRequestBody(method string) bool {
+	switch method {
+	case http.MethodGet, http.MethodHead:
+		return false
+	default:
+		return true
+	}
+}
+
+// copyProxyRequestHeaders копирует заголовки из входящего запроса в исходящий.
+// Пропускаем служебные заголовки чтобы не перезаписать их при проксировании.
+func copyProxyRequestHeaders(dst, src http.Header) {
+	for key, values := range src {
+		switch http.CanonicalHeaderKey(key) {
+		case "Authorization", "X-Auth-Token", "X-Auth-Env", "Host", "Content-Length":
+			continue
+		}
+		for _, value := range values {
+			dst.Add(key, value)
+		}
+	}
+}
+
+// copyProxyResponseHeaders копирует все заголовки из upstream-ответа в ответ клиенту.
+func copyProxyResponseHeaders(dst, src http.Header) {
+	for key, values := range src {
+		for _, value := range values {
+			dst.Add(key, value)
+		}
+	}
+}
+
+// doRequestWithContextTimeout выполняет HTTP-запрос без глобального таймаута клиента.
+// Реальный лимит задаётся через context — это позволяет функции иметь свой таймаут
+// независимо от общего HTTP-таймаута console.
+func doRequestWithContextTimeout(client *http.Client, req *http.Request) (*http.Response, error) {
+	if client == nil {
+		return http.DefaultClient.Do(req)
+	}
+	invokeClient := *client
+	invokeClient.Timeout = 0
+	return invokeClient.Do(req)
+}
+
+// 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("{}")
+	}
+
+	ns := s.userNS(r)
+	lookupCtx, lookupCancel := context.WithTimeout(r.Context(), 10*time.Second)
+	defer lookupCancel()
+
+	// Проверяем существование функции до вызова — лучше 404 чем непонятный timeout
+	fn, err2 := s.dyn.Resource(fission.FunctionGVR).Namespace(ns).Get(lookupCtx, name, metav1.GetOptions{})
+	if 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
+	}
+
+	invokeTimeout := s.resolveInvokeTimeout(fn)
+	ctx, cancel := context.WithTimeout(r.Context(), invokeTimeout)
+	defer cancel()
+
+	// Ищем HTTPTrigger чтобы получить реальный URL и метод
+	invokeURL := buildInternalInvokeURL(s.routerURL, ns, 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 := doRequestWithContextTimeout(s.http, req)
+	if err != nil {
+		// Отличаем timeout от сетевой ошибки.
+		if errors.Is(err, context.DeadlineExceeded) {
+			writeJSONError(w, http.StatusBadGateway, fmt.Sprintf("invoke %q timeout after %s", 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", name, invokeTimeout))
+			return
+		}
+		writeJSONError(w, http.StatusBadGateway, fmt.Sprintf("invoke %q: %v", name, err))
+		return
+	}
+	defer resp.Body.Close()
+
+	respBody, _ := io.ReadAll(resp.Body)
+
+	durationMS := time.Since(start).Milliseconds()
+	s.billing.RecordInvocation(billing.Invocation{
+		Namespace:     ns,
+		FunctionName:  name,
+		TriggerType:   billing.TriggerConsole,
+		Route:         invokeURL,
+		HTTPMethod:    invokeMethod,
+		StartedAt:     start,
+		DurationMS:    durationMS,
+		StatusCode:    resp.StatusCode,
+		RequestBytes:  int64(len(bodyBytes)),
+		ResponseBytes: int64(len(respBody)),
+		RecordedBy:    "console",
+		EventType:     "invoke",
+	})
+
+	writeAnyJSON(w, http.StatusOK, map[string]any{
+		"status":       resp.StatusCode,
+		"latency_ms":   durationMS,
+		"response_raw": string(respBody),
+	})
+}
+
+// handleFissionFunctionGateway принимает внутренние invoke-запросы timer/router
+// и проксирует их через console в upstream router с корректным router JWT.
+func (s *Server) handleFissionFunctionGateway(w http.ResponseWriter, r *http.Request) {
+	rawPath := strings.Trim(strings.TrimPrefix(r.URL.Path, "/fission-function"), "/")
+	if rawPath == "" {
+		http.NotFound(w, r)
+		return
+	}
+
+	parts := strings.Split(rawPath, "/")
+	namespace := s.ns
+	functionName := ""
+	remainingPath := ""
+
+	if len(parts) == 1 {
+		functionName = strings.TrimSpace(parts[0])
+	} else {
+		namespace = strings.TrimSpace(parts[0])
+		functionName = strings.TrimSpace(parts[1])
+		if len(parts) > 2 {
+			remainingPath = "/" + strings.Join(parts[2:], "/")
+		}
+	}
+
+	if namespace == "" || functionName == "" {
+		writeJSONError(w, http.StatusBadRequest, "namespace and function name are required")
+		return
+	}
+
+	s.invokeInternalFunction(w, r, namespace, functionName, remainingPath)
+}
+
+// invokeInternalFunction проксирует вызов функции к Fission router.
+// Используется как из handleFissionFunctionGateway (cron/timer), так и из handleInvokeRoute.
+func (s *Server) invokeInternalFunction(w http.ResponseWriter, r *http.Request, namespace, functionName, extraPath 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("{}")
+	}
+
+	lookupCtx, lookupCancel := context.WithTimeout(r.Context(), 10*time.Second)
+	defer lookupCancel()
+
+	fn, err := s.dyn.Resource(fission.FunctionGVR).Namespace(namespace).Get(lookupCtx, functionName, metav1.GetOptions{})
+	if err != nil {
+		if apierrors.IsNotFound(err) {
+			writeJSONError(w, http.StatusNotFound, fmt.Sprintf("function %q not found", functionName))
+			return
+		}
+		writeJSONError(w, http.StatusBadGateway, fmt.Sprintf("get function %q: %v", functionName, err))
+		return
+	}
+
+	invokeTimeout := s.resolveInvokeTimeout(fn)
+	ctx, cancel := context.WithTimeout(r.Context(), invokeTimeout)
+	defer cancel()
+
+	invokeURL := buildInternalInvokeURL(s.routerURL, namespace, functionName) + extraPath
+	if r.URL.RawQuery != "" {
+		invokeURL += "?" + r.URL.RawQuery
+	}
+
+	var invokeBody io.Reader
+	if shouldForwardRequestBody(r.Method) {
+		invokeBody = bytes.NewReader(bodyBytes)
+	}
+
+	req, err := http.NewRequestWithContext(ctx, r.Method, invokeURL, invokeBody)
+	if err != nil {
+		writeJSONError(w, http.StatusInternalServerError, fmt.Sprintf("build invoke request: %v", err))
+		return
+	}
+	if shouldForwardRequestBody(r.Method) {
+		req.Header.Set("Content-Type", "application/json")
+	}
+	copyProxyRequestHeaders(req.Header, r.Header)
+	if token := s.getRouterToken(); token != "" {
+		req.Header.Set("Authorization", "Bearer "+token)
+	}
+
+	start := time.Now()
+	resp, err := doRequestWithContextTimeout(s.http, req)
+	if err != nil {
+		if errors.Is(err, context.DeadlineExceeded) {
+			writeJSONError(w, http.StatusBadGateway, fmt.Sprintf("invoke %q timeout after %s", functionName, invokeTimeout))
+			return
+		}
+		var netErr net.Error
+		if errors.As(err, &netErr) && netErr.Timeout() {
+			writeJSONError(w, http.StatusBadGateway, fmt.Sprintf("invoke %q timeout after %s", functionName, invokeTimeout))
+			return
+		}
+		writeJSONError(w, http.StatusBadGateway, fmt.Sprintf("invoke %q: %v", functionName, err))
+		return
+	}
+	defer resp.Body.Close()
+
+	respBody, _ := io.ReadAll(resp.Body)
+
+	durationMS := time.Since(start).Milliseconds()
+	s.billing.RecordInvocation(billing.Invocation{
+		Namespace:     namespace,
+		FunctionName:  functionName,
+		TriggerType:   billing.TriggerHTTP,
+		Route:         extraPath,
+		HTTPMethod:    r.Method,
+		StartedAt:     start,
+		DurationMS:    durationMS,
+		StatusCode:    resp.StatusCode,
+		RequestBytes:  int64(len(bodyBytes)),
+		ResponseBytes: int64(len(respBody)),
+		RecordedBy:    "console",
+		EventType:     "invoke",
+	})
+
+	writeAnyJSON(w, http.StatusOK, map[string]any{
+		"status":       resp.StatusCode,
+		"latency_ms":   durationMS,
+		"response_raw": string(respBody),
+	})
+}
+
+// handleInvokeRoute даёт пользователю прямой HTTP gateway к своей функции по route.
+// Внешний контракт: /fn/<route> + Authorization: Bearer <user-token>.
+func (s *Server) handleInvokeRoute(w http.ResponseWriter, r *http.Request) {
+	route := normalizeRoute(strings.TrimPrefix(r.URL.Path, "/fn"))
+	if route == "/" {
+		writeJSONError(w, http.StatusBadRequest, "route is required")
+		return
+	}
+
+	ns := s.userNS(r)
+	lookupCtx, lookupCancel := context.WithTimeout(r.Context(), 10*time.Second)
+	defer lookupCancel()
+
+	triggers, err := s.dyn.Resource(fission.HTTPTrigGVR).Namespace(ns).List(lookupCtx, metav1.ListOptions{})
+	if err != nil {
+		writeJSONError(w, http.StatusBadGateway, fmt.Sprintf("list httptriggers: %v", err))
+		return
+	}
+
+	matchedFunction := ""
+	allowedMethods := make([]string, 0, 4)
+	for _, trig := range triggers.Items {
+		trigRoute, _, _ := unstructured.NestedString(trig.Object, "spec", "relativeurl")
+		if normalizeRoute(trigRoute) != route {
+			continue
+		}
+		methods, _, _ := unstructured.NestedStringSlice(trig.Object, "spec", "methods")
+		allowedMethods = appendUniqueMethods(allowedMethods, methods)
+		if !routeAllowsMethod(methods, r.Method) {
+			continue
+		}
+		matchedFunction, _, _ = unstructured.NestedString(trig.Object, "spec", "functionref", "name")
+		if matchedFunction != "" {
+			break
+		}
+	}
+
+	if matchedFunction == "" {
+		if len(allowedMethods) > 0 {
+			w.Header().Set("Allow", strings.Join(allowedMethods, ", "))
+			writeJSONError(w, http.StatusMethodNotAllowed, fmt.Sprintf("route %q does not allow method %s", route, r.Method))
+			return
+		}
+		writeJSONError(w, http.StatusNotFound, fmt.Sprintf("route %q not found", route))
+		return
+	}
+
+	fn, err := s.dyn.Resource(fission.FunctionGVR).Namespace(ns).Get(lookupCtx, matchedFunction, metav1.GetOptions{})
+	if err != nil {
+		writeJSONError(w, http.StatusBadGateway, fmt.Sprintf("get function %q: %v", matchedFunction, err))
+		return
+	}
+
+	bodyBytes, err := io.ReadAll(r.Body)
+	if err != nil {
+		writeJSONError(w, http.StatusBadRequest, fmt.Sprintf("read request body: %v", err))
+		return
+	}
+
+	invokeTimeout := s.resolveInvokeTimeout(fn)
+	ctx, cancel := context.WithTimeout(r.Context(), invokeTimeout)
+	defer cancel()
+
+	invokeURL := s.routerURL + route
+	if r.URL.RawQuery != "" {
+		invokeURL += "?" + r.URL.RawQuery
+	}
+
+	var invokeBody io.Reader
+	if shouldForwardRequestBody(r.Method) {
+		invokeBody = bytes.NewReader(bodyBytes)
+	}
+
+	req, err := http.NewRequestWithContext(ctx, r.Method, invokeURL, invokeBody)
+	if err != nil {
+		writeJSONError(w, http.StatusInternalServerError, fmt.Sprintf("build invoke request: %v", err))
+		return
+	}
+	copyProxyRequestHeaders(req.Header, r.Header)
+	if token := s.getRouterToken(); token != "" {
+		req.Header.Set("Authorization", "Bearer "+token)
+	}
+
+	resp, err := doRequestWithContextTimeout(s.http, req)
+	if err != nil {
+		if errors.Is(err, context.DeadlineExceeded) {
+			writeJSONError(w, http.StatusBadGateway, fmt.Sprintf("invoke route %q timeout after %s", route, invokeTimeout))
+			return
+		}
+		var netErr net.Error
+		if errors.As(err, &netErr) && netErr.Timeout() {
+			writeJSONError(w, http.StatusBadGateway, fmt.Sprintf("invoke route %q timeout after %s", route, invokeTimeout))
+			return
+		}
+		writeJSONError(w, http.StatusBadGateway, fmt.Sprintf("invoke route %q: %v", route, err))
+		return
+	}
+	defer resp.Body.Close()
+
+	copyProxyResponseHeaders(w.Header(), resp.Header)
+	w.WriteHeader(resp.StatusCode)
+	_, _ = io.Copy(w, resp.Body)
+}

client-console/internal/api/handlers.go

@@ -0,0 +1,292 @@
+// Package api — роутинг и общие утилиты HTTP-обработчиков консоли.
+//
+// Этот файл содержит:
+//   - Константы и regex для валидации функций
+//   - handleFunctionsRoot / handleFunctionsAction — диспетчеры запросов к /functions
+//   - handleAuth — аутентификация пользователя (POST /auth)
+//   - parseTTL, normalizeMethods, normalizeRoute и другие утилиты
+//
+// Реализация конкретных операций с функциями вынесена в отдельные файлы:
+//   - function_code.go    — создание и обновление из кода
+//   - function_archive.go — создание и обновление из zip-архива
+//   - function_crud.go    — GET, DELETE, обновление таймаута, логи
+//   - function_invoke.go  — вызов функции через Fission router
+//   - storagesvc.go       — загрузка/удаление архивов в S3 через storagesvc
+package api
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"regexp"
+	"strconv"
+	"strings"
+	"time"
+
+	"fission-console/internal/auth"
+)
+
+// 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])?$`)
+
+// ⛔⛔⛔ НЕ МЕНЯТЬ БЕЗ ЯВНОГО РАЗРЕШЕНИЯ ВЛАДЕЛЬЦА.
+// Любые "улучшения", рефакторинг, новые фичи — ЗАПРЕЩЕНЫ без команды.
+// Прецедент: самодеятельный helm upgrade сломал JWT secret router → 401 у всех функций.
+
+// maxCodeSize — максимальный размер кода функции (1 MB).
+// Выше — не имеет смысла для inline функции; лучше использовать Package с URL.
+const maxCodeSize = 1 << 20
+
+// maxArchiveUploadSize — максимальный размер zip-архива при загрузке функции (32 MB).
+const maxArchiveUploadSize = 32 << 20
+
+// fissionSourceTypeAnnotation — аннотация на Function, хранит тип источника: "code" или "archive".
+const fissionSourceTypeAnnotation = "fission-console/source-type"
+
+// defaultFunctionInvokeTimeout совпадает с дефолтом Fission для spec.functionTimeout.
+const defaultFunctionInvokeTimeout = 60 * time.Second
+
+// handleFunctionsRoot обрабатывает запросы к /console/api/functions без имени функции.
+// GET → список всех функций со статусами, POST → создать новую.
+func (s *Server) handleFunctionsRoot(w http.ResponseWriter, r *http.Request) {
+	switch r.Method {
+	case http.MethodGet:
+		s.handleListFunctionsWithStatus(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", "archive", "invoke", "logs", "timeout").
+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/timeout — обновление только таймаута (без замены архива/кода)
+	if len(parts) == 2 && parts[1] == "timeout" && r.Method == http.MethodPut {
+		s.handleUpdateFunctionTimeout(w, r, name)
+		return
+	}
+
+	// /functions/:name/archive — обновление через zip-архив
+	if len(parts) == 2 && parts[1] == "archive" && r.Method == http.MethodPut {
+		s.handleUpdateFunctionArchive(w, r, name)
+		return
+	}
+
+	// /functions/:name/invoke — вызов функции
+	if len(parts) == 2 && parts[1] == "invoke" && r.Method == http.MethodPost {
+		s.handleInvokeFunction(w, r, name)
+		return
+	}
+
+	// /functions/:name/logs — логи подов функции
+	if len(parts) == 2 && parts[1] == "logs" && r.Method == http.MethodGet {
+		s.handleGetFunctionLogs(w, r, name)
+		return
+	}
+
+	// /functions/:name/envvars — переменные окружения
+	if len(parts) == 2 && parts[1] == "envvars" {
+		switch r.Method {
+		case http.MethodGet:
+			s.handleGetFunctionEnvVars(w, r, name)
+		case http.MethodPut:
+			s.handlePutFunctionEnvVars(w, r, name)
+		default:
+			http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
+		}
+		return
+	}
+
+	// /functions/:name/clone — клонировать функцию с новым именем
+	if len(parts) == 2 && parts[1] == "clone" && r.Method == http.MethodPost {
+		s.handleCloneFunction(w, r, name)
+		return
+	}
+
+	http.NotFound(w, r)
+}
+
+// handleAuth обрабатывает POST /console/api/auth.
+// Валидирует токен через 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")
+		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 := normalizeEnv(body.Env)
+
+	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 {
+		fmt.Printf("handleAuth: ensureUserNS %s: %v\n", ns, ensureErr)
+	}
+
+	// Провизируем Grafana Org для этого namespace (fire-and-forget, идемпотентно).
+	go func() {
+		if err := s.stats.EnsureOrgForNamespace(context.Background(), ns, identity.Email); err != nil {
+			fmt.Printf("handleAuth: EnsureOrgForNamespace %s: %v\n", ns, err)
+		}
+	}()
+
+	w.Header().Set("Content-Type", "application/json; charset=utf-8")
+	_ = json.NewEncoder(w).Encode(map[string]any{"ok": true, "env": env, "namespace": ns, "email": identity.Email})
+}
+
+// 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
+}
+
+// normalizeFunctionTimeout нормализует таймаут: отрицательные и нулевые значения
+// заменяются дефолтным значением Fission (defaultFunctionInvokeTimeout).
+func normalizeFunctionTimeout(seconds int64) int64 {
+	if seconds <= 0 {
+		return int64(defaultFunctionInvokeTimeout / time.Second)
+	}
+	return seconds
+}
+
+// normalizeRoute нормализует URL-маршрут: убирает пробелы, гарантирует prefix "/".
+func normalizeRoute(route string) string {
+	route = strings.TrimSpace(route)
+	if route == "" || route == "/" {
+		return "/"
+	}
+	if !strings.HasPrefix(route, "/") {
+		return "/" + route
+	}
+	return route
+}
+
+// routeAllowsMethod проверяет, допускает ли маршрут указанный HTTP-метод.
+// Пустой список methods означает "любой метод".
+func routeAllowsMethod(methods []string, method string) bool {
+	if len(methods) == 0 {
+		return true
+	}
+	for _, candidate := range methods {
+		if strings.EqualFold(strings.TrimSpace(candidate), method) {
+			return true
+		}
+	}
+	return false
+}
+
+// appendUniqueMethods добавляет методы из src в dst без дублей (case-insensitive).
+func appendUniqueMethods(dst []string, src []string) []string {
+	for _, method := range src {
+		method = strings.ToUpper(strings.TrimSpace(method))
+		if method == "" {
+			continue
+		}
+		seen := false
+		for _, existing := range dst {
+			if existing == method {
+				seen = true
+				break
+			}
+		}
+		if !seen {
+			dst = append(dst, method)
+		}
+	}
+	return dst
+}

client-console/internal/api/kwtriggers.go

@@ -0,0 +1,241 @@
+package api
+
+// kwtriggers.go — CRUD хендлеры для KubernetesWatchTrigger (Fission KW Trigger).
+//
+// РЕШЕНИЕ ПО АРХИТЕКТУРЕ (2026-05-11):
+//   KubernetesWatchTrigger позволяет вызывать функцию при изменении K8s объектов.
+//   spec.type      — тип ресурса: Pod, Service, Deployment, ConfigMap, и т.д.
+//   spec.namespace — namespace для слежения (по умолчанию = namespace пользователя)
+//   spec.labelselector — label selector в формате "key=value,key2=value2"
+//   spec.functionref — ссылка на функцию
+//
+// ОСОБЕННОСТИ:
+//   - Fission kubewatcher компонент должен быть задеплоен.
+//   - namespace в spec — это WATCHED namespace (не namespace триггера).
+//     Для безопасности ограничиваем: только namespace пользователя или пустое (тогда = userNS).
+//   - labelselector опционален, "" = смотрим на все ресурсы типа resourceType в namespace.
+//
+// ОШИБКИ В ПРОЦЕССЕ:
+//   - (нет, первая реализация)
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"strings"
+	"time"
+
+	"fission-console/internal/fission"
+	"fission-console/internal/model"
+
+	apierrors "k8s.io/apimachinery/pkg/api/errors"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
+)
+
+// validKWResourceTypes — поддерживаемые типы ресурсов для слежения.
+// Расширяемо — это не ограничение CRD, просто UI-валидация.
+var validKWResourceTypes = map[string]struct{}{
+	"pod":         {},
+	"service":     {},
+	"deployment":  {},
+	"configmap":   {},
+	"secret":      {},
+	"namespace":   {},
+	"replicaset":  {},
+	"statefulset": {},
+	"daemonset":   {},
+	"job":         {},
+}
+
+func (s *Server) handleKWTriggersRoot(w http.ResponseWriter, r *http.Request) {
+	switch r.Method {
+	case http.MethodGet:
+		s.handleList(fission.KWTrigGVR)(w, r)
+	case http.MethodPost:
+		s.handleCreateKWTrigger(w, r)
+	default:
+		http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
+	}
+}
+
+func (s *Server) handleKWTriggersAction(w http.ResponseWriter, r *http.Request) {
+	path := strings.TrimPrefix(r.URL.Path, "/console/api/kwtriggers/")
+	path = strings.TrimPrefix(path, "/api/kwtriggers/")
+	name := strings.Trim(path, "/")
+	if name == "" || strings.Contains(name, "/") {
+		http.NotFound(w, r)
+		return
+	}
+
+	switch r.Method {
+	case http.MethodGet:
+		s.handleGetKWTrigger(w, r, name)
+	case http.MethodDelete:
+		s.handleDeleteKWTrigger(w, r, name)
+	default:
+		http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
+	}
+}
+
+func (s *Server) handleCreateKWTrigger(w http.ResponseWriter, r *http.Request) {
+	var req model.CreateKWTriggerRequest
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		writeJSONError(w, http.StatusBadRequest, fmt.Sprintf("decode request: %v", err))
+		return
+	}
+
+	ns := s.userNS(r)
+
+	// Если namespace не задан — используем namespace пользователя
+	if strings.TrimSpace(req.Namespace) == "" {
+		req.Namespace = ns
+	}
+
+	// Безопасность: нельзя смотреть за чужим namespace
+	if req.Namespace != ns {
+		writeJSONError(w, http.StatusForbidden, "can only watch your own namespace")
+		return
+	}
+
+	if err := validateKWTriggerRequest(req); err != nil {
+		writeJSONError(w, http.StatusBadRequest, err.Error())
+		return
+	}
+
+	ctx, cancel := context.WithTimeout(r.Context(), 15*time.Second)
+	defer cancel()
+
+	// Проверяем что функция существует
+	if _, err := s.dyn.Resource(fission.FunctionGVR).Namespace(ns).Get(ctx, req.FunctionName, metav1.GetOptions{}); err != nil {
+		if apierrors.IsNotFound(err) {
+			writeJSONError(w, http.StatusBadRequest, fmt.Sprintf("function %q not found", req.FunctionName))
+			return
+		}
+		writeJSONError(w, http.StatusBadGateway, fmt.Sprintf("get function: %v", err))
+		return
+	}
+
+	obj := buildKWTriggerObject(ns, req)
+	created, err := s.dyn.Resource(fission.KWTrigGVR).Namespace(ns).Create(ctx, obj, metav1.CreateOptions{})
+	if err != nil {
+		if apierrors.IsAlreadyExists(err) {
+			writeJSONError(w, http.StatusConflict, fmt.Sprintf("kwtrigger %q already exists", req.Name))
+			return
+		}
+		writeJSONError(w, http.StatusBadGateway, fmt.Sprintf("create kwtrigger: %v", err))
+		return
+	}
+
+	writeAnyJSON(w, http.StatusCreated, kwTriggerResponse(created))
+}
+
+func (s *Server) handleGetKWTrigger(w http.ResponseWriter, r *http.Request, name string) {
+	ctx, cancel := context.WithTimeout(r.Context(), 10*time.Second)
+	defer cancel()
+
+	obj, err := s.dyn.Resource(fission.KWTrigGVR).Namespace(s.userNS(r)).Get(ctx, name, metav1.GetOptions{})
+	if err != nil {
+		status := http.StatusBadGateway
+		if apierrors.IsNotFound(err) {
+			status = http.StatusNotFound
+		}
+		writeJSONError(w, status, fmt.Sprintf("get kwtrigger %q: %v", name, err))
+		return
+	}
+
+	writeAnyJSON(w, http.StatusOK, kwTriggerResponse(obj))
+}
+
+func (s *Server) handleDeleteKWTrigger(w http.ResponseWriter, r *http.Request, name string) {
+	ctx, cancel := context.WithTimeout(r.Context(), 10*time.Second)
+	defer cancel()
+
+	if err := s.dyn.Resource(fission.KWTrigGVR).Namespace(s.userNS(r)).Delete(ctx, name, metav1.DeleteOptions{}); err != nil {
+		status := http.StatusBadGateway
+		if apierrors.IsNotFound(err) {
+			status = http.StatusNotFound
+		}
+		writeJSONError(w, status, fmt.Sprintf("delete kwtrigger %q: %v", name, err))
+		return
+	}
+
+	writeAnyJSON(w, http.StatusOK, map[string]any{"deleted": true, "name": name})
+}
+
+// --- Вспомогательные функции ---
+
+func validateKWTriggerRequest(req model.CreateKWTriggerRequest) error {
+	if strings.TrimSpace(req.Name) == "" {
+		return fmt.Errorf("name is required")
+	}
+	if strings.TrimSpace(req.FunctionName) == "" {
+		return fmt.Errorf("functionName is required")
+	}
+	rt := strings.ToLower(strings.TrimSpace(req.ResourceType))
+	if _, ok := validKWResourceTypes[rt]; !ok {
+		return fmt.Errorf("resourceType must be one of: Pod, Service, Deployment, ConfigMap, Secret, Namespace, ReplicaSet, StatefulSet, DaemonSet, Job")
+	}
+	return nil
+}
+
+func buildKWTriggerObject(ns string, req model.CreateKWTriggerRequest) *unstructured.Unstructured {
+	// Fission ожидает capitalize: Pod, Service, Deployment
+	resourceType := capitalize(strings.TrimSpace(req.ResourceType))
+
+	spec := map[string]any{
+		"type":      resourceType,
+		"namespace": req.Namespace,
+		"functionref": map[string]any{
+			"type": "name",
+			"name": req.FunctionName,
+		},
+	}
+	if req.LabelSelector != "" {
+		spec["labelselector"] = req.LabelSelector
+	}
+
+	return &unstructured.Unstructured{Object: map[string]any{
+		"apiVersion": "fission.io/v1",
+		"kind":       "KubernetesWatchTrigger",
+		"metadata": map[string]any{
+			"name":      req.Name,
+			"namespace": ns,
+		},
+		"spec": spec,
+	}}
+}
+
+func kwTriggerResponse(obj *unstructured.Unstructured) map[string]any {
+	spec, _ := obj.Object["spec"].(map[string]any)
+	if spec == nil {
+		spec = map[string]any{}
+	}
+	fnref, _ := spec["functionref"].(map[string]any)
+	fnName := ""
+	if fnref != nil {
+		fnName, _ = fnref["name"].(string)
+	}
+	return map[string]any{
+		"metadata": map[string]any{
+			"name":      obj.GetName(),
+			"namespace": obj.GetNamespace(),
+		},
+		"spec": map[string]any{
+			"resourceType":  spec["type"],
+			"namespace":     spec["namespace"],
+			"labelSelector": spec["labelselector"],
+			"functionName":  fnName,
+		},
+	}
+}
+
+// capitalize приводит первый символ к верхнему регистру, остальное без изменений.
+// "pod" → "Pod", "deployment" → "Deployment"
+func capitalize(s string) string {
+	if s == "" {
+		return s
+	}
+	return strings.ToUpper(s[:1]) + strings.ToLower(s[1:])
+}

client-console/internal/api/lint_archive.go

@@ -0,0 +1,301 @@
+package api
+
+import (
+	"archive/zip"
+	"bytes"
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"net/http"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"time"
+)
+
+const (
+	// maxArchiveBytes — максимальный размер zip-архива (100 KB).
+	// Serverless-функции не должны быть большими — только скрипты и небольшие зависимости.
+	maxArchiveBytes = 100 * 1024
+
+	// maxUnzippedBytes — ограничение на суммарный распакованный размер (защита от zip bomb).
+	// 100 KB реального кода — достаточно для любой serverless-функции.
+	maxUnzippedBytes = 100 * 1024
+)
+
+// lintResult — результат проверки одного файла.
+type lintResult struct {
+	File   string `json:"file"`
+	OK     bool   `json:"ok"`
+	Output string `json:"output,omitempty"`
+}
+
+// handleLintArchive — POST /console/api/ai/lint-archive
+// Принимает zip-архив (multipart/form-data, поле "archive"),
+// прогоняет линтер по всем файлам с известным расширением,
+// возвращает список результатов по файлам.
+func (s *Server) handleLintArchive(w http.ResponseWriter, r *http.Request) {
+	if r.Method != http.MethodPost {
+		writeJSONError(w, http.StatusMethodNotAllowed, "method not allowed")
+		return
+	}
+
+	// Hard-limit 10 MB чтобы соединение не обрывалось (MaxBytesReader с маленьким лимитом
+	// закрывает соединение до отправки ответа — клиент получает 000 вместо 413).
+	// Реальный лимит размера архива проверяется после чтения файла.
+	r.Body = http.MaxBytesReader(w, r.Body, 10*1024*1024)
+
+	if err := r.ParseMultipartForm(maxArchiveBytes); err != nil {
+		var maxErr *http.MaxBytesError
+		if errors.As(err, &maxErr) {
+			writeJSONError(w, http.StatusRequestEntityTooLarge,
+				fmt.Sprintf("архив слишком большой: максимум %d KB", maxArchiveBytes/1024))
+		} else {
+			writeJSONError(w, http.StatusBadRequest, "ошибка разбора multipart: "+err.Error())
+		}
+		return
+	}
+
+	// Опциональный entrypoint для проверки наличия файла в архиве (формат: "module.function")
+	entrypoint := strings.TrimSpace(r.FormValue("entrypoint"))
+	// Опциональный язык для проверки соответствия файлов в архиве
+	selectedLang := strings.ToLower(strings.TrimSpace(r.FormValue("language")))
+
+	f, _, err := r.FormFile("archive")
+	if err != nil {
+		writeJSONError(w, http.StatusBadRequest, "поле 'archive' обязательно")
+		return
+	}
+	defer f.Close()
+
+	// Читаем архив в память
+	var buf bytes.Buffer
+	if _, err := buf.ReadFrom(f); err != nil {
+		writeJSONError(w, http.StatusBadRequest, "ошибка чтения архива: "+err.Error())
+		return
+	}
+	if buf.Len() > maxArchiveBytes {
+		writeJSONError(w, http.StatusRequestEntityTooLarge,
+			fmt.Sprintf("архив слишком большой: %d байт, максимум %d KB", buf.Len(), maxArchiveBytes/1024))
+		return
+	}
+
+	// Открываем zip из памяти
+	zr, err := zip.NewReader(bytes.NewReader(buf.Bytes()), int64(buf.Len()))
+	if err != nil {
+		writeJSONError(w, http.StatusBadRequest, "не удалось открыть zip: "+err.Error())
+		return
+	}
+
+	// Считаем суммарный распакованный размер (защита от zip bomb)
+	var totalUnzipped uint64
+	for _, zf := range zr.File {
+		totalUnzipped += zf.UncompressedSize64
+	}
+	if totalUnzipped > maxUnzippedBytes {
+		writeJSONError(w, http.StatusRequestEntityTooLarge,
+			fmt.Sprintf("суммарный размер распакованных файлов превышает %d KB", maxUnzippedBytes/1024))
+		return
+	}
+
+	// Карта линтеров по расширению
+	type linterCfg struct {
+		cmd      []string
+		stdinOk  bool   // поддерживает stdin
+		stdinArg string // аргумент для stdin-режима (имя "файла")
+	}
+	linters := map[string]linterCfg{
+		".py":  {cmd: []string{"python3", "-m", "py_compile"}, stdinOk: false},
+		".js":  {cmd: []string{"node", "--check"}, stdinOk: false},
+		".rb":  {cmd: []string{"ruby", "-c"}, stdinOk: true},
+		".php": {cmd: []string{"php", "-l"}, stdinOk: false},
+	}
+
+	var results []lintResult
+	var hasError bool
+
+	for _, zf := range zr.File {
+		if zf.FileInfo().IsDir() {
+			continue
+		}
+		ext := strings.ToLower(filepath.Ext(zf.Name))
+		cfg, supported := linters[ext]
+		if !supported {
+			continue
+		}
+
+		// Читаем содержимое файла из zip в память
+		rc, err := zf.Open()
+		if err != nil {
+			results = append(results, lintResult{File: zf.Name, OK: false, Output: "ошибка чтения: " + err.Error()})
+			hasError = true
+			continue
+		}
+		var content bytes.Buffer
+		_, readErr := content.ReadFrom(rc)
+		rc.Close()
+		if readErr != nil {
+			results = append(results, lintResult{File: zf.Name, OK: false, Output: "ошибка чтения: " + readErr.Error()})
+			hasError = true
+			continue
+		}
+
+		var res lintResult
+		res.File = zf.Name
+
+		// Записываем во временный файл в /dev/shm (RAM) если доступен, иначе os.TempDir()
+		tmpDir := "/dev/shm"
+		if _, statErr := os.Stat(tmpDir); statErr != nil {
+			tmpDir = ""
+		}
+		tmpf, tmpErr := os.CreateTemp(tmpDir, "fission-lint-*"+ext)
+		if tmpErr != nil {
+			res.OK = false
+			res.Output = "не удалось создать tmp: " + tmpErr.Error()
+			results = append(results, res)
+			hasError = true
+			continue
+		}
+		tmpName := tmpf.Name()
+		_, writeErr := tmpf.Write(content.Bytes())
+		tmpf.Close()
+
+		if writeErr != nil {
+			os.Remove(tmpName)
+			res.OK = false
+			res.Output = "ошибка записи tmp: " + writeErr.Error()
+			results = append(results, res)
+			hasError = true
+			continue
+		}
+
+		ctx, cancel := context.WithTimeout(r.Context(), 10*time.Second)
+		args := append(cfg.cmd, tmpName) //nolint:gocritic — намеренно создаём новый слайс
+		//nolint:gosec — cmd содержит только захардкоженные команды из linters
+		out, lintErr := exec.CommandContext(ctx, args[0], args[1:]...).CombinedOutput()
+		cancel()
+		os.Remove(tmpName)
+
+		outStr := strings.TrimSpace(string(out))
+		// Скрываем путь к tmp-файлу от пользователя
+		outStr = strings.ReplaceAll(outStr, tmpName, zf.Name)
+
+		if lintErr == nil {
+			res.OK = true
+		} else {
+			res.OK = false
+			hasError = true
+			if outStr != "" {
+				res.Output = outStr
+			} else {
+				res.Output = fmt.Sprintf("ошибка синтаксиса (%v)", lintErr)
+			}
+		}
+		results = append(results, res)
+	}
+
+	if len(results) == 0 {
+		writeJSONError(w, http.StatusBadRequest, "архив не содержит файлов поддерживаемых языков (.py, .js, .rb, .php)")
+		return
+	}
+
+	// Проверяем соответствие выбранного языка файлам в архиве
+	if selectedLang != "" {
+		langExt := map[string]string{
+			"python": ".py", "python3": ".py",
+			"node.js": ".js", "nodejs": ".js", "javascript": ".js", "node": ".js",
+			"ruby": ".rb",
+			"php":  ".php",
+			"go":   ".go",
+			"perl": ".pl",
+		}
+		expectedExt, known := langExt[selectedLang]
+		if known {
+			// Собираем расширения файлов в архиве
+			extCount := map[string]int{}
+			for _, zf := range zr.File {
+				if !zf.FileInfo().IsDir() {
+					ext := strings.ToLower(filepath.Ext(zf.Name))
+					if ext != "" {
+						extCount[ext]++
+					}
+				}
+			}
+			// Если нет ни одного файла с ожидаемым расширением — предупреждение
+			if extCount[expectedExt] == 0 {
+				found := []string{}
+				for ext := range extCount {
+					found = append(found, ext)
+				}
+				results = append(results, lintResult{
+					File:   "язык",
+					OK:     false,
+					Output: fmt.Sprintf("выбран язык '%s' (ожидается %s), но в архиве таких файлов нет (найдено: %s)", selectedLang, expectedExt, strings.Join(found, ", ")),
+				})
+				hasError = true
+			}
+		}
+	}
+
+	// Проверяем entrypoint: формат "module.function" → файл "module.py" должен быть в архиве
+	if entrypoint != "" {
+		parts := strings.SplitN(entrypoint, ".", 2)
+		if len(parts) == 2 {
+			module := parts[0]
+			funcName := parts[1]
+			// Ищем файл module.py в архиве (поддерживаем вложенные пути)
+			foundFile := false
+			funcDefined := false
+			for _, zf := range zr.File {
+				base := strings.TrimSuffix(filepath.Base(zf.Name), ".py")
+				if base == module && strings.HasSuffix(zf.Name, ".py") {
+					foundFile = true
+					// Читаем содержимое и ищем определение функции
+					rc, openErr := zf.Open()
+					if openErr == nil {
+						var content bytes.Buffer
+						content.ReadFrom(rc) //nolint:errcheck
+						rc.Close()
+						for _, line := range strings.Split(content.String(), "\n") {
+							trimmed := strings.TrimSpace(line)
+							if strings.HasPrefix(trimmed, "def "+funcName+"(") || trimmed == "def "+funcName+":" {
+								funcDefined = true
+								break
+							}
+						}
+					}
+					break
+				}
+			}
+			if !foundFile {
+				results = append(results, lintResult{
+					File:   entrypoint,
+					OK:     false,
+					Output: fmt.Sprintf("файл '%s.py' не найден в архиве — проверьте Entrypoint", module),
+				})
+				hasError = true
+			} else if !funcDefined {
+				results = append(results, lintResult{
+					File:   entrypoint,
+					OK:     false,
+					Output: fmt.Sprintf("функция '%s' не найдена в '%s.py' — проверьте Entrypoint", funcName, module),
+				})
+				hasError = true
+			} else {
+				results = append(results, lintResult{
+					File:   entrypoint,
+					OK:     true,
+					Output: fmt.Sprintf("entrypoint '%s' найден", entrypoint),
+				})
+			}
+		}
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(map[string]any{
+		"ok":      !hasError,
+		"results": results,
+	})
+}

client-console/internal/api/mqtriggers.go

@@ -0,0 +1,286 @@
+package api
+
+// mqtriggers.go — CRUD для MQ-триггеров через K8s Deployment + Secret.
+//
+// АРХИТЕКТУРА (2026-05-11):
+//   Вместо Fission MessageQueueTrigger CRD (требует mqtrigger компонент Kafka/NATS)
+//   Console деплоит собственный sqs-consumer Deployment в namespace пользователя.
+//
+//   При CREATE:
+//     1. Создаём K8s Secret (sqs-mq-<name>) с SQS credentials
+//     2. Создаём K8s Deployment (mq-<name>) с образом naeel/sqs-consumer:v1.0
+//        FUNCTION_URL = http://router.fission.svc.cluster.local/<functionName>
+//     Лейблы: app.kubernetes.io/managed-by=fission-console, component=mq-trigger
+//
+//   При LIST: deployments -n <ns> -l component=mq-trigger
+//   При DELETE: удаляем Deployment + Secret
+//
+// ИЗМЕНЕНИЯ:
+//   v1 — использовал Fission MQ CRD (компонент отсутствует в кластере)
+//   v2 — K8s Deployment + наш sqs-consumer образ
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"strings"
+	"time"
+
+	"fission-console/internal/model"
+
+	appsv1 "k8s.io/api/apps/v1"
+	corev1 "k8s.io/api/core/v1"
+	apierrors "k8s.io/apimachinery/pkg/api/errors"
+	"k8s.io/apimachinery/pkg/api/resource"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+)
+
+const (
+	sqsConsumerImage   = "naeel/sqs-consumer:v1.0"
+	sqsDefaultEndpoint = "http://shared-sqs.shared-sqs.svc.cluster.local:4100"
+	fissionRouterBase  = "http://router.fission.svc.cluster.local"
+	mqTriggerLabelKey  = "component"
+	mqTriggerLabelVal  = "mq-trigger"
+	mqManagedByLabel   = "app.kubernetes.io/managed-by"
+	mqManagedByVal     = "fission-console"
+)
+
+func mqSecretName(name string) string { return "sqs-mq-" + name }
+func mqDeployName(name string) string { return "mq-" + name }
+
+// ── HTTP хендлеры ────────────────────────────────────────────────────
+
+func (s *Server) handleMQTriggersRoot(w http.ResponseWriter, r *http.Request) {
+	switch r.Method {
+	case http.MethodGet:
+		s.handleListMQTriggers(w, r)
+	case http.MethodPost:
+		s.handleCreateMQTrigger(w, r)
+	default:
+		http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
+	}
+}
+
+func (s *Server) handleMQTriggersAction(w http.ResponseWriter, r *http.Request) {
+	path := strings.TrimPrefix(r.URL.Path, "/console/api/mqtriggers/")
+	name := strings.Trim(path, "/")
+	if name == "" || strings.Contains(name, "/") {
+		http.NotFound(w, r)
+		return
+	}
+	switch r.Method {
+	case http.MethodDelete:
+		s.handleDeleteMQTrigger(w, r, name)
+	default:
+		http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
+	}
+}
+
+// ── LIST ────────────────────────────────────────────────────────────
+
+func (s *Server) handleListMQTriggers(w http.ResponseWriter, r *http.Request) {
+	ns := s.userNS(r)
+	ctx, cancel := context.WithTimeout(r.Context(), 10*time.Second)
+	defer cancel()
+
+	labelSel := fmt.Sprintf("%s=%s,%s=%s", mqManagedByLabel, mqManagedByVal, mqTriggerLabelKey, mqTriggerLabelVal)
+	deployList, err := s.kube.AppsV1().Deployments(ns).List(ctx, metav1.ListOptions{LabelSelector: labelSel})
+	if err != nil {
+		writeJSONError(w, http.StatusBadGateway, fmt.Sprintf("list mq deployments: %v", err))
+		return
+	}
+
+	items := make([]map[string]any, 0, len(deployList.Items))
+	for i := range deployList.Items {
+		items = append(items, mqDeployToResponse(&deployList.Items[i]))
+	}
+	writeAnyJSON(w, http.StatusOK, map[string]any{"items": items})
+}
+
+// ── CREATE ──────────────────────────────────────────────────────────
+
+func (s *Server) handleCreateMQTrigger(w http.ResponseWriter, r *http.Request) {
+	var req model.CreateMQTriggerRequest
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		writeJSONError(w, http.StatusBadRequest, "decode request: "+err.Error())
+		return
+	}
+	if err := validateMQRequest(req); err != nil {
+		writeJSONError(w, http.StatusBadRequest, err.Error())
+		return
+	}
+
+	ns := s.userNS(r)
+	ctx, cancel := context.WithTimeout(r.Context(), 20*time.Second)
+	defer cancel()
+
+	endpoint := strings.TrimSpace(req.SqsEndpoint)
+	if endpoint == "" {
+		endpoint = sqsDefaultEndpoint
+	}
+	functionURL := fissionRouterBase + "/" + req.FunctionName
+	secretName := mqSecretName(req.Name)
+	deployName := mqDeployName(req.Name)
+
+	// 1. Secret с SQS credentials
+	secret := &corev1.Secret{
+		ObjectMeta: metav1.ObjectMeta{
+			Name:      secretName,
+			Namespace: ns,
+			Labels: map[string]string{
+				mqManagedByLabel:  mqManagedByVal,
+				mqTriggerLabelKey: mqTriggerLabelVal,
+				"mq-trigger-name": req.Name,
+			},
+		},
+		StringData: map[string]string{
+			"SQS_ACCESS_KEY": req.AccessKey,
+			"SQS_SECRET_KEY": req.SecretKey,
+			"SQS_ENDPOINT":   endpoint,
+		},
+	}
+	if _, err := s.kube.CoreV1().Secrets(ns).Create(ctx, secret, metav1.CreateOptions{}); err != nil {
+		if apierrors.IsAlreadyExists(err) {
+			writeJSONError(w, http.StatusConflict, fmt.Sprintf("mq trigger %q already exists", req.Name))
+			return
+		}
+		writeJSONError(w, http.StatusBadGateway, "create secret: "+err.Error())
+		return
+	}
+
+	// 2. Deployment (sqs-consumer)
+	replicas := int32(1)
+	deploy := &appsv1.Deployment{
+		ObjectMeta: metav1.ObjectMeta{
+			Name:      deployName,
+			Namespace: ns,
+			Labels: map[string]string{
+				mqManagedByLabel:  mqManagedByVal,
+				mqTriggerLabelKey: mqTriggerLabelVal,
+				"mq-trigger-name": req.Name,
+			},
+			Annotations: map[string]string{
+				"fission-console/mq-trigger-name": req.Name,
+				"fission-console/function":        req.FunctionName,
+				"fission-console/queue":           req.Queue,
+				"fission-console/sqs-endpoint":    endpoint,
+			},
+		},
+		Spec: appsv1.DeploymentSpec{
+			Replicas: &replicas,
+			Selector: &metav1.LabelSelector{
+				MatchLabels: map[string]string{"mq-trigger-name": req.Name},
+			},
+			Template: corev1.PodTemplateSpec{
+				ObjectMeta: metav1.ObjectMeta{
+					Labels: map[string]string{
+						"mq-trigger-name": req.Name,
+						mqTriggerLabelKey: mqTriggerLabelVal,
+					},
+				},
+				Spec: corev1.PodSpec{
+					Containers: []corev1.Container{{
+						Name:            "sqs-consumer",
+						Image:           sqsConsumerImage,
+						ImagePullPolicy: corev1.PullAlways,
+						Env: []corev1.EnvVar{
+							{Name: "SQS_QUEUE_NAME", Value: req.Queue},
+							{Name: "SQS_REGION", Value: "us-east-1"},
+							{Name: "FUNCTION_URL", Value: functionURL},
+							{Name: "POLL_INTERVAL", Value: "5"},
+							{Name: "MAX_MESSAGES", Value: "1"},
+							{Name: "MAX_RETRIES", Value: "3"},
+						},
+						EnvFrom: []corev1.EnvFromSource{{
+							SecretRef: &corev1.SecretEnvSource{
+								LocalObjectReference: corev1.LocalObjectReference{Name: secretName},
+							},
+						}},
+						Resources: corev1.ResourceRequirements{
+							Limits: corev1.ResourceList{
+								corev1.ResourceCPU:    resource.MustParse("50m"),
+								corev1.ResourceMemory: resource.MustParse("32Mi"),
+							},
+							Requests: corev1.ResourceList{
+								corev1.ResourceCPU:    resource.MustParse("10m"),
+								corev1.ResourceMemory: resource.MustParse("16Mi"),
+							},
+						},
+					}},
+				},
+			},
+		},
+	}
+
+	created, err := s.kube.AppsV1().Deployments(ns).Create(ctx, deploy, metav1.CreateOptions{})
+	if err != nil {
+		_ = s.kube.CoreV1().Secrets(ns).Delete(ctx, secretName, metav1.DeleteOptions{})
+		writeJSONError(w, http.StatusBadGateway, "create deployment: "+err.Error())
+		return
+	}
+
+	writeAnyJSON(w, http.StatusCreated, mqDeployToResponse(created))
+}
+
+// ── DELETE ──────────────────────────────────────────────────────────
+
+func (s *Server) handleDeleteMQTrigger(w http.ResponseWriter, r *http.Request, name string) {
+	ns := s.userNS(r)
+	ctx, cancel := context.WithTimeout(r.Context(), 15*time.Second)
+	defer cancel()
+
+	dErr := s.kube.AppsV1().Deployments(ns).Delete(ctx, mqDeployName(name), metav1.DeleteOptions{})
+	sErr := s.kube.CoreV1().Secrets(ns).Delete(ctx, mqSecretName(name), metav1.DeleteOptions{})
+
+	if dErr != nil && !apierrors.IsNotFound(dErr) {
+		writeJSONError(w, http.StatusBadGateway, "delete deployment: "+dErr.Error())
+		return
+	}
+	if sErr != nil && !apierrors.IsNotFound(sErr) {
+		writeJSONError(w, http.StatusBadGateway, "delete secret: "+sErr.Error())
+		return
+	}
+	writeAnyJSON(w, http.StatusOK, map[string]any{"deleted": true, "name": name})
+}
+
+// ── Вспомогательные ─────────────────────────────────────────────────
+
+func validateMQRequest(req model.CreateMQTriggerRequest) error {
+	if strings.TrimSpace(req.Name) == "" {
+		return fmt.Errorf("name is required")
+	}
+	if strings.TrimSpace(req.FunctionName) == "" {
+		return fmt.Errorf("functionName is required")
+	}
+	if strings.TrimSpace(req.Queue) == "" {
+		return fmt.Errorf("queue is required")
+	}
+	if strings.TrimSpace(req.AccessKey) == "" {
+		return fmt.Errorf("accessKey is required")
+	}
+	if strings.TrimSpace(req.SecretKey) == "" {
+		return fmt.Errorf("secretKey is required")
+	}
+	return nil
+}
+
+func mqDeployToResponse(d *appsv1.Deployment) map[string]any {
+	ann := d.Annotations
+	if ann == nil {
+		ann = map[string]string{}
+	}
+	triggerName := ann["fission-console/mq-trigger-name"]
+	if triggerName == "" {
+		triggerName = strings.TrimPrefix(d.Name, "mq-")
+	}
+	return map[string]any{
+		"name":         triggerName,
+		"deployName":   d.Name,
+		"functionName": ann["fission-console/function"],
+		"queue":        ann["fission-console/queue"],
+		"sqsEndpoint":  ann["fission-console/sqs-endpoint"],
+		"ready":        d.Status.ReadyReplicas > 0,
+		"replicas":     d.Status.ReadyReplicas,
+	}
+}

client-console/internal/api/package.go

@@ -7,6 +7,7 @@ import (
 	"encoding/base64"
 	"encoding/json"
 	"io"
+	"log"
 	"net/http"
 	"regexp"
 	"sort"
@@ -16,6 +17,7 @@ import (
 	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
 )
 
+// ⛔⛔⛔ НЕ МЕНЯТЬ БЕЗ ЯВНОГО РАЗРЕШЕНИЯ ВЛАДЕЛЬЦА.
 // extractPackageSourceCode пытается извлечь исходный код из Fission Package.
 // Порядок попыток:
 //  1. spec.source.literal (base64) — Go функции (source package)
@@ -51,10 +53,13 @@ func extractPackageSourceCode(ctx context.Context, s *Server, pkg *unstructured.
 		}
 		archiveBytes, err := fetchPackageArchive(ctx, s, urlValue)
 		if err != nil {
+			log.Printf("extractPackageSourceCode: fetchPackageArchive %s: %v", urlValue, err)
 			continue
 		}
 		if code, err := decodeArchiveBytesToSource(archiveBytes); err == nil && strings.TrimSpace(code) != "" {
 			return code
+		} else {
+			log.Printf("extractPackageSourceCode: decodeArchiveBytesToSource %s: err=%v, len=%d", urlValue, err, len(archiveBytes))
 		}
 	}
 
@@ -108,7 +113,7 @@ func decodeArchiveBytesToSource(decoded []byte) (string, error) {
 	return "", io.ErrUnexpectedEOF
 }
 
-var nodeJSWrapperPattern = regexp.MustCompile(`(?s)^const __mod = \{ exports: \{\} \};\s*\(new Function\('module', 'exports', (.+?)\)\)\(__mod, __mod\.exports\);\s*const _fn = __mod\.exports;`)
+var nodeJSWrapperPattern = regexp.MustCompile(`(?s)^const __mod = \{ exports: \{\} \};\s*\(new Function\('module', 'exports', (?:'require', )?(.+?)\)\)\(__mod, __mod\.exports(?:, require)?\);\s*const _fn = __mod\.exports;`)
 
 func decodeNodeJSWrapperSource(decoded []byte) (string, bool) {
 	text := string(decoded)

client-console/internal/api/server.go

@@ -5,49 +5,46 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
-	"io"
+	"log"
 	"net/http"
 	"os"
 	"strings"
 	"sync"
 	"time"
 
+	"fission-console/internal/auth"
+	"fission-console/internal/billing"
 	"fission-console/internal/cloud"
 	"fission-console/internal/fission"
+	"fission-console/internal/stats"
 	"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"
+	"k8s.io/client-go/kubernetes"
 )
 
-// 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")
+	kube      kubernetes.Interface // typed client — только для логов подов
+	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
+	authUser      string
+	authPass      string
+	storagesvcURL string // URL Fission storagesvc для загрузки архивов кода в S3
 
 	// --- ai/ask feature (удалить блок целиком чтобы выкосить) ---
 	llmURL string // FISSION_LLM_URL
@@ -59,17 +56,23 @@ 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
+
+	// billing — слой записи статистики вызовов. NoopStore если BILLING_DSN не задан.
+	billing billing.Store
+
+	// stats — аналитический слой (Grafana Organizations). NoopProvider если не настроен.
+	stats stats.StatsProvider
 }
 
 // Config содержит все параметры для создания Server.
 type Config struct {
 	Dyn           dynamic.Interface
+	Kube          kubernetes.Interface
 	Namespace     string
 	RouterURL     string
 	HTTPTimeout   time.Duration
@@ -77,15 +80,20 @@ type Config struct {
 	SATokenPath   string
 	AuthUser      string
 	AuthPass      string
-	TestMode      bool
+	StoragesvcURL string
+	Authenticator auth.Authenticator // слой аутентификации
 	LLMUrl        string
 	LLMKey        string
+	Billing       billing.Store       // слой статистики (NoopStore если не задан)
+	Stats         stats.StatsProvider // аналитика (NoopProvider если не настроен)
 }
 
 // NewServer создаёт и настраивает HTTP Server со всеми зависимостями.
 func NewServer(cfg Config) *Server {
+	log.Printf("NewServer: storagesvcURL=%q", cfg.StoragesvcURL)
 	return &Server{
 		dyn:           cfg.Dyn,
+		kube:          cfg.Kube,
 		ns:            cfg.Namespace,
 		routerURL:     cfg.RouterURL,
 		http:          &http.Client{Timeout: cfg.HTTPTimeout},
@@ -93,10 +101,13 @@ 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),
+		billing:       cfg.Billing,
+		stats:         cfg.Stats,
 	}
 }
 
@@ -127,6 +138,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
 
@@ -149,9 +169,16 @@ func (s *Server) RegisterRoutes(mux *http.ServeMux) {
 	mux.HandleFunc("/console/api/httptriggers", auth(s.handleList(fission.HTTPTrigGVR)))
 	mux.HandleFunc("/console/api/timetriggers", auth(s.handleTimeTriggersRoot))
 	mux.HandleFunc("/console/api/timetriggers/", auth(s.handleTimeTriggersAction))
+	mux.HandleFunc("/console/api/mqtriggers", auth(s.handleMQTriggersRoot))
+	mux.HandleFunc("/console/api/mqtriggers/", auth(s.handleMQTriggersAction))
+	mux.HandleFunc("/console/api/kwtriggers", auth(s.handleKWTriggersRoot))
+	mux.HandleFunc("/console/api/kwtriggers/", auth(s.handleKWTriggersAction))
 	mux.HandleFunc("/console/api/ns/status", auth(s.handleNSStatus))
 	mux.HandleFunc("/console/api/ns/debug", auth(s.handleNSDebug))
+	mux.HandleFunc("/console/api/stats/dashboard-url", auth(s.handleStatsDashboard))
 	mux.HandleFunc("/console/api/ai/check", auth(s.handleAICheck))
+	mux.HandleFunc("/console/api/ai/lint-archive", auth(s.handleLintArchive))
+	mux.HandleFunc("/console/api/ai/explain-archive", auth(s.handleExplainArchive))
 	// --- ai/ask feature (удалить строку чтобы выкосить роут) ---
 	mux.HandleFunc("/console/api/ai/ask", auth(s.handleAIAsk))
 	// --- end ai/ask feature ---
@@ -265,43 +292,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
-}

client-console/internal/api/stats.go

@@ -0,0 +1,25 @@
+package api
+
+import (
+	"encoding/json"
+	"net/http"
+)
+
+// handleStatsDashboard GET /console/api/stats/dashboard-url
+// Возвращает публичный URL дашборда Grafana для текущего namespace пользователя.
+// Если аналитика не настроена — возвращает {"url":""}.
+func (s *Server) handleStatsDashboard(w http.ResponseWriter, r *http.Request) {
+	if r.Method != http.MethodGet {
+		writeJSONError(w, http.StatusMethodNotAllowed, "method not allowed")
+		return
+	}
+
+	ns := s.userNS(r)
+	url := s.stats.DashboardURL(r.Context(), ns)
+
+	w.Header().Set("Content-Type", "application/json; charset=utf-8")
+	_ = json.NewEncoder(w).Encode(map[string]any{
+		"url":       url,
+		"namespace": ns,
+	})
+}

client-console/internal/api/status.go

@@ -0,0 +1,138 @@
+// Package api — определение статуса функции.
+//
+// Этот файл содержит функции для определения статуса функции на основе:
+// - buildStatus пакета (Package CRD)
+// - состояния pod-а (kubernetes Pod)
+//
+// Возможные статусы:
+// - "Ready" (зелёный) — Pod в состоянии Running
+// - "Cold" (синий) — функция готова, но нет активного Pod
+// - "Building" (жёлтый) — Package ещё собирается (buildStatus != "succeeded")
+// - "Error" (красный) — Pod в состоянии ошибки (CrashLoopBackOff, ImagePullBackOff и т.д.) или build failed
+package api
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+	"time"
+
+	"fission-console/internal/fission"
+
+	apierrors "k8s.io/apimachinery/pkg/api/errors"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
+)
+
+// FunctionStatus — расширенный объект Function с полем status.
+type FunctionStatus struct {
+	// Встраиваем исходный объект и добавляем status
+	Object map[string]any `json:"object,inline"`
+	Status string         `json:"status"` // "Ready", "Cold", "Building", "Error"
+}
+
+// getFunctionStatus определяет статус функции на основе pod-ов и Package.
+func (s *Server) getFunctionStatus(ctx context.Context, ns string, fn *unstructured.Unstructured) (string, error) {
+	fnName := fn.GetName()
+
+	// Шаг 1: проверяем buildStatus пакета (если есть)
+	packageName, _, _ := unstructured.NestedString(fn.Object, "spec", "package", "packageref", "name")
+	if packageName != "" {
+		pkg, pkgErr := s.dyn.Resource(fission.PackageGVR).Namespace(ns).Get(ctx, packageName, metav1.GetOptions{})
+		if pkgErr == nil {
+			buildStatus, _, _ := unstructured.NestedString(pkg.Object, "status", "buildstatus")
+			// "failed" → Error
+			// "none", "succeeded" → OK, Package готов
+			// "pending", "building" и т.д. → Building
+			if buildStatus == "failed" {
+				return "Error", nil
+			}
+			if buildStatus != "" && buildStatus != "succeeded" && buildStatus != "none" {
+				// Building, Pending и т.д.
+				return "Building", nil
+			}
+		}
+	}
+
+	// Шаг 2: ищем Pod-ы для этой функции (по лейблу functionName=<name>)
+	pods, err := s.kube.CoreV1().Pods(ns).List(ctx, metav1.ListOptions{
+		LabelSelector: fmt.Sprintf("functionName=%s", fnName),
+	})
+	if err != nil && !apierrors.IsNotFound(err) {
+		// Логируем ошибку, но не падаем — возвращаем "Cold" (функция есть, но pod-а нет)
+		return "Cold", nil
+	}
+
+	// Шаг 3: анализируем состояние pod-ов
+	if pods != nil && len(pods.Items) > 0 {
+		for _, pod := range pods.Items {
+			// Проверяем фазу pod-а
+			phase := pod.Status.Phase
+			if phase == "Running" {
+				// Дополнительная проверка: все контейнеры готовы?
+				allReady := true
+				for _, status := range pod.Status.ContainerStatuses {
+					if !status.Ready {
+						allReady = false
+						break
+					}
+				}
+				if allReady {
+					return "Ready", nil
+				}
+			}
+
+			// Проверяем состояние контейнеров (CrashLoopBackOff, ImagePullBackOff и т.д.)
+			for _, status := range pod.Status.ContainerStatuses {
+				if status.State.Waiting != nil && status.State.Waiting.Reason == "CrashLoopBackOff" {
+					return "Error", nil
+				}
+				if status.State.Waiting != nil && status.State.Waiting.Reason == "ImagePullBackOff" {
+					return "Error", nil
+				}
+				if status.LastTerminationState.Terminated != nil && status.LastTerminationState.Terminated.ExitCode != 0 {
+					return "Error", nil
+				}
+			}
+		}
+
+		// Pod есть, но не в Running или Error состоянии → Building/Deploying
+		return "Building", nil
+	}
+
+	// Нет pod-ов → Cold (функция холодная, но готова)
+	return "Cold", nil
+}
+
+// handleListFunctionsWithStatus возвращает список функций с полем "status".
+// Добавляет status в поле .metadata.annotations["fission-console/status"] каждой функции.
+func (s *Server) handleListFunctionsWithStatus(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(), 30*time.Second) // 30 сек для определения статуса всех функций
+	defer cancel()
+	ns := s.userNS(r)
+
+	// Получаем список функций
+	list, err := s.dyn.Resource(fission.FunctionGVR).Namespace(ns).List(ctx, metav1.ListOptions{})
+	if err != nil {
+		writeJSONError(w, http.StatusBadGateway, fmt.Sprintf("list functions: %v", err))
+		return
+	}
+
+	// Обогащаем каждую функцию статусом (добавляем в .metadata.annotations["fission-console/status"])
+	for i := range list.Items {
+		status, _ := s.getFunctionStatus(ctx, ns, &list.Items[i])
+		anns := list.Items[i].GetAnnotations()
+		if anns == nil {
+			anns = make(map[string]string)
+		}
+		anns["fission-console/status"] = status
+		list.Items[i].SetAnnotations(anns)
+	}
+
+	writeJSON(w, http.StatusOK, list.Items)
+}

client-console/internal/api/storagesvc.go

@@ -0,0 +1,118 @@
+// Package api — работа с Fission storagesvc (S3-совместимое хранилище архивов).
+//
+// Этот файл содержит низкоуровневые операции загрузки и удаления архивов через
+// HTTP API storagesvc. Storagesvc хранит zip-архивы функций в S3 (bucket sless-functions).
+// Package CRD ссылается на архив через spec.deployment.url (type: url).
+//
+// Используется из function_code.go и function_archive.go для сохранения/замены кода функций.
+package api
+
+import (
+	"bytes"
+	"context"
+	"encoding/base64"
+	"encoding/json"
+	"fmt"
+	"io"
+	"log"
+	"net/http"
+	"net/url"
+	"strings"
+	"time"
+)
+
+// 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
+}

client-console/internal/api/timetriggers.go

@@ -19,10 +19,10 @@ import (
 )
 
 const (
-	timeTriggerDefaultMethod = http.MethodPost
+	timeTriggerDefaultMethod  = http.MethodPost
 	timeTriggerDefaultSubPath = "/"
 	timeTriggerMaxNameLen     = 63
-	cronGatewayURL           = "http://fission-console.fission.svc.cluster.local"
+	cronGatewayURL            = "http://fission-console.fission.svc.cluster.local"
 )
 
 var validTimeTriggerMethods = map[string]struct{}{
@@ -502,4 +502,4 @@ func errStatus(err error) int {
 		return ae.status
 	}
 	return http.StatusInternalServerError
-}
+}

client-console/internal/auth/auth.go

@@ -0,0 +1,256 @@
+// 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.
+// Если sub начинается с "test-" → "fission-test-" + hex(SHA256(sub)[:8])
+// Иначе → "fission-" + hex(SHA256(sub)[:8])
+func NamespaceForSub(sub string) string {
+	h := sha256.Sum256([]byte(sub))
+	if strings.HasPrefix(sub, "test-") {
+		return "fission-test-" + hex.EncodeToString(h[:8])
+	}
+	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")
+	}
+	sub := uuidV5(login)
+	// Если логин начинается с "test-" — помечаем Sub так же, чтобы
+	// NamespaceForSub мог создать fission-test-* namespace.
+	if strings.HasPrefix(login, "test-") {
+		sub = "test-" + sub
+	}
+	return UserIdentity{Sub: sub, 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)
+}

client-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")
+	}
+}

client-console/internal/billing/billing.go

@@ -0,0 +1,42 @@
+// Package billing — слой записи статистики вызовов функций.
+//
+// Независим от типа БД: снаружи виден только интерфейс Store.
+// Если BILLING_DSN не задан — работает NoopStore (тихо, не крашит).
+package billing
+
+import "time"
+
+// TriggerType описывает источник вызова.
+const (
+	TriggerHTTP    = "http"    // вызов через /fn/... снаружи
+	TriggerCron    = "cron"    // вызов по расписанию
+	TriggerConsole = "console" // вызов через кнопку «Вызов» в UI
+	TriggerEvent   = "event"   // lifecycle: create/delete/clone/update
+)
+
+// Invocation — одна запись о вызове или событии функции.
+type Invocation struct {
+	Namespace     string    // пользовательский namespace (= пользователь)
+	FunctionName  string    // имя функции
+	TriggerType   string    // TriggerHTTP / TriggerCron / TriggerConsole / TriggerEvent
+	Route         string    // HTTP маршрут (/abc123/my-func), пусто для event
+	HTTPMethod    string    // GET/POST/... пусто для event
+	StartedAt     time.Time // время начала
+	DurationMS    int64     // длительность в миллисекундах (0 для event)
+	StatusCode    int       // HTTP статус ответа (0 для event)
+	ColdStart     bool      // true = первый вызов после создания/простоя
+	RequestBytes  int64     // размер тела запроса
+	ResponseBytes int64     // размер тела ответа
+	ErrorMsg      string    // сообщение об ошибке, пусто если успех
+	RecordedBy    string    // "console" | "router"
+	EventType     string    // для TriggerEvent: "create" | "delete" | "clone" | "update" | "invoke"
+}
+
+// Store — интерфейс записи статистики.
+// Реализации: pgStore (PostgreSQL через pgx), NoopStore (заглушка).
+type Store interface {
+	// RecordInvocation записывает одно событие асинхронно (fire-and-forget).
+	RecordInvocation(inv Invocation)
+	// Close освобождает ресурсы (пул соединений и т.д.).
+	Close()
+}

client-console/internal/billing/factory.go

@@ -0,0 +1,23 @@
+package billing
+
+import (
+	"context"
+	"log"
+	"os"
+)
+
+// NewStore создаёт Store из переменной окружения BILLING_DSN.
+// Если DSN пустой — возвращает NoopStore (статистика отключена, сервер работает нормально).
+func NewStore() Store {
+	dsn := os.Getenv("BILLING_DSN")
+	if dsn == "" {
+		log.Printf("billing: BILLING_DSN not set, statistics disabled")
+		return NoopStore{}
+	}
+	store, err := NewPostgresStore(context.Background(), dsn)
+	if err != nil {
+		log.Printf("billing: failed to connect to PostgreSQL: %v — statistics disabled", err)
+		return NoopStore{}
+	}
+	return store
+}

client-console/internal/billing/noop.go

@@ -0,0 +1,8 @@
+package billing
+
+// NoopStore — заглушка Store, которая тихо игнорирует все записи.
+// Используется когда BILLING_DSN не задан.
+type NoopStore struct{}
+
+func (NoopStore) RecordInvocation(_ Invocation) {}
+func (NoopStore) Close()                        {}

client-console/internal/billing/pg.go

@@ -0,0 +1,90 @@
+package billing
+
+import (
+	"context"
+	"log"
+	"time"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+// pgStore — реализация Store поверх PostgreSQL через pgx connection pool.
+type pgStore struct {
+	pool *pgxpool.Pool
+}
+
+// NewPostgresStore создаёт Store с пулом соединений к PostgreSQL.
+// dsn — строка вида postgres://user:pass@host:5432/dbname
+// При ошибке подключения — возвращает ошибку, вызывающий код решает как реагировать.
+func NewPostgresStore(ctx context.Context, dsn string) (Store, error) {
+	cfg, err := pgxpool.ParseConfig(dsn)
+	if err != nil {
+		return nil, err
+	}
+	cfg.MaxConns = 4
+	cfg.MinConns = 1
+	cfg.MaxConnIdleTime = 5 * time.Minute
+
+	pool, err := pgxpool.NewWithConfig(ctx, cfg)
+	if err != nil {
+		return nil, err
+	}
+	// Проверяем живость соединения
+	if err := pool.Ping(ctx); err != nil {
+		pool.Close()
+		return nil, err
+	}
+	log.Printf("billing: connected to PostgreSQL")
+	return &pgStore{pool: pool}, nil
+}
+
+// RecordInvocation вставляет запись асинхронно — не блокирует основной поток.
+func (s *pgStore) RecordInvocation(inv Invocation) {
+	go func() {
+		ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+		defer cancel()
+
+		_, err := s.pool.Exec(ctx, `
+			INSERT INTO invocations (
+				namespace, function_name, trigger_type, route, http_method,
+				started_at, duration_ms, status_code, cold_start,
+				request_bytes, response_bytes, error_msg, recorded_by, event_type
+			) VALUES (
+				$1,$2,$3,$4,$5,
+				$6,$7,$8,$9,
+				$10,$11,$12,$13,$14
+			)`,
+			inv.Namespace,
+			inv.FunctionName,
+			inv.TriggerType,
+			inv.Route,
+			inv.HTTPMethod,
+			inv.StartedAt,
+			inv.DurationMS,
+			inv.StatusCode,
+			inv.ColdStart,
+			inv.RequestBytes,
+			inv.ResponseBytes,
+			nullIfEmpty(inv.ErrorMsg),
+			inv.RecordedBy,
+			nullIfEmpty(inv.EventType),
+		)
+		if err != nil {
+			log.Printf("billing: insert invocation: %v", err)
+		}
+	}()
+}
+
+// Close закрывает пул соединений.
+func (s *pgStore) Close() {
+	s.pool.Close()
+	log.Printf("billing: connection pool closed")
+}
+
+// nullIfEmpty возвращает nil для пустой строки (SQL NULL вместо пустой строки).
+func nullIfEmpty(s string) interface{} {
+	if s == "" {
+		return nil
+	}
+	return s
+}

client-console/internal/cloud/tenant.go

@@ -3,6 +3,8 @@ package cloud
 import (
 	"context"
 	"log"
+	"os"
+	"sort"
 	"strings"
 	"sync"
 	"time"
@@ -10,6 +12,7 @@ import (
 	apierrors "k8s.io/apimachinery/pkg/api/errors"
 	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"
 
 	"fission-console/internal/fission"
@@ -140,6 +143,171 @@ func (m *NSManager) provisionNamespace(ctx context.Context, ns string) error {
 	return nil
 }
 
+var deployGVR = schema.GroupVersionResource{Group: "apps", Version: "v1", Resource: "deployments"}
+
+// fissionSystemNS возвращает namespace где живут компоненты Fission (router, executor, ...).
+func fissionSystemNS() string {
+	if ns := os.Getenv("FISSION_SYSTEM_NAMESPACE"); ns != "" {
+		return ns
+	}
+	return "fission"
+}
+
+// StartNSReconciler запускает фоновый goroutine который синхронизирует FISSION_RESOURCE_NAMESPACES
+// в router и executor со всеми реально существующими пользовательскими namespace-ами.
+//
+// Почему reconciler, а не прямой патч в EnsureUserNS:
+//   - Прямой патч → rolling restart при каждом новом логине → cold start для всех
+//   - Reconciler батчит изменения, не делает лишних патчей если список не изменился
+//   - Автоматически убирает ghost namespace-ы (удалённые вручную через kubectl)
+func (m *NSManager) StartNSReconciler(interval time.Duration) {
+	go func() {
+		ticker := time.NewTicker(interval)
+		defer ticker.Stop()
+		log.Printf("cloud.NSReconciler: started, interval=%v", interval)
+		for range ticker.C {
+			m.reconcileNSList()
+		}
+	}()
+}
+
+// reconcileNSList синхронизирует FISSION_RESOURCE_NAMESPACES в router и executor.
+// Читает все Active namespace-ы с меткой managed-by=fission-console,
+// сравнивает с текущим значением в router, патчит только если есть разница.
+func (m *NSManager) reconcileNSList() {
+	ctx, cancel := context.WithTimeout(context.Background(), 60*time.Second)
+	defer cancel()
+
+	sysNS := fissionSystemNS()
+
+	// Шаг 1: реальные namespace-ы с нашей меткой (только Active)
+	nsList, err := m.dyn.Resource(fission.NamespaceGVR).List(ctx, metav1.ListOptions{
+		LabelSelector: "managed-by=fission-console",
+	})
+	if err != nil {
+		log.Printf("cloud.NSReconciler: list namespaces: %v", err)
+		return
+	}
+	desired := map[string]struct{}{"default": {}}
+	for _, ns := range nsList.Items {
+		phase, _, _ := unstructured.NestedString(ns.Object, "status", "phase")
+		if phase == "Active" {
+			desired[ns.GetName()] = struct{}{}
+		}
+	}
+
+	// Шаг 2: текущее значение из router (источник истины)
+	routerDep, err := m.dyn.Resource(deployGVR).Namespace(sysNS).Get(ctx, "router", metav1.GetOptions{})
+	if err != nil {
+		log.Printf("cloud.NSReconciler: get router deployment: %v", err)
+		return
+	}
+	currentVal := currentFissionResourceNS(routerDep)
+
+	// Шаг 3: сравниваем
+	currentSet := map[string]struct{}{}
+	for _, p := range strings.Split(currentVal, ",") {
+		if t := strings.TrimSpace(p); t != "" {
+			currentSet[t] = struct{}{}
+		}
+	}
+	same := len(currentSet) == len(desired)
+	if same {
+		for k := range desired {
+			if _, ok := currentSet[k]; !ok {
+				same = false
+				break
+			}
+		}
+	}
+	if same {
+		return // ничего не изменилось — нет патча, нет rolling restart
+	}
+
+	// Шаг 4: строим новое значение
+	parts := make([]string, 0, len(desired))
+	for ns := range desired {
+		parts = append(parts, ns)
+	}
+	sort.Strings(parts)
+	newVal := strings.Join(parts, ",")
+
+	// Шаг 5: патчим router и executor
+	for _, depName := range []string{"router", "executor"} {
+		if patchErr := m.patchDeployFissionNS(ctx, sysNS, depName, newVal); patchErr != nil {
+			log.Printf("cloud.NSReconciler: patch %s: %v", depName, patchErr)
+		}
+	}
+	log.Printf("cloud.NSReconciler: synced FISSION_RESOURCE_NAMESPACES: %q → %q", currentVal, newVal)
+}
+
+// currentFissionResourceNS читает текущий FISSION_RESOURCE_NAMESPACES из deployment.
+func currentFissionResourceNS(dep *unstructured.Unstructured) string {
+	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 && v != "" {
+					return v
+				}
+			}
+		}
+		break
+	}
+	return "default"
+}
+
+// patchDeployFissionNS обновляет FISSION_RESOURCE_NAMESPACES в указанном deployment.
+func (m *NSManager) patchDeployFissionNS(ctx context.Context, sysNS, depName, newVal string) error {
+	dep, err := m.dyn.Resource(deployGVR).Namespace(sysNS).Get(ctx, depName, metav1.GetOptions{})
+	if err != nil {
+		return err
+	}
+	containers, _, _ := unstructured.NestedSlice(dep.Object, "spec", "template", "spec", "containers")
+	if len(containers) == 0 {
+		return nil
+	}
+	cont, ok := containers[0].(map[string]any)
+	if !ok {
+		return nil
+	}
+	envs, _, _ := unstructured.NestedSlice(cont, "env")
+	updated := false
+	for i, e := range envs {
+		env, ok := e.(map[string]any)
+		if !ok {
+			continue
+		}
+		if env["name"] == "FISSION_RESOURCE_NAMESPACES" {
+			if env["value"] != newVal {
+				env["value"] = newVal
+				envs[i] = env
+				updated = true
+			}
+			break
+		}
+	}
+	if !updated {
+		envs = append(envs, map[string]any{"name": "FISSION_RESOURCE_NAMESPACES", "value": newVal})
+	}
+	cont["env"] = envs
+	containers[0] = cont
+	if err := unstructured.SetNestedSlice(dep.Object, containers, "spec", "template", "spec", "containers"); err != nil {
+		return err
+	}
+	_, err = m.dyn.Resource(deployGVR).Namespace(sysNS).Update(ctx, dep, metav1.UpdateOptions{})
+	return err
+}
+
 // StartExpiryReaper запускает фоновый goroutine для удаления функций с истёкшим TTL.
 // Interval — как часто проверять. Рекомендуемое значение: 5 минут.
 func (m *NSManager) StartExpiryReaper(interval time.Duration) {
@@ -225,7 +393,17 @@ func (m *NSManager) reapExpiredFunctionsInNS(ctx context.Context, ns string, now
 		}
 	}
 
-	// Orphan packages — пакеты без соответствующей функции
+	// Orphan packages — пакеты без соответствующей функции.
+	// Перечитываем Functions заново (fresh LIST) чтобы избежать race condition:
+	// новая функция может быть создана между снятием activeFunctions и этой проверкой.
+	freshFunctions, freshErr := m.dyn.Resource(fission.FunctionGVR).Namespace(ns).List(ctx, metav1.ListOptions{})
+	if freshErr != nil {
+		return
+	}
+	freshFunctionSet := make(map[string]struct{}, len(freshFunctions.Items))
+	for _, fn := range freshFunctions.Items {
+		freshFunctionSet[fn.GetName()] = struct{}{}
+	}
 	packages, pkgListErr := m.dyn.Resource(fission.PackageGVR).Namespace(ns).List(ctx, metav1.ListOptions{})
 	if pkgListErr == nil {
 		for _, pkg := range packages.Items {
@@ -233,8 +411,13 @@ func (m *NSManager) reapExpiredFunctionsInNS(ctx context.Context, ns string, now
 			if !strings.HasSuffix(pkgName, "-pkg") {
 				continue
 			}
+			// Пропускаем свежесозданные пакеты: Function CRD может ещё не успеть
+			// создаться после загрузки Package (race condition при быстром ExpiryReaper).
+			if age := time.Since(pkg.GetCreationTimestamp().Time); age < 2*time.Minute {
+				continue
+			}
 			fnName := strings.TrimSuffix(pkgName, "-pkg")
-			if _, exists := activeFunctions[fnName]; !exists {
+			if _, exists := freshFunctionSet[fnName]; !exists {
 				log.Printf("cloud.ExpiryReaper: deleting orphan package %s/%s", ns, pkgName)
 				_ = m.dyn.Resource(fission.PackageGVR).Namespace(ns).Delete(ctx, pkgName, metav1.DeleteOptions{})
 			}

client-console/internal/fission/client.go

@@ -12,6 +12,8 @@ var (
 	FunctionGVR    = schema.GroupVersionResource{Group: "fission.io", Version: "v1", Resource: "functions"}
 	HTTPTrigGVR    = schema.GroupVersionResource{Group: "fission.io", Version: "v1", Resource: "httptriggers"}
 	TimeTrigGVR    = schema.GroupVersionResource{Group: "fission.io", Version: "v1", Resource: "timetriggers"}
+	MQTrigGVR      = schema.GroupVersionResource{Group: "fission.io", Version: "v1", Resource: "messagequeuetriggers"}
+	KWTrigGVR      = schema.GroupVersionResource{Group: "fission.io", Version: "v1", Resource: "kuberneteswatchtriggers"}
 
 	NamespaceGVR  = schema.GroupVersionResource{Group: "", Version: "v1", Resource: "namespaces"}
 	DeploymentGVR = schema.GroupVersionResource{Group: "apps", Version: "v1", Resource: "deployments"}

client-console/internal/fission/environment.go

@@ -28,9 +28,20 @@ func EnsureEnvironment(ctx context.Context, dyn dynamic.Interface, ns, lang stri
 	envName := "console-" + lang + "-env"
 
 	// Проверяем существование — Get быстрее чем Create+IsAlreadyExists
-	_, getErr := dyn.Resource(EnvironmentGVR).Namespace(ns).Get(ctx, envName, metav1.GetOptions{})
+	existing, getErr := dyn.Resource(EnvironmentGVR).Namespace(ns).Get(ctx, envName, metav1.GetOptions{})
 	if getErr == nil {
-		return envName, nil // уже существует — быстрый путь
+		// Уже существует — проверяем образ. Если устарел — обновляем.
+		currentImage, _, _ := unstructured.NestedString(existing.Object, "spec", "runtime", "image")
+		if currentImage != langDef.Image {
+			if patchErr := unstructured.SetNestedField(existing.Object, langDef.Image, "spec", "runtime", "image"); patchErr == nil {
+				if _, updateErr := dyn.Resource(EnvironmentGVR).Namespace(ns).Update(ctx, existing, metav1.UpdateOptions{}); updateErr != nil {
+					log.Printf("ensureEnvironment: update image %s/%s: %v", ns, envName, updateErr)
+				} else {
+					log.Printf("ensureEnvironment: updated image %s/%s: %s → %s", ns, envName, currentImage, langDef.Image)
+				}
+			}
+		}
+		return envName, nil
 	}
 	if !apierrors.IsNotFound(getErr) {
 		return "", fmt.Errorf("check environment %q: %w", envName, getErr)

client-console/internal/fission/namespace.go

@@ -12,6 +12,7 @@ import (
 	"fmt"
 	"log"
 	"os"
+	"strings"
 
 	apierrors "k8s.io/apimachinery/pkg/api/errors"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
@@ -37,16 +38,20 @@ import (
 //     (не ClusterRoleBinding) безопасен — даёт полный доступ только внутри NS.
 func SetupFissionNamespace(ctx context.Context, dyn dynamic.Interface, ns string) error {
 	// 1. Namespace
+	labels := map[string]any{
+		"managed-by":         "fission-console",
+		"fission.io/managed": "true", // Layer 1: executor NSWatcher auto-discovers this NS
+	}
+	if strings.HasPrefix(ns, "fission-test-") {
+		labels["fission-console/env"] = "test"
+	}
 	nsObj := &unstructured.Unstructured{
 		Object: map[string]any{
 			"apiVersion": "v1",
 			"kind":       "Namespace",
 			"metadata": map[string]any{
-				"name": ns,
-				"labels": map[string]any{
-					"managed-by":         "fission-console",
-					"fission.io/managed": "true", // Layer 1: executor NSWatcher auto-discovers this NS
-				},
+				"name":   ns,
+				"labels": labels,
 			},
 		},
 	}

client-console/internal/model/types.go

@@ -5,11 +5,14 @@ package model
 
 // CreateFunctionRequest — тело POST /console/api/functions.
 // TTL пустой → функция живёт вечно; "1d", "24h" — протухнет через указанное время.
+// Deps — содержимое файла зависимостей: requirements.txt (python), package.json deps (nodejs),
+// Gemfile (ruby), composer.json (php). Если задан — код упаковывается в zip вместе с deps-файлом.
 type CreateFunctionRequest struct {
 	Name        string   `json:"name"`
 	Language    string   `json:"language"`
 	Environment string   `json:"environment"`
 	Code        string   `json:"code"`
+	Deps        string   `json:"deps"` // содержимое файла зависимостей (опционально)
 	Entrypoint  string   `json:"entrypoint"`
 	Route       string   `json:"route"`
 	Methods     []string `json:"methods"`
@@ -26,9 +29,32 @@ type CreateTimeTriggerRequest struct {
 	SubPath      string `json:"subpath"`
 }
 
+// CreateMQTriggerRequest — тело POST /console/api/mqtriggers.
+// Архитектура: Console создаёт K8s Deployment (sqs-consumer) + Secret с credentials
+// в namespace пользователя. sqs-consumer поллит shared-sqs → вызывает Fission-функцию.
+type CreateMQTriggerRequest struct {
+	Name         string `json:"name"`
+	FunctionName string `json:"functionName"`
+	Queue        string `json:"queue"`       // имя очереди в SQS
+	SqsEndpoint  string `json:"sqsEndpoint"` // URL SQS сервиса (default: internal shared-sqs)
+	AccessKey    string `json:"accessKey"`   // SQS access key тенанта
+	SecretKey    string `json:"secretKey"`   // SQS secret key тенанта
+}
+
+// CreateKWTriggerRequest — тело POST /console/api/kwtriggers.
+// Документация полей: kubectl get crd kuberneteswatchtriggers.fission.io -o json
+type CreateKWTriggerRequest struct {
+	Name          string `json:"name"`
+	FunctionName  string `json:"functionName"`
+	ResourceType  string `json:"resourceType"`  // Pod, Service, Deployment и т.д.
+	Namespace     string `json:"namespace"`     // пустое = namespace пользователя
+	LabelSelector string `json:"labelSelector"` // "app=foo" или "" для всех
+}
+
 // UpdateCodeRequest — тело PUT /console/api/functions/:name/code.
 type UpdateCodeRequest struct {
 	Code    string `json:"code"`
+	Deps    string `json:"deps"` // содержимое файла зависимостей (опционально)
 	Timeout int64  `json:"timeout"`
 }
 
@@ -44,7 +70,7 @@ type LangEnvDef struct {
 // LangEnvMap сопоставляет идентификатор языка (string) с описанием среды выполнения.
 // Ключ используется в createFunctionRequest.Language и как суффикс имени Environment.
 var LangEnvMap = map[string]LangEnvDef{
-	"python": {Image: "ghcr.io/fission/python-env"},
+	"python": {Image: "naeel/fission-python-env:v1.1"},
 	"nodejs": {Image: "ghcr.io/fission/node-env"},
 	"go":     {Image: "ghcr.io/fission/go-env", BuilderImage: "naeel/go-builder-fast:v1"},
 	"php":    {Image: "ghcr.io/fission/php-env"},

client-console/internal/runtime/entrypoint.go

@@ -11,6 +11,9 @@ package runtime
 func DefaultEntrypoint(lang string) string {
 	switch lang {
 	case "nodejs":
+		// "main" (без .js): node-env.specializeV2 делает split(".") для functionName
+		// с точкой → funcname="js" → ищет экспорт "js" → 500.
+		// Без расширения: funcname=undefined → берёт default export (module.exports = __invoke).
 		return "main"
 	case "php":
 		// Fission php-env: filename::functionName

client-console/internal/runtime/helpers.go

@@ -0,0 +1,52 @@
+package runtime
+
+import (
+	"archive/zip"
+	"bytes"
+)
+
+// buildZip создаёт zip-архив с одним файлом fileName и содержимым content.
+// Вспомогательная функция: используется в buildScriptZip (PHP/Ruby),
+// а также как основа для buildGoSourceZip и buildJSDeployZip.
+func buildZip(fileName string, content []byte) ([]byte, error) {
+	var buf bytes.Buffer
+	zw := zip.NewWriter(&buf)
+
+	fw, err := zw.Create(fileName)
+	if err != nil {
+		return nil, err
+	}
+	if _, err := fw.Write(content); err != nil {
+		return nil, err
+	}
+
+	if err := zw.Close(); err != nil {
+		return nil, err
+	}
+	return buf.Bytes(), nil
+}
+
+// buildZipTwo создаёт zip-архив с двумя файлами.
+// Используется когда пользователь указал файл зависимостей (requirements.txt и т.д.).
+func buildZipTwo(file1, file2 string, content1, content2 []byte) ([]byte, error) {
+	var buf bytes.Buffer
+	zw := zip.NewWriter(&buf)
+
+	for _, f := range []struct {
+		name    string
+		content []byte
+	}{{file1, content1}, {file2, content2}} {
+		fw, err := zw.Create(f.name)
+		if err != nil {
+			return nil, err
+		}
+		if _, err := fw.Write(f.content); err != nil {
+			return nil, err
+		}
+	}
+
+	if err := zw.Close(); err != nil {
+		return nil, err
+	}
+	return buf.Bytes(), nil
+}

client-console/internal/runtime/nodejs.go

@@ -23,10 +23,12 @@ func BuildJSDeployZip(code string) ([]byte, error) {
 
 	// main.js — CommonJS wrapper:
 	// 1. new Function создаёт функцию в пустом модульном контексте (нет import/export)
-	// 2. Передаём ей module и exports как параметры → пользовательский CJS код работает
-	// 3. Экспортируем main/handler/default через module.exports
+	// 2. Передаём ей module, exports и require как параметры → пользовательский CJS код работает
+	// 3. require передаётся явно, т.к. new Function выполняется в глобальном scope
+	//    и не имеет доступа к module-local require из CJS контекста main.js
+	// 4. Экспортируем main/handler/default через module.exports
 	wrapper := fmt.Sprintf(`const __mod = { exports: {} };
-(new Function('module', 'exports', %s))(__mod, __mod.exports);
+(new Function('module', 'exports', 'require', %s))(__mod, __mod.exports, require);
 const _fn = __mod.exports;
 
 	async function __invoke(ctx) {

client-console/internal/runtime/nodejs_test.go

@@ -33,18 +33,20 @@ func TestBuildJSDeployZipExportsMainAndHandler(t *testing.T) {
 		files[file.Name] = string(content)
 	}
 
-	if files["package.json"] != `{"type":"module"}` {
-		t.Fatalf("package.json = %q, want ESM marker", files["package.json"])
-	}
-
 	mainJS := files["main.js"]
-	if !strings.Contains(mainJS, `export { __invoke as main, __invoke as handler };`) {
-		t.Fatalf("main.js does not export both main and handler: %s", mainJS)
+	if mainJS == "" {
+		t.Fatalf("main.js not found in zip, files: %v", files)
 	}
-	if !strings.Contains(mainJS, `export default __invoke;`) {
-		t.Fatalf("main.js does not export default invoke: %s", mainJS)
+	if !strings.Contains(mainJS, `new Function('module', 'exports', 'require',`) {
+		t.Fatalf("main.js does not pass require to new Function: %s", mainJS)
+	}
+	if !strings.Contains(mainJS, `__mod.exports, require)`) {
+		t.Fatalf("main.js does not forward require: %s", mainJS)
+	}
+	if !strings.Contains(mainJS, `module.exports = __invoke`) {
+		t.Fatalf("main.js does not export __invoke via module.exports: %s", mainJS)
 	}
 	if !strings.Contains(mainJS, `_fn.default || _fn.handler || _fn.main`) {
 		t.Fatalf("main.js lost user export resolution: %s", mainJS)
 	}
-}
+}

client-console/internal/runtime/script.go

@@ -0,0 +1,30 @@
+package runtime
+
+// BuildScriptZip создаёт zip-архив с одним файлом fileName и содержимым code.
+// Используется для PHP и Ruby — языков где среда Fission ожидает
+// именованный файл (handler.rb, handler.pl, main.php и т.д.) внутри архива.
+//
+// Почему zip, а не просто literal:
+// Fission poolmgr при специализации пода распаковывает deployment archive,
+// находит нужный файл по имени и загружает его в среду выполнения.
+// Если передать просто байты кода в deployment.literal — среда не знает расширение.
+func BuildScriptZip(code, fileName string) ([]byte, error) {
+	return buildZip(fileName, []byte(code))
+}
+
+// BuildScriptZipWithDeps создаёт zip с кодом и файлом зависимостей.
+// fileName — имя файла кода (handler.rb, main.php и т.д.)
+// depsName — имя файла зависимостей (Gemfile, composer.json и т.д.)
+func BuildScriptZipWithDeps(code, fileName, deps, depsName string) ([]byte, error) {
+	return buildZipTwo(fileName, depsName, []byte(code), []byte(deps))
+}
+
+// BuildPythonZip создаёт zip с main.py (и опционально requirements.txt).
+// Если deps пустой — возвращает raw bytes кода (текущее поведение Python).
+// Если deps задан — zip с main.py + requirements.txt для pip install.
+func BuildPythonZip(code, deps string) ([]byte, error) {
+	if deps == "" {
+		return []byte(code), nil
+	}
+	return buildZipTwo("main.py", "requirements.txt", []byte(code), []byte(deps))
+}

client-console/internal/stats/factory.go

@@ -0,0 +1,36 @@
+package stats
+
+import (
+	"log"
+	"os"
+	"strings"
+)
+
+// NewProvider создаёт StatsProvider из переменных окружения.
+//
+// Переменные:
+//   - GRAFANA_INTERNAL_URL — внутренний URL (http://grafana.grafana.svc.cluster.local:3000)
+//   - GRAFANA_PUBLIC_URL   — публичный URL для ссылок (https://fission.kube5s.ru/grafana)
+//   - GRAFANA_ADMIN_USER   — имя admin (default: "admin")
+//   - GRAFANA_ADMIN_PASS   — пароль admin
+func NewProvider() StatsProvider {
+	internalURL := strings.TrimSpace(os.Getenv("GRAFANA_INTERNAL_URL"))
+	if internalURL == "" {
+		log.Printf("stats: GRAFANA_INTERNAL_URL not set — using NoopProvider")
+		return NoopProvider{}
+	}
+
+	publicURL := strings.TrimSpace(os.Getenv("GRAFANA_PUBLIC_URL"))
+	if publicURL == "" {
+		publicURL = "https://fission.kube5s.ru/grafana"
+	}
+
+	adminUser := strings.TrimSpace(os.Getenv("GRAFANA_ADMIN_USER"))
+	if adminUser == "" {
+		adminUser = "admin"
+	}
+	adminPass := os.Getenv("GRAFANA_ADMIN_PASS")
+
+	log.Printf("stats: GrafanaProvider internalURL=%s publicURL=%s user=%s", internalURL, publicURL, adminUser)
+	return NewGrafanaProvider(internalURL, publicURL, adminUser, adminPass)
+}

client-console/internal/stats/grafana.go

@@ -0,0 +1,382 @@
+package stats
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"log"
+	"net/http"
+	"strings"
+	"sync"
+	"time"
+)
+
+// GrafanaProvider реализует StatsProvider через Grafana HTTP API.
+//
+// Для каждого namespace создаётся изолированная Grafana Organization:
+//   - PostgreSQL datasource (тот же DSN, uid="fission-user-pg")
+//   - Dashboard с hardcoded WHERE namespace='...'
+//   - Public Dashboard (без логина) → accessToken
+//
+// Потокобезопасен: sync.RWMutex + per-namespace singleflight.
+type GrafanaProvider struct {
+	internalURL string // http://grafana.grafana.svc.cluster.local:3000
+	publicURL   string // https://fission.kube5s.ru/grafana
+	adminUser   string
+	adminPass   string
+	http        *http.Client
+
+	mu     sync.RWMutex
+	tokens map[string]string // namespace → publicDashboardAccessToken
+	orgIDs map[string]int64  // namespace → grafana orgId
+}
+
+// NewGrafanaProvider создаёт GrafanaProvider.
+func NewGrafanaProvider(internalURL, publicURL, adminUser, adminPass string) *GrafanaProvider {
+	return &GrafanaProvider{
+		internalURL: strings.TrimRight(internalURL, "/"),
+		publicURL:   strings.TrimRight(publicURL, "/"),
+		adminUser:   adminUser,
+		adminPass:   adminPass,
+		http:        &http.Client{Timeout: 20 * time.Second},
+		tokens:      make(map[string]string),
+		orgIDs:      make(map[string]int64),
+	}
+}
+
+// EnsureOrgForNamespace идемпотентно создаёт Grafana Org + datasource + dashboard + public link.
+func (g *GrafanaProvider) EnsureOrgForNamespace(ctx context.Context, namespace, email string) error {
+	// Быстрый путь: уже провизировано в этом процессе
+	g.mu.RLock()
+	_, cached := g.tokens[namespace]
+	g.mu.RUnlock()
+	if cached {
+		return nil
+	}
+
+	// Шаг 1: получить или создать Org
+	orgID, err := g.getOrCreateOrg(ctx, namespace)
+	if err != nil {
+		return fmt.Errorf("getOrCreateOrg(%s): %w", namespace, err)
+	}
+
+	// Шаг 2: создать datasource в этой Org (идемпотентно)
+	if err := g.ensureDatasource(ctx, orgID); err != nil {
+		log.Printf("stats: ensureDatasource org=%d ns=%s: %v", orgID, namespace, err)
+		// не фатально — dashboard может не работать но org создана
+	}
+
+	// Шаг 3: создать dashboard с hardcoded namespace (идемпотентно)
+	dashUID, err := g.ensureDashboard(ctx, orgID, namespace)
+	if err != nil {
+		return fmt.Errorf("ensureDashboard org=%d ns=%s: %w", orgID, namespace, err)
+	}
+
+	// Шаг 4: получить или создать public dashboard → accessToken
+	token, err := g.ensurePublicDashboard(ctx, orgID, dashUID)
+	if err != nil {
+		return fmt.Errorf("ensurePublicDashboard org=%d dash=%s: %w", orgID, dashUID, err)
+	}
+
+	// Кэшируем
+	g.mu.Lock()
+	g.tokens[namespace] = token
+	g.orgIDs[namespace] = orgID
+	g.mu.Unlock()
+
+	log.Printf("stats: org provisioned ns=%s orgId=%d publicToken=%s...", namespace, orgID, token[:8])
+	return nil
+}
+
+// DashboardURL возвращает публичный URL или "" если ещё не провизировано.
+func (g *GrafanaProvider) DashboardURL(ctx context.Context, namespace string) string {
+	// Сначала пробуем из кэша
+	g.mu.RLock()
+	token, ok := g.tokens[namespace]
+	g.mu.RUnlock()
+	if ok && token != "" {
+		return g.publicURL + "/public-dashboards/" + token
+	}
+
+	// Кэш промах (после перезапуска сервера) — провизируем заново
+	if err := g.EnsureOrgForNamespace(ctx, namespace, ""); err != nil {
+		log.Printf("stats: DashboardURL re-provision ns=%s: %v", namespace, err)
+		return ""
+	}
+
+	g.mu.RLock()
+	token = g.tokens[namespace]
+	g.mu.RUnlock()
+	if token == "" {
+		return ""
+	}
+	return g.publicURL + "/public-dashboards/" + token
+}
+
+// --- Grafana API helpers ---
+
+// getOrCreateOrg возвращает orgId существующей или создаёт новую Org.
+func (g *GrafanaProvider) getOrCreateOrg(ctx context.Context, namespace string) (int64, error) {
+	// Проверяем кэш orgIDs
+	g.mu.RLock()
+	if id, ok := g.orgIDs[namespace]; ok {
+		g.mu.RUnlock()
+		return id, nil
+	}
+	g.mu.RUnlock()
+
+	// GET /api/orgs/name/{namespace}
+	resp, body, err := g.grafanaRequest(ctx, http.MethodGet, "/api/orgs/name/"+namespace, 0, nil)
+	if err != nil {
+		return 0, err
+	}
+	if resp.StatusCode == http.StatusOK {
+		var org struct {
+			ID int64 `json:"id"`
+		}
+		if err := json.Unmarshal(body, &org); err != nil {
+			return 0, fmt.Errorf("parse org: %w", err)
+		}
+		return org.ID, nil
+	}
+
+	// Org не найдена — создаём
+	payload := map[string]string{"name": namespace}
+	resp, body, err = g.grafanaRequest(ctx, http.MethodPost, "/api/orgs", 0, payload)
+	if err != nil {
+		return 0, err
+	}
+	if resp.StatusCode != http.StatusOK && resp.StatusCode != http.StatusCreated {
+		return 0, fmt.Errorf("create org status=%d body=%s", resp.StatusCode, string(body))
+	}
+	var created struct {
+		OrgID int64 `json:"orgId"`
+	}
+	if err := json.Unmarshal(body, &created); err != nil {
+		return 0, fmt.Errorf("parse create org: %w", err)
+	}
+	return created.OrgID, nil
+}
+
+// ensureDatasource создаёт PostgreSQL datasource в org (uid="fission-user-pg").
+// Идемпотентен: 409 Conflict считается успехом.
+func (g *GrafanaProvider) ensureDatasource(ctx context.Context, orgID int64) error {
+	// Проверяем есть ли уже datasource в этой org
+	resp, _, err := g.grafanaRequest(ctx, http.MethodGet, "/api/datasources/uid/fission-user-pg", orgID, nil)
+	if err != nil {
+		return err
+	}
+	if resp.StatusCode == http.StatusOK {
+		return nil // уже есть
+	}
+
+	// Получаем DSN из уже существующего datasource в Org 1 (uid=fission-pg)
+	_, body, err := g.grafanaRequest(ctx, http.MethodGet, "/api/datasources/uid/fission-pg", 1, nil)
+	if err != nil {
+		return fmt.Errorf("get main datasource: %w", err)
+	}
+	var ds struct {
+		URL            string          `json:"url"`
+		JSONData       json.RawMessage `json:"jsonData"`
+		SecureJSONData struct {
+			Password string `json:"password"`
+		} `json:"secureJsonData"`
+	}
+	if err := json.Unmarshal(body, &ds); err != nil {
+		return fmt.Errorf("parse main datasource: %w", err)
+	}
+
+	// Создаём копию datasource в новой Org
+	payload := map[string]any{
+		"name":   "fission-pg",
+		"type":   "postgres",
+		"uid":    "fission-user-pg",
+		"url":    ds.URL,
+		"access": "proxy",
+		"jsonData": map[string]any{
+			"sslmode":         "disable",
+			"postgresVersion": 1700,
+			"timescaledb":     false,
+		},
+		"secureJsonData": ds.SecureJSONData,
+	}
+	resp, body, err = g.grafanaRequest(ctx, http.MethodPost, "/api/datasources", orgID, payload)
+	if err != nil {
+		return err
+	}
+	if resp.StatusCode == http.StatusConflict {
+		return nil // уже существует
+	}
+	if resp.StatusCode != http.StatusOK && resp.StatusCode != http.StatusCreated {
+		return fmt.Errorf("create datasource status=%d body=%s", resp.StatusCode, string(body))
+	}
+	return nil
+}
+
+// ensureDashboard создаёт/обновляет user-дашборд в org.
+// Возвращает uid дашборда.
+func (g *GrafanaProvider) ensureDashboard(ctx context.Context, orgID int64, namespace string) (string, error) {
+	const dashUID = "fission-user-overview"
+
+	// Проверяем существование
+	resp, _, err := g.grafanaRequest(ctx, http.MethodGet, "/api/dashboards/uid/"+dashUID, orgID, nil)
+	if err != nil {
+		return "", err
+	}
+	if resp.StatusCode == http.StatusOK {
+		return dashUID, nil // уже есть
+	}
+
+	// Импортируем dashboard JSON с hardcoded namespace
+	dashJSON := userDashboardJSON(namespace)
+	payload := map[string]any{
+		"dashboard": json.RawMessage(dashJSON),
+		"overwrite": true,
+		"folderId":  0,
+	}
+	resp, body, err := g.grafanaRequest(ctx, http.MethodPost, "/api/dashboards/db", orgID, payload)
+	if err != nil {
+		return "", err
+	}
+	if resp.StatusCode != http.StatusOK {
+		return "", fmt.Errorf("import dashboard status=%d body=%s", resp.StatusCode, string(body))
+	}
+	return dashUID, nil
+}
+
+// ensurePublicDashboard создаёт public dashboard и возвращает accessToken.
+// Идемпотентен: если уже существует — возвращает существующий token.
+func (g *GrafanaProvider) ensurePublicDashboard(ctx context.Context, orgID int64, dashUID string) (string, error) {
+	path := "/api/dashboards/uid/" + dashUID + "/public-dashboards"
+
+	// Проверяем существование
+	resp, body, err := g.grafanaRequest(ctx, http.MethodGet, path, orgID, nil)
+	if err != nil {
+		return "", err
+	}
+	if resp.StatusCode == http.StatusOK {
+		var pd struct {
+			AccessToken string `json:"accessToken"`
+		}
+		if err := json.Unmarshal(body, &pd); err != nil {
+			return "", fmt.Errorf("parse public dashboard: %w", err)
+		}
+		if pd.AccessToken != "" {
+			return pd.AccessToken, nil
+		}
+	}
+
+	// Создаём
+	payload := map[string]any{
+		"isEnabled":            true,
+		"annotationsEnabled":   false,
+		"timeSelectionEnabled": true,
+	}
+	resp, body, err = g.grafanaRequest(ctx, http.MethodPost, path, orgID, payload)
+	if err != nil {
+		return "", err
+	}
+	if resp.StatusCode != http.StatusOK && resp.StatusCode != http.StatusCreated {
+		return "", fmt.Errorf("create public dashboard status=%d body=%s", resp.StatusCode, string(body))
+	}
+
+	var pd struct {
+		AccessToken string `json:"accessToken"`
+	}
+	if err := json.Unmarshal(body, &pd); err != nil {
+		return "", fmt.Errorf("parse created public dashboard: %w", err)
+	}
+	if pd.AccessToken == "" {
+		return "", fmt.Errorf("empty accessToken in response: %s", string(body))
+	}
+	return pd.AccessToken, nil
+}
+
+// grafanaRequest выполняет HTTP запрос к Grafana API.
+// orgID > 0 → устанавливает X-Grafana-Org-Id заголовок (thread-safe, без смены контекста).
+// orgID == 0 → без заголовка (используется Org 1 admin по умолчанию).
+func (g *GrafanaProvider) grafanaRequest(ctx context.Context, method, path string, orgID int64, payload any) (*http.Response, []byte, error) {
+	var bodyReader io.Reader
+	if payload != nil {
+		data, err := json.Marshal(payload)
+		if err != nil {
+			return nil, nil, fmt.Errorf("marshal payload: %w", err)
+		}
+		bodyReader = bytes.NewReader(data)
+	}
+
+	req, err := http.NewRequestWithContext(ctx, method, g.internalURL+path, bodyReader)
+	if err != nil {
+		return nil, nil, fmt.Errorf("new request: %w", err)
+	}
+	req.SetBasicAuth(g.adminUser, g.adminPass)
+	if payload != nil {
+		req.Header.Set("Content-Type", "application/json")
+	}
+	if orgID > 0 {
+		req.Header.Set("X-Grafana-Org-Id", fmt.Sprintf("%d", orgID))
+	}
+
+	resp, err := g.http.Do(req)
+	if err != nil {
+		return nil, nil, fmt.Errorf("do request %s %s: %w", method, path, err)
+	}
+	defer resp.Body.Close()
+
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return resp, nil, fmt.Errorf("read body: %w", err)
+	}
+	return resp, body, nil
+}
+
+// userDashboardJSON генерирует JSON дашборда для конкретного namespace.
+// Namespace вшит прямо в SQL запросы — без template variables.
+// Dashboard uid="fission-user-overview" (per-org, без конфликтов между org).
+func userDashboardJSON(namespace string) string {
+	// Безопасное экранирование namespace для SQL (namespace это sha256 hex — только [a-z0-9-])
+	ns := strings.ReplaceAll(namespace, "'", "''")
+	return fmt.Sprintf(`{
+  "title": "Мои функции — %s",
+  "uid": "fission-user-overview",
+  "tags": ["fission", "user"],
+  "timezone": "browser",
+  "refresh": "1m",
+  "time": {"from": "now-24h", "to": "now"},
+  "panels": [
+    {
+      "id": 1, "title": "Вызовы в час", "type": "timeseries",
+      "gridPos": {"x": 0, "y": 0, "w": 16, "h": 8},
+      "datasource": {"type": "postgres", "uid": "fission-user-pg"},
+      "targets": [{"rawSql": "SELECT date_trunc('hour', started_at) AS time, count(*) AS value, function_name FROM invocations WHERE namespace = '%s' AND started_at BETWEEN $__timeFrom() AND $__timeTo() GROUP BY 1, function_name ORDER BY 1", "format": "time_series", "refId": "A"}]
+    },
+    {
+      "id": 2, "title": "Успех vs Ошибки", "type": "piechart",
+      "gridPos": {"x": 16, "y": 0, "w": 8, "h": 8},
+      "datasource": {"type": "postgres", "uid": "fission-user-pg"},
+      "targets": [{"rawSql": "SELECT CASE WHEN status_code >= 200 AND status_code < 300 THEN 'success' WHEN status_code = 0 THEN 'event' ELSE 'error' END AS metric, count(*) AS value FROM invocations WHERE namespace = '%s' AND started_at BETWEEN $__timeFrom() AND $__timeTo() GROUP BY 1", "format": "table", "refId": "A"}]
+    },
+    {
+      "id": 3, "title": "Топ функций", "type": "bargauge",
+      "gridPos": {"x": 0, "y": 8, "w": 12, "h": 8},
+      "datasource": {"type": "postgres", "uid": "fission-user-pg"},
+      "targets": [{"rawSql": "SELECT function_name AS metric, count(*) AS value FROM invocations WHERE namespace = '%s' AND started_at BETWEEN $__timeFrom() AND $__timeTo() GROUP BY 1 ORDER BY 2 DESC LIMIT 10", "format": "table", "refId": "A"}]
+    },
+    {
+      "id": 4, "title": "Средняя латентность (ms)", "type": "timeseries",
+      "gridPos": {"x": 12, "y": 8, "w": 12, "h": 8},
+      "datasource": {"type": "postgres", "uid": "fission-user-pg"},
+      "targets": [{"rawSql": "SELECT date_trunc('hour', started_at) AS time, round(avg(duration_ms)) AS avg_ms FROM invocations WHERE namespace = '%s' AND started_at BETWEEN $__timeFrom() AND $__timeTo() AND trigger_type != 'event' GROUP BY 1 ORDER BY 1", "format": "time_series", "refId": "A"}]
+    },
+    {
+      "id": 5, "title": "Последние события", "type": "table",
+      "gridPos": {"x": 0, "y": 16, "w": 24, "h": 8},
+      "datasource": {"type": "postgres", "uid": "fission-user-pg"},
+      "targets": [{"rawSql": "SELECT started_at AS time, function_name, trigger_type, event_type, status_code, duration_ms, error_msg FROM invocations WHERE namespace = '%s' ORDER BY started_at DESC LIMIT 50", "format": "table", "refId": "A"}]
+    }
+  ],
+  "schemaVersion": 39
+}`, namespace, ns, ns, ns, ns, ns)
+}

client-console/internal/stats/noop.go

@@ -0,0 +1,10 @@
+package stats
+
+import "context"
+
+// NoopProvider — заглушка когда GRAFANA_INTERNAL_URL не задан.
+// Ни на что не влияет, не крашит.
+type NoopProvider struct{}
+
+func (NoopProvider) EnsureOrgForNamespace(_ context.Context, _, _ string) error { return nil }
+func (NoopProvider) DashboardURL(_ context.Context, _ string) string            { return "" }

client-console/internal/stats/provider.go

@@ -0,0 +1,20 @@
+// Package stats — аналитический слой консоли.
+//
+// StatsProvider абстрагирует конкретный инструмент (Grafana, Prometheus, etc.).
+// При смене инструмента достаточно заменить реализацию и переменные окружения.
+package stats
+
+import "context"
+
+// StatsProvider — интерфейс аналитики.
+// Реализации: GrafanaProvider (GRAFANA_INTERNAL_URL задан), NoopProvider (заглушка).
+type StatsProvider interface {
+	// EnsureOrgForNamespace идемпотентно создаёт аналитическое пространство
+	// для namespace (Grafana Org + datasource + dashboard + public link).
+	// Вызывается при handleAuth — fire-and-forget горутиной.
+	EnsureOrgForNamespace(ctx context.Context, namespace, email string) error
+
+	// DashboardURL возвращает публичный URL дашборда без логина.
+	// Возвращает "" если аналитика не настроена или provisioning не завершён.
+	DashboardURL(ctx context.Context, namespace string) string
+}

client-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))
+	})
+}

client-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>

client-console/ui/css/styles.css

@@ -0,0 +1,332 @@
+: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;
+}
+
+.modal-error {
+  display: none;
+  margin-top: 10px;
+  padding: 8px 12px;
+  border-radius: 6px;
+  background: #3a1a1a;
+  color: #f88;
+  font-size: 13px;
+  white-space: pre-wrap;
+  word-break: break-word;
+}

client-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 {

client-console/ui/index.html

@@ -0,0 +1,710 @@
+<!doctype html>
+<html lang="ru">
+
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <title>NUBES Fission Console</title>
+  <link rel="icon" type="image/png"
+    href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAEAAAABACAYAAACqaXHeAAAACXBIWXMAAA7DAAAOwwHHb6hkAAAAGXRFWHRTb2Z0d2FyZQB3d3cuaW5rc2NhcGUub3Jnm+48GgAAA4ZJREFUeJztm8+Lm0UYxz/fySZUoWIrVtbmXfyBP05Fa3e3rogsglJRK0p7E2svnrz6B3gQ8eRJFooXET14KKJ4FUQo3UQQ9CRC6W4WQW0VXZduTd7HQ9c22bzbTCY/ZpO8n0syb56Z+c437zPvhMzIzJhkXGwBsckNiC0gNrkBsQXEZsonSJLj4GNPgb2ACo9j9gDOvrSV6qkB6+sJ6WSJ5MIxUo4h5sDuI9U7tlZ57/+YTAN0zyOPUi+9jOxJxMOUj9wJOBBg117QvqGMwhNpcQ/J+rOkPIc0j+xeytyGsaWXa2+kvc312gxQMleHYgFtrQ9GYJmgmSfup3z15xuDNW/dGXOAjd680NgshlYdvcH2mfEwQIU0tOp4GNADuQGxBcRmPAyQgh/W42FAD+QGxBYQm/EwIF8HhJMbEFtAX3DreQqEkhsQW0BsxsMAlz8Gg8kNiC0gNuNhgJvK54BQcgNiC+gLhUlPgcuTbkAP5AbEFhCbcAOM4LyLitIW3eEGyP7qWUwMHFdaixNO1v4Av5pG8H/yfWfvesk7tq5GczHDAHnmtu727nTQbJYe8o51+qOl2BYgNv1a0iHvTgeNGq94x6buYnOx3YCU3/1asn06ePQZ744HiXTCO3a6/m1zsd0Ax/f+HTc+kU76598AUDL/LpjfjjWxYdXqRvOljDvAfezfO3dQvvCDtLjHu04f0czsaSx9y7uC8eP2S20GWO38Z+A7DwDwIOX135TMvylpKI9VJQv7lcx+hfEhurELsCPOfdDWVtZ5ASWzZ4GXArQ1QJfA/kTW6BhtLgX+7qL9IqTTmKa7GjgAumKry7dsv5q9Vfbfq29QLL1I9wulAtgB4ADmoy9kY4fodugAODuT2dpOJ0aUzH8E6asBXe0+zP5h7bvbzay+/aOdv+Ha8mnE5YEKGxqF17MGDzcxwMzqTBUWgc65vKuxT7cm9kx2TIHrATOzxzHOEpZ5sanYamXuZgEdJzlbqXyOmzrO6N0J56hVj3YK8prl7eK5L6g3DmFc6l3XEDCWbLWyYGYdf9h1TIGWYMmRHDlDaqcY0qKnO/Qr4oStLH/jXSPk4KSShf2ovoTZ80Db4iICv2D2ttWqS91WDDKgpYHy4adR8TWww8BdmN2KrOg5Zwoo+PV0">
+  <script>
+    if (window.location.protocol !== 'https:' && window.location.hostname !== 'localhost' && window.location.hostname !== '127.0.0.1') {
+      window.location.replace('https://' + window.location.host + window.location.pathname + window.location.search + window.location.hash);
+    }
+  </script>
+  <link rel="stylesheet" href="css/styles.css">
+  <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/triggers.js"></script>
+  <script src="js/modals.js"></script>
+  <script src="js/init.js"></script>
+  <script src="js/functions.js"></script>
+  <script src="js/fn-code.js"></script>
+  <script src="js/fn-archive.js"></script>
+  <script src="js/ai.js"></script>
+  <script src="js/app.js"></script>
+  <script src="js/mq.js"></script>
+</head>
+
+<body>
+  <div id="login-overlay"
+    style="display:none; position:fixed; inset:0; background:rgba(0,0,0,.85); z-index:999; align-items:center; justify-content:center; padding:16px;">
+    <div class="panel" style="width:min(440px,100%);">
+      <div class="brand" style="margin-bottom:24px;">
+        <div class="brand-mark">N</div>
+        <div class="brand-text">
+          <div class="nubes">NUBES</div>
+          <div class="product">FISSION CONSOLE</div>
+        </div>
+      </div>
+      <div class="row" style="flex-direction:column; gap:6px; margin-bottom:12px;">
+        <label style="font-size:12px; color:#999;">Стенд</label>
+        <select id="l-env"
+          style="background:var(--bg-base); border:1px solid var(--border); color:var(--fg); padding:8px 10px; border-radius:6px;">
+          <option value="dev">Dev</option>
+          <option value="test" selected>Test</option>
+          <option value="prod">Prod</option>
+        </select>
+      </div>
+      <div class="row" style="flex-direction:column; gap:6px; margin-bottom:12px;">
+        <label style="font-size:12px; color:#999;">Токен или логин</label>
+        <textarea id="l-token" rows="5"
+          style="background:var(--bg-base); border:1px solid var(--border); color:var(--fg); padding:8px 10px; border-radius:6px; font-family:monospace; font-size:12px; resize:vertical; width:100%; box-sizing:border-box;"
+          placeholder="Введите токен или любой логин (не менее 6 символов)..."></textarea>
+        <div style="font-size:11px; color:var(--text-secondary); margin-top:4px;">Токен из ЛК: <strong
+            style="color:#8bc7ff;">Личный кабинет → Профиль пользователя → Токены</strong><br>Или введите любой логин не менее 6 символов для демо-доступа.</div>
+      </div>
+      <div id="l-error" style="display:none; color:#ff6b6b; font-size:13px; margin-bottom:10px;"></div>
+      <button id="l-btn" class="btn" style="width:100%;" onclick="doLogin()">Войти</button>
+    </div>
+  </div>
+  <!-- Overlay: инициализация нового окружения -->
+  <div id="init-overlay"
+    style="display:none; position:fixed; inset:0; background:rgba(0,0,0,.88); z-index:1000; align-items:center; justify-content:center; padding:16px;">
+    <div class="panel" style="width:min(520px,100%);">
+      <div style="margin-bottom:16px;">
+        <div style="font-size:16px; font-weight:700; margin-bottom:6px;">⚙️ Инициализация окружения</div>
+        <div style="font-size:13px; color:var(--text-secondary);">Первый вход. Настраиваем ваше окружение — это займёт
+          ~5 минут.</div>
+      </div>
+      <div style="display:grid; grid-template-columns:repeat(2,minmax(0,1fr)); gap:10px; margin-bottom:12px;">
+        <div style="background:#0d1827; border:1px solid var(--border); border-radius:6px; padding:10px;">
+          <div style="font-size:11px; color:var(--text-secondary); margin-bottom:4px;">Время настройки</div>
+          <div id="init-elapsed" style="font-size:18px; font-weight:700; color:#8bc7ff;">0с</div>
+        </div>
+        <div style="background:#0d1827; border:1px solid var(--border); border-radius:6px; padding:10px;">
+          <div style="font-size:11px; color:var(--text-secondary); margin-bottom:4px;">Текущий этап</div>
+          <div id="init-current-stage" style="font-size:14px; font-weight:600; color:#f4f7fb;">Ожидание старта</div>
+        </div>
+      </div>
+      <div id="init-summary"
+        style="display:none; margin-bottom:10px; background:#101c2b; border:1px solid var(--border); border-radius:6px; padding:10px 12px; font-size:13px; color:#d8e5f2;">
+      </div>
+      <div id="init-reason"
+        style="display:none; margin-bottom:10px; background:#2d2310; border:1px solid #6a5427; border-radius:6px; padding:10px 12px; font-size:13px; color:#ffd98a;">
+      </div>
+      <div id="init-error"
+        style="display:none; margin-bottom:10px; background:#2a1416; border:1px solid #7d3138; border-radius:6px; padding:10px 12px; font-size:13px; color:#ff9da5;">
+      </div>
+      <div id="init-log"
+        style="background:#000d1a; border:1px solid var(--border); border-radius:6px; padding:12px; font-family:monospace; font-size:12px; height:160px; overflow-y:auto; color:#4fc3f7; white-space:pre-wrap; line-height:1.6;">
+      </div>
+      <div id="init-stages" style="margin-top:14px; display:flex; flex-direction:column; gap:8px;"></div>
+      <div style="margin-top:14px; font-size:12px; color:var(--text-secondary);">Страница обновится автоматически когда
+        всё будет готово.</div>
+    </div>
+  </div>
+
+  <div class="navbar">
+    <div class="brand-mark" id="user-avatar">N</div>
+    <div class="brand-text" style="margin-left:auto; text-align:right;">
+      <div class="nubes">NUBES</div>
+      <div class="product">FISSION CONSOLE</div>
+    </div>
+    <div style="font-size:0.65rem; color:var(--text-secondary); margin-left:10px; align-self:center; opacity:0.7;">v1.3.96</div>
+  </div>
+  <div class="row" style="margin:0;">
+    <button class="btn ghost" onclick="reloadAll()">Refresh</button>
+    <button class="btn" onclick="openCreateCode()">✏️ Из кода</button>
+    <button class="btn" onclick="openCreateArchive()">📦 Из архива</button>
+    <button class="btn ghost" onclick="openHelp()">Help</button>
+    <button class="btn ghost" onclick="openAnalytics()" title="Открыть дашборд Grafana">📊 Аналитика</button>
+    <button class="btn ghost" onclick="doLogout()" style="margin-left:8px;">Выход</button>
+  </div>
+  </div>
+
+  <div class="wrap">
+    <div class="grid">
+      <div class="card">
+        <div class="k">Окружения</div>
+        <div id="env-count" class="v">-</div>
+      </div>
+      <div class="card">
+        <div class="k">Пакеты</div>
+        <div id="pkg-count" class="v">-</div>
+      </div>
+      <div class="card">
+        <div class="k">Функции</div>
+        <div id="fn-count" class="v">-</div>
+      </div>
+      <div class="card">
+        <div class="k">HTTP-триггеры</div>
+        <div id="http-count" class="v">-</div>
+      </div>
+      <div class="card">
+        <div class="k">Крон-функции</div>
+        <div id="cron-count" class="v">-</div>
+      </div>
+      <div class="card">
+        <div class="k">MQ-триггеры</div>
+        <div id="mq-count" class="v">-</div>
+      </div>
+    </div>
+
+    <div class="box">
+      <div class="toolbar">
+        <div style="font-weight:600;">Функции</div>
+        <div class="hint">Actions: view, edit code, invoke, delete</div>
+      </div>
+      
+      <!-- Легенда статусов -->
+      <div style="margin-bottom:12px; padding:8px; background:var(--bg-alt); border-radius:4px; font-size:0.9em; color:var(--text-secondary);">
+        <strong>Статусы функций:</strong>
+        <span style="margin-left:16px;">
+          <span style="display:inline-block; width:10px; height:10px; border-radius:50%; background:#2a2; vertical-align:middle;"></span> Готова
+          <span style="margin-left:12px; display:inline-block; width:10px; height:10px; border-radius:50%; background:#22a; vertical-align:middle;"></span> Холодная
+          <span style="margin-left:12px; display:inline-block; width:10px; height:10px; border-radius:50%; background:#aa2; vertical-align:middle;"></span> Сборка
+          <span style="margin-left:12px; display:inline-block; width:10px; height:10px; border-radius:50%; background:#a22; vertical-align:middle;"></span> Ошибка
+        </span>
+      </div>
+      
+      <table>
+        <thead>
+          <tr>
+            <th>Имя</th>
+            <th title="Статус функции (Готова / Холодная / Сборка / Ошибка)">Статус</th>
+            <th title="Тип источника функции">Тип</th>
+            <th>Создана</th>
+            <th>Изменена</th>
+            <th>Маршрут</th>
+            <th>Методы</th>
+            <th>Cron</th>
+            <th class="nowrap">Действия</th>
+          </tr>
+        </thead>
+        <tbody id="fn-rows"></tbody>
+      </table>
+      <div id="status" class="status"></div>
+      <div class="hint">Изменения применяются напрямую через CRD Fission.</div>
+    </div>
+
+    <!-- MQ-триггеры -->
+    <div class="box">
+      <div class="toolbar">
+        <div style="font-weight:600;">MQ-триггеры</div>
+        <button class="btn" onclick="openCreateMQ()">+ Добавить</button>
+      </div>
+      <table>
+        <thead>
+          <tr>
+            <th>Имя</th>
+            <th>Очередь</th>
+            <th>Функция</th>
+            <th>Endpoint SQS</th>
+            <th>Статус</th>
+            <th>Действия</th>
+          </tr>
+        </thead>
+        <tbody id="mq-rows">
+          <tr><td colspan="6" style="color:var(--fg-muted,#888);text-align:center;">Загрузка...</td></tr>
+        </tbody>
+      </table>
+      <div class="hint">MQ-триггер поллит очередь SQS и вызывает Fission-функцию при появлении сообщений.</div>
+    </div>
+  </div>
+
+  <!-- Модалка: создать MQ-триггер -->
+  <div id="mq-create-modal" class="modal">
+    <div class="panel" style="width:520px;max-width:96vw;">
+      <h3>📨 Создать MQ-триггер</h3>
+      <div class="row">
+        <div class="field">
+          <label>Имя триггера</label>
+          <input id="mq-name" placeholder="weather-trigger">
+        </div>
+        <div class="field">
+          <label>Функция</label>
+          <input id="mq-fn" placeholder="weather-store">
+        </div>
+      </div>
+      <div class="row">
+        <div class="field">
+          <label>Имя очереди (SQS)</label>
+          <input id="mq-queue" placeholder="weather-raw">
+        </div>
+        <div class="field">
+          <label>SQS Endpoint</label>
+          <input id="mq-endpoint" placeholder="http://shared-sqs.shared-sqs.svc.cluster.local:4100">
+        </div>
+      </div>
+      <div class="row">
+        <div class="field">
+          <label>Access Key</label>
+          <input id="mq-access-key" placeholder="SSAK-...">
+        </div>
+        <div class="field">
+          <label>Secret Key</label>
+          <input id="mq-secret-key" type="password" placeholder="...">
+        </div>
+      </div>
+      <div id="mq-create-error" class="modal-error"></div>
+      <div class="actions">
+        <button class="btn ghost" onclick="closeMQCreate()">Отмена</button>
+        <button class="btn" onclick="submitCreateMQ()">Создать</button>
+      </div>
+    </div>
+  </div>
+
+  <!-- Модалка: создать функцию из кода (prefix cc-) -->
+  <div id="create-code-modal" class="modal">
+    <div class="panel">
+      <h3>✏️ Создать функцию из кода</h3>
+      <div class="row">
+        <div class="field">
+          <label>Name</label>
+          <input id="cc-name" placeholder="demo-fn">
+        </div>
+        <div class="field">
+          <label>Language</label>
+          <select id="cc-lang" onchange="onLangChangeCode()">
+            <option value="python">Python</option>
+            <option value="nodejs">Node.js</option>
+            <option value="php">PHP</option>
+            <option value="ruby">Ruby</option>
+          </select>
+        </div>
+        <div class="field">
+          <label>Entrypoint</label>
+          <input id="cc-entry" value="main.main">
+        </div>
+      </div>
+      <div class="row">
+        <div class="field">
+          <label>Route</label>
+          <input id="cc-route" placeholder="/demo-fn">
+        </div>
+        <div class="field">
+          <label>Методы (через запятую)</label>
+          <input id="cc-methods" value="GET">
+        </div>
+        <div class="field">
+          <label>Timeout (сек)</label>
+          <input id="cc-timeout" type="number" min="1" value="60">
+        </div>
+      </div>
+      <div class="row">
+        <div class="field" style="min-width:240px; flex:0 0 260px;">
+          <label style="display:flex; align-items:center; gap:8px; color:var(--text-primary); margin-top:18px;">
+            <input id="cc-schedule-enabled" type="checkbox" onchange="toggleScheduleFields('cc')" style="width:auto;">
+            Выполнять по расписанию
+          </label>
+        </div>
+        <div class="field">
+          <label>Cron</label>
+          <input id="cc-cron" placeholder="*/5 * * * *" disabled>
+        </div>
+      </div>
+      <div>
+        <div id="cc-code-area">
+          <textarea id="cc-code">def main():
+    return {"ok": True, "msg": "hello from fission console"}
+</textarea>
+          <div style="margin-top:6px; display:flex; gap:6px; flex-wrap:wrap;">
+            <button class="btn ghost" id="cc-ai-btn" onclick="aiCheck('cc-code','cc-lang','cc-ai-result')">&#x1F50D; Проверить синтаксис линтером</button>
+            <button class="btn ghost" id="cc-gen-btn" onclick="showGenPrompt('cc')">&#x2728; Сгенерировать код LLM</button>
+            <button class="btn ghost" id="cc-exp-btn" onclick="aiExplain('cc-code','cc-lang','cc-ai-result')">&#x1F4D6; LLM: Что делает?</button>
+          </div>
+          <div style="margin-top:10px;">
+            <label id="cc-deps-label" style="font-size:12px; color:var(--text-secondary); margin-bottom:4px; display:block;">Зависимости (requirements.txt)</label>
+            <textarea id="cc-deps" rows="3" placeholder="boto3
+requests>=2.28
+psycopg2-binary" style="width:100%; box-sizing:border-box; font-family:monospace; font-size:12px; background:#1a1a2e; border:1px dashed #3a3a5c; border-radius:4px; color:#cdd6f4; padding:6px 8px; resize:none; overflow-y:auto;"></textarea>
+          </div>
+        </div>
+        <div id="cc-gen-prompt" style="display:none; margin-top:8px; gap:6px; align-items:center;">
+          <input id="cc-gen-desc" type="text"
+            placeholder="Что должна делать функция? (напр: принять JSON, вернуть сумму чисел)"
+            style="flex:1; background:#2a2a42; border:1px solid #3a3a5c; border-radius:4px; color:#cdd6f4; padding:6px 8px; font-size:.82rem; outline:none; width:100%;"
+            onkeydown="if(event.key==='Enter')aiGenerate('cc')" />
+          <button class="btn" onclick="aiGenerate('cc')" style="white-space:nowrap;">▶ Генерировать LLM</button>
+        </div>
+        <div id="cc-ai-result"
+          style="display:none;margin-top:8px;padding:10px 12px;border-radius:6px;font-size:13px;line-height:1.5;white-space:pre-wrap;font-family:monospace;">
+        </div>
+      </div>
+      <div id="cc-error" class="modal-error"></div>
+      <div class="actions">
+        <button class="btn ghost" onclick="closeCreateCode()">Отмена</button>
+        <button id="cc-submit" class="btn" onclick="submitCreateCode()">Создать</button>
+      </div>
+    </div>
+  </div>
+
+  <!-- Модалка: создать функцию из архива (prefix ca-) -->
+  <div id="create-archive-modal" class="modal">
+    <div class="panel">
+      <h3>📦 Создать функцию из архива</h3>
+      <div class="row">
+        <div class="field">
+          <label>Name</label>
+          <input id="ca-name" placeholder="demo-fn">
+        </div>
+        <div class="field">
+          <label>Language</label>
+          <select id="ca-lang" onchange="onLangChangeArchive()">
+            <option value="python">Python</option>
+            <option value="nodejs">Node.js</option>
+            <option value="php">PHP</option>
+            <option value="ruby">Ruby</option>
+          </select>
+        </div>
+        <div class="field">
+          <label>Entrypoint</label>
+          <input id="ca-entry" value="main.main">
+        </div>
+      </div>
+      <div class="row">
+        <div class="field">
+          <label>Route</label>
+          <input id="ca-route" placeholder="/demo-fn">
+        </div>
+        <div class="field">
+          <label>Методы (через запятую)</label>
+          <input id="ca-methods" value="GET">
+        </div>
+        <div class="field">
+          <label>Timeout (сек)</label>
+          <input id="ca-timeout" type="number" min="1" value="60">
+        </div>
+      </div>
+      <div class="row">
+        <div class="field" style="min-width:240px; flex:0 0 260px;">
+          <label style="display:flex; align-items:center; gap:8px; color:var(--text-primary); margin-top:18px;">
+            <input id="ca-schedule-enabled" type="checkbox" onchange="toggleScheduleFields('ca')" style="width:auto;">
+            Выполнять по расписанию
+          </label>
+        </div>
+        <div class="field">
+          <label>Cron</label>
+          <input id="ca-cron" placeholder="*/5 * * * *" disabled>
+        </div>
+      </div>
+      <div>
+        <div id="ca-archive-area">
+          <label>Архив (.zip)</label>
+          <input type="file" id="ca-archive-file" accept=".zip" style="display:block; margin-bottom:8px; color:var(--text-primary);">
+          <div style="display:flex; gap:6px; flex-wrap:wrap;">
+            <button id="ca-lint-btn" class="btn ghost" onclick="lintArchiveFile('ca')">&#x1F50D; Проверка архива линтером</button>
+            <button id="ca-explain-archive-btn" class="btn ghost" onclick="explainArchiveFile('ca')">&#x1F4D6; LLM: Что делает?</button>
+          </div>
+        </div>
+        <div id="ca-ai-result"
+          style="display:none;margin-top:8px;padding:10px 12px;border-radius:6px;font-size:13px;line-height:1.5;white-space:pre-wrap;font-family:monospace;">
+        </div>
+      </div>
+      <div id="ca-error" class="modal-error"></div>
+      <div class="actions">
+        <button class="btn ghost" onclick="closeCreateArchive()">Отмена</button>
+        <button id="ca-submit" class="btn" onclick="submitCreateArchive()">Создать</button>
+      </div>
+    </div>
+  </div>
+
+  <div id="edit-modal" class="modal">
+    <div class="panel">
+      <h3 id="e-title">Редактирование кода</h3>
+      <div id="e-tf-warn"
+        style="display:none;background:#553300;color:#ffa;padding:8px 12px;border-radius:6px;margin-bottom:10px;font-size:13px;">
+        &#x26a0;&#xfe0f; Эта функция управляется Terraform. Изменения могут быть перезаписаны при следующем
+        <code>terraform apply</code>.
+      </div>
+      <input type="hidden" id="e-lang-hidden" value="">
+      <div class="row">
+        <div class="field">
+          <label>Name</label>
+          <input id="e-name" disabled>
+        </div>
+        <div class="field">
+          <label>Environment</label>
+          <input id="e-env" disabled>
+        </div>
+        <div class="field">
+          <label>Entrypoint</label>
+          <input id="e-entry">
+        </div>
+        <div class="field">
+          <label>Timeout (сек)</label>
+          <input id="e-timeout" type="number" min="1" value="60">
+        </div>
+      </div>
+      <div class="row">
+        <div class="field" style="min-width:240px; flex:0 0 260px;">
+          <label style="display:flex; align-items:center; gap:8px; color:var(--text-primary); margin-top:18px;">
+            <input id="e-schedule-enabled" type="checkbox" onchange="toggleScheduleFields('e')" style="width:auto;">
+            Выполнять по расписанию
+          </label>
+        </div>
+        <div class="field">
+          <label>Cron</label>
+          <input id="e-cron" placeholder="*/5 * * * *" disabled>
+        </div>
+      </div>
+      <div>
+        <div id="e-code-area">
+          <label>Код</label>
+          <textarea id="e-code"></textarea>
+          <div style="margin-top:6px; display:flex; gap:6px; flex-wrap:wrap;">
+            <button class="btn ghost" id="e-ai-btn" onclick="aiCheck('e-code','e-lang-hidden','e-ai-result')">&#x1F50D;
+              Проверить синтаксис линтером</button>
+            <button class="btn ghost" id="e-exp-btn" onclick="aiExplain('e-code','e-lang-hidden','e-ai-result')">&#x1F4D6;
+              LLM: Что делает?</button>
+          </div>
+          <div style="margin-top:10px;">
+            <label id="e-deps-label" style="font-size:12px; color:var(--text-secondary); margin-bottom:4px; display:block;">Зависимости (requirements.txt)</label>
+            <textarea id="e-deps" rows="3" placeholder="boto3
+requests>=2.28
+psycopg2-binary" style="width:100%; box-sizing:border-box; font-family:monospace; font-size:12px; background:#1a1a2e; border:1px dashed #3a3a5c; border-radius:4px; color:#cdd6f4; padding:6px 8px; resize:none; overflow-y:auto;"></textarea>
+          </div>
+        </div>
+        <div id="e-archive-area" style="display:none;">
+          <div id="e-archive-current" style="margin-bottom:10px; padding:8px 12px; background:var(--bg-alt); border-radius:6px; font-size:13px; color:var(--text-secondary);">
+            📦 <span id="e-archive-name"></span>
+          </div>
+          <label style="font-size:12px; color:var(--text-secondary); margin-bottom:4px; display:block;">Заменить архив (необязательно)</label>
+          <input type="file" id="e-archive-file" accept=".zip" style="display:block; margin-bottom:8px; color:var(--text-primary);">
+          <div style="display:flex; gap:6px; flex-wrap:wrap;">
+            <button id="e-lint-btn" class="btn ghost" onclick="lintArchiveFile('e')">&#x1F50D; Проверка архива линтером</button>
+            <button id="e-explain-archive-btn" class="btn ghost" onclick="explainArchiveFile('e')">&#x1F4D6; LLM: Что делает?</button>
+          </div>
+        </div>
+        <div id="e-ai-result"
+          style="display:none;margin-top:8px;padding:10px 12px;border-radius:6px;font-size:13px;line-height:1.5;white-space:pre-wrap;font-family:monospace;">
+        </div>
+      </div>
+
+      <!-- Переменные окружения -->
+      <div style="margin-top:16px;">
+        <div style="font-weight:600; margin-bottom:8px; font-size:13px;">Переменные окружения</div>
+        <div id="e-tf-env-warn" style="display:none; margin-bottom:8px; padding:6px 10px; background:#553300; color:#ffa; border-radius:4px; font-size:12px;">
+          ⚠️ Функция управляется Terraform — переменные только для чтения
+        </div>
+        <div id="e-envvars-list" style="display:flex; flex-direction:column; gap:4px; margin-bottom:8px;"></div>
+        <button id="e-add-envvar-btn" class="btn ghost" style="font-size:12px;" onclick="addEnvVarRow('e')">+ Добавить переменную</button>
+      </div>
+
+      <div id="e-error-msg" style="display:none;color:#f66;font-size:0.85rem;margin-bottom:8px;"></div>
+
+      <div id="e-clone-area" style="display:none;margin-top:10px;padding:10px 12px;background:var(--bg-alt,#2a2a3a);border-radius:6px;border:1px solid var(--border,#444);">
+        <div style="font-size:0.82rem;color:var(--fg-muted,#aaa);margin-bottom:6px;">Имя новой функции (копии):</div>
+        <div style="display:flex;gap:8px;align-items:center;">
+          <input id="e-clone-name" placeholder="new-function-name" style="flex:1;font-size:0.85rem;">
+          <button class="btn" onclick="submitClone()">Клонировать</button>
+          <button class="btn ghost" onclick="toggleCloneArea(false)">✕</button>
+        </div>
+        <div id="e-clone-error" style="display:none;color:#f66;font-size:0.78rem;margin-top:5px;"></div>
+      </div>
+
+      <div class="actions">
+        <button class="btn ghost" onclick="toggleCloneArea(true)" title="Создать копию функции">📋 Клон</button>
+        <button class="btn ghost" onclick="closeEdit()">Отмена</button>
+        <button id="e-submit" class="btn" onclick="submitEdit()">Сохранить</button>
+      </div>
+    </div>
+  </div>
+
+  <div id="info-modal" class="modal">
+    <div class="panel" style="width:560px; max-width:95vw;">
+      <h3 id="info-title">Информация о функции</h3>
+      <table class="info-table">
+        <tbody id="info-rows"></tbody>
+      </table>
+      <div class="actions" style="margin-top:14px;">
+        <button class="btn ghost" onclick="closeInfo()">Закрыть</button>
+      </div>
+    </div>
+  </div>
+
+  <div id="logs-modal" class="modal">
+    <div class="panel" style="width:700px; max-width:95vw;">
+      <h3 id="logs-title">Логи функции</h3>
+      <textarea id="logs-output" readonly
+        style="width:100%; height:340px; font-family:monospace; font-size:12px; background:var(--bg-alt); color:var(--text-primary); border:1px solid var(--border); border-radius:6px; padding:10px; resize:vertical; white-space:pre;"></textarea>
+      <div class="actions">
+        <button class="btn ghost" onclick="closeLogs()">Закрыть</button>
+        <button class="btn ghost" onclick="refreshLogs()">Обновить</button>
+      </div>
+    </div>
+  </div>
+
+  <div id="help-modal" class="modal">
+    <div class="panel">
+      <h3>Help</h3>
+
+      <div class="help-section">
+        <h4>Поля при создании функции</h4>
+        <div class="help-list">
+          <div><strong>Name</strong> — имя Function в Fission. Используется в CRD и в связанных объектах.</div>
+          <div><strong>Language</strong> — язык runtime. От него зависят environment, шаблон кода и entrypoint по
+            умолчанию.</div>
+          <div><strong>Entrypoint</strong> — точка входа внутри пакета. Например, <span class="mono">main.main</span>
+            для Python или <span class="mono">main.php::handler</span> для PHP.</div>
+          <div><strong>Route</strong> — HTTP путь функции. Внешний пользовательский вызов идёт через <span
+              class="mono">/fn + ваш Route</span>.</div>
+          <div><strong>Методы</strong> — HTTP методы route, например <span class="mono">GET</span> или <span
+              class="mono">GET,POST</span>.</div>
+          <div><strong>Timeout (сек)</strong> — максимум времени выполнения именно этой функции.</div>
+          <div><strong>Код</strong> — исходный код функции.</div>
+        </div>
+      </div>
+
+      <div class="help-section">
+        <h4>Поля при редактировании функции</h4>
+        <div class="help-list">
+          <div><strong>Name</strong> — только для просмотра, не редактируется.</div>
+          <div><strong>Environment</strong> — только для просмотра, не редактируется из этой формы.</div>
+          <div><strong>Entrypoint</strong> — только для просмотра, не редактируется из этой формы.</div>
+          <div><strong>Timeout (сек)</strong> — редактируется и сохраняется в <span
+              class="mono">spec.functionTimeout</span>.</div>
+          <div><strong>Код</strong> — редактируется и обновляет Package функции.</div>
+        </div>
+      </div>
+
+      <div class="help-section">
+        <h4>Переменные окружения функции</h4>
+        <div class="help-list">
+          <div>В редакторе функции (кнопка <strong>Ред.</strong>) есть раздел <strong>Переменные окружения</strong>.</div>
+          <div>Нажмите <strong>+ Добавить</strong> чтобы задать переменную: введите имя и значение, нажмите <strong>Сохранить env vars</strong>.</div>
+          <div>Переменные доступны внутри функции через <span class="mono">os.environ</span> (Python), <span class="mono">process.env</span> (Node.js), <span class="mono">os.Getenv</span> (Go) и т.д.</div>
+          <div>Изменения применяются к запущенному поду функции сразу после сохранения.</div>
+        </div>
+      </div>
+
+      <div class="help-section">
+        <h4>Клонирование функции</h4>
+        <div class="help-list">
+          <div>В редакторе функции (кнопка <strong>Ред.</strong>) есть кнопка <strong>📋 Клон</strong> в нижней панели.</div>
+          <div>Введите имя для новой функции и нажмите <strong>Клонировать</strong>.</div>
+          <div>Клон получает тот же код, язык, entrypoint, timeout и env vars. Маршрут назначается автоматически.</div>
+          <div>Имя: строчные буквы, цифры, дефис; не начинается и не заканчивается дефисом; до 57 символов.</div>
+        </div>
+      </div>
+
+      <div class="help-section">
+        <h4>Как вызвать функцию вне веб-интерфейса</h4>
+        <div class="help-list">
+          <div>Функции доступны через <span class="mono">/fn/...</span> с вашим токеном или демо-логином в заголовке <span class="mono">Authorization: Bearer</span>.</div>
+          <div>Gateway может возвращать редирект — используйте флаг <span class="mono">-L</span> в curl для его автоматического следования.</div>
+          <div>Работают обычные HTTP методы: <span class="mono">GET</span>, <span class="mono">POST</span>, <span
+              class="mono">PUT</span>, <span class="mono">DELETE</span> и другие, если они разрешены в поле Методы.
+          </div>
+        </div>
+        <div class="help-code">export TOKEN="&lt;токен или демо-логин&gt;"
+          curl -skL -X POST https://fission.kube5s.ru/fn/ВАШ_ROUTE \
+          -H "Authorization: Bearer $TOKEN" \
+          -H "Content-Type: application/json" \
+          -d '{"x":1,"y":2}'</div>
+        <div class="help-code">export TOKEN="&lt;токен или демо-логин&gt;"
+          curl -skL https://fission.kube5s.ru/fn/ВАШ_ROUTE \
+          -H "Authorization: Bearer $TOKEN"</div>
+        <div class="help-code">import requests
+
+          token = "ВАШ_ТОКЕН"
+          url = "https://fission.kube5s.ru/fn/ВАШ_ROUTE"
+
+          response = requests.post(
+          url,
+          headers={"Authorization": f"Bearer {token}"},
+          json={"x": 1, "y": 2},
+          timeout=60,
+          )
+
+          print(response.status_code)
+          print(response.text)</div>
+      </div>
+
+      <div class="help-section">
+        <h4>Где взять токен</h4>
+        <div class="help-list">
+          <div><strong>Токен из ЛК</strong> — Профиль пользователя → Токены. Подходит и для входа в console, и для вызова через <span class="mono">/fn/</span>.</div>
+          <div><strong>Демо-логин</strong> — любая строка не менее 6 символов. Тот же логин даёт тот же namespace — ваше окружение сохраняется.</div>
+          <div>Токен удобно класть в переменную окружения и потом подставлять в curl как <span
+              class="mono">$TOKEN</span>.</div>
+        </div>
+        <div class="help-code">export TOKEN="&lt;вставьте сюда токен или демо-логин&gt;"</div>
+      </div>
+
+      <div class="actions" style="justify-content:space-between; align-items:center;">
+        <span style="font-size:0.75rem; color:var(--text-secondary);">v1.3.96</span>
+        <button class="btn ghost" onclick="closeHelp()">Закрыть</button>
+      </div>
+    </div>
+  </div>
+
+  <div id="invoke-modal" class="modal">
+    <div class="panel">
+      <h3 id="i-title">Вызов</h3>
+      <div>
+        <label>JSON тело запроса</label>
+        <textarea id="i-body">{"name":"world"}</textarea>
+      </div>
+      <div class="actions">
+        <button class="btn ghost" onclick="closeInvoke()">Отмена</button>
+        <button id="i-submit" class="btn" onclick="submitInvoke()">Вызвать</button>
+      </div>
+      <div id="i-status" style="margin-top:8px;font-size:13px;color:var(--text-secondary);min-height:20px;"></div>
+      <div id="i-meta"
+        style="display:none;margin-top:8px;background:#101c2b;border:1px solid var(--border);border-radius:6px;padding:10px 12px;font-size:13px;color:#d8e5f2;white-space:pre-wrap;">
+      </div>
+      <div style="margin-top:6px;">
+        <label>Response</label>
+        <textarea id="i-resp" readonly style="min-height:160px;"></textarea>
+      </div>
+    </div>
+  </div>
+
+  <script>
+    const API_BASE = window.location.pathname.startsWith('/console') ? '/console/api' : '/api';
+
+    const S = {
+      envs: [],
+      fns: [],
+      httpTriggers: [],
+      timeTriggers: [],
+      currentEdit: null,
+      currentInvoke: null
+    };
+
+    checkAuth();
+  </script>
+
+  <!-- ================================================================
+       ai/ask feature — удалить весь блок до "end ai/ask feature"
+       ================================================================ -->
+  <div id="assistant-panel" style="
+    position:fixed; bottom:0; right:24px;
+    width:720px; background:#1e1e2e; border:1px solid #3a3a5c;
+    border-bottom:none; border-radius:8px 8px 0 0;
+    font-family:inherit; z-index:900; box-shadow:0 -2px 12px rgba(0,0,0,.4);
+  ">
+    <div id="assistant-header" onclick="toggleAssistant()" style="
+      display:flex; align-items:center; justify-content:space-between;
+      padding:8px 12px; cursor:pointer; background:#2a2a42; border-radius:8px 8px 0 0;
+      user-select:none;
+    ">
+      <span style="font-weight:600; font-size:.85rem;">💬 LLM Ассистент</span>
+      <span id="assistant-toggle-icon" style="font-size:.75rem; opacity:.7;">▲</span>
+    </div>
+    <div id="assistant-body" style="padding:10px; display:flex; flex-direction:column; gap:8px;">
+      <div id="assistant-messages" style="
+        min-height:80px; max-height:400px; overflow-y:auto;
+        font-size:.82rem; line-height:1.5; color:#cdd6f4;
+        background:#13131f; border-radius:4px; padding:8px;
+        white-space:pre-wrap; word-break:break-word;
+      ">Чем могу помочь?</div>
+      <div style="display:flex; gap:6px;">
+        <input id="assistant-input" type="text" placeholder="Введи вопрос..." style="flex:1; background:#2a2a42; border:1px solid #3a3a5c; border-radius:4px;
+            color:#cdd6f4; padding:6px 8px; font-size:.82rem; outline:none;"
+          onkeydown="if(event.key==='Enter')askAssistant()" />
+        <button onclick="askAssistant()" style="
+          background:#7c3aed; color:#fff; border:none; border-radius:4px;
+          padding:6px 12px; cursor:pointer; font-size:.82rem; white-space:nowrap;
+        ">→</button>
+      </div>
+    </div>
+  </div>
+
+</body>
+
+</html>

client-console/ui/js/ai.js

@@ -0,0 +1,207 @@
+/* ai.js — AI/LLM функции: проверка, генерация, объяснение, ассистент */
+
+// PYTHON_STDLIB — стандартная библиотека Python (не требуют pip install).
+var PYTHON_STDLIB = new Set([
+  'os','sys','json','time','re','math','io','collections','itertools','functools',
+  'datetime','pathlib','urllib','http','threading','asyncio','logging','random',
+  'string','struct','hashlib','hmac','base64','uuid','copy','abc','typing',
+  'dataclasses','contextlib','enum','warnings','traceback','inspect','importlib',
+  'subprocess','socket','ssl','email','html','xml','csv','sqlite3','unittest',
+  'gc','weakref','array','queue','heapq','bisect','decimal','fractions',
+  'statistics','textwrap','difflib','shutil','glob','fnmatch','tempfile',
+  'zipfile','tarfile','gzip','bz2','lzma','pickle','shelve','codecs',
+  'unicodedata','ast','dis','types','builtins','operator','numbers','cmath',
+  'pprint','reprlib','platform','signal','mmap','ctypes','multiprocessing',
+  'concurrent','select','selectors','errno','atexit','sched','calendar',
+  'locale','gettext','argparse','getopt','shlex','configparser','tokenize',
+  'runpy','pkgutil','site','sysconfig','distutils','zipimport','abc','io',
+  '__future__','_thread','threading','contextvars','netrc','plistlib',
+  'html','xml','http','urllib','email','mailbox','mimetypes','encodings',
+  'codecs','unicodedata','readline','rlcompleter','curses','idlelib','tkinter',
+]);
+
+// detectExternalPythonImports — возвращает список модулей, которых нет в stdlib.
+function detectExternalPythonImports(code) {
+  var external = [];
+  var seen = {};
+  var patterns = [/^import\s+([\w]+)/gm, /^from\s+([\w]+)/gm];
+  for (var pi = 0; pi < patterns.length; pi++) {
+    var m;
+    while ((m = patterns[pi].exec(code)) !== null) {
+      var mod = m[1];
+      if (!PYTHON_STDLIB.has(mod) && !seen[mod]) {
+        seen[mod] = true;
+        external.push(mod);
+      }
+    }
+  }
+  return external;
+}
+
+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';
+    var resultText = data.result || '(пустой ответ)';
+
+    // Для Python: проверяем внешние импорты vs поле зависимостей
+    if (lang === 'python') {
+      var depsId = codeId.replace('-code', '-deps'); // cc-code→cc-deps, e-code→e-deps
+      var depsEl = document.getElementById(depsId);
+      var depsVal = depsEl ? depsEl.value.trim() : '';
+      var external = detectExternalPythonImports(code);
+      if (external.length > 0 && !depsVal) {
+        resultText += '\n\n⚠️ Внешние библиотеки: ' + external.join(', ') +
+          '\nДобавьте их в поле "Зависимости (requirements.txt)" или убедитесь что они уже есть в Python-окружении.';
+        if (data.ok) {
+          resEl.style.background = '#3a2a00';
+          resEl.style.color = '#ffa';
+        }
+      }
+    }
+
+    resEl.textContent = resultText;
+  } 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(prefix) {
+  prefix = prefix || 'cc';
+  var el = document.getElementById(prefix + '-gen-prompt');
+  el.style.display = 'flex';
+  document.getElementById(prefix + '-gen-desc').focus();
+}
+
+async function aiGenerate(prefix) {
+  prefix = prefix || 'cc';
+  var name = (document.getElementById(prefix + '-name').value || '').trim() || 'my-func';
+  var lang = document.getElementById(prefix + '-lang').value || 'python';
+  var desc = (document.getElementById(prefix + '-gen-desc').value || '').trim();
+  if (!desc) { document.getElementById(prefix + '-gen-desc').focus(); return; }
+  var btn = document.getElementById(prefix + '-gen-btn');
+  var resEl = document.getElementById(prefix + '-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(prefix + '-code').value = addLLMWarning(code, lang);
+    document.getElementById(prefix + '-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: Что делает?';
+  }
+}

client-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;
+}

client-console/ui/js/app.js

@@ -0,0 +1,126 @@
+/* app.js — основная логика: загрузка данных, таблица функций */
+
+async function reloadAll() {
+  const progress = startTimedStatus('Загрузка...', 'Загрузка данных', null);
+
+  // Показываем таблицу сразу с placeholder'ом
+  document.getElementById('fn-rows').innerHTML =
+    '<tr><td colspan="8" 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')
+    ]);
+
+    // MQ-триггеры загружаем параллельно, не блокируем основную таблицу
+    if (typeof loadMQTriggers === 'function') loadMQTriggers();
+
+    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 entrypoint = (spec.package && spec.package.functionName) || '-';
+      const timeout = spec.functionTimeout || 60;
+      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;
+      const sourceType = ann['fission-console/source-type'] || 'code';
+      const status = ann['fission-console/status'] || 'Cold';
+      
+      // Статус функции: иконка и цвет
+      const statusColor = {
+        'Ready': '#2a2', 'Cold': '#22a', 'Building': '#aa2', 'Error': '#a22'
+      }[status] || '#666';
+      const statusTitle = {
+        'Ready': 'Готова (есть pod)', 
+        'Cold': 'Холодная (pod создаётся при первом вызове)',
+        'Building': 'Собирается / деплоится',
+        'Error': 'Ошибка (pod в CrashLoopBackOff или build failed)'
+      }[status] || 'Неизвестно';
+      const statusDot = '<span style="display:inline-block; width:12px; height:12px; border-radius:50%; background:' + statusColor + '; cursor:default;" title="' + h(statusTitle) + '"></span>';
+      
+      const sourceIcon = sourceType === 'archive'
+        ? '<span title="Из архива (.zip)" style="font-size:1.1em; cursor:default;">📦</span>'
+        : '<span title="Из кода (редактор)" style="font-size:1.1em; cursor:default;">📝</span>';
+      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> ' : '';
+      // Сохраняем все данные в data-атрибуте для openInfo (избегаем повторного запроса)
+      var infoData = h(JSON.stringify({
+        name: name, env: env, pkg: pkg, entrypoint: entrypoint, timeout: timeout,
+        route: route, methods: methods, sourceType: sourceType,
+        createdAt: createdAt, updatedAt: updatedAt, cron: cron, status: status
+      }));
+      var actions = tfBadge +
+        '<button class="btn ghost" onclick="openInfo(\'' + h(name) + '\', this)" data-info="' + infoData + '">Info</button> ' +
+        '<button class="btn ghost" onclick="openEdit(\'' + h(name) + '\')">Ред.</button> ' +
+        '<button class="btn ghost" onclick="openInvoke(\'' + h(name) + '\')">Вызов</button> ' +
+        '<button class="btn ghost" onclick="openLogs(\'' + h(name) + '\')">Логи</button> ' +
+        '<button class="btn danger" onclick="removeFn(\'' + h(name) + '\')">Удалить</button>';
+      return '<tr>' +
+        '<td class="mono">' + h(name) + '</td>' +
+        '<td style="text-align:center;">' + statusDot + '</td>' +
+        '<td style="text-align:center;">' + sourceIcon + '</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="8">Нет функций</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="8">Load error: ' + e.message + '</td></tr>';
+    progress.stop('Ошибка загрузки: ' + e.message, 'err');
+  }
+}

client-console/ui/js/auth.js

@@ -0,0 +1,126 @@
+/* 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();
+}
+
+async function openAnalytics() {
+  var token = localStorage.getItem('auth_token');
+  var env = localStorage.getItem('auth_env') || 'test';
+  if (!token) { alert('Требуется авторизация'); return; }
+  try {
+    var r = await fetch(API_BASE + '/stats/dashboard-url', {
+      headers: { 'X-Auth-Token': token, 'X-Auth-Env': env }
+    });
+    if (!r.ok) throw new Error('HTTP ' + r.status);
+    var d = await r.json();
+    if (d.url) {
+      window.open(d.url, '_blank', 'noopener');
+    } else {
+      // Grafana не настроена или org ещё провизируется — ссылка на оператора
+      window.open('/grafana/', '_blank', 'noopener');
+    }
+  } catch (e) {
+    alert('Аналитика временно недоступна: ' + e.message);
+  }
+}
+
+function checkAuth() {
+  var storedToken = localStorage.getItem('auth_token');
+  if (!storedToken) {
+    showLoginOverlay();
+    return;
+  }
+  setUserAvatar(storedToken);
+  hideLoginOverlay();
+  reloadAll();
+}

client-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'
+  }
+};

client-console/ui/js/fn-archive.js

@@ -0,0 +1,86 @@
+/* fn-archive.js — создание функции из архива (независимый модуль) */
+
+function onLangChangeArchive() {
+  var lang = document.getElementById('ca-lang').value;
+  var t = LANG_TEMPLATES[lang];
+  if (t) {
+    document.getElementById('ca-entry').value = t.entrypoint;
+  }
+}
+
+function openCreateArchive() {
+  document.getElementById('ca-lang').value = 'python';
+  onLangChangeArchive();
+  document.getElementById('ca-name').value = '';
+  document.getElementById('ca-route').value = '';
+  document.getElementById('ca-methods').value = 'GET';
+  document.getElementById('ca-timeout').value = '60';
+  document.getElementById('ca-schedule-enabled').checked = false;
+  document.getElementById('ca-cron').value = '';
+  toggleScheduleFields('ca');
+  var fileInput = document.getElementById('ca-archive-file');
+  if (fileInput) fileInput.value = '';
+  var aiRes = document.getElementById('ca-ai-result');
+  if (aiRes) { aiRes.style.display = 'none'; aiRes.textContent = ''; }
+  hideModalError('ca-error');
+  document.getElementById('create-archive-modal').classList.add('open');
+  document.getElementById('ca-name').focus();
+}
+
+function closeCreateArchive() {
+  document.getElementById('create-archive-modal').classList.remove('open');
+}
+
+async function submitCreateArchive() {
+  const btn = document.getElementById('ca-submit');
+  btn.disabled = true;
+  const progress = startTimedStatus('Создаём функцию...', 'Создание функции...', explainDelay);
+  try {
+    const name = document.getElementById('ca-name').value.trim();
+    if (!name) throw new Error('name is required');
+    const lang = document.getElementById('ca-lang').value.trim();
+    if (!lang) throw new Error('language is required');
+    const archiveFile = document.getElementById('ca-archive-file').files[0];
+    if (!archiveFile) throw new Error('выберите .zip архив');
+    if (!archiveFile.name.toLowerCase().endsWith('.zip')) throw new Error('файл должен быть .zip архивом, не .' + archiveFile.name.split('.').pop());
+
+    var fd = new FormData();
+    fd.append('name', name);
+    fd.append('language', lang);
+    fd.append('entrypoint', document.getElementById('ca-entry').value.trim());
+    fd.append('route', document.getElementById('ca-route').value.trim());
+    fd.append('methods', document.getElementById('ca-methods').value.trim());
+    fd.append('timeout', String(parseTimeout(document.getElementById('ca-timeout').value)));
+    fd.append('archive', archiveFile);
+
+    var resp = await fetch(API_BASE + '/functions', {
+      method: 'POST',
+      headers: authHeaders(),
+      body: fd
+    });
+    if (!resp.ok) {
+      var e = await resp.json().catch(() => ({}));
+      throw new Error(e.error || resp.statusText);
+    }
+
+    try {
+      await syncScheduleForFunction(name, 'ca');
+    } catch (scheduleErr) {
+      try {
+        await requestJSON(API_BASE + '/functions/' + encodeURIComponent(name), 'DELETE');
+      } catch (rollbackErr) {
+        scheduleErr.message += '; rollback failed: ' + rollbackErr.message;
+      }
+      throw scheduleErr;
+    }
+
+    closeCreateArchive();
+    progress.stop('Функция создана: ' + name, 'ok');
+    await reloadAll();
+  } catch (e) {
+    progress.stop('Ошибка создания: ' + e.message, 'err');
+    showModalError('ca-error', 'Ошибка: ' + e.message);
+  } finally {
+    btn.disabled = false;
+  }
+}

client-console/ui/js/fn-code.js

@@ -0,0 +1,92 @@
+/* fn-code.js — создание функции из кода (независимый модуль) */
+
+function onLangChangeCode() {
+  var lang = document.getElementById('cc-lang').value;
+  var t = LANG_TEMPLATES[lang];
+  if (t) {
+    document.getElementById('cc-entry').value = t.entrypoint;
+    document.getElementById('cc-code').value = t.code;
+  }
+  // Обновляем лейбл поля зависимостей под язык
+  var depsLabels = {
+    python:  'Зависимости (requirements.txt)',
+    nodejs:  'Зависимости (package.json dependencies)',
+    php:     'Зависимости (composer.json)',
+    ruby:    'Зависимости (Gemfile)',
+  };
+  var depsPlaceholders = {
+    python:  'boto3\nrequests>=2.28\npsycopg2-binary',
+    nodejs:  'express: ^4.18.2\naxios: ^1.6.0',
+    php:     '{\n  "require": {\n    "guzzlehttp/guzzle": "^7.0"\n  }\n}',
+    ruby:    "gem 'httparty'\ngem 'pg'",
+  };
+  var label = document.getElementById('cc-deps-label');
+  var area  = document.getElementById('cc-deps');
+  if (label) label.textContent = depsLabels[lang] || 'Зависимости';
+  if (area)  area.placeholder  = depsPlaceholders[lang] || '';
+}
+
+function openCreateCode() {
+  document.getElementById('cc-lang').value = 'python';
+  onLangChangeCode();
+  document.getElementById('cc-name').value = '';
+  document.getElementById('cc-route').value = '';
+  document.getElementById('cc-methods').value = 'GET';
+  document.getElementById('cc-timeout').value = '60';
+  document.getElementById('cc-deps').value = '';
+  document.getElementById('cc-schedule-enabled').checked = false;
+  document.getElementById('cc-cron').value = '';
+  toggleScheduleFields('cc');
+  var aiRes = document.getElementById('cc-ai-result');
+  if (aiRes) { aiRes.style.display = 'none'; aiRes.textContent = ''; }
+  hideModalError('cc-error');
+  document.getElementById('create-code-modal').classList.add('open');
+  document.getElementById('cc-name').focus();
+}
+
+function closeCreateCode() {
+  document.getElementById('create-code-modal').classList.remove('open');
+}
+
+async function submitCreateCode() {
+  const btn = document.getElementById('cc-submit');
+  btn.disabled = true;
+  const progress = startTimedStatus('Создаём функцию...', 'Создание функции...', explainDelay);
+  try {
+    const name = document.getElementById('cc-name').value.trim();
+    if (!name) throw new Error('name is required');
+    const lang = document.getElementById('cc-lang').value.trim();
+    if (!lang) throw new Error('language is required');
+
+    await requestJSON(API_BASE + '/functions', 'POST', {
+      name: name,
+      language: lang,
+      entrypoint: document.getElementById('cc-entry').value.trim(),
+      route: document.getElementById('cc-route').value.trim(),
+      methods: parseMethods(document.getElementById('cc-methods').value),
+      timeout: parseTimeout(document.getElementById('cc-timeout').value),
+      code: document.getElementById('cc-code').value,
+      deps: document.getElementById('cc-deps').value.trim(),
+    });
+
+    try {
+      await syncScheduleForFunction(name, 'cc');
+    } catch (scheduleErr) {
+      try {
+        await requestJSON(API_BASE + '/functions/' + encodeURIComponent(name), 'DELETE');
+      } catch (rollbackErr) {
+        scheduleErr.message += '; rollback failed: ' + rollbackErr.message;
+      }
+      throw scheduleErr;
+    }
+
+    closeCreateCode();
+    progress.stop('Функция создана: ' + name, 'ok');
+    await reloadAll();
+  } catch (e) {
+    progress.stop('Ошибка создания: ' + e.message, 'err');
+    showModalError('cc-error', 'Ошибка: ' + e.message);
+  } finally {
+    btn.disabled = false;
+  }
+}