Merged main into release while building v2.0.11

Merged main into release while building v2.0.10
2025-11-16 17:49:55 +00:00 · 2025-10-28 17:30:35 +06:00 · 2025-10-28 16:58:58 +06:00 · 2025-10-28 16:07:20 +06:00 · 2025-10-28 15:12:13 +06:00 · 2025-10-28 14:52:58 +06:00
37 changed files with 112 additions and 2091 deletions
--- a/.goreleaser.yaml
+++ b/.goreleaser.yaml
@@ -1,32 +0,0 @@
 # Goreleaser configuration version 2
 version: 2
 builds:
  - id: lcg
    binary: "lcg_{{ .Version }}"
    goos:
      - linux
      - windows
      - darwin
    goarch:
      - amd64
      - arm64
    env:
      - CGO_ENABLED=0
    ldflags:
      - -s -w
      - -X main.version={{.Version}}
      - -X main.commit={{.Commit}}
      - -X main.date={{.Date}}
    main: .
    dir: .
 archives:
  - id: lcg
    ids:
      - lcg
    formats:
      - binary
    name_template: "{{ .Binary }}_{{ .Os }}_{{ .Arch }}"
    files:
      - "lcg_{{ .Version }}"
--- a/CHANGELOG.txt
+++ b/CHANGELOG.txt
@@ -1,36 +1,6 @@
 CHANGELOG
 =========
 Версия 2.0.6 (2025-10-28)
 =========================
 ## ✨ НОВОЕ И ИЗМЕНЕНО
 - 🌐 Поддержка BasePath для всех веб‑роутов и шаблонов
  - Новый параметр: `LCG_BASE_URL` (пример: `/lcg`) — префикс для всех страниц и API
  - Обновлены редиректы и middleware с учетом BasePath
 - 🧭 Кастомная страница 404 (красная тема), показывается для любого неизвестного пути под BasePath
 - 📱 Улучшена мобильная верстка результатов — стиль карточек как в истории
 - 🗂️ Человекочитаемые заголовки результатов: преобразование имени файла в «заголовок — дата время»
 - 🗑️ Иконки удаления: единый бледно‑красный крест ✖ в результатах и истории
 ## 🐛 ИСПРАВЛЕНИЯ
 - 🛡️ Исправлен просмотр/удаление файла при включенном BasePath (правильный разбор URL)
 - 🧰 На старте сервера гарантируется создание `ResultFolder` и пустого `ResultHistory` (без 500)
 - 🚧 Главная страница обрабатывается только по точному пути BasePath, а не по произвольным под‑путям
 ## ⚙️ КОНФИГУРАЦИЯ
 - 🔍 Debug режим теперь включается и флагом `--debug`, и переменной `LCG_DEBUG=1|true`
 - 🍪 Уточнена работа с `CookiePath`/`BasePath` в middleware
 ## 📚 ДОКУМЕНТАЦИЯ
 - Обновлены `README.md`, `USAGE_GUIDE.md`, `API_GUIDE.md`, `REVERSE_PROXY_GUIDE.md` — добавлены примеры с BasePath и примечания к 404
 ---
 Версия 2.0.1 (2025-10-22)
 =========================
--- a/Dockerfiles/OllamaServer/.dockerignore
+++ b/Dockerfiles/OllamaServer/.dockerignore
@@ -1,52 +0,0 @@
 # Git
 .git
 .gitignore
 .gitattributes
 # Build artifacts
 dist/
 *.exe
 *.dll
 *.so
 *.dylib
 lcg
 go-lcg
 # IDE
 .idea/
 .vscode/
 *.swp
 *.swo
 *~
 # Documentation
 docs/
 *.md
 !README.md
 # Tests
 *_test.go
 test_*.sh
 # Deployment scripts
 deploy/
 shell-code/
 kustomize/
 # Temporary files
 *.log
 *.tmp
 *.temp
 # OS files
 .DS_Store
 Thumbs.db
 # Go
 vendor/
 # Docker
 Dockerfile*
 docker-compose*.yml
 .dockerignore
--- a/Dockerfiles/OllamaServer/.gitignore
+++ b/Dockerfiles/OllamaServer/.gitignore
@@ -1,15 +0,0 @@
 # Временные файлы
 *.log
 *.tmp
 *.temp
 # IDE
 .idea/
 .vscode/
 *.swp
 *.swo
 # OS files
 .DS_Store
 Thumbs.db
--- a/Dockerfiles/OllamaServer/Dockerfile
+++ b/Dockerfiles/OllamaServer/Dockerfile
@@ -1,93 +0,0 @@
 # Используем готовый образ Ollama
 FROM localhost/ollama_packed:latest
 RUN apt-get update && apt-get install -y --no-install-recommends bash && apt-get install -y --no-install-recommends curl \
 && apt-get install -y --no-install-recommends jq && apt-get install -y --no-install-recommends wget 
 # Устанавливаем bash если его нет (базовый образ ollama может быть на разных дистрибутивах)
 RUN if ! command -v bash >/dev/null 2>&1; then \
        if command -v apk >/dev/null 2>&1; then \
            apk add --no-cache bash; \
        elif command -v apt-get >/dev/null 2>&1; then \
            apt-get update && apt-get install -y --no-install-recommends bash && rm -rf /var/lib/apt/lists/*; \
        fi; \
    fi
 # Определяем архитектуру для копирования правильного бинарника
 ARG TARGETARCH
 ARG TARGETOS=linux
 # Копируем папку dist с бинарниками
 # Структура: dist/lcg_linux_amd64_v1/lcg_* или dist/lcg_linux_arm64_v8.0/lcg_*
 COPY dist/ /tmp/dist/
 # Выбираем правильный бинарник в зависимости от архитектуры
 # Если TARGETARCH не установлен, определяем архитектуру через uname
 RUN ARCH="${TARGETARCH:-$(uname -m)}" && \
    case "${ARCH}" in \
    amd64|x86_64) \
        BIN_FILE=$(find /tmp/dist/lcg_linux_amd64_v* -name "lcg_*" -type f 2>/dev/null | head -1) && \
        if [ -n "$BIN_FILE" ]; then \
            cp "$BIN_FILE" /usr/local/bin/lcg && \
            echo "Установлен бинарник для amd64: $BIN_FILE"; \
        else \
            echo "Бинарник для amd64 не найден в /tmp/dist/" && exit 1; \
        fi ;; \
    arm64|aarch64|arm) \
        BIN_FILE=$(find /tmp/dist/lcg_linux_arm64_v* -name "lcg_*" -type f 2>/dev/null | head -1) && \
        if [ -n "$BIN_FILE" ]; then \
            cp "$BIN_FILE" /usr/local/bin/lcg && \
            echo "Установлен бинарник для arm64: $BIN_FILE"; \
        else \
            echo "Бинарник для arm64 не найден в /tmp/dist/" && exit 1; \
        fi ;; \
    *) \
        echo "Unsupported architecture: ${ARCH}" && \
        echo "Доступные бинарники:" && \
        find /tmp/dist -name "lcg_*" -type f 2>/dev/null && \
        exit 1 ;; \
    esac && \
    chmod +x /usr/local/bin/lcg && \
    rm -rf /tmp/dist && \
    (lcg --version || echo "Бинарник lcg установлен")
 # Копируем entrypoint скрипт
 COPY --chmod=755 Dockerfiles/OllamaServer/entrypoint.sh /entrypoint.sh
 # Создаем директории для данных LCG
 # В базовом образе ollama уже есть пользователь ollama
 RUN mkdir -p /app/data/results /app/data/prompts /app/data/config
 # Устанавливаем права доступа (пользователь ollama должен существовать в базовом образе)
 RUN chown -R ollama:ollama /app/data 2>/dev/null || \
    (chown -R 1000:1000 /app/data 2>/dev/null || true)
 # Настройки по умолчанию
 ENV TZ='Asia/Omsk'
 RUN ln -snf /usr/share/zoneinfo/$TZ /etc/localtime && echo $TZ > /etc/timezone
 ENV LCG_PROVIDER=ollama
 ENV LCG_HOST=http://127.0.0.1:11434/
 ENV LCG_MODEL=qwen2.5-coder:1.5b
 ENV LCG_RESULT_FOLDER=/app/data/results
 ENV LCG_PROMPT_FOLDER=/app/data/prompts
 ENV LCG_CONFIG_FOLDER=/app/data/config
 ENV LCG_SERVER_HOST=0.0.0.0
 ENV LCG_SERVER_PORT=8080
 ENV LCG_DOMAIN="remote.ollama-server.ru"
 ENV LCG_COOKIE_PATH="/lcg"
 # ENV LCG_FORCE_NO_CSRF=true
 # ENV LCG_SERVER_ALLOW_HTTP=true
 # ENV OLLAMA_HOST=127.0.0.1
 # ENV OLLAMA_PORT=11434
 # Expose порты
 EXPOSE 8080
 WORKDIR /home/ollama
 # Запускаем entrypoint
 ENTRYPOINT ["/entrypoint.sh"]
 CMD []
--- a/Dockerfiles/OllamaServer/Makefile
+++ b/Dockerfiles/OllamaServer/Makefile
@@ -1,141 +0,0 @@
 .PHONY: build build-podman run run-podman stop stop-podman logs logs-podman clean help
 # Переменные
 IMAGE_NAME = lcg-ollama
 IMAGE_TAG = latest
 CONTAINER_NAME = lcg-ollama
 DOCKERFILE = Dockerfile
 CONTEXT = ../..
 help: ## Показать справку
 	@echo "Доступные команды:"
 	@echo "  make build          - Собрать Docker образ"
 	@echo "  make build-podman   - Собрать Podman образ"
 	@echo "  make run            - Запустить контейнер (Docker)"
 	@echo "  make run-podman     - Запустить контейнер (Podman)"
 	@echo "  make stop           - Остановить контейнер (Docker)"
 	@echo "  make stop-podman    - Остановить контейнер (Podman)"
 	@echo "  make logs           - Показать логи (Docker)"
 	@echo "  make logs-podman    - Показать логи (Podman)"
 	@echo "  make clean          - Удалить контейнер и образ"
 	@echo "  make compose-up     - Запустить через docker-compose"
 	@echo "  make compose-down   - Остановить docker-compose"
 	@echo "  make podman-compose-up   - Запустить через podman-compose"
 	@echo "  make podman-compose-down - Остановить podman-compose"
 build: ## Собрать Docker образ (требует собранных бинарников в dist/)
 	@echo "⚠️  Убедитесь, что бинарники собраны: goreleaser build --snapshot --clean"
 	docker build -f $(DOCKERFILE) -t $(IMAGE_NAME):$(IMAGE_TAG) $(CONTEXT)
 	@echo "Образ $(IMAGE_NAME):$(IMAGE_TAG) успешно собран"
 build-podman: ## Собрать Podman образ (требует собранных бинарников в dist/)
 	@echo "⚠️  Убедитесь, что бинарники собраны: goreleaser build --snapshot --clean"
 	podman build -f $(DOCKERFILE) -t $(IMAGE_NAME):$(IMAGE_TAG) $(CONTEXT)
 	@echo "Образ $(IMAGE_NAME):$(IMAGE_TAG) успешно собран"
 build-binaries: ## Собрать бинарники перед сборкой образа
 	@echo "Сборка бинарников..."
 	cd $(CONTEXT) && goreleaser build --snapshot --clean
 	@echo "Бинарники собраны в $(CONTEXT)/dist/"
 build-all: build-binaries build ## Собрать бинарники и Docker образ
 	@echo "✅ Все готово!"
 build-all-podman: build-binaries build-podman ## Собрать бинарники и Podman образ
 	@echo "✅ Все готово!"
 run: ## Запустить контейнер (Docker)
 	docker run -d \
 		--name ${CONTAINER_NAME} \
 		-p 8989:8080 \		
 		-v ollama-data:/home/ollama/.ollama \
 		-v lcg-results:/app/data/results \
 		-v lcg-prompts:/app/data/prompts \
 		-v lcg-config:/app/data/config \
 		${IMAGE_NAME}:${IMAGE_TAG} ollama serve
 	@echo "Контейнер ${CONTAINER_NAME} запущен"
 run-podman: ## Запустить контейнер (Podman)
 	echo "Запустить контейнер ${CONTAINER_NAME}"
 	echo "IMAGE_NAME: ${IMAGE_NAME}"
 	echo "IMAGE_TAG: ${IMAGE_TAG}"
 	echo "CONTAINER_NAME: ${CONTAINER_NAME}"
 	podman run -d \
 		--name ${CONTAINER_NAME} \
 		--restart always \
 		-p 8989:8080 \
 		-v ollama-data:/home/ollama/.ollama \
 		-v lcg-results:/app/data/results \
 		-v lcg-prompts:/app/data/prompts \
 		-v lcg-config:/app/data/config \
 		${IMAGE_NAME}:${IMAGE_TAG} ollama serve
 	@echo "Контейнер ${CONTAINER_NAME} запущен"
 run-podman-nodemon: ## Запустить контейнер (Podman) без -d
 	echo "Запустить контейнер ${CONTAINER_NAME}"
 	echo "IMAGE_NAME: ${IMAGE_NAME}"
 	echo "IMAGE_TAG: ${IMAGE_TAG}"
 	echo "CONTAINER_NAME: ${CONTAINER_NAME}"
 	podman run \
 		--name ${CONTAINER_NAME} \
 		--restart always \
 		-p 8989:8080 \
 		-v ollama-data:/home/ollama/.ollama \
 		-v lcg-results:/app/data/results \
 		-v lcg-prompts:/app/data/prompts \
 		-v lcg-config:/app/data/config \
 		${IMAGE_NAME}:${IMAGE_TAG} ollama serve
 	@echo "Контейнер ${CONTAINER_NAME} запущен"
 stop: ## Остановить контейнер (Docker)
 	docker stop $(CONTAINER_NAME) || true
 	docker rm $(CONTAINER_NAME) || true
 	@echo "Контейнер $(CONTAINER_NAME) остановлен и удален"
 stop-podman: ## Остановить контейнер (Podman)
 	podman stop $(CONTAINER_NAME) || true
 	podman rm $(CONTAINER_NAME) || true
 	@echo "Контейнер $(CONTAINER_NAME) остановлен и удален"
 logs: ## Показать логи (Docker)
 	docker logs -f $(CONTAINER_NAME)
 logs-podman: ## Показать логи (Podman)
 	podman logs -f $(CONTAINER_NAME)
 clean: ## Удалить контейнер и образ
 	docker stop $(CONTAINER_NAME) || true
 	docker rm $(CONTAINER_NAME) || true
 	docker rmi $(IMAGE_NAME):$(IMAGE_TAG) || true
 	@echo "Контейнер и образ удалены"
 compose-up: ## Запустить через docker-compose
 	docker-compose up -d
 	@echo "Сервисы запущены через docker-compose"
 compose-down: ## Остановить docker-compose
 	docker-compose down
 	@echo "Сервисы остановлены"
 podman-compose-up: ## Запустить через podman-compose
 	podman-compose -f podman-compose.yml up -d
 	@echo "Сервисы запущены через podman-compose"
 podman-compose-down: ## Остановить podman-compose
 	podman-compose -f podman-compose.yml down
 	@echo "Сервисы остановлены"
 shell: ## Подключиться к контейнеру (Docker)
 	docker exec -it $(CONTAINER_NAME) sh
 shell-podman: ## Подключиться к контейнеру (Podman)
 	podman exec -it $(CONTAINER_NAME) sh
 pull-model: ## Загрузить модель codegeex4 (Docker)
 	docker exec $(CONTAINER_NAME) ollama pull codegeex4
 pull-model-podman: ## Загрузить модель codegeex4 (Podman)
 	podman exec $(CONTAINER_NAME) ollama pull codegeex4
--- a/Dockerfiles/OllamaServer/QUICKSTART.md
+++ b/Dockerfiles/OllamaServer/QUICKSTART.md
@@ -1,185 +0,0 @@
 # 🚀 Быстрый старт - LCG с Ollama
 ## Подготовка
 1. Убедитесь, что у вас установлен Docker или Podman
 2. Клонируйте репозиторий (если еще не сделали)
 3. Соберите бинарники (требуется перед сборкой образа)
 ```bash
 # Из корня проекта
 goreleaser build --snapshot --clean
 # Или используйте скрипт
 ./deploy/4.build-binaries.sh v2.0.15
 ```
 4. Перейдите в папку с Dockerfile
 ```bash
 cd Dockerfiles/OllamaServer
 ```
 ## Запуск с Docker
 ### Вариант 1: Docker Compose (рекомендуется)
 ```bash
 # Важно: убедитесь, что бинарники собраны в ../../dist/
 docker-compose up -d
 ```
 ### Вариант 2: Ручная сборка и запуск
 ```bash
 # Сборка образа (контекст должен быть корень проекта)
 cd ../..  # Переходим в корень проекта
 docker build -f Dockerfiles/OllamaServer/Dockerfile -t lcg-ollama:latest .
 # Запуск контейнера
 docker run -d \
  --name lcg-ollama \
  -p 8080:8080 \
  -p 11434:11434 \
  -v ollama-data:/home/ollama/.ollama \
  -v lcg-results:/app/data/results \
  lcg-ollama:latest
 ```
 ## Запуск с Podman
 ### Вариант 1: Podman Compose
 ```bash
 podman-compose -f podman-compose.yml up -d
 ```
 ### Вариант 2: Ручная сборка и запуск
 ```bash
 # Сборка образа (контекст должен быть корень проекта)
 cd ../..  # Переходим в корень проекта
 podman build -f Dockerfiles/OllamaServer/Dockerfile -t lcg-ollama:latest .
 # Запуск контейнера
 podman run -d \
  --name lcg-ollama \
  -p 8080:8080 \
  -p 11434:11434 \
  -v ollama-data:/home/ollama/.ollama \
  -v lcg-results:/app/data/results \
  lcg-ollama:latest
 ```
 ## Проверка запуска
 ### Проверка логов
 ```bash
 # Docker
 docker logs -f lcg-ollama
 # Podman
 podman logs -f lcg-ollama
 ```
 Дождитесь сообщений:
 - `Ollama сервер готов!`
 - `LCG сервер запущен на http://0.0.0.0:8080`
 ### Проверка доступности
 ```bash
 # Проверка Ollama
 curl http://localhost:11434/api/tags
 # Проверка LCG
 curl http://localhost:8080/
 ```
 ## Загрузка модели
 После запуска контейнера загрузите модель:
 ```bash
 # Docker
 docker exec lcg-ollama ollama pull codegeex4
 # Podman
 podman exec lcg-ollama ollama pull codegeex4
 ```
 Или используйте модель по умолчанию, указанную в переменных окружения.
 ## Доступ к веб-интерфейсу
 Откройте в браузере: http://localhost:8080
 ## Остановка
 ```bash
 # Docker
 docker-compose down
 # Podman
 podman-compose -f podman-compose.yml down
 ```
 Или для ручного запуска:
 ```bash
 # Docker
 docker stop lcg-ollama
 docker rm lcg-ollama
 # Podman
 podman stop lcg-ollama
 podman rm lcg-ollama
 ```
 ## Решение проблем
 ### Порт занят
 Измените порты в docker-compose.yml или команде run:
 ```bash
 -p 9000:8080  # LCG на порту 9000
 -p 11435:11434  # Ollama на порту 11435
 ```
 ### Контейнер не запускается
 Проверьте логи:
 ```bash
 docker logs lcg-ollama
 # или
 podman logs lcg-ollama
 ```
 ### Модель не загружена
 Убедитесь, что модель существует:
 ```bash
 docker exec lcg-ollama ollama list
 # или
 podman exec lcg-ollama ollama list
 ```
 Если модели нет, загрузите её:
 ```bash
 docker exec lcg-ollama ollama pull codegeex4
 # или
 podman exec lcg-ollama ollama pull codegeex4
 ```
 ## Следующие шаги
 - Прочитайте полную документацию в [README.md](README.md)
 - Настройте аутентификацию для продакшена
 - Настройте reverse proxy для HTTPS
 - Загрузите нужные модели Ollama
--- a/Dockerfiles/OllamaServer/README.md
+++ b/Dockerfiles/OllamaServer/README.md
@@ -1,454 +0,0 @@
 # 🐳 LCG с Ollama Server - Docker/Podman контейнер
 Этот образ содержит Linux Command GPT (LCG) и Ollama сервер, работающие вместе в одном контейнере.
 Поддерживается запуск через Docker и Podman.
 ## 📋 Описание
 Контейнер автоматически запускает:
 1 **Ollama сервер** (v0.9.5) на порту 11434
 2 **LCG веб-сервер** на порту 8080
 Ollama используется как провайдер LLM для генерации Linux команд.
 ## 🚀 Быстрый старт
 ### Предварительные требования
 Перед сборкой Docker образа необходимо собрать бинарники:
 ```bash
 # Из корня проекта
 # Используйте goreleaser для сборки бинарников
 goreleaser build --snapshot --clean
 # Или используйте скрипт сборки
 ./deploy/4.build-binaries.sh v2.0.15
 ```
 Убедитесь, что в папке `dist/` есть бинарники:
 - `dist/lcg_linux_amd64_v1/lcg_*` для amd64
 - `dist/lcg_linux_arm64_v8.0/lcg_*` для arm64
 ### Сборка образа
 #### Docker
 ```bash
 # Из корня проекта (важно: контекст должен быть корень проекта)
 docker build -f Dockerfiles/OllamaServer/Dockerfile -t lcg-ollama:latest .
 # Или с указанием архитектуры
 docker buildx build \
  --platform linux/amd64,linux/arm64 \
  -f Dockerfiles/OllamaServer/Dockerfile \
  -t lcg-ollama:latest .
 ```
 #### Podman
 ```bash
 # Из корня проекта
 podman build -f Dockerfiles/OllamaServer/Dockerfile -t lcg-ollama:latest .
 # Или с указанием архитектуры
 podman build \
  --platform linux/amd64,linux/arm64 \
  -f Dockerfiles/OllamaServer/Dockerfile \
  -t lcg-ollama:latest .
 ```
 ### Запуск контейнера
 #### Docker run
 ```bash
 docker run -d \
  --name lcg-ollama \
  -p 8080:8080 \  
  lcg-ollama:latest
  ollama serve
 ```
 #### Podman run
 ```bash
 podman run -d \
  --name lcg-ollama \
  -p 8989:8080 \
  --restart always \
  lcg-ollama:latest \
  ollama serve
 ```
 когда контейнер запущен на удаленном хосте - можете воспользоваться консольными возможностями утилиты lcg следующим образом
 ``` bash
 ssh user@[host_where_contaier_running] 'podman exec -it $(podman ps -q --filter \"ancestor=localhost/lcg-ollama:latest\") lcg [your query]
 ```
 ``` bash
 ssh user@[host_where_contaier_running] 'podman exec -it $(podman ps -q --filter "ancestor=localhost/lcg-ollama:latest") /bin/sh -c "export LCG_MODEL=qwen3:0.6b && lcg config --full"'
 ### Использование docker-compose / podman-compose
 #### Docker Compose
 ```bash
 cd Dockerfiles/OllamaServer
 docker-compose up -d
 ```
 #### Podman Compose
 ```bash
 cd Dockerfiles/OllamaServer
 podman-compose -f podman-compose.yml up -d
 ```
 Или используйте встроенную поддержку Podman:
 ```bash
 cd Dockerfiles/OllamaServer
 podman play kube podman-compose.yml
 ```
 ## 🌐 Доступ к сервисам
 После запуска контейнера доступны:
 - **LCG веб-интерфейс**: <http://localhost:8080>
 - **Ollama API**: <http://localhost:11434>
 ## ⚙️ Переменные окружения
 ### Настройки LCG
 | Переменная | Значение по умолчанию | Описание |
 |------------|----------------------|----------|
 | `LCG_PROVIDER` | `ollama` | Тип провайдера |
 | `LCG_HOST` | `http://127.0.0.1:11434/` | URL Ollama API |
 | `LCG_MODEL` | `codegeex4` | Модель для использования |
 | `LCG_SERVER_HOST` | `0.0.0.0` | Хост LCG сервера |
 | `LCG_SERVER_PORT` | `8080` | Порт LCG сервера |
 | `LCG_SERVER_ALLOW_HTTP` | `true` | Разрешить HTTP |
 | `LCG_RESULT_FOLDER` | `/app/data/results` | Папка для результатов |
 | `LCG_PROMPT_FOLDER` | `/app/data/prompts` | Папка для промптов |
 | `LCG_CONFIG_FOLDER` | `/app/data/config` | Папка для конфигурации |
 ### Настройки Ollama
 | Переменная | Значение по умолчанию | Описание |
 |------------|----------------------|----------|
 | `OLLAMA_HOST` | `127.0.0.1` | Хост Ollama сервера |
 | `OLLAMA_PORT` | `11434` | Порт Ollama сервера |
 ### Безопасность
 | Переменная | Значение по умолчанию | Описание |
 |------------|----------------------|----------|
 | `LCG_SERVER_REQUIRE_AUTH` | `false` | Требовать аутентификацию |
 | `LCG_SERVER_PASSWORD` | `admin#123456` | Пароль для аутентификации |
 ## 📦 Volumes
 Рекомендуется монтировать volumes для персистентного хранения данных:
 ```bash
 docker run -d \
  --name lcg-ollama \
  -p 8080:8080 \
  -p 11434:11434 \
  -v ollama-data:/home/ollama/.ollama \
  -v lcg-results:/app/data/results \
  -v lcg-prompts:/app/data/prompts \
  -v lcg-config:/app/data/config \
  lcg-ollama:latest
 ```
 ### Volumes описание
 - `ollama-data`: Модели и данные Ollama
 - `lcg-results`: Результаты генерации команд
 - `lcg-prompts`: Системные промпты
 - `lcg-config`: Конфигурация LCG
 ## 🔧 Примеры использования
 ### Запуск с кастомной моделью
 ```bash
 docker run -d \
  --name lcg-ollama \
  -p 8080:8080 \
  -p 11434:11434 \
  -e LCG_MODEL=llama3:8b \
  lcg-ollama:latest
 ```
 ### Запуск с аутентификацией
 ```bash
 docker run -d \
  --name lcg-ollama \
  -p 8080:8080 \
  -p 11434:11434 \
  -e LCG_SERVER_REQUIRE_AUTH=true \
  -e LCG_SERVER_PASSWORD=my_secure_password \
  lcg-ollama:latest
 ```
 ### Запуск с кастомным портом
 ```bash
 docker run -d \
  --name lcg-ollama \
  -p 9000:9000 \
  -p 11434:11434 \
  -e LCG_SERVER_PORT=9000 \
  lcg-ollama:latest
 ```
 ## 📥 Загрузка моделей Ollama
 После запуска контейнера можно загрузить модели:
 ```bash
 # Подключиться к контейнеру
 docker exec -it lcg-ollama sh
 # Загрузить модель
 ollama pull codegeex4
 ollama pull llama3:8b
 ollama pull qwen2.5:7b
 ```
 Или извне контейнера:
 ```bash
 # Убедитесь, что Ollama доступен извне (OLLAMA_HOST=0.0.0.0)
 docker exec lcg-ollama ollama pull codegeex4
 ```
 ## 🔍 Проверка работоспособности
 ### Проверка Ollama
 ```bash
 # Проверка health
 curl http://localhost:11434/api/tags
 # Список моделей
 curl http://localhost:11434/api/tags | jq '.models'
 ```
 ### Проверка LCG
 ```bash
 # Проверка веб-интерфейса
 curl http://localhost:8080/
 # Проверка через API
 curl -X POST http://localhost:8080/api/execute \
  -H "Content-Type: application/json" \
  -d '{"prompt": "создать директорию test"}'
 ```
 ## 🐧 Podman специфичные инструкции
 ### Запуск с Podman
 Podman работает аналогично Docker, но есть несколько отличий:
 #### Создание сетей (если нужно)
 ```bash
 podman network create lcg-network
 ```
 #### Запуск с сетью
 ```bash
 podman run -d \
  --name lcg-ollama \
  --network lcg-network \
  -p 8080:8080 \
  -p 11434:11434 \
  lcg-ollama:latest
 ```
 #### Запуск в rootless режиме
 Podman по умолчанию работает в rootless режиме, что повышает безопасность:
 ```bash
 # Не требует sudo
 podman run -d \
  --name lcg-ollama \
  -p 8080:8080 \
  -p 11434:11434 \
  lcg-ollama:latest
 ```
 #### Использование systemd для автозапуска
 Создайте systemd unit файл:
 ```bash
 # Генерируем unit файл
 podman generate systemd --name lcg-ollama --files
 # Копируем в systemd
 sudo cp container-lcg-ollama.service /etc/systemd/system/
 # Включаем автозапуск
 sudo systemctl enable container-lcg-ollama.service
 sudo systemctl start container-lcg-ollama.service
 ```
 #### Проверка статуса
 ```bash
 # Статус контейнера
 podman ps
 # Логи
 podman logs lcg-ollama
 # Логи в реальном времени
 podman logs -f lcg-ollama
 ```
 ## 🐛 Отладка
 ### Просмотр логов
 #### Docker log
 ```bash
 # Логи контейнера
 docker logs lcg-ollama
 # Логи в реальном времени
 docker logs -f lcg-ollama
 ```
 #### Podman log
 ```bash
 # Логи контейнера
 podman logs lcg-ollama
 # Логи в реальном времени
 podman logs -f lcg-ollama
 ```
 ### Подключение к контейнеру
 #### Docker exec
 ```bash
 docker exec -it lcg-ollama sh
 ```
 #### Podman exec
 ```bash
 podman exec -it lcg-ollama sh
 ```
 ### Проверка процессов
 #### Docker check ps
 ```bash
 docker exec lcg-ollama ps aux
 ```
 #### Podman  check ps
 ```bash
 podman exec lcg-ollama ps aux
 ```
 ## 🔒 Безопасность
 ### Рекомендации для продакшена
 1. **Используйте аутентификацию**:
   ```bash
   -e LCG_SERVER_REQUIRE_AUTH=true
   -e LCG_SERVER_PASSWORD=strong_password
   ```
 2. **Ограничьте доступ к портам**:
   - Используйте firewall правила
   - Не экспортируйте порты на публичный интерфейс
 3. **Используйте HTTPS**:
   - Настройте reverse proxy (nginx, traefik)
   - Используйте SSL сертификаты
 4. **Ограничьте ресурсы**:
   ```bash
   docker run -d \
     --name lcg-ollama \
     --memory="4g" \
     --cpus="2" \
     lcg-ollama:latest
   ```
 ## 📊 Мониторинг
 ### Healthcheck
 Контейнер включает healthcheck, который проверяет доступность LCG сервера:
 ```bash
 docker inspect lcg-ollama | jq '.[0].State.Health'
 ```
 ### Метрики
 LCG предоставляет Prometheus метрики на `/metrics` endpoint (если включено).
 ## 🚀 Production Deployment
 ### С docker-compose
 ```bash
 cd Dockerfiles/OllamaServer
 docker-compose up -d
 ```
 ### С Kubernetes
 Используйте манифесты из папки `deploy/` или `kustomize/`.
 ## 📝 Примечания
 - Ollama версия: 0.9.5
 - LCG версия: см. VERSION.txt
 - Минимальные требования: 2GB RAM, 2 CPU cores
 - Рекомендуется: 4GB+ RAM для больших моделей
 ## 🔗 Полезные ссылки
 - [Ollama документация](https://github.com/ollama/ollama)
 - [LCG документация](../../docs/README.md)
 - [LCG API Guide](../../docs/API_GUIDE.md)
 ## ❓ Поддержка
 При возникновении проблем:
 1. Проверьте логи: `docker logs lcg-ollama`
 2. Проверьте переменные окружения
 3. Убедитесь, что порты не заняты
 4. Проверьте, что модели загружены в Ollama
--- a/Dockerfiles/OllamaServer/STRUCTURE.md
+++ b/Dockerfiles/OllamaServer/STRUCTURE.md
@@ -1,143 +0,0 @@
 # 📁 Структура проекта OllamaServer
 ## Файлы
 ```
 Dockerfiles/OllamaServer/
 ├── Dockerfile              # Multi-stage Dockerfile для сборки образа
 ├── entrypoint.sh           # Скрипт запуска LCG и Ollama серверов
 ├── docker-compose.yml      # Docker Compose конфигурация
 ├── podman-compose.yml      # Podman Compose конфигурация
 ├── Makefile                # Команды для сборки и запуска
 ├── README.md               # Полная документация
 ├── QUICKSTART.md           # Быстрый старт
 ├── STRUCTURE.md            # Этот файл
 ├── .dockerignore           # Исключения для Docker build
 └── .gitignore              # Исключения для Git
 ```
 ## Описание файлов
 ### Dockerfile
 Dockerfile, который:
 1. Использует готовый образ `ollama/ollama:0.9.5` как базовый
 2. Копирует предварительно собранный бинарник LCG из папки `dist/`
 3. Выбирает правильный бинарник в зависимости от архитектуры (amd64/arm64)
 4. Устанавливает entrypoint.sh для запуска обоих сервисов
 5. Настраивает рабочее окружение и переменные окружения
 **Важно**: Перед сборкой образа необходимо собрать бинарники с помощью `goreleaser build --snapshot --clean`
 ### entrypoint.sh
 Скрипт запуска, который:
 1. Запускает Ollama сервер в фоне
 2. Ожидает готовности Ollama API
 3. Запускает LCG сервер в фоне
 4. Мониторит состояние процессов
 5. Корректно обрабатывает сигналы завершения
 ### docker-compose.yml / podman-compose.yml
 Конфигурация для запуска через compose:
 - Настройки портов
 - Переменные окружения
 - Volumes для персистентного хранения
 - Healthcheck
 ### Makefile
 Удобные команды для:
 - Сборки образа
 - Запуска/остановки контейнера
 - Просмотра логов
 - Работы с compose
 ### README.md
 Полная документация с:
 - Описанием функциональности
 - Инструкциями по установке
 - Настройками переменных окружения
 - Примерами использования
 - Решением проблем
 ### QUICKSTART.md
 Краткое руководство для быстрого старта.
 ## Порты
 - **8080**: LCG веб-сервер
 - **11434**: Ollama API
 ## Volumes
 - `ollama-data`: Данные Ollama (модели)
 - `lcg-results`: Результаты генерации команд
 - `lcg-prompts`: Системные промпты
 - `lcg-config`: Конфигурация LCG
 ## Переменные окружения
 Основные переменные (см. README.md для полного списка):
 - `LCG_PROVIDER=ollama`
 - `LCG_HOST=http://127.0.0.1:11434/`
 - `LCG_MODEL=codegeex4`
 - `OLLAMA_HOST=0.0.0.0`
 - `OLLAMA_PORT=11434`
 ## Запуск
 ### Предварительная подготовка
 Перед сборкой образа необходимо собрать бинарники:
 ```bash
 # Из корня проекта
 goreleaser build --snapshot --clean
 ```
 Убедитесь, что в папке `dist/` есть бинарники для нужных архитектур.
 ### Docker
 ```bash
 cd Dockerfiles/OllamaServer
 docker-compose up -d
 ```
 ### Podman
 ```bash
 cd Dockerfiles/OllamaServer
 podman-compose -f podman-compose.yml up -d
 ```
 ### Make
 ```bash
 cd Dockerfiles/OllamaServer
 make build-all      # Собрать бинарники и Docker образ
 make compose-up     # Запустить через docker-compose
 # Или для Podman
 make build-all-podman
 make podman-compose-up
 ```
 ## Архитектура
 Контейнер запускает два сервиса:
 1. **Ollama** (порт 11434) - LLM сервер
 2. **LCG** (порт 8080) - Веб-интерфейс и API
 Оба сервиса работают в одном контейнере и общаются через localhost.
--- a/Dockerfiles/OllamaServer/docker-compose.yml
+++ b/Dockerfiles/OllamaServer/docker-compose.yml
@@ -1,55 +0,0 @@
 version: '3.8'
 services:
  lcg-ollama:
    build:
      context: ../..  # Контекст сборки - корень проекта (для доступа к dist/)
      dockerfile: Dockerfiles/OllamaServer/Dockerfile
      # TARGETARCH определяется автоматически Docker на основе платформы хоста
    container_name: lcg-ollama
    ports:
      - "8080:8080"  # LCG веб-сервер
      - "11434:11434"  # Ollama API
    environment:
      # Настройки LCG
      - LCG_PROVIDER=ollama
      - LCG_HOST=http://127.0.0.1:11434/
      - LCG_MODEL=codegeex4
      - LCG_RESULT_FOLDER=/app/data/results
      - LCG_PROMPT_FOLDER=/app/data/prompts
      - LCG_CONFIG_FOLDER=/app/data/config
      - LCG_SERVER_HOST=0.0.0.0
      - LCG_SERVER_PORT=8080
      - LCG_SERVER_ALLOW_HTTP=true
      # Настройки Ollama
      - OLLAMA_HOST=0.0.0.0
      - OLLAMA_PORT=11434
      - OLLAMA_ORIGINS=*
      # Опционально: настройки безопасности
      - LCG_SERVER_REQUIRE_AUTH=false
      - LCG_SERVER_PASSWORD=admin#123456
    volumes:
      # Персистентное хранилище для данных Ollama
      - ollama-data:/home/ollama/.ollama
      # Персистентное хранилище для результатов LCG
      - lcg-results:/app/data/results
      - lcg-prompts:/app/data/prompts
      - lcg-config:/app/data/config
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8080/"]
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 40s
 volumes:
  ollama-data:
    driver: local
  lcg-results:
    driver: local
  lcg-prompts:
    driver: local
  lcg-config:
    driver: local
--- a/Dockerfiles/OllamaServer/entrypoint.sh
+++ b/Dockerfiles/OllamaServer/entrypoint.sh
@@ -1,104 +0,0 @@
 #!/bin/bash
 set -e
 # Цвета для вывода
 RED='\033[0;31m'
 GREEN='\033[0;32m'
 YELLOW='\033[1;33m'
 BLUE='\033[0;34m'
 NC='\033[0m' # No Color
 # Функция для логирования
 log() {
    echo -e "${GREEN}[$(date +'%Y-%m-%d %H:%M:%S')]${NC} $1"
 }
 error() {
    echo -e "${RED}[ERROR]${NC} $1" >&2
 }
 warn() {
    echo -e "${YELLOW}[WARN]${NC} $1"
 }
 info() {
    echo -e "${BLUE}[INFO]${NC} $1"
 }
 # Обработка сигналов для корректного завершения
 cleanup() {
    log "Получен сигнал завершения, останавливаем сервисы..."
    if [ ! -z "$LCG_PID" ]; then
        kill $LCG_PID 2>/dev/null || true
        wait $LCG_PID 2>/dev/null || true
    fi
    log "Сервисы остановлены"
    exit 0
 }
 trap cleanup SIGTERM SIGINT
 # Проверка наличия бинарника lcg
 if [ ! -f /usr/local/bin/lcg ]; then
    error "Бинарник lcg не найден в /usr/local/bin/lcg"
    exit 1
 fi
 # Создаем необходимые директории
 mkdir -p "${LCG_RESULT_FOLDER:-/app/data/results}"
 mkdir -p "${LCG_PROMPT_FOLDER:-/app/data/prompts}"
 mkdir -p "${LCG_CONFIG_FOLDER:-/app/data/config}"
 # Настройка переменных окружения для Ollama
 export OLLAMA_HOST="${OLLAMA_HOST:-0.0.0.0}"
 export OLLAMA_PORT="${OLLAMA_PORT:-11434}"
 export OLLAMA_ORIGINS="*"
 # Настройка переменных окружения для LCG
 export LCG_PROVIDER="${LCG_PROVIDER:-ollama}"
 export LCG_HOST="${LCG_HOST:-http://0.0.0.0:11434/}"
 export LCG_MODEL="${LCG_MODEL:-qwen2.5-coder:1.5b}"
 export LCG_RESULT_FOLDER="${LCG_RESULT_FOLDER:-/app/data/results}"
 export LCG_PROMPT_FOLDER="${LCG_PROMPT_FOLDER:-/app/data/prompts}"
 export LCG_CONFIG_FOLDER="${LCG_CONFIG_FOLDER:-/app/data/config}"
 export LCG_SERVER_HOST="${LCG_SERVER_HOST:-0.0.0.0}"
 export LCG_SERVER_PORT="${LCG_SERVER_PORT:-8080}"
 export LCG_SERVER_ALLOW_HTTP="${LCG_SERVER_ALLOW_HTTP:-false}"
 export LCG_FORCE_NO_CSRF="${LCG_FORCE_NO_CSRF:-false}"
 export LCG_CSRF_DEBUG_FILE="${LCG_CSRF_DEBUG_FILE:-/app/data/csrf-debug.log}"
 if [ "$LCG_FORCE_NO_CSRF" = "true" ]; then
    info "CSRF проверка отключена через LCG_FORCE_NO_CSRF"
 fi
 log "=========================================="
 log "Запуск LCG с Ollama сервером"
 log "=========================================="
 info "LCG Provider: $LCG_PROVIDER"
 info "LCG Host: $LCG_HOST"
 info "LCG Model: $LCG_MODEL"
 info "LCG Server: http://${LCG_SERVER_HOST}:${LCG_SERVER_PORT}"
 info "Ollama Host: $OLLAMA_HOST:$OLLAMA_PORT"
 log "=========================================="
 log "Запуск LCG сервера..."
 /usr/local/bin/lcg serve \
    --host "${LCG_SERVER_HOST}" \
    --port "${LCG_SERVER_PORT}" &
 LCG_PID=$!
 # Ждем, пока LCG запустится
 sleep 3
 # Проверяем, что LCG запущен
 if ! kill -0 $LCG_PID 2>/dev/null; then
    error "LCG сервер не запустился"    
    exit 1
 fi
 log "LCG сервер запущен на http://${LCG_SERVER_HOST}:${LCG_SERVER_PORT}"
 # Запускаем переданные аргументы
 exec "$@"
--- a/Dockerfiles/OllamaServer/podman-compose.yml
+++ b/Dockerfiles/OllamaServer/podman-compose.yml
@@ -1,54 +0,0 @@
 version: '3.8'
 services:
  lcg-ollama:
    build:
      context: ../..
      dockerfile: Dockerfiles/OllamaServer/Dockerfile
    container_name: lcg-ollama
    ports:
      - "8080:8080"  # LCG веб-сервер
      - "11434:11434"  # Ollama API
    environment:
      # Настройки LCG
      - LCG_PROVIDER=ollama
      - LCG_HOST=http://127.0.0.1:11434/
      - LCG_MODEL=codegeex4
      - LCG_RESULT_FOLDER=/app/data/results
      - LCG_PROMPT_FOLDER=/app/data/prompts
      - LCG_CONFIG_FOLDER=/app/data/config
      - LCG_SERVER_HOST=0.0.0.0
      - LCG_SERVER_PORT=8080
      - LCG_SERVER_ALLOW_HTTP=true
      # Настройки Ollama
      - OLLAMA_HOST=0.0.0.0
      - OLLAMA_PORT=11434
      - OLLAMA_ORIGINS=*
      # Опционально: настройки безопасности
      - LCG_SERVER_REQUIRE_AUTH=false
      - LCG_SERVER_PASSWORD=admin#123456
    volumes:
      # Персистентное хранилище для данных Ollama
      - ollama-data:/home/ollama/.ollama
      # Персистентное хранилище для результатов LCG
      - lcg-results:/app/data/results
      - lcg-prompts:/app/data/prompts
      - lcg-config:/app/data/config
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8080/"]
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 40s
 volumes:
  ollama-data:
    driver: local
  lcg-results:
    driver: local
  lcg-prompts:
    driver: local
  lcg-config:
    driver: local
--- a/VERSION.txt
+++ b/VERSION.txt
@@ -1 +1 @@
-v.2.0.26
+v2.0.11
--- a/config/config.go
+++ b/config/config.go
@@ -27,8 +27,6 @@ type Config struct {
 	ResultHistory  string
 	NoHistoryEnv   string
 	AllowExecution bool
 	Think          bool
 	Query          string
 	MainFlags      MainFlags
 	Server         ServerConfig
 	Validation     ValidationConfig
@@ -59,7 +57,6 @@ type ServerConfig struct {
 	CookieSecure   bool
 	CookiePath     string
 	CookieTTLHours int
 	ForceNoCSRF    bool
 }
 type ValidationConfig struct {
@@ -168,7 +165,6 @@ func Load() Config {
 			BasePath:       getEnv("LCG_BASE_URL", "/lcg"),
 			HealthUrl:      getEnv("LCG_HEALTH_URL", "/api/v1/protected/sberchat/health"),
 			ProxyUrl:       getEnv("LCG_PROXY_URL", "/api/v1/protected/sberchat/chat"),
 			ForceNoCSRF:    isForceNoCSRF(),
 		},
 		Validation: ValidationConfig{
 			MaxSystemPromptLength: getEnvInt("LCG_MAX_SYSTEM_PROMPT_LENGTH", 2000),
@@ -217,15 +213,6 @@ func isCookieSecure() bool {
 	return vLower == "1" || vLower == "true"
 }
 func isForceNoCSRF() bool {
 	v := strings.TrimSpace(getEnv("LCG_FORCE_NO_CSRF", ""))
 	if v == "" {
 		return false
 	}
 	vLower := strings.ToLower(v)
 	return vLower == "1" || vLower == "true"
 }
 var AppConfig Config
 func init() {
--- a/deploy/.goreleaser.yaml
+++ b/deploy/.goreleaser.yaml
@@ -6,8 +6,6 @@ builds:
    binary: "lcg_{{ .Version }}"
    goos:
      - linux
      - windows
      - darwin
    goarch:
      - amd64
      - arm64
@@ -23,10 +21,9 @@ builds:
 archives:
  - id: lcg
-    ids:
+    builds:
      - lcg
-    formats:
+    format: binary
      - binary
    name_template: "{{ .Binary }}_{{ .Os }}_{{ .Arch }}"
    files:
      - "lcg_{{ .Version }}"
--- a/deploy/VERSION.txt
+++ b/deploy/VERSION.txt
@@ -1 +1 @@
-v.2.0.26
+v2.0.11
--- a/deploy/release-goreleaser.sh
+++ b/deploy/release-goreleaser.sh
@@ -1,170 +0,0 @@
 #!/usr/bin/env bash
 set -euo pipefail
 # release-goreleaser.sh
 # Копирует deploy/.goreleaser.yaml в корень, запускает релиз и удаляет файл.
 #
 # Использование:
 #   deploy/release-goreleaser.sh            # обычный релиз на GitHub (нужен GITHUB_TOKEN)
 #   deploy/release-goreleaser.sh --snapshot # локальный снепшот без публикации
 ROOT_DIR="$(git rev-parse --show-toplevel 2>/dev/null || pwd)"
 SRC_CFG="$ROOT_DIR/deploy/.goreleaser.yaml"
 DST_CFG="$ROOT_DIR/.goreleaser.yaml"
 log() { echo -e "\033[36m[release]\033[0m $*"; }
 err() { echo -e "\033[31m[error]\033[0m $*" >&2; }
 if ! command -v goreleaser >/dev/null 2>&1; then
  err "goreleaser не найден. Установите: https://goreleaser.com/install/"
  exit 1
 fi
 if [[ ! -f "$SRC_CFG" ]]; then
  err "Не найден файл конфигурации: $SRC_CFG"
  exit 1
 fi
 MODE="release"
 if [[ "${1:-}" == "--snapshot" ]]; then
  MODE="snapshot"
  shift || true
 fi
 if [[ -f "$DST_CFG" ]]; then
  err "В корне уже существует .goreleaser.yaml. Удалите/переименуйте перед запуском."
  exit 1
 fi
 cleanup() {
  if [[ -f "$DST_CFG" ]]; then
    rm -f "$DST_CFG" || true
    log "Удалил временный $DST_CFG"
  fi
 }
 trap cleanup EXIT
 log "Копирую конфиг: $SRC_CFG -> $DST_CFG"
 cp "$SRC_CFG" "$DST_CFG"
 pushd "$ROOT_DIR" >/dev/null
 EXTRA_FLAGS=()
 PREV_HEAD="$(git rev-parse HEAD 2>/dev/null || echo "")"
 git add .
 git commit --amend --no-edit || true
 ## Версию берём из deploy/VERSION.txt или VERSION.txt в корне
 VERSION_FILE="$ROOT_DIR/deploy/VERSION.txt"
 [[ -f "$VERSION_FILE" ]] || VERSION_FILE="$ROOT_DIR/VERSION.txt"
 if [[ -f "$VERSION_FILE" ]]; then
  VERSION_RAW="$(head -n1 "$VERSION_FILE" | tr -d ' \t\r\n')"
  if [[ -n "$VERSION_RAW" ]]; then
    TAG="$VERSION_RAW"
    [[ "$TAG" == v* ]] || TAG="v$TAG"
    export GORELEASER_CURRENT_TAG="$TAG"
    log "Версия релиза: $TAG (из $(realpath --relative-to="$ROOT_DIR" "$VERSION_FILE" 2>/dev/null || echo "$VERSION_FILE"))"
  fi
 fi
 create_and_push_tag() {
  local tag="$1"
  if git rev-parse "$tag" >/dev/null 2>&1; then
    log "Git tag уже существует: $tag"
  else
    log "Создаю git tag: $tag"
    git tag -a "$tag" -m "Release $tag"
    if [[ "${NO_GIT_PUSH:-false}" != "true" ]]; then
      log "Пушу тег $tag на origin"
      git push origin "$tag"
    else
      log "Пропущен пуш тега (NO_GIT_PUSH=true)"
    fi
  fi
 }
 move_tag_to_head() {
  local tag="$1"
  if [[ -z "$tag" ]]; then
    return 0
  fi
  if git rev-parse "$tag" >/dev/null 2>&1; then
    log "Переношу тег $tag на текущий коммит (HEAD)"
    git tag -f "$tag" HEAD
    if [[ "${NO_GIT_PUSH:-false}" != "true" ]]; then
      log "Форс‑пуш тега $tag на origin"
      git push -f origin "$tag"
    else
      log "Пропущен пуш тега (NO_GIT_PUSH=true)"
    fi
  else
    log "Тега $tag нет — пропускаю перенос"
  fi
 }
 fetch_token_from_k8s() {
  export KUBECONFIG=/home/su/.kube/config_hlab
  local ns="${K8S_NAMESPACE:-flux-system}"
  local name="${K8S_SECRET_NAME:-git-secrets}"
  # Предпочитаем jq (как в примере), при отсутствии используем jsonpath + base64 -d
  if command -v jq >/dev/null 2>&1; then
    kubectl get secret "$name" -n "$ns" -o json \
      | jq -r '.data.password | @base64d'
  else
    kubectl get secret "$name" -n "$ns" -o jsonpath='{.data.password}' \
      | base64 -d 2>/dev/null || true
  fi
 }
 if [[ "$MODE" == "snapshot" ]]; then
  log "Запуск goreleaser (snapshot, без публикации)"
  goreleaser release --snapshot --clean --config "$DST_CFG" "${EXTRA_FLAGS[@]}"
 else
  # Если версия определена и тега нет — создадим (goreleaser ориентируется на теги)
  if [[ -n "${GORELEASER_CURRENT_TAG:-}" ]]; then
    create_and_push_tag "$GORELEASER_CURRENT_TAG"
    # Перемещаем тег на текущий HEAD (если существовал ранее, закрепим на последнем коммите)
    move_tag_to_head "$GORELEASER_CURRENT_TAG"
  else
    # Если версия не задана, попробуем взять последний существующий тег и перенести его на HEAD
    LAST_TAG="$(git describe --tags --abbrev=0 2>/dev/null || true)"
    if [[ -n "$LAST_TAG" ]]; then
      move_tag_to_head "$LAST_TAG"
      export GORELEASER_CURRENT_TAG="$LAST_TAG"
      log "Использую последний тег: $LAST_TAG"
    fi
  fi
  if [[ -z "${GITHUB_TOKEN:-}" ]]; then
    log "GITHUB_TOKEN не задан — пробую получить из k8s секрета (${K8S_NAMESPACE:-flux-system}/${K8S_SECRET_NAME:-git-secrets}, ключ: password)"
    if ! command -v kubectl >/dev/null 2>&1; then
      err "kubectl не найден, а GITHUB_TOKEN не задан. Установите kubectl или экспортируйте GITHUB_TOKEN."
      exit 1
    fi
    TOKEN_FROM_K8S="$(fetch_token_from_k8s || true)"
    if [[ -n "$TOKEN_FROM_K8S" && "$TOKEN_FROM_K8S" != "null" ]]; then
      export GITHUB_TOKEN="$TOKEN_FROM_K8S"
      log "GITHUB_TOKEN получен из секрета Kubernetes."
    else
      err "Не удалось получить GITHUB_TOKEN из секрета Kubernetes. Экспортируйте GITHUB_TOKEN и повторите."
      exit 1
    fi
  fi
  log "Запуск goreleaser (публикация на GitHub)"
  goreleaser release --clean --config "$DST_CFG" "${EXTRA_FLAGS[@]}"
 fi
 popd >/dev/null
 # Откатываем временный коммит, если он был
 if [[ "${TEMP_COMMIT_DONE:-false}" == "true" && -n "$PREV_HEAD" ]]; then
  if git reset --soft "$PREV_HEAD" >/dev/null 2>&1; then
    log "Откатил временный коммит"
  else
    log "Не удалось откатить временный коммит — проверьте историю вручную"
  fi
 fi
 log "Готово."
--- a/docs/CONFIG_COMMAND.md
+++ b/docs/CONFIG_COMMAND.md
@@ -69,8 +69,8 @@ lcg co -f
    "host": "localhost"
  },
  "validation": {
-    "max_system_prompt_length": 2000,
+    "max_system_prompt_length": 1000,
-    "max_user_message_length": 4000,
+    "max_user_message_length": 2000,
    "max_prompt_name_length": 2000,
    "max_prompt_desc_length": 5000,
    "max_command_length": 8000,
@@ -116,12 +116,12 @@ lcg co -f
 ### Настройки валидации (validation)
- **max_system_prompt_length** - максимальная длина системного промпта (по умолчанию: 2000)
+- **max_system_prompt_length** - максимальная длина системного промпта
- **max_user_message_length** - максимальная длина пользовательского сообщения (по умолчанию: 4000)
+- **max_user_message_length** - максимальная длина пользовательского сообщения
- **max_prompt_name_length** - максимальная длина названия промпта (по умолчанию: 2000)
+- **max_prompt_name_length** - максимальная длина названия промпта
- **max_prompt_desc_length** - максимальная длина описания промпта (по умолчанию: 5000)
+- **max_prompt_desc_length** - максимальная длина описания промпта
- **max_command_length** - максимальная длина команды/ответа (по умолчанию: 8000)
+- **max_command_length** - максимальная длина команды/ответа
- **max_explanation_length** - максимальная длина объяснения (по умолчанию: 20000)
+- **max_explanation_length** - максимальная длина объяснения
 ## 🔒 Безопасность
--- a/docs/README.md
+++ b/docs/README.md
@@ -35,17 +35,10 @@ Explanations:
 Clipboard support requires `xclip` or `xsel`.
-## What's new in 2.0.14
+## What's new in 2.0.1
- Authentication: JWT-based authentication with HTTP-only cookies
+- Mobile UI improvements: better responsiveness (buttons, fonts, spacing) and reduced motion support
- CSRF protection: Full CSRF protection with tokens and middleware
+- Public REST endpoint: `POST /execute` (curl-only) for programmatic access — see `API_GUIDE.md`
 - Security: Enhanced security with token validation and sessions
 - Kubernetes deployment: Full set of manifests for Kubernetes deployment with Traefik
 - Reverse Proxy: Support for working behind reverse proxy with cookie configuration
 - Web interface: Improved web interface with modern design
 - Monitoring: Prometheus metrics and ServiceMonitor
 - Scaling: HPA for automatic scaling
 - Testing: CSRF protection testing tools
 ## Environment
@@ -140,15 +133,10 @@ The `serve` command provides both a web interface and REST API:
 **Web Interface:**
- Browse results at `http://localhost:8080/` (or `http://localhost:8080<BASE_PATH>/` if `LCG_BASE_URL` set)
+- Browse results at `http://localhost:8080/`
- Execute requests at `.../run`
+- Execute requests at `http://localhost:8080/run`
- Manage prompts at `.../prompts`
+- Manage prompts at `http://localhost:8080/prompts`
- View history at `.../history`
+- View history at `http://localhost:8080/history`
 Notes:
 - Base path: set `LCG_BASE_URL` (e.g. `/lcg`) to prefix all routes and API.
 - Custom 404: unknown paths under base path render a modern 404 page.
 - Debug: enable via flag `--debug` or env `LCG_DEBUG=1|true`.
 **REST API:**
--- a/docs/USAGE_GUIDE.md
+++ b/docs/USAGE_GUIDE.md
@@ -22,7 +22,7 @@ sudo apt-get install xsel
 ```bash
-git clone --depth 1 https://github.com/Direct-Dev-Ru/linux-command-gpt.git ~/.linux-command-gpt
+git clone --depth 1 https://github.com/Direct-Dev-Ru/go-lcg.git ~/.linux-command-gpt
 cd ~/.linux-command-gpt
 go build -o lcg
@@ -60,7 +60,7 @@ lcg --file /path/to/context.txt "хочу вывести список дирек
 Действия: (c)копировать, (s)сохранить, (r)перегенерировать, (e)выполнить, (v|vv|vvv)подробно, (n)ничего:
 ```
-### Что нового в 2.0.14
+### Что нового в 3.0.0
 - **Аутентификация**: Добавлена система аутентификации с JWT токенами и HTTP-only cookies
 - **CSRF защита**: Полная защита от CSRF атак с токенами и middleware
--- a/docs/VALIDATION_CONFIG.md
+++ b/docs/VALIDATION_CONFIG.md
@@ -8,26 +8,26 @@
 | Переменная | Описание | По умолчанию |
 |------------|----------|--------------|
-| `LCG_MAX_SYSTEM_PROMPT_LENGTH` | Максимальная длина системного промпта | 2000 |
+| `LCG_MAX_SYSTEM_PROMPT_LENGTH` | Максимальная длина системного промпта | 1000 |
-| `LCG_MAX_USER_MESSAGE_LENGTH` | Максимальная длина пользовательского сообщения | 4000 |
+| `LCG_MAX_USER_MESSAGE_LENGTH` | Максимальная длина пользовательского сообщения | 2000 |
-| `LCG_MAX_PROMPT_NAME_LENGTH` | Максимальная длина названия промпта | 2000 |
+| `LCG_MAX_PROMPT_NAME_LENGTH` | Максимальная длина названия промпта | 200 |
-| `LCG_MAX_PROMPT_DESC_LENGTH` | Максимальная длина описания промпта | 5000 |
+| `LCG_MAX_PROMPT_DESC_LENGTH` | Максимальная длина описания промпта | 500 |
-| `LCG_MAX_COMMAND_LENGTH` | Максимальная длина команды/ответа | 8000 |
+| `LCG_MAX_COMMAND_LENGTH` | Максимальная длина команды/ответа | 2000 |
-| `LCG_MAX_EXPLANATION_LENGTH` | Максимальная длина объяснения | 20000 |
+| `LCG_MAX_EXPLANATION_LENGTH` | Максимальная длина объяснения | 2000 |
 ## 🚀 Примеры использования
 ### Установка через переменные окружения
 ```bash
-# Увеличить лимит системного промпта до 3к символов
+# Увеличить лимит системного промпта до 2к символов
-export LCG_MAX_SYSTEM_PROMPT_LENGTH=3000
+export LCG_MAX_SYSTEM_PROMPT_LENGTH=2000
-# Уменьшить лимит пользовательского сообщения до 2к символов
+# Уменьшить лимит пользовательского сообщения до 1к символов
-export LCG_MAX_USER_MESSAGE_LENGTH=2000
+export LCG_MAX_USER_MESSAGE_LENGTH=1000
-# Увеличить лимит названия промпта до 3000 символов
+# Увеличить лимит названия промпта до 500 символов
-export LCG_MAX_PROMPT_NAME_LENGTH=3000
+export LCG_MAX_PROMPT_NAME_LENGTH=500
 ```
 ### Установка в .env файле
@@ -35,11 +35,11 @@ export LCG_MAX_PROMPT_NAME_LENGTH=3000
 ```bash
 # .env файл
 LCG_MAX_SYSTEM_PROMPT_LENGTH=2000
-LCG_MAX_USER_MESSAGE_LENGTH=4000
+LCG_MAX_USER_MESSAGE_LENGTH=1500
-LCG_MAX_PROMPT_NAME_LENGTH=2000
+LCG_MAX_PROMPT_NAME_LENGTH=300
-LCG_MAX_PROMPT_DESC_LENGTH=5000
+LCG_MAX_PROMPT_DESC_LENGTH=1000
-LCG_MAX_COMMAND_LENGTH=8000
+LCG_MAX_COMMAND_LENGTH=3000
-LCG_MAX_EXPLANATION_LENGTH=20000
+LCG_MAX_EXPLANATION_LENGTH=5000
 ```
 ### Установка в systemd сервисе
@@ -55,8 +55,8 @@ User=lcg
 WorkingDirectory=/opt/lcg
 ExecStart=/opt/lcg/lcg serve
 Environment=LCG_MAX_SYSTEM_PROMPT_LENGTH=2000
-Environment=LCG_MAX_USER_MESSAGE_LENGTH=4000
+Environment=LCG_MAX_USER_MESSAGE_LENGTH=1500
-Environment=LCG_MAX_PROMPT_NAME_LENGTH=2000
+Environment=LCG_MAX_PROMPT_NAME_LENGTH=300
 Restart=always
 [Install]
@@ -72,7 +72,7 @@ FROM golang:1.21-alpine AS builder
 FROM alpine:latest
 COPY --from=builder /app/lcg /usr/local/bin/
 ENV LCG_MAX_SYSTEM_PROMPT_LENGTH=2000
-ENV LCG_MAX_USER_MESSAGE_LENGTH=4000
+ENV LCG_MAX_USER_MESSAGE_LENGTH=1500
 CMD ["lcg", "serve"]
 ```
@@ -84,8 +84,8 @@ services:
    image: lcg:latest
    environment:
      - LCG_MAX_SYSTEM_PROMPT_LENGTH=2000
-      - LCG_MAX_USER_MESSAGE_LENGTH=4000
+      - LCG_MAX_USER_MESSAGE_LENGTH=1500
-      - LCG_MAX_PROMPT_NAME_LENGTH=2000
+      - LCG_MAX_PROMPT_NAME_LENGTH=300
    ports:
      - "8080:8080"
 ```
@@ -153,9 +153,9 @@ validation.FormatLengthInfo(systemPrompt, userMessage)
 ## 📝 Примеры сообщений об ошибках
 ```
-❌ Ошибка: system_prompt: системный промпт слишком длинный: 2500 символов (максимум 2000)
+❌ Ошибка: system_prompt: системный промпт слишком длинный: 1500 символов (максимум 1000)
-❌ Ошибка: user_message: пользовательское сообщение слишком длинное: 4500 символов (максимум 4000)
+❌ Ошибка: user_message: пользовательское сообщение слишком длинное: 2500 символов (максимум 2000)
-❌ Ошибка: prompt_name: название промпта слишком длинное: 2500 символов (максимум 2000)
+❌ Ошибка: prompt_name: название промпта слишком длинное: 300 символов (максимум 200)
 ```
 ## 🔄 Миграция с жестко заданных значений
@@ -179,25 +179,25 @@ if err := validation.ValidateSystemPrompt(prompt); err != nil {
 ### Для разработки
 ```bash
 export LCG_MAX_SYSTEM_PROMPT_LENGTH=2000
-export LCG_MAX_USER_MESSAGE_LENGTH=4000
+export LCG_MAX_USER_MESSAGE_LENGTH=2000
-export LCG_MAX_PROMPT_NAME_LENGTH=2000
+export LCG_MAX_PROMPT_NAME_LENGTH=200
-export LCG_MAX_PROMPT_DESC_LENGTH=5000
+export LCG_MAX_PROMPT_DESC_LENGTH=500
 ```
 ### Для продакшена
 ```bash
-export LCG_MAX_SYSTEM_PROMPT_LENGTH=2000
+export LCG_MAX_SYSTEM_PROMPT_LENGTH=1000
-export LCG_MAX_USER_MESSAGE_LENGTH=4000
+export LCG_MAX_USER_MESSAGE_LENGTH=1500
-export LCG_MAX_PROMPT_NAME_LENGTH=2000
+export LCG_MAX_PROMPT_NAME_LENGTH=100
-export LCG_MAX_PROMPT_DESC_LENGTH=5000
+export LCG_MAX_PROMPT_DESC_LENGTH=300
 ```
 ### Для высоконагруженных систем
 ```bash
-export LCG_MAX_SYSTEM_PROMPT_LENGTH=1000
+export LCG_MAX_SYSTEM_PROMPT_LENGTH=500
-export LCG_MAX_USER_MESSAGE_LENGTH=2000
+export LCG_MAX_USER_MESSAGE_LENGTH=1000
-export LCG_MAX_PROMPT_NAME_LENGTH=1000
+export LCG_MAX_PROMPT_NAME_LENGTH=50
-export LCG_MAX_PROMPT_DESC_LENGTH=2500
+export LCG_MAX_PROMPT_DESC_LENGTH=200
 ```
 ---
--- a/gpt/gpt.go
+++ b/gpt/gpt.go
@@ -49,14 +49,6 @@ type Gpt3Request struct {
 	Options  Gpt3Options `json:"options"`
 }
 type Gpt3ThinkRequest struct {
 	Model  string `json:"model"`
 	Stream bool   `json:"stream"`
 	Think  bool   `json:"think"`
 	Messages []Chat `json:"messages"`
 	Options  Gpt3Options `json:"options"`
 }
 type Gpt3Options struct {
 	Temperature float64 `json:"temperature"`
 }
--- a/gpt/providers.go
+++ b/gpt/providers.go
@@ -200,26 +200,12 @@ func (p *ProxyAPIProvider) Health() error {
 // Chat для OllamaProvider
 func (o *OllamaProvider) Chat(messages []Chat) (string, error) {
-
+	payload := Gpt3Request{
 	think := config.AppConfig.Think
 	var payload interface{}
 	if think {
 	payload = Gpt3Request{
 		Model:    o.Model,
 		Messages: messages,
 		Stream:   false,
 		Options:  Gpt3Options{o.Temperature},
 	}
 	} else {
 		payload = Gpt3ThinkRequest{
 			Model:    o.Model,
 			Messages: messages,
 			Stream:   false,
 			Think:    false,
 			Options:  Gpt3Options{o.Temperature},
 		}
 	}
 	jsonData, err := json.Marshal(payload)
 	if err != nil {
--- a/kustomize/configmap.yaml
+++ b/kustomize/configmap.yaml
@@ -5,7 +5,7 @@ metadata:
  namespace: lcg
 data:
  # Основные настройки
-  LCG_VERSION: "v.2.0.26"
+  LCG_VERSION: "v2.0.11"
  LCG_BASE_PATH: "/lcg"
  LCG_SERVER_HOST: "0.0.0.0"
  LCG_SERVER_PORT: "8080"  
--- a/kustomize/deployment.yaml
+++ b/kustomize/deployment.yaml
@@ -5,7 +5,7 @@ metadata:
  namespace: lcg
  labels:
    app: lcg
-    version: v.2.0.26
+    version: v2.0.11
 spec:
  replicas: 1
  selector:
@@ -18,7 +18,7 @@ spec:
    spec:
      containers:
      - name: lcg
-        image: kuznetcovay/lcg:v.2.0.26
+        image: kuznetcovay/lcg:v2.0.11
        imagePullPolicy: Always
        ports:
        - containerPort: 8080
--- a/kustomize/kustomization.yaml
+++ b/kustomize/kustomization.yaml
@@ -15,11 +15,11 @@ resources:
 # Common labels
 # commonLabels:
 #   app: lcg
-#   version: v.2.0.26
+#   version: v2.0.11
 #   managed-by: kustomize
 # Images
 # images:
 #   - name: lcg
 #     newName: kuznetcovay/lcg
-#     newTag: v.2.0.26
+#     newTag: v2.0.11
--- a/main.go
+++ b/main.go
@@ -9,7 +9,6 @@ import (
 	"os/exec"
 	"os/user"
 	"path/filepath"
 	"slices"
 	"strconv"
 	"strings"
 	"time"
@@ -61,7 +60,7 @@ func main() {
 		CompileConditions.NoServe = false
 	}
-	// fmt.Println("Build conditions:", CompileConditions)
+	fmt.Println("Build conditions:", CompileConditions)
 	_ = colorBlue
@@ -77,12 +76,6 @@ func main() {
 		Usage:    config.AppConfig.AppName + " - Генерация Linux команд из описаний",
 		Version:  Version,
 		Commands: getCommands(),
 		Before: func(c *cli.Context) error {
 			// Применяем флаги приложения к конфигурации перед выполнением любой команды
 			// Это гарантирует, что флаги будут применены даже для команд, которые не используют основной Action
 			applyAppFlagsToConfig(c)
 			return nil
 		},
 		UsageText: `
 lcg [опции] <описание команды>
@@ -94,57 +87,12 @@ lcg [опции] <описание команды>
 {{.AppName}} - инструмент для генерации Linux команд из описаний на естественном языке.
 Поддерживает чтение частей промпта из файлов и позволяет сохранять, копировать или перегенерировать результаты.
 может задавать системный промпт или выбирать из предустановленных промптов.
 Переменные окружения:
-
+  LCG_HOST          Endpoint для LLM API (по умолчанию: http://192.168.87.108:11434/)
-Основные настройки:
+  LCG_MODEL         Название модели (по умолчанию: codegeex4)
-  LCG_HOST                Endpoint для LLM API (по умолчанию: http://192.168.87.108:11434/)
+  LCG_PROMPT        Текст промпта по умолчанию
-  LCG_MODEL               Название модели (по умолчанию: hf.co/yandex/YandexGPT-5-Lite-8B-instruct-GGUF:Q4_K_M)
+  LCG_PROVIDER      Тип провайдера: "ollama" или "proxy" (по умолчанию: ollama)
-  LCG_PROMPT              Текст промпта по умолчанию
+  LCG_JWT_TOKEN     JWT токен для proxy провайдера
  LCG_PROVIDER            Тип провайдера: "ollama" или "proxy" (по умолчанию: ollama)
  LCG_JWT_TOKEN           JWT токен для proxy провайдера
  LCG_PROMPT_ID           ID промпта по умолчанию (по умолчанию: 1)
  LCG_TIMEOUT             Таймаут запроса в секундах (по умолчанию: 300)
  LCG_COMPLETIONS_PATH    Путь к API для завершений (по умолчанию: api/chat)
  LCG_PROXY_URL           URL прокси для proxy провайдера (по умолчанию: /api/v1/protected/sberchat/chat)
  LCG_API_KEY_FILE        Файл с API ключом (по умолчанию: .openai_api_key)
  LCG_APP_NAME            Название приложения (по умолчанию: Linux Command GPT)
  LCG_ALLOW_THINK         только для ollama: разрешить модели отправлять свои размышления ("1" или "true" = разрешено, пусто = запрещено). Имеет смысл для моделей, которые поддерживают эти действия: qwen3, deepseek.  
 Настройки истории и выполнения:
  LCG_NO_HISTORY          Отключить запись истории ("1" или "true" = отключено, пусто = включено)
  LCG_ALLOW_EXECUTION     Разрешить выполнение команд ("1" или "true" = разрешено, пусто = запрещено)
  LCG_RESULT_FOLDER       Папка для сохранения результатов (по умолчанию: ~/.config/lcg/gpt_results)
  LCG_RESULT_HISTORY      Файл истории результатов (по умолчанию: <result_folder>/lcg_history.json)
  LCG_PROMPT_FOLDER       Папка для системных промптов (по умолчанию: ~/.config/lcg/gpt_sys_prompts)
  LCG_CONFIG_FOLDER       Папка для конфигурации (по умолчанию: ~/.config/lcg/config)
 Настройки сервера (команда serve):
  LCG_SERVER_PORT         Порт сервера (по умолчанию: 8080)
  LCG_SERVER_HOST         Хост сервера (по умолчанию: localhost)
  LCG_SERVER_ALLOW_HTTP   Разрешить HTTP соединения ("true" для localhost, "false" для других хостов)
  LCG_SERVER_REQUIRE_AUTH Требовать аутентификацию ("1" или "true" = требуется, пусто = не требуется)
  LCG_SERVER_PASSWORD     Пароль администратора (по умолчанию: admin#123456)
  LCG_SERVER_SSL_CERT_FILE Путь к SSL сертификату
  LCG_SERVER_SSL_KEY_FILE  Путь к приватному ключу SSL
  LCG_DOMAIN              Домен для сервера (по умолчанию: значение LCG_SERVER_HOST)
  LCG_COOKIE_SECURE       Безопасные cookie ("1" или "true" = включено, пусто = выключено)
  LCG_COOKIE_PATH         Путь для cookie (по умолчанию: /lcg)
  LCG_COOKIE_TTL_HOURS    Время жизни cookie в часах (по умолчанию: 168)
  LCG_BASE_URL            Базовый URL приложения (по умолчанию: /lcg)
  LCG_HEALTH_URL          URL для проверки здоровья API (по умолчанию: /api/v1/protected/sberchat/health)
 Настройки валидации:
  LCG_MAX_SYSTEM_PROMPT_LENGTH    Максимальная длина системного промпта (по умолчанию: 2000)
  LCG_MAX_USER_MESSAGE_LENGTH     Максимальная длина пользовательского сообщения (по умолчанию: 4000)
  LCG_MAX_PROMPT_NAME_LENGTH      Максимальная длина названия промпта (по умолчанию: 2000)
  LCG_MAX_PROMPT_DESC_LENGTH      Максимальная длина описания промпта (по умолчанию: 5000)
  LCG_MAX_COMMAND_LENGTH          Максимальная длина команды (по умолчанию: 8000)
  LCG_MAX_EXPLANATION_LENGTH      Максимальная длина объяснения (по умолчанию: 20000)
 Отладка и браузер:
  LCG_DEBUG               Включить режим отладки ("1" или "true" = включено, пусто = выключено)
  LCG_BROWSER_PATH        Путь к браузеру для автоматического открытия (команда serve --browser)
 `,
 		Flags: []cli.Flag{
 			&cli.StringFlag{
@@ -152,31 +100,12 @@ lcg [опции] <описание команды>
 				Aliases: []string{"f"},
 				Usage:   "Read part of the command from a file",
 			},
 			&cli.StringFlag{
 				Name:        "model",
 				Aliases:     []string{"M"},
 				DefaultText: "Use model from LCG_MODEL or default model",
 				Usage:       "Model to use",
 			},
 			&cli.BoolFlag{
 				Name:    "no-history",
 				Aliases: []string{"nh"},
 				Usage:   "Disable writing/updating command history (overrides LCG_NO_HISTORY)",
 				Value:   false,
 			},
 			&cli.BoolFlag{
 				Name:        "think",
 				Aliases:     []string{"T"},
 				Usage:       "Разрешить модели отправлять свои размышления",
 				Value:       false,				
 			},
 			&cli.StringFlag{
 				Name:        "query",
 				Aliases:     []string{"Q"},
 				Usage:       "Query to send to the model",
 				DefaultText: "Привет! Порадуй меня случайной Linux командой ...",
 				Value:       "Привет! Порадуй меня случайной Linux командой ...",
 			},
 			&cli.StringFlag{
 				Name:        "sys",
 				Aliases:     []string{"s"},
@@ -208,28 +137,16 @@ lcg [опции] <описание команды>
 		Action: func(c *cli.Context) error {
 			file := c.String("file")
 			system := c.String("sys")
 			model := c.String("model")
 			query := c.String("query")
 			// обновляем конфиг на основе флагов
-			if c.IsSet("sys") && system != "" {
+			if system != "" {
 				config.AppConfig.Prompt = system
 			}
 			if c.IsSet("query") && query != "" {
 				config.AppConfig.Query = query
 			}
 			if c.IsSet("timeout") {
 				config.AppConfig.Timeout = fmt.Sprintf("%d", c.Int("timeout"))
 			}
 			if c.IsSet("model") {
 				config.AppConfig.Model = model
 			}
 			config.AppConfig.Think = false
 			if c.IsSet("think") {
 				config.AppConfig.Think = c.Bool("think")
 			}
 			promptID := c.Int("prompt-id")
 			timeout := c.Int("timeout")
-
+			// сохраняем конкретные значения флагов
 			config.AppConfig.MainFlags = config.MainFlags{
 				File:      file,
 				NoHistory: c.Bool("no-history"),
@@ -242,9 +159,12 @@ lcg [опции] <описание команды>
 			config.AppConfig.MainFlags.Debug = config.AppConfig.MainFlags.Debug || config.GetEnvBool("LCG_DEBUG", false)
 			fmt.Println("Debug:", config.AppConfig.MainFlags.Debug)
 			fmt.Println("LCG_DEBUG:", config.GetEnvBool("LCG_DEBUG", false))
 			args := c.Args().Slice()
-			if len(args) == 0 && config.AppConfig.Query == "" {
+			if len(args) == 0 {
 				cli.ShowAppHelp(c)
 				showTips()
 				return nil
@@ -267,12 +187,6 @@ lcg [опции] <описание команды>
 					os.Exit(1)
 				}
 			}
 			if config.AppConfig.Query != "" {
 				executeMain(file, system, config.AppConfig.Query, timeout)
 				return nil
 			}
 			executeMain(file, system, strings.Join(args, " "), timeout)
 			return nil
 		},
@@ -293,31 +207,6 @@ lcg [опции] <описание команды>
 	}
 }
 // applyAppFlagsToConfig применяет флаги приложения к конфигурации
 // Работает как для основного Action, так и для команд
 func applyAppFlagsToConfig(c *cli.Context) {
 	// Применяем флаг model - проверяем и через IsSet, и значение напрямую
 	// так как IsSet может не работать для флагов без значения по умолчанию
 	if model := c.String("model"); model != "" {
 		config.AppConfig.Model = model
 	}
 	// Применяем флаг sys
 	if sys := c.String("sys"); sys != "" {
 		config.AppConfig.Prompt = sys
 	}
 	// Применяем флаг timeout (только если явно установлен)
 	if c.IsSet("timeout") {
 		config.AppConfig.Timeout = fmt.Sprintf("%d", c.Int("timeout"))
 	}
 	// Применяем флаг query (игнорируем значение по умолчанию)
 	if query := c.String("query"); query != "" && query != "Hello? what day is it today?" {
 		config.AppConfig.Query = query
 	}
 }
 func getCommands() []*cli.Command {
 	commands := []*cli.Command{
 		{
@@ -457,10 +346,6 @@ func getCommands() []*cli.Command {
 				},
 			},
 			Action: func(c *cli.Context) error {
 				// Флаги приложения уже применены через глобальный Before hook
 				// Но применяем их еще раз на случай, если глобальный Before не сработал
 				applyAppFlagsToConfig(c)
 				if c.Bool("full") {
 					// Выводим полную конфигурацию в JSON формате
 					showFullConfig()
@@ -1028,7 +913,7 @@ func printDebugInfo(file, system, commandInput string, timeout int) {
 	fmt.Printf("📁 Файл: %s\n", file)
 	fmt.Printf("🤖 Системный промпт: %s\n", system)
 	fmt.Printf("💬 Запрос: %s\n", commandInput)
-	fmt.Printf("⏱️ Таймаут: %d сек\n", timeout)
+	fmt.Printf("⏱️  Таймаут: %d сек\n", timeout)
 	fmt.Printf("🌐 Провайдер: %s\n", config.AppConfig.ProviderType)
 	fmt.Printf("🏠 Хост: %s\n", config.AppConfig.Host)
 	fmt.Printf("🧠 Модель: %s\n", config.AppConfig.Model)
@@ -1098,7 +983,12 @@ func getServerAllowHTTPForHost(host string) bool {
 // isSecureHost проверяет, является ли хост безопасным для HTTP
 func isSecureHost(host string) bool {
 	secureHosts := []string{"localhost", "127.0.0.1", "::1"}
-	return slices.Contains(secureHosts, host)
+	for _, secureHost := range secureHosts {
 		if host == secureHost {
 			return true
 		}
 	}
 	return false
 }
 // showShortConfig показывает краткую конфигурацию
--- a/serve/auth.go
+++ b/serve/auth.go
@@ -127,6 +127,7 @@ func getTokenFromCookie(r *http.Request) (string, error) {
 func setAuthCookie(w http.ResponseWriter, token string) {
 	cookie := &http.Cookie{
 		Name:     "auth_token",
 		Domain:   config.AppConfig.Server.Domain,
 		Value:    token,
 		Path:     config.AppConfig.Server.CookiePath,
 		HttpOnly: true,
--- a/serve/csrf.go
+++ b/serve/csrf.go
@@ -8,89 +8,11 @@ import (
 	"fmt"
 	"net/http"
 	"os"
 	"path/filepath"
 	"sync"
 	"time"
 	"github.com/direct-dev-ru/linux-command-gpt/config"
 )
 const (
 	// CSRFTokenLifetimeHours минимальное время жизни CSRF токена в часах (не менее 12 часов)
 	CSRFTokenLifetimeHours = 12
 	// CSRFTokenLifetimeSeconds минимальное время жизни CSRF токена в секундах
 	CSRFTokenLifetimeSeconds = CSRFTokenLifetimeHours * 60 * 60
 )
 var (
 	// csrfDebugFile файл для отладочного вывода CSRF
 	csrfDebugFile *os.File
 	// csrfDebugFileMutex мьютекс для безопасной записи в файл
 	csrfDebugFileMutex sync.Mutex
 )
 // initCSRFDebugFile инициализирует файл для отладочного вывода CSRF
 func initCSRFDebugFile() error {
 	debugFile := os.Getenv("LCG_CSRF_DEBUG_FILE")
 	if debugFile == "" {
 		return nil // Файл не указан, ничего не делаем
 	}
 	// Создаем директорию для файла, если нужно
 	dir := filepath.Dir(debugFile)
 	if dir != "." && dir != "" {
 		if err := os.MkdirAll(dir, 0755); err != nil {
 			return fmt.Errorf("failed to create directory for CSRF debug file %s: %v", dir, err)
 		}
 	}
 	// Создаем/перезаписываем файл
 	file, err := os.Create(debugFile)
 	if err != nil {
 		return fmt.Errorf("failed to create CSRF debug file %s: %v", debugFile, err)
 	}
 	csrfDebugFileMutex.Lock()
 	// Закрываем старый файл, если был открыт
 	if csrfDebugFile != nil {
 		csrfDebugFile.Close()
 	}
 	csrfDebugFile = file
 	csrfDebugFileMutex.Unlock()
 	// Записываем заголовок
 	header := fmt.Sprintf("=== CSRF Debug Log Started at %s ===\n", time.Now().Format(time.RFC3339))
 	if _, err := csrfDebugFile.WriteString(header); err != nil {
 		return fmt.Errorf("failed to write header to CSRF debug file: %v", err)
 	}
 	if err := csrfDebugFile.Sync(); err != nil {
 		return fmt.Errorf("failed to sync CSRF debug file: %v", err)
 	}
 	return nil
 }
 // csrfDebugPrint выводит отладочную информацию
 // Если установлен LCG_CSRF_DEBUG_FILE - всегда пишет в файл (независимо от debug режима)
 // Если включен debug режим - также пишет в консоль
 func csrfDebugPrint(format string, args ...any) {
 	message := fmt.Sprintf(format, args...)
 	// Записываем в файл, если он установлен
 	csrfDebugFileMutex.Lock()
 	if csrfDebugFile != nil {
 		csrfDebugFile.WriteString(message)
 		// Синхронизируем сразу для отладки (может быть медленно, но гарантирует запись)
 		csrfDebugFile.Sync()
 	}
 	csrfDebugFileMutex.Unlock()
 	// Записываем в консоль, если включен debug режим
 	if config.AppConfig.MainFlags.Debug {
 		fmt.Print(message)
 	}
 }
 // CSRFManager управляет CSRF токенами
 type CSRFManager struct {
 	secretKey []byte
@@ -146,8 +68,6 @@ func getCSRFSecretKey() ([]byte, error) {
 // GenerateToken генерирует CSRF токен для пользователя
 func (c *CSRFManager) GenerateToken(userID string) (string, error) {
 	csrfDebugPrint("[CSRF DEBUG] Генерация нового токена для UserID: %s\n", userID)
 	// Создаем данные токена
 	data := CSRFData{
 		Token:     generateRandomString(32),
@@ -155,85 +75,53 @@ func (c *CSRFManager) GenerateToken(userID string) (string, error) {
 		UserID:    userID,
 	}
 	csrfDebugPrint("[CSRF DEBUG] Созданные данные токена: Token (первые 20 символов): %s..., Timestamp: %d, UserID: %s\n",
 		safeSubstring(data.Token, 0, 20), data.Timestamp, data.UserID)
 	// Создаем подпись
 	signature := c.createSignature(data)
 	csrfDebugPrint("[CSRF DEBUG] Созданная подпись (первые 20 символов): %s...\n", safeSubstring(signature, 0, 20))
 	// Кодируем данные в base64
 	encodedData := base64.StdEncoding.EncodeToString([]byte(fmt.Sprintf("%s:%d:%s", data.Token, data.Timestamp, data.UserID)))
 	csrfDebugPrint("[CSRF DEBUG] Закодированные данные (первые 30 символов): %s...\n", safeSubstring(encodedData, 0, 30))
-	token := fmt.Sprintf("%s.%s", encodedData, signature)
+	return fmt.Sprintf("%s.%s", encodedData, signature), nil
 	csrfDebugPrint("[CSRF DEBUG] Итоговый токен сгенерирован (первые 50 символов): %s...\n", safeSubstring(token, 0, 50))
 	return token, nil
 }
 // ValidateToken проверяет CSRF токен
 func (c *CSRFManager) ValidateToken(token, userID string) bool {
 	csrfDebugPrint("[CSRF DEBUG] Начало валидации токена. UserID из запроса: %s\n", userID)
 	csrfDebugPrint("[CSRF DEBUG] Токен (первые 50 символов): %s...\n", safeSubstring(token, 0, 50))
 	// Разделяем токен на данные и подпись
 	parts := splitToken(token)
 	if len(parts) != 2 {
 		csrfDebugPrint("[CSRF DEBUG] ❌ ОШИБКА: Токен не может быть разделен на 2 части. Получено частей: %d\n", len(parts))
 		return false
 	}
 	encodedData, signature := parts[0], parts[1]
 	csrfDebugPrint("[CSRF DEBUG] Токен разделен на encodedData (первые 30 символов): %s... и signature (первые 20 символов): %s...\n",
 		safeSubstring(encodedData, 0, 30), safeSubstring(signature, 0, 20))
 	// Декодируем данные
 	dataBytes, err := base64.StdEncoding.DecodeString(encodedData)
 	if err != nil {
 		csrfDebugPrint("[CSRF DEBUG] ❌ ОШИБКА: Не удалось декодировать base64 данные: %v\n", err)
 		return false
 	}
 	csrfDebugPrint("[CSRF DEBUG] Данные декодированы. Длина: %d байт\n", len(dataBytes))
 	// Парсим данные
 	dataParts := splitString(string(dataBytes), ":")
 	if len(dataParts) != 3 {
 		csrfDebugPrint("[CSRF DEBUG] ❌ ОШИБКА: Данные не могут быть разделены на 3 части. Получено частей: %d. Данные: %s\n", len(dataParts), string(dataBytes))
 		return false
 	}
 	tokenValue, timestampStr, tokenUserID := dataParts[0], dataParts[1], dataParts[2]
 	csrfDebugPrint("[CSRF DEBUG] Распарсены данные: tokenValue (первые 20 символов): %s..., timestamp: %s, tokenUserID: %s\n",
 		safeSubstring(tokenValue, 0, 20), timestampStr, tokenUserID)
 	// Проверяем пользователя
 	if tokenUserID != userID {
 		csrfDebugPrint("[CSRF DEBUG] ❌ ОШИБКА: UserID не совпадает! Ожидался: '%s', получен из токена: '%s'\n", userID, tokenUserID)
 		return false
 	}
 	csrfDebugPrint("[CSRF DEBUG] ✅ UserID совпадает: %s\n", userID)
-	// Проверяем время жизни токена (минимум 12 часов)
+	// Проверяем время жизни токена (24 часа)
 	timestamp, err := parseInt64(timestampStr)
 	if err != nil {
 		csrfDebugPrint("[CSRF DEBUG] ❌ ОШИБКА: Не удалось распарсить timestamp '%s': %v\n", timestampStr, err)
 		return false
 	}
-	now := time.Now().Unix()
+	if time.Now().Unix()-timestamp > 24*60*60 {
 	age := now - timestamp
 	ageHours := float64(age) / 3600.0
 	csrfDebugPrint("[CSRF DEBUG] Текущее время: %d, timestamp токена: %d, возраст токена: %d сек (%.2f часов)\n", now, timestamp, age, ageHours)
 	// Минимальное время жизни токена: 12 часов (не менее 12 часов согласно требованиям)
 	if age > CSRFTokenLifetimeSeconds {
 		csrfDebugPrint("[CSRF DEBUG] ❌ ОШИБКА: Токен устарел! Возраст: %d сек (%.2f часов), максимум: %d сек (%.2f часов)\n",
 			age, ageHours, CSRFTokenLifetimeSeconds, float64(CSRFTokenLifetimeSeconds)/3600.0)
 		return false
 	}
 	csrfDebugPrint("[CSRF DEBUG] ✅ Токен не устарел (возраст в пределах лимита)\n")
 	// Создаем данные для проверки подписи
 	data := CSRFData{
@@ -244,30 +132,7 @@ func (c *CSRFManager) ValidateToken(token, userID string) bool {
 	// Проверяем подпись
 	expectedSignature := c.createSignature(data)
-	signatureMatch := signature == expectedSignature
+	return signature == expectedSignature
 	if !signatureMatch {
 		csrfDebugPrint("[CSRF DEBUG] ❌ ОШИБКА: Подпись не совпадает!\n")
 		csrfDebugPrint("[CSRF DEBUG] Ожидаемая подпись (первые 20 символов): %s...\n", safeSubstring(expectedSignature, 0, 20))
 		csrfDebugPrint("[CSRF DEBUG] Полученная подпись (первые 20 символов): %s...\n", safeSubstring(signature, 0, 20))
 		csrfDebugPrint("[CSRF DEBUG] Данные для подписи: Token=%s (первые 20), Timestamp=%d, UserID=%s\n",
 			safeSubstring(tokenValue, 0, 20), timestamp, tokenUserID)
 	} else {
 		csrfDebugPrint("[CSRF DEBUG] ✅ Подпись совпадает\n")
 	}
 	csrfDebugPrint("[CSRF DEBUG] Результат валидации: %t\n", signatureMatch)
 	return signatureMatch
 }
 // safeSubstring безопасно обрезает строку
 func safeSubstring(s string, start, length int) string {
 	if start >= len(s) {
 		return ""
 	}
 	end := start + length
 	if end > len(s) {
 		end = len(s)
 	}
 	return s[start:end]
 }
 // createSignature создает подпись для данных
@@ -288,35 +153,22 @@ func GetCSRFTokenFromCookie(r *http.Request) string {
 // setCSRFCookie устанавливает CSRF токен в cookie
 func setCSRFCookie(w http.ResponseWriter, token string) {
 	csrfDebugPrint("[CSRF DEBUG] Установка CSRF cookie. Токен (первые 50 символов): %s...\n", safeSubstring(token, 0, 50))
 	csrfDebugPrint("[CSRF DEBUG] Cookie настройки: Path=%s, Secure=%t, Domain=%s, MaxAge=%d сек\n",
 		config.AppConfig.Server.CookiePath,
 		config.AppConfig.Server.CookieSecure,
 		config.AppConfig.Server.Domain,
 		CSRFTokenLifetimeSeconds)
 	// Минимальное время жизни токена: 12 часов (не менее 12 часов согласно требованиям)
 	cookie := &http.Cookie{
 		Name:     "csrf_token",
 		Value:    token,
 		Path:     config.AppConfig.Server.CookiePath,
 		HttpOnly: true,
 		Secure:   config.AppConfig.Server.CookieSecure,
-		SameSite: http.SameSiteLaxMode,     // Более мягкий режим для reverse proxy
+		SameSite: http.SameSiteLaxMode, // Более мягкий режим для reverse proxy
-		MaxAge:   CSRFTokenLifetimeSeconds, // Минимум 12 часов в секундах
+		MaxAge:   1 * 60 * 60,
 	}
 	// Добавляем домен если указан
 	if config.AppConfig.Server.Domain != "" {
 		cookie.Domain = config.AppConfig.Server.Domain
 		csrfDebugPrint("[CSRF DEBUG] Cookie Domain установлен: %s\n", cookie.Domain)
 	} else {
 		csrfDebugPrint("[CSRF DEBUG] Cookie Domain не установлен (пустой)\n")
 	}
 	http.SetCookie(w, cookie)
 	csrfDebugPrint("[CSRF DEBUG] ✅ CSRF cookie установлен: Name=%s, Path=%s, Domain=%s, Secure=%t, HttpOnly=%t, SameSite=%v, MaxAge=%d\n",
 		cookie.Name, cookie.Path, cookie.Domain, cookie.Secure, cookie.HttpOnly, cookie.SameSite, cookie.MaxAge)
 }
 // clearCSRFCookie удаляет CSRF cookie
@@ -400,11 +252,6 @@ var csrfManager *CSRFManager
 // InitCSRFManager инициализирует глобальный CSRF менеджер
 func InitCSRFManager() error {
 	// Инициализируем файл для отладки CSRF, если указан LCG_CSRF_DEBUG_FILE
 	if err := initCSRFDebugFile(); err != nil {
 		return fmt.Errorf("failed to initialize CSRF debug file: %v", err)
 	}
 	var err error
 	csrfManager, err = NewCSRFManager()
 	return err
--- a/serve/execute_page.go
+++ b/serve/execute_page.go
@@ -233,9 +233,6 @@ func handleExecuteRequest(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 	// Устанавливаем CSRF токен в cookie после обработки запроса
 	setCSRFCookie(w, csrfToken)
 	data := ExecutePageData{
 		Title:                "Результат выполнения",
 		Header:               "Результат выполнения",
--- a/serve/login.go
+++ b/serve/login.go
@@ -92,7 +92,6 @@ func RenderLoginPage(w http.ResponseWriter, data LoginPageData) error {
 func getSessionID(r *http.Request) string {
 	// Пытаемся получить из cookie
 	if cookie, err := r.Cookie("session_id"); err == nil {
 		csrfDebugPrint("[CSRF DEBUG] SessionID получен из cookie: %s\n", cookie.Value)
 		return cookie.Value
 	}
@@ -100,12 +99,7 @@ func getSessionID(r *http.Request) string {
 	ip := r.RemoteAddr
 	userAgent := r.Header.Get("User-Agent")
 	csrfDebugPrint("[CSRF DEBUG] SessionID не найден в cookie. Генерация нового на основе IP=%s, User-Agent (первые 50 символов): %s...\n",
 		ip, safeSubstring(userAgent, 0, 50))
 	// Создаем простой хеш для сессии
 	hash := sha256.Sum256([]byte(ip + userAgent))
-	sessionID := hex.EncodeToString(hash[:])[:16]
+	return hex.EncodeToString(hash[:])[:16]
 	csrfDebugPrint("[CSRF DEBUG] Сгенерирован SessionID: %s\n", sessionID)
 	return sessionID
 }
--- a/serve/middleware.go
+++ b/serve/middleware.go
@@ -45,77 +45,25 @@ func AuthMiddleware(next http.HandlerFunc) http.HandlerFunc {
 // CSRFMiddleware проверяет CSRF токены для POST/PUT/DELETE запросов
 func CSRFMiddleware(next http.HandlerFunc) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
 		// Проверяем, нужно ли пропустить CSRF проверку
 		if config.AppConfig.Server.ForceNoCSRF {
 			csrfDebugPrint("[CSRF MIDDLEWARE] ⚠️  CSRF проверка отключена через LCG_FORCE_NO_CSRF\n")
 			next(w, r)
 			return
 		}
 		csrfDebugPrint("\n[CSRF MIDDLEWARE] ==========================================\n")
 		csrfDebugPrint("[CSRF MIDDLEWARE] Обработка запроса: %s %s\n", r.Method, r.URL.Path)
 		csrfDebugPrint("[CSRF MIDDLEWARE] RemoteAddr: %s\n", r.RemoteAddr)
 		csrfDebugPrint("[CSRF MIDDLEWARE] Host: %s\n", r.Host)
 		// Выводим все заголовки
 		csrfDebugPrint("[CSRF MIDDLEWARE] Заголовки:\n")
 		for name, values := range r.Header {
 			if name == "Cookie" {
 				// Cookie выводим отдельно, разбирая их
 				csrfDebugPrint("[CSRF MIDDLEWARE]   %s: %s\n", name, strings.Join(values, "; "))
 			} else {
 				csrfDebugPrint("[CSRF MIDDLEWARE]   %s: %s\n", name, strings.Join(values, ", "))
 			}
 		}
 		// Выводим все cookies
 		csrfDebugPrint("[CSRF MIDDLEWARE] Все cookies:\n")
 		if len(r.Cookies()) == 0 {
 			csrfDebugPrint("[CSRF MIDDLEWARE]   (нет cookies)\n")
 		} else {
 			for _, cookie := range r.Cookies() {
 				csrfDebugPrint("[CSRF MIDDLEWARE]   %s = %s (Path: %s, Domain: %s, Secure: %t, HttpOnly: %t, SameSite: %v, MaxAge: %d)\n",
 					cookie.Name,
 					safeSubstring(cookie.Value, 0, 50),
 					cookie.Path,
 					cookie.Domain,
 					cookie.Secure,
 					cookie.HttpOnly,
 					cookie.SameSite,
 					cookie.MaxAge)
 			}
 		}
 		// Проверяем только изменяющие запросы
 		if r.Method == "GET" || r.Method == "HEAD" || r.Method == "OPTIONS" {
 			csrfDebugPrint("[CSRF MIDDLEWARE] Пропускаем проверку CSRF для метода %s\n", r.Method)
 			next(w, r)
 			return
 		}
 		// Исключаем некоторые API endpoints (с учетом BasePath)
 		if r.URL.Path == makePath("/api/login") || r.URL.Path == makePath("/api/logout") {
 			csrfDebugPrint("[CSRF MIDDLEWARE] Пропускаем проверку CSRF для пути %s\n", r.URL.Path)
 			next(w, r)
 			return
 		}
 		// Получаем CSRF токен из заголовка или формы
-		csrfTokenFromHeader := r.Header.Get("X-CSRF-Token")
+		csrfToken := r.Header.Get("X-CSRF-Token")
 		csrfTokenFromForm := r.FormValue("csrf_token")
 		csrfDebugPrint("[CSRF MIDDLEWARE] CSRF токен из заголовка X-CSRF-Token: %s\n",
 			safeSubstring(csrfTokenFromHeader, 0, 50))
 		csrfDebugPrint("[CSRF MIDDLEWARE] CSRF токен из формы csrf_token: %s\n",
 			safeSubstring(csrfTokenFromForm, 0, 50))
 		csrfToken := csrfTokenFromHeader
 		if csrfToken == "" {
-			csrfToken = csrfTokenFromForm
+			csrfToken = r.FormValue("csrf_token")
 		}
 		if csrfToken == "" {
 			csrfDebugPrint("[CSRF MIDDLEWARE] ❌ ОШИБКА: CSRF токен не найден ни в заголовке, ни в форме!\n")
 			// Для API запросов возвращаем JSON ошибку
 			if isAPIRequest(r) {
 				w.Header().Set("Content-Type", "application/json")
@@ -129,67 +77,12 @@ func CSRFMiddleware(next http.HandlerFunc) http.HandlerFunc {
 			return
 		}
 		csrfDebugPrint("[CSRF MIDDLEWARE] Используемый CSRF токен (первые 50 символов): %s...\n",
 			safeSubstring(csrfToken, 0, 50))
 		// Получаем сессионный ID
 		sessionID := getSessionID(r)
 		csrfDebugPrint("[CSRF MIDDLEWARE] SessionID: %s\n", sessionID)
 		// Получаем CSRF токен из cookie для сравнения
 		csrfTokenFromCookie := GetCSRFTokenFromCookie(r)
 		valid := true
 		if csrfTokenFromCookie != "" {
 			csrfDebugPrint("[CSRF MIDDLEWARE] CSRF токен из cookie (первые 50 символов): %s...\n",
 				safeSubstring(csrfTokenFromCookie, 0, 50))
 			if csrfTokenFromCookie != csrfToken {
 				csrfDebugPrint("[CSRF MIDDLEWARE] ⚠️  ВНИМАНИЕ: Токен из cookie отличается от токена в запросе!\n")
 				valid = false
 			} else {
 				csrfDebugPrint("[CSRF MIDDLEWARE] ✅ Токен из cookie совпадает с токеном в запросе\n")
 				valid = true
 			}
 		} else {
 			csrfDebugPrint("[CSRF MIDDLEWARE] ⚠️  ВНИМАНИЕ: CSRF токен не найден в cookie!\n")
 			valid = false
 		}
 		// Проверяем CSRF токен
 		if !valid {
 			csrfDebugPrint("[CSRF MIDDLEWARE] ❌ ОШИБКА: Валидация CSRF токена не прошла!\n")
 			// Для API запросов возвращаем JSON ошибку
 			if isAPIRequest(r) {
 				w.Header().Set("Content-Type", "application/json")
 				w.WriteHeader(http.StatusForbidden)
 				w.Write([]byte(`{"success": false, "error": "Invalid CSRF token"}`))
 				return
 			}
 			// Для веб-запросов возвращаем ошибку
 			http.Error(w, "Invalid OR Empty CSRF token", http.StatusForbidden)
 			return
 		}
 		csrfManager := GetCSRFManager()
-		if csrfManager == nil {
+		if csrfManager == nil || !csrfManager.ValidateToken(csrfToken, sessionID) {
 			csrfDebugPrint("[CSRF MIDDLEWARE] ❌ ОШИБКА: CSRF менеджер не инициализирован!\n")
 			if isAPIRequest(r) {
 				w.Header().Set("Content-Type", "application/json")
 				w.WriteHeader(http.StatusForbidden)
 				w.Write([]byte(`{"success": false, "error": "Invalid CSRF token"}`))
 				return
 			}
 			http.Error(w, "Invalid CSRF token", http.StatusForbidden)
 			return
 		}
 		csrfDebugPrint("[CSRF MIDDLEWARE] Вызов ValidateToken с токеном и sessionID: %s\n", sessionID)
 		valid = csrfManager.ValidateToken(csrfToken, sessionID)
 		csrfDebugPrint("[CSRF MIDDLEWARE] Результат ValidateToken: %t\n", valid)
 		if !valid {
 			csrfDebugPrint("[CSRF MIDDLEWARE] ❌ ОШИБКА: Валидация CSRF токена не прошла!\n")
 			// Для API запросов возвращаем JSON ошибку
 			if isAPIRequest(r) {
 				w.Header().Set("Content-Type", "application/json")
@@ -203,8 +96,6 @@ func CSRFMiddleware(next http.HandlerFunc) http.HandlerFunc {
 			return
 		}
 		csrfDebugPrint("[CSRF MIDDLEWARE] ✅ CSRF токен валиден, продолжаем обработку запроса\n")
 		csrfDebugPrint("[CSRF MIDDLEWARE] ==========================================\n\n")
 		// CSRF токен валиден, продолжаем
 		next(w, r)
 	}
--- a/serve/serve.go
+++ b/serve/serve.go
@@ -232,11 +232,11 @@ func registerRoutesExceptHome() {
 	http.HandleFunc(makePath("/api/add-to-history"), AuthMiddleware(CSRFMiddleware(handleAddToHistory)))
 	// Catch-all 404 для любых незарегистрированных путей (только когда BasePath задан)
-	// if getBasePath() != "" {
+	if getBasePath() != "" {
-	// 	http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
+		http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
-	// 		renderNotFound(w, "Страница не найдена", getBasePath())
+			renderNotFound(w, "Страница не найдена", getBasePath())
-	// 	})
+		})
-	// }
+	}
 }
 // registerRoutes регистрирует все маршруты сервера
--- a/serve/templates/execute.css.go
+++ b/serve/templates/execute.css.go
@@ -72,9 +72,8 @@ var ExecutePageCSSTemplate = template.Must(template.New("execute_css").Parse(`
            text-align: center;
        }
        .header h1 {
            margin: 0;
            font-size: 2.5em;
-            font-weight: 300;
+            margin-bottom: 10px;
        }
        .header p {
            opacity: 0.9;
--- a/serve/templates/history.go
+++ b/serve/templates/history.go
@@ -118,19 +118,17 @@ const HistoryPageTemplate = `
            -webkit-box-orient: vertical;
        }
        .delete-btn {
-            background: transparent;
+            background: #e74c3c;
-            color: #ef9a9a; /* бледно-красный */
+            color: white;
            border: none;
-            padding: 2px 6px;
+            padding: 6px 12px;
            border-radius: 4px;
            cursor: pointer;
-            font-size: 18px;
+            font-size: 0.8em;
-            line-height: 1;
+            transition: background 0.3s ease;
            transition: color 0.2s ease, transform 0.2s ease;
        }
        .delete-btn:hover {
-            color: rgb(171, 27, 24); /* ярче при ховере */
+            background: #c0392b;
            transform: translateY(-1px);
        }
        .empty-state {
            text-align: center;
@@ -187,7 +185,7 @@ const HistoryPageTemplate = `
                        <span class="history-index">#{{.Index}}</span>
                        <span class="history-timestamp">{{.Timestamp}}</span>
                    </div>
-                    <button class="delete-btn" onclick="event.stopPropagation(); deleteHistoryEntry({{.Index}})">✖</button>
+                    <button class="delete-btn" onclick="event.stopPropagation(); deleteHistoryEntry({{.Index}})">🗑️ Удалить</button>
                </div>
                <div class="history-command">{{.Command}}</div>
                <div class="history-response">{{.Response}}</div>
--- a/serve/templates/not_found.go
+++ b/serve/templates/not_found.go
@@ -53,16 +53,6 @@ const NotFoundTemplate = `
      backdrop-filter: blur(10px);
      text-align: center;
    }
    @keyframes pulse {
      0%, 100% {
        transform: scale(1);
        text-shadow: 0 8px 40px var(--accentGlow);
      }
      50% {
        transform: scale(1.15);
        text-shadow: 0 12px 60px var(--accentGlow), 0 0 30px var(--accentGlow2);
      }
    }
    .code {
      font-size: clamp(48px, 12vw, 120px);
      line-height: 0.9;
@@ -74,8 +64,6 @@ const NotFoundTemplate = `
      color: transparent;
      margin: 8px 0 12px 0;
      text-shadow: 0 8px 40px var(--accentGlow);
      animation: pulse 2.5s ease-in-out infinite;
      transform-origin: center;
    }
    .title {
      font-size: clamp(18px, 3.2vw, 28px);
@@ -145,7 +133,7 @@ const NotFoundTemplate = `
  <div class="card">
    <div class="code">404</div>
    <div class="title">Страница не найдена</div>
-    <p class="desc">Такой страницы не существует. Вы можете вернуться на главную страницу или выполнить команду.</p>
+    <p class="desc">{{.Message}}</p>
    <div class="btns">
      <a class="btn" href="{{.BasePath}}/">🏠 На главную</a>
      <a class="btn secondary" href="{{.BasePath}}/run">🚀 К выполнению</a>
@@ -155,3 +143,5 @@ const NotFoundTemplate = `
 </body>
 </html>
 `
--- a/serve/templates/results.go
+++ b/serve/templates/results.go
@@ -173,15 +173,7 @@ const ResultsPageTemplate = `
            .header { padding: 20px; }
            .header h1 { font-size: 1.9em; }
            .content { padding: 20px; }
-            .files-grid { dummy-attr: none; }
+            .files-grid { grid-template-columns: 1fr; }
            /* Стили карточек как в истории */
            .file-card { background: #f0f8f0; border: 1px solid #a8e6cf; padding: 15px; }
            .file-card:hover { border-color: #2d5016; box-shadow: 0 8px 25px rgba(45,80,22,0.2); transform: translateY(-2px); }
            .file-name { color: #333; margin-bottom: 8px; }
            .file-info { color: #666; font-size: 0.9em; }
            .file-preview { background: #f8f9fa; border-left: 3px solid #2d5016; font-size: 0.85em; }
            .file-actions { top: 8px; left: 8px; }
            .delete-btn { padding: 2px 6px; font-size: 16px; }
            .stats { grid-template-columns: 1fr 1fr; }
            .nav-buttons { flex-direction: column; gap: 8px; }
            .nav-btn, .nav-button { text-align: center; padding: 12px 16px; font-size: 14px; }
Author	SHA1	Message	Date
Anton Kuznetcov	a20fb846f0	Merged main into release while building v2.0.11	2025-10-28 17:30:35 +06:00
Anton Kuznetcov	90cfc6fb0c	Merged main into release while building v2.0.11	2025-10-28 16:58:58 +06:00
Anton Kuznetcov	114146f4d2	Merged main into release while building v2.0.10	2025-10-28 16:07:20 +06:00
Anton Kuznetcov	b4b902cb4c	Merged main into release while building v2.0.7	2025-10-28 15:12:13 +06:00
Anton Kuznetcov	7933abe62d	Merged main into release while building v2.0.7	2025-10-28 14:52:58 +06:00
Anton Kuznetcov	d213de7a95	Merged main into release while building v2.0.5	2025-10-28 14:42:21 +06:00
Anton Kuznetcov	81b01d74ae	Merged main into release while building v2.0.6	2025-10-28 14:33:44 +06:00
Anton Kuznetcov	1fbdd237a3	Merged main into release while building v2.0.5	2025-10-28 14:25:53 +06:00
Anton Kuznetcov	2d82b91090	Merged main into release while building v2.0.5	2025-10-28 14:24:25 +06:00
Anton Kuznetcov	5d3829d1fe	Merged main into release while building v2.0.5	2025-10-28 12:56:19 +06:00
Anton Kuznetcov	edadedcf80	Merged main into release while building v2.0.4	2025-10-28 12:48:28 +06:00
Anton Kuznetcov	5ff6d4e072	Merged main into release while building v2.0.4	2025-10-28 12:05:38 +06:00
Anton Kuznetcov	ffc2d6ba0a	Merged main into release while building v2.0.4	2025-10-28 11:58:25 +06:00
Anton Kuznetcov	dab94df7d2	Merged main into release while building v2.0.3	2025-10-28 10:38:19 +06:00
Anton Kuznetcov	281f7f877a	Merged main into release while building v2.0.3	2025-10-28 10:29:20 +06:00