Merge branch 'main' of github.com:Direct-Dev-Ru/go-lcg into main

.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 }}"

Dockerfiles/OllamaServer/Dockerfile

@@ -1,74 +1,89 @@
-# Multi-stage build для LCG с Ollama
+# Используем готовый образ Ollama
-FROM golang:1.24.6-alpine3.22 AS builder
+FROM localhost/ollama_packed:latest
 
-WORKDIR /build
+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 
 
-# Копируем файлы зависимостей
-COPY go.mod go.sum ./
-RUN go mod download
 
-# Копируем исходный код
+# Устанавливаем bash если его нет (базовый образ ollama может быть на разных дистрибутивах)
-COPY . .
+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
 
-# Собираем бинарник
+# Определяем архитектуру для копирования правильного бинарника
-RUN CGO_ENABLED=0 GOOS=linux go build -ldflags="-w -s -buildid=" -trimpath -o /build/lcg .
-
-# Финальный образ с Ollama
-FROM alpine:3.22
-
-# Устанавливаем необходимые пакеты
-RUN apk add --no-cache \
-    curl \
-    ca-certificates \
-    bash \
-    && rm -rf /var/cache/apk/*
-
-# Устанавливаем Ollama 0.9.5 (поддержка разных архитектур)
 ARG TARGETARCH
-RUN case ${TARGETARCH} in \
+ARG TARGETOS=linux
-    amd64) OLLAMA_ARCH=amd64 ;; \
+
-    arm64) OLLAMA_ARCH=arm64 ;; \
+# Копируем папку dist с бинарниками
-    arm) OLLAMA_ARCH=arm64 ;; \
+# Структура: dist/lcg_linux_amd64_v1/lcg_* или dist/lcg_linux_arm64_v8.0/lcg_*
-    *) echo "Unsupported architecture: ${TARGETARCH}" && exit 1 ;; \
+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 && \
-    curl -L https://github.com/ollama/ollama/releases/download/v0.9.5/ollama-linux-${OLLAMA_ARCH} -o /usr/local/bin/ollama \
+    chmod +x /usr/local/bin/lcg && \
-    && chmod +x /usr/local/bin/ollama
+    rm -rf /tmp/dist && \
-
+    (lcg --version || echo "Бинарник lcg установлен")
-# Создаем пользователя для запуска сервисов
-RUN addgroup -g 1000 ollama && \
-    adduser -D -u 1000 -G ollama ollama && \
-    mkdir -p /home/ollama/.ollama && \
-    chown -R ollama:ollama /home/ollama
-
-# Копируем бинарник lcg
-COPY --from=builder /build/lcg /usr/local/bin/lcg
-RUN chmod +x /usr/local/bin/lcg
 
 # Копируем entrypoint скрипт
 COPY --chmod=755 Dockerfiles/OllamaServer/entrypoint.sh /entrypoint.sh
 
-# Создаем директории для данных
+# Создаем директории для данных LCG
-RUN mkdir -p /app/data/results /app/data/prompts /app/data/config \
+# В базовом образе ollama уже есть пользователь ollama
-    && chown -R ollama:ollama /app/data
+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=codegeex4
+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_SERVER_ALLOW_HTTP=true
+ENV LCG_DOMAIN="remote.ollama-server.ru"
-ENV OLLAMA_HOST=0.0.0.0
+ENV LCG_COOKIE_PATH="/lcg"
-ENV OLLAMA_PORT=11434
+# 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 11434
+EXPOSE 8080
-
-# Переключаемся на пользователя ollama
-USER ollama
 
 WORKDIR /home/ollama
 

Dockerfiles/OllamaServer/Makefile

@@ -23,37 +23,71 @@ help: ## Показать справку
 	@echo "  make podman-compose-up   - Запустить через podman-compose"
 	@echo "  make podman-compose-down - Остановить podman-compose"
 
-build: ## Собрать Docker образ
+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 образ
+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) \
+		--name ${CONTAINER_NAME} \
-		-p 8080:8080 \
+		-p 8989: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 \
-		$(IMAGE_NAME):$(IMAGE_TAG)
+		${IMAGE_NAME}:${IMAGE_TAG} ollama serve
-	@echo "Контейнер $(CONTAINER_NAME) запущен"
+	@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) \
+		--name ${CONTAINER_NAME} \
-		-p 8080:8080 \
+		--restart always \
-		-p 11434:11434 \
+		-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)
+		${IMAGE_NAME}:${IMAGE_TAG} ollama serve
-	@echo "Контейнер $(CONTAINER_NAME) запущен"
+	@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

Dockerfiles/OllamaServer/QUICKSTART.md

@@ -4,7 +4,17 @@
 
 1. Убедитесь, что у вас установлен Docker или Podman
 2. Клонируйте репозиторий (если еще не сделали)
-3. Перейдите в папку с Dockerfile
+3. Соберите бинарники (требуется перед сборкой образа)
+
+```bash
+# Из корня проекта
+goreleaser build --snapshot --clean
+
+# Или используйте скрипт
+./deploy/4.build-binaries.sh v2.0.15
+```
+
+4. Перейдите в папку с Dockerfile
 
 ```bash
 cd Dockerfiles/OllamaServer
@@ -15,14 +25,16 @@ cd Dockerfiles/OllamaServer
 ### Вариант 1: Docker Compose (рекомендуется)
 
 ```bash
+# Важно: убедитесь, что бинарники собраны в ../../dist/
 docker-compose up -d
 ```
 
 ### Вариант 2: Ручная сборка и запуск
 
 ```bash
-# Сборка образа
+# Сборка образа (контекст должен быть корень проекта)
-docker build -f Dockerfile -t lcg-ollama:latest ../..
+cd ../..  # Переходим в корень проекта
+docker build -f Dockerfiles/OllamaServer/Dockerfile -t lcg-ollama:latest .
 
 # Запуск контейнера
 docker run -d \
@@ -45,8 +57,9 @@ podman-compose -f podman-compose.yml up -d
 ### Вариант 2: Ручная сборка и запуск
 
 ```bash
-# Сборка образа
+# Сборка образа (контекст должен быть корень проекта)
-podman build -f Dockerfile -t lcg-ollama:latest ../..
+cd ../..  # Переходим в корень проекта
+podman build -f Dockerfiles/OllamaServer/Dockerfile -t lcg-ollama:latest .
 
 # Запуск контейнера
 podman run -d \

Dockerfiles/OllamaServer/README.md

@@ -7,62 +7,111 @@
 ## 📋 Описание
 
 Контейнер автоматически запускает:
-1. **Ollama сервер** (v0.9.5) на порту 11434
+
-2. **LCG веб-сервер** на порту 8080
+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
+#### Docker run
+
 ```bash
 docker run -d \
   --name lcg-ollama \
-  -p 8080:8080 \
+  -p 8080:8080 \  
-  -p 11434:11434 \
   lcg-ollama:latest
+  ollama serve
 ```
 
-#### Podman
+#### Podman run
+
 ```bash
 podman run -d \
   --name lcg-ollama \
-  -p 8080:8080 \
+  -p 8989:8080 \
-  -p 11434:11434 \
+  --restart always \
-  lcg-ollama:latest
+  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
@@ -72,8 +121,8 @@ podman play kube podman-compose.yml
 
 После запуска контейнера доступны:
 
-- **LCG веб-интерфейс**: http://localhost:8080
+- **LCG веб-интерфейс**: <http://localhost:8080>
-- **Ollama API**: http://localhost:11434
+- **Ollama API**: <http://localhost:11434>
 
 ## ⚙️ Переменные окружения
 
@@ -278,7 +327,8 @@ podman logs -f lcg-ollama
 
 ### Просмотр логов
 
-#### Docker
+#### Docker log
+
 ```bash
 # Логи контейнера
 docker logs lcg-ollama
@@ -287,7 +337,8 @@ docker logs lcg-ollama
 docker logs -f lcg-ollama
 ```
 
-#### Podman
+#### Podman log
+
 ```bash
 # Логи контейнера
 podman logs lcg-ollama
@@ -298,24 +349,28 @@ podman logs -f lcg-ollama
 
 ### Подключение к контейнеру
 
-#### Docker
+#### Docker exec
+
 ```bash
 docker exec -it lcg-ollama sh
 ```
 
-#### Podman
+#### Podman exec
+
 ```bash
 podman exec -it lcg-ollama sh
 ```
 
 ### Проверка процессов
 
-#### Docker
+#### Docker check ps
+
 ```bash
 docker exec lcg-ollama ps aux
 ```
 
-#### Podman
+#### Podman  check ps
+
 ```bash
 podman exec lcg-ollama ps aux
 ```
@@ -325,6 +380,7 @@ podman exec lcg-ollama ps aux
 ### Рекомендации для продакшена
 
 1. **Используйте аутентификацию**:
+
    ```bash
    -e LCG_SERVER_REQUIRE_AUTH=true
    -e LCG_SERVER_PASSWORD=strong_password
@@ -339,6 +395,7 @@ podman exec lcg-ollama ps aux
    - Используйте SSL сертификаты
 
 4. **Ограничьте ресурсы**:
+
    ```bash
    docker run -d \
      --name lcg-ollama \
@@ -390,8 +447,8 @@ docker-compose up -d
 ## ❓ Поддержка
 
 При возникновении проблем:
+
 1. Проверьте логи: `docker logs lcg-ollama`
 2. Проверьте переменные окружения
 3. Убедитесь, что порты не заняты
 4. Проверьте, что модели загружены в Ollama
-

Dockerfiles/OllamaServer/STRUCTURE.md

@@ -19,14 +19,21 @@ Dockerfiles/OllamaServer/
 ## Описание файлов
 
 ### Dockerfile
-Multi-stage Dockerfile, который:
+
-1. Собирает бинарник LCG из исходного кода
+Dockerfile, который:
-2. Устанавливает Ollama 0.9.5
+
-3. Создает пользователя ollama
+1. Использует готовый образ `ollama/ollama:0.9.5` как базовый
-4. Настраивает рабочее окружение
+2. Копирует предварительно собранный бинарник LCG из папки `dist/`
+3. Выбирает правильный бинарник в зависимости от архитектуры (amd64/arm64)
+4. Устанавливает entrypoint.sh для запуска обоих сервисов
+5. Настраивает рабочее окружение и переменные окружения
+
+**Важно**: Перед сборкой образа необходимо собрать бинарники с помощью `goreleaser build --snapshot --clean`
 
 ### entrypoint.sh
+
 Скрипт запуска, который:
+
 1. Запускает Ollama сервер в фоне
 2. Ожидает готовности Ollama API
 3. Запускает LCG сервер в фоне
@@ -34,21 +41,27 @@ Multi-stage Dockerfile, который:
 5. Корректно обрабатывает сигналы завершения
 
 ### docker-compose.yml / podman-compose.yml
+
 Конфигурация для запуска через compose:
+
 - Настройки портов
 - Переменные окружения
 - Volumes для персистентного хранения
 - Healthcheck
 
 ### Makefile
+
 Удобные команды для:
+
 - Сборки образа
 - Запуска/остановки контейнера
 - Просмотра логов
 - Работы с compose
 
 ### README.md
+
 Полная документация с:
+
 - Описанием функциональности
 - Инструкциями по установке
 - Настройками переменных окружения
@@ -56,6 +69,7 @@ Multi-stage Dockerfile, который:
 - Решением проблем
 
 ### QUICKSTART.md
+
 Краткое руководство для быстрого старта.
 
 ## Порты
@@ -73,6 +87,7 @@ Multi-stage Dockerfile, который:
 ## Переменные окружения
 
 Основные переменные (см. README.md для полного списка):
+
 - `LCG_PROVIDER=ollama`
 - `LCG_HOST=http://127.0.0.1:11434/`
 - `LCG_MODEL=codegeex4`
@@ -81,31 +96,48 @@ Multi-stage Dockerfile, который:
 
 ## Запуск
 
+### Предварительная подготовка
+
+Перед сборкой образа необходимо собрать бинарники:
+
+```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 compose-up
+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.
-

Dockerfiles/OllamaServer/docker-compose.yml

@@ -3,8 +3,9 @@ version: '3.8'
 services:
   lcg-ollama:
     build:
-      context: ../..
+      context: ../..  # Контекст сборки - корень проекта (для доступа к dist/)
       dockerfile: Dockerfiles/OllamaServer/Dockerfile
+      # TARGETARCH определяется автоматически Docker на основе платформы хоста
     container_name: lcg-ollama
     ports:
       - "8080:8080"  # LCG веб-сервер

Dockerfiles/OllamaServer/entrypoint.sh

@@ -32,10 +32,6 @@ cleanup() {
         kill $LCG_PID 2>/dev/null || true
         wait $LCG_PID 2>/dev/null || true
     fi
-    if [ ! -z "$OLLAMA_PID" ]; then
-        kill $OLLAMA_PID 2>/dev/null || true
-        wait $OLLAMA_PID 2>/dev/null || true
-    fi
     log "Сервисы остановлены"
     exit 0
 }
@@ -48,11 +44,6 @@ if [ ! -f /usr/local/bin/lcg ]; then
     exit 1
 fi
 
-# Проверка наличия Ollama
-if [ ! -f /usr/local/bin/ollama ]; then
-    error "Ollama не найден в /usr/local/bin/ollama"
-    exit 1
-fi
 
 # Создаем необходимые директории
 mkdir -p "${LCG_RESULT_FOLDER:-/app/data/results}"
@@ -66,14 +57,20 @@ export OLLAMA_ORIGINS="*"
 
 # Настройка переменных окружения для LCG
 export LCG_PROVIDER="${LCG_PROVIDER:-ollama}"
-export LCG_HOST="${LCG_HOST:-http://127.0.0.1:11434/}"
+export LCG_HOST="${LCG_HOST:-http://0.0.0.0:11434/}"
-export LCG_MODEL="${LCG_MODEL:-codegeex4}"
+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:-true}"
+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 сервером"
@@ -85,39 +82,7 @@ info "LCG Server: http://${LCG_SERVER_HOST}:${LCG_SERVER_PORT}"
 info "Ollama Host: $OLLAMA_HOST:$OLLAMA_PORT"
 log "=========================================="
 
-# Запускаем Ollama сервер в фоне
-log "Запуск Ollama сервера..."
-/usr/local/bin/ollama serve &
-OLLAMA_PID=$!
 
-# Ждем, пока Ollama запустится
-log "Ожидание запуска Ollama сервера..."
-sleep 5
-
-# Проверяем, что Ollama запущен
-if ! kill -0 $OLLAMA_PID 2>/dev/null; then
-    error "Ollama сервер не запустился"
-    exit 1
-fi
-
-# Проверяем доступность Ollama API
-max_attempts=30
-attempt=0
-while [ $attempt -lt $max_attempts ]; do
-    # Проверяем через localhost, так как OLLAMA_HOST может быть 0.0.0.0
-    if curl -s -f "http://127.0.0.1:${OLLAMA_PORT}/api/tags" > /dev/null 2>&1; then
-        log "Ollama сервер готов!"
-        break
-    fi
-    attempt=$((attempt + 1))
-    if [ $attempt -eq $max_attempts ]; then
-        error "Ollama сервер не отвечает после $max_attempts попыток"
-        exit 1
-    fi
-    sleep 1
-done
-
-# Запускаем LCG сервер в фоне
 log "Запуск LCG сервера..."
 /usr/local/bin/lcg serve \
     --host "${LCG_SERVER_HOST}" \
@@ -129,43 +94,11 @@ sleep 3
 
 # Проверяем, что LCG запущен
 if ! kill -0 $LCG_PID 2>/dev/null; then
-    error "LCG сервер не запустился"
+    error "LCG сервер не запустился"    
-    kill $OLLAMA_PID 2>/dev/null || true
     exit 1
 fi
 
 log "LCG сервер запущен на http://${LCG_SERVER_HOST}:${LCG_SERVER_PORT}"
-log "Ollama сервер доступен на http://${OLLAMA_HOST}:${OLLAMA_PORT}"
-log "=========================================="
-log "Сервисы запущены и готовы к работе!"
-log "=========================================="
-
-# Функция для проверки здоровья процессов
-health_check() {
-    while true; do
-        # Проверяем Ollama
-        if ! kill -0 $OLLAMA_PID 2>/dev/null; then
-            error "Ollama процесс завершился неожиданно"
-            kill $LCG_PID 2>/dev/null || true
-            exit 1
-        fi
-        
-        # Проверяем LCG
-        if ! kill -0 $LCG_PID 2>/dev/null; then
-            error "LCG процесс завершился неожиданно"
-            kill $OLLAMA_PID 2>/dev/null || true
-            exit 1
-        fi
-        
-        sleep 10
-    done
-}
-
-# Запускаем проверку здоровья в фоне
-health_check &
-HEALTH_CHECK_PID=$!
-
-# Ждем завершения процессов
-wait $LCG_PID $OLLAMA_PID
-kill $HEALTH_CHECK_PID 2>/dev/null || true
 
+# Запускаем переданные аргументы
+exec "$@"

VERSION.txt

@@ -1 +1 @@
-v2.0.15
+v2.0.28

config/config.go

@@ -27,6 +27,8 @@ type Config struct {
 	ResultHistory  string
 	NoHistoryEnv   string
 	AllowExecution bool
+	Think          bool
+	Query          string
 	MainFlags      MainFlags
 	Server         ServerConfig
 	Validation     ValidationConfig
@@ -57,6 +59,7 @@ type ServerConfig struct {
 	CookieSecure   bool
 	CookiePath     string
 	CookieTTLHours int
+	ForceNoCSRF    bool
 }
 
 type ValidationConfig struct {
@@ -165,6 +168,7 @@ 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),
@@ -213,6 +217,15 @@ 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() {

deploy/VERSION.txt

@@ -1 +1 @@
-v2.0.15
+v2.0.28

gpt/gpt.go

@@ -44,11 +44,19 @@ type Chat struct {
 
 type Gpt3Request struct {
 	Model    string      `json:"model"`
-	Stream   bool        `json:"stream"`
+	Stream   bool        `json:"stream"`	
 	Messages []Chat      `json:"messages"`
 	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"`
 }

gpt/providers.go

@@ -200,12 +200,26 @@ 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,
+		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 {

kustomize/configmap.yaml

@@ -5,7 +5,7 @@ metadata:
   namespace: lcg
 data:
   # Основные настройки
-  LCG_VERSION: "v2.0.14"
+  LCG_VERSION: "v2.0.28"
   LCG_BASE_PATH: "/lcg"
   LCG_SERVER_HOST: "0.0.0.0"
   LCG_SERVER_PORT: "8080"  

kustomize/deployment.yaml

@@ -5,7 +5,7 @@ metadata:
   namespace: lcg
   labels:
     app: lcg
-    version: v2.0.14
+    version: v2.0.28
 spec:
   replicas: 1
   selector:
@@ -18,7 +18,7 @@ spec:
     spec:
       containers:
       - name: lcg
-        image: kuznetcovay/lcg:v2.0.14
+        image: kuznetcovay/lcg:v2.0.28
         imagePullPolicy: Always
         ports:
         - containerPort: 8080

kustomize/kustomization.yaml

@@ -15,11 +15,11 @@ resources:
 # Common labels
 # commonLabels:
 #   app: lcg
-#   version: v2.0.14
+#   version: v2.0.28
 #   managed-by: kustomize
 
 # Images
 # images:
 #   - name: lcg
 #     newName: kuznetcovay/lcg
-#     newTag: v2.0.14
+#     newTag: v2.0.28

main.go

@@ -9,6 +9,7 @@ import (
 	"os/exec"
 	"os/user"
 	"path/filepath"
+	"slices"
 	"strconv"
 	"strings"
 	"time"
@@ -76,6 +77,12 @@ func main() {
 		Usage:    config.AppConfig.AppName + " - Генерация Linux команд из описаний",
 		Version:  Version,
 		Commands: getCommands(),
+		Before: func(c *cli.Context) error {
+			// Применяем флаги приложения к конфигурации перед выполнением любой команды
+			// Это гарантирует, что флаги будут применены даже для команд, которые не используют основной Action
+			applyAppFlagsToConfig(c)
+			return nil
+		},
 		UsageText: `
 lcg [опции] <описание команды>
 
@@ -102,6 +109,7 @@ lcg [опции] <описание команды>
   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" = отключено, пусто = включено)
@@ -144,12 +152,31 @@ 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"},
@@ -181,16 +208,28 @@ lcg [опции] <описание команды>
 		Action: func(c *cli.Context) error {
 			file := c.String("file")
 			system := c.String("sys")
+			model := c.String("model")
+			query := c.String("query")
 			// обновляем конфиг на основе флагов
-			if system != "" {
+			if c.IsSet("sys") && 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"),
@@ -203,12 +242,9 @@ 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 {
+			if len(args) == 0 && config.AppConfig.Query == "" {
 				cli.ShowAppHelp(c)
 				showTips()
 				return nil
@@ -231,6 +267,12 @@ 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
 		},
@@ -251,6 +293,31 @@ 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{
 		{
@@ -390,6 +457,10 @@ func getCommands() []*cli.Command {
 				},
 			},
 			Action: func(c *cli.Context) error {
+				// Флаги приложения уже применены через глобальный Before hook
+				// Но применяем их еще раз на случай, если глобальный Before не сработал
+				applyAppFlagsToConfig(c)
+
 				if c.Bool("full") {
 					// Выводим полную конфигурацию в JSON формате
 					showFullConfig()
@@ -957,7 +1028,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)
@@ -1027,12 +1098,7 @@ func getServerAllowHTTPForHost(host string) bool {
 // isSecureHost проверяет, является ли хост безопасным для HTTP
 func isSecureHost(host string) bool {
 	secureHosts := []string{"localhost", "127.0.0.1", "::1"}
-	for _, secureHost := range secureHosts {
+	return slices.Contains(secureHosts, host)
-		if host == secureHost {
-			return true
-		}
-	}
-	return false
 }
 
 // showShortConfig показывает краткую конфигурацию

serve/auth.go

@@ -127,7 +127,6 @@ 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,

serve/csrf.go

@@ -8,11 +8,89 @@ 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
@@ -68,6 +146,8 @@ 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),
@@ -75,53 +155,85 @@ 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))
 
-	return fmt.Sprintf("%s.%s", encodedData, signature), nil
+	token := fmt.Sprintf("%s.%s", encodedData, signature)
+	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)
 
-	// Проверяем время жизни токена (24 часа)
+	// Проверяем время жизни токена (минимум 12 часов)
 	timestamp, err := parseInt64(timestampStr)
 	if err != nil {
+		csrfDebugPrint("[CSRF DEBUG] ❌ ОШИБКА: Не удалось распарсить timestamp '%s': %v\n", timestampStr, err)
 		return false
 	}
 
-	if time.Now().Unix()-timestamp > 24*60*60 {
+	now := time.Now().Unix()
+	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{
@@ -132,7 +244,30 @@ func (c *CSRFManager) ValidateToken(token, userID string) bool {
 
 	// Проверяем подпись
 	expectedSignature := c.createSignature(data)
-	return signature == expectedSignature
+	signatureMatch := 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 создает подпись для данных
@@ -153,22 +288,35 @@ 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:   1 * 60 * 60,
+		MaxAge:   CSRFTokenLifetimeSeconds, // Минимум 12 часов в секундах
 	}
 
 	// Добавляем домен если указан
 	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
@@ -252,6 +400,11 @@ 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

serve/execute_page.go

@@ -233,6 +233,9 @@ func handleExecuteRequest(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
+	// Устанавливаем CSRF токен в cookie после обработки запроса
+	setCSRFCookie(w, csrfToken)
+
 	data := ExecutePageData{
 		Title:                "Результат выполнения",
 		Header:               "Результат выполнения",

serve/login.go

@@ -92,6 +92,7 @@ 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
 	}
 
@@ -99,7 +100,12 @@ 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))
-	return hex.EncodeToString(hash[:])[:16]
+	sessionID := hex.EncodeToString(hash[:])[:16]
+	csrfDebugPrint("[CSRF DEBUG] Сгенерирован SessionID: %s\n", sessionID)
+	return sessionID
 }

serve/middleware.go

@@ -45,25 +45,77 @@ 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 токен из заголовка или формы
-		csrfToken := r.Header.Get("X-CSRF-Token")
+		csrfTokenFromHeader := 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 = r.FormValue("csrf_token")
+			csrfToken = csrfTokenFromForm
 		}
 
 		if csrfToken == "" {
+			csrfDebugPrint("[CSRF MIDDLEWARE] ❌ ОШИБКА: CSRF токен не найден ни в заголовке, ни в форме!\n")
 			// Для API запросов возвращаем JSON ошибку
 			if isAPIRequest(r) {
 				w.Header().Set("Content-Type", "application/json")
@@ -77,12 +129,67 @@ 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 || !csrfManager.ValidateToken(csrfToken, sessionID) {
+		if csrfManager == nil {
+			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")
@@ -96,6 +203,8 @@ func CSRFMiddleware(next http.HandlerFunc) http.HandlerFunc {
 			return
 		}
 
+		csrfDebugPrint("[CSRF MIDDLEWARE] ✅ CSRF токен валиден, продолжаем обработку запроса\n")
+		csrfDebugPrint("[CSRF MIDDLEWARE] ==========================================\n\n")
 		// CSRF токен валиден, продолжаем
 		next(w, r)
 	}

serve/templates/execute.css.go

@@ -72,8 +72,9 @@ var ExecutePageCSSTemplate = template.Must(template.New("execute_css").Parse(`
             text-align: center;
         }
         .header h1 {
+            margin: 0;
             font-size: 2.5em;
-            margin-bottom: 10px;
+            font-weight: 300;
         }
         .header p {
             opacity: 0.9;