docs: add release notes for v0.2.7

**Windows compatibility:**
- Added filepath.Join for all template and static paths
- Fixes "path not found" errors on Windows

**Localhost binding:**
- Changed default host from 0.0.0.0 to 127.0.0.1
- Browser always opens on 127.0.0.1 (localhost)
- Setup mode now listens on 127.0.0.1:8080
- Updated config.example.yaml with comment about 0.0.0.0

This ensures the app works correctly on Windows and opens
browser on the correct localhost address.

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>

.dockerignore

@@ -1,33 +0,0 @@
-# Git
-.git
-.gitignore
-
-# IDE
-.idea
-.vscode
-*.swp
-*.swo
-
-# Build artifacts
-server
-*.exe
-bin/
-
-# Config with secrets
-config.yaml
-
-# Documentation
-*.md
-LICENSE
-
-# Claude
-.claude
-
-# Test files
-*_test.go
-test_*.csv
-test_*.xlsx
-
-# Misc
-.DS_Store
-*.log

.gitignore

@@ -1,6 +1,12 @@
 # QuoteForge
 config.yaml
 
+# Local SQLite database (contains encrypted credentials)
+/data/*.db
+/data/*.db-journal
+/data/*.db-shm
+/data/*.db-wal
+
 # Binaries
 /server
 /importer
@@ -35,3 +41,4 @@ Network Trash Folder
 Temporary Items
 .apdisk
 
+releases/

CLAUDE.md

@@ -1,392 +1,163 @@
 # QuoteForge - Claude Code Instructions
 
-## Project Overview
+## Overview
+Корпоративный конфигуратор серверов и формирование КП. MariaDB (RFQ_LOG) + SQLite для оффлайн.
 
-QuoteForge — корпоративный инструмент для конфигурирования серверов и формирования коммерческих предложений (КП). Приложение интегрируется с существующей базой данных RFQ_LOG.
+## Development Phases
+
+### Phase 1: Pricelists in MariaDB ✅ DONE
+### Phase 2: Local SQLite Database ✅ DONE
+
+### Phase 2.5: Full Offline Mode 🔶 IN PROGRESS
+**Local-first architecture:** приложение ВСЕГДА работает с SQLite, MariaDB только для синхронизации.
+
+**Принцип работы:**
+- ВСЕ операции (CRUD) выполняются в SQLite
+- При создании конфигурации:
+  1. Если online → проверить новые прайслисты на сервере → скачать если есть
+  2. Далее работаем с local_pricelists (и online, и offline одинаково)
+- Background sync: push pending_changes → pull updates
+
+**DONE:**
+- ✅ Sync queue table (pending_changes) - `internal/localdb/models.go`
+- ✅ Model converters: MariaDB ↔ SQLite - `internal/localdb/converters.go`
+- ✅ LocalConfigurationService: все CRUD через SQLite - `internal/services/local_configuration.go`
+- ✅ Pre-create pricelist check: `SyncPricelistsIfNeeded()` - `internal/services/sync/service.go`
+- ✅ Push pending changes: `PushPendingChanges()` - sync service + handlers
+- ✅ Sync API endpoints: `/api/sync/push`, `/pending/count`, `/pending`
+- ✅ Integrate LocalConfigurationService in main.go (replace ConfigurationService)
+- ✅ Add routes for new sync endpoints (`/api/sync/push`, `/pending/count`, `/pending`)
+- ✅ ConfigurationGetter interface for handler compatibility
+- ✅ Background sync worker: auto-sync every 5min (push + pull) - `internal/services/sync/worker.go`
+- ✅ UI: sync status indicator (pending badge + sync button + offline/online dot) - `web/templates/partials/sync_status.html`
+- ✅ RefreshPrices for local mode:
+  - `RefreshPrices()` / `RefreshPricesNoAuth()` в `local_configuration.go`
+  - Берёт цены из `local_components.current_price`
+  - Graceful degradation при отсутствии компонента
+  - Добавлено поле `price_updated_at` в `LocalConfiguration` (models.go:72)
+  - Обновлены converters для PriceUpdatedAt
+  - UI кнопка "Пересчитать цену" работает offline/online
+- ✅ Fixed sync bugs:
+  - Duplicate entry error при update конфигураций (`sync/service.go:334-365`)
+  - pushConfigurationUpdate теперь проверяет наличие server_id перед update
+  - Если нет ID → получает из LocalConfiguration.ServerID или ищет на сервере
+  - Fixed setup.go: `settings.Password` → `settings.PasswordEncrypted`
+
+**TODO:**
+- ❌ Conflict resolution (Phase 4, last-write-wins default)
+
+### UI Improvements ✅ MOSTLY DONE
+
+**1. Sync UI + pricelist badge: ✅ DONE**
+- ✅ `sync_status.html`: SVG иконки Online/Offline (кликабельные → открывают модал)
+- ✅ Кнопка sync → иконка circular arrows (только full sync)
+- ✅ Модальное окно "Статус системы" в `base.html` (info о БД, ошибки синхронизации)
+- ✅ `configs.html`: badge с версией активного прайслиста
+- ✅ Загрузка через `/api/pricelists/latest` при DOMContentLoaded
+- ✅ Удалён dropdown с Push changes (упрощение UI)
+
+**2. Прайслисты → вкладка в "Администратор цен": ✅ DONE**
+- ✅ `base.html`: убрана ссылка "Прайслисты" из навигации
+- ✅ `admin_pricing.html`: добавлена вкладка "Прайслисты"
+- ✅ Логика перенесена из `pricelists.html` (table, create modal, CRUD)
+- ✅ Route `/pricelists` → редирект на `/admin/pricing?tab=pricelists`
+- ✅ Поддержка URL param `?tab=pricelists`
+
+**3. Модал "Настройка цены" - кол-во котировок с учётом периода: ❌ TODO**
+- Текущее: показывает только общее кол-во котировок
+- Новое: показывать `N (всего: M)` где N - за выбранный период, M - всего
+- ❌ `admin_pricing.html`: обновить `#modal-quote-count`
+- ❌ `admin_pricing_handler.go`: в `/api/admin/pricing/preview` возвращать `quote_count_period` + `quote_count_total`
+
+**4. Страница настроек: ❌ ОТЛОЖЕНО**
+- Перенесено в Phase 3 (после основных UI улучшений)
+
+### Phase 3: Projects and Specifications
+- qt_projects, qt_specifications tables (MariaDB)
+- Replace qt_configurations → Project/Specification hierarchy
+- Fields: opty, customer_requirement, variant, qty, rev
+- Local projects/specs with server sync
+
+### Phase 4: Price Versioning
+- Bind specifications to pricelist versions
+- Price diff comparison
+- Auto-cleanup expired pricelists (>1 year, usage_count=0)
 
 ## Tech Stack
+Go 1.22+ | Gin | GORM | MariaDB 11 | SQLite (glebarez/sqlite) | htmx + Tailwind CDN | excelize
 
-- **Language:** Go 1.22+
-- **Web Framework:** Gin (github.com/gin-gonic/gin)
-- **ORM:** GORM (gorm.io/gorm)
-- **Database:** MariaDB 11 (existing database RFQ_LOG)
-- **Frontend:** HTML templates + htmx + Tailwind CSS (CDN)
-- **Excel Export:** excelize (github.com/xuri/excelize/v2)
-- **Auth:** JWT (github.com/golang-jwt/jwt/v5)
+## Key Tables
 
-## Project Structure
+### READ-ONLY (external systems)
+- `lot` (lot_name PK, lot_description)
+- `lot_log` (lot, supplier, date, price, quality, comments)
+- `supplier` (supplier_name PK)
 
-```
-quoteforge/
-├── cmd/
-│   ├── server/main.go           # Main HTTP server
-│   └── importer/main.go         # Import metadata from lot table
-├── internal/
-│   ├── config/config.go         # YAML config loading
-│   ├── models/                   # GORM models
-│   ├── handlers/                 # Gin HTTP handlers
-│   ├── services/                 # Business logic
-│   ├── middleware/               # Auth, CORS, roles
-│   └── repository/               # Database queries
-├── web/
-│   ├── templates/                # Go HTML templates
-│   └── static/                   # CSS, JS
-├── migrations/                   # SQL migration files
-├── config.yaml
-└── go.mod
-```
+### MariaDB (qt_* prefix)
+- `qt_lot_metadata` - component prices, methods, popularity
+- `qt_categories` - category codes and names
+- `qt_pricelists` - version snapshots (YYYY-MM-DD-NNN format)
+- `qt_pricelist_items` - prices per pricelist
+- `qt_projects` - uuid, opty, customer_requirement, name (Phase 3)
+- `qt_specifications` - project_id, pricelist_id, variant, rev, qty, items JSON (Phase 3)
 
-## Existing Database Tables (READ-ONLY - DO NOT MODIFY)
+### SQLite (data/quoteforge.db)
+- `connection_settings` - encrypted DB credentials (PasswordEncrypted field)
+- `local_pricelists/items` - cached from server
+- `local_components` - lot cache for offline search (with current_price)
+- `local_configurations` - UUID, items, price_updated_at, sync_status (pending/synced/conflict), server_id
+- `local_projects/specifications` - Phase 3
+- `pending_changes` - sync queue (entity_type, uuid, op, payload, created_at, attempts, last_error)
 
-These tables are used by other systems. Our app only reads from them:
+## Business Logic
 
-```sql
--- Component catalog
-CREATE TABLE lot (
-    lot_name CHAR(255) PRIMARY KEY,      -- e.g., "CPU_AMD_9654", "MB_INTEL_4.Sapphire_2S"
-    lot_description VARCHAR(10000)
-);
+**Part number parsing:** `CPU_AMD_9654` → category=`CPU`, model=`AMD_9654`
 
--- Price history from suppliers
-CREATE TABLE lot_log (
-    lot_log_id BIGINT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
-    lot CHAR(255) NOT NULL,              -- FK → lot.lot_name
-    supplier CHAR(255) NOT NULL,         -- FK → supplier.supplier_name
-    date DATE NOT NULL,
-    price DOUBLE NOT NULL,
-    quality CHAR(255),
-    comments VARCHAR(15000),
-    FOREIGN KEY (lot) REFERENCES lot(lot_name),
-    FOREIGN KEY (supplier) REFERENCES supplier(supplier_name)
-);
+**Price methods:** manual | median | average | weighted_median
 
--- Supplier catalog
-CREATE TABLE supplier (
-    supplier_name CHAR(255) PRIMARY KEY,
-    supplier_comment VARCHAR(10000)
-);
-```
+**Price freshness:** fresh (<30d, ≥3 quotes) | normal (<60d) | stale (<90d) | critical
 
-## New Tables (prefix qt_)
-
-QuoteForge creates these tables:
-
-```sql
--- Users
-CREATE TABLE qt_users (
-    id INT AUTO_INCREMENT PRIMARY KEY,
-    username VARCHAR(100) UNIQUE NOT NULL,
-    email VARCHAR(255) UNIQUE NOT NULL,
-    password_hash VARCHAR(255) NOT NULL,
-    role ENUM('viewer', 'editor', 'pricing_admin', 'admin') DEFAULT 'viewer',
-    is_active BOOLEAN DEFAULT TRUE,
-    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
-);
-
--- Component metadata (extends lot table)
-CREATE TABLE qt_lot_metadata (
-    lot_name CHAR(255) PRIMARY KEY,
-    category_id INT,
-    model VARCHAR(100),                   -- Parsed: CPU_AMD_9654 → "9654"
-    specs JSON,
-    current_price DECIMAL(12,2),
-    price_method ENUM('manual', 'median', 'average', 'weighted_median') DEFAULT 'median',
-    price_period_days INT DEFAULT 90,
-    price_updated_at TIMESTAMP,
-    request_count INT DEFAULT 0,
-    last_request_date DATE,
-    popularity_score DECIMAL(10,4),
-    FOREIGN KEY (lot_name) REFERENCES lot(lot_name)
-);
-
--- Categories
-CREATE TABLE qt_categories (
-    id INT AUTO_INCREMENT PRIMARY KEY,
-    code VARCHAR(20) UNIQUE NOT NULL,    -- MB, CPU, MEM, GPU, SSD, HDD, RAID, NIC, HCA, HBA, DPU, PS
-    name VARCHAR(100) NOT NULL,
-    name_ru VARCHAR(100),
-    display_order INT DEFAULT 0,
-    is_required BOOLEAN DEFAULT FALSE
-);
-
--- Saved configurations
-CREATE TABLE qt_configurations (
-    id INT AUTO_INCREMENT PRIMARY KEY,
-    uuid VARCHAR(36) UNIQUE NOT NULL,
-    user_id INT NOT NULL,
-    name VARCHAR(200) NOT NULL,
-    items JSON NOT NULL,                  -- [{"lot_name": "CPU_AMD_9654", "quantity": 2, "unit_price": 11500}]
-    total_price DECIMAL(12,2),
-    custom_price DECIMAL(12,2),           -- User-defined target price (for discounts)
-    notes TEXT,
-    is_template BOOLEAN DEFAULT FALSE,
-    server_count INT DEFAULT 1,           -- Number of servers in configuration
-    price_updated_at TIMESTAMP,           -- Last time prices were refreshed
-    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-    FOREIGN KEY (user_id) REFERENCES qt_users(id)
-);
-
--- Price overrides
-CREATE TABLE qt_price_overrides (
-    id INT AUTO_INCREMENT PRIMARY KEY,
-    lot_name CHAR(255) NOT NULL,
-    price DECIMAL(12,2) NOT NULL,
-    valid_from DATE NOT NULL,
-    valid_until DATE,
-    reason TEXT,
-    created_by INT NOT NULL,
-    FOREIGN KEY (lot_name) REFERENCES lot(lot_name)
-);
-
--- Alerts for pricing admins
-CREATE TABLE qt_pricing_alerts (
-    id INT AUTO_INCREMENT PRIMARY KEY,
-    lot_name CHAR(255) NOT NULL,
-    alert_type ENUM('high_demand_stale_price', 'price_spike', 'price_drop', 'no_recent_quotes', 'trending_no_price') NOT NULL,
-    severity ENUM('low', 'medium', 'high', 'critical') DEFAULT 'medium',
-    message TEXT NOT NULL,
-    details JSON,
-    status ENUM('new', 'acknowledged', 'resolved', 'ignored') DEFAULT 'new',
-    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
-);
-
--- Usage statistics
-CREATE TABLE qt_component_usage_stats (
-    lot_name CHAR(255) PRIMARY KEY,
-    quotes_total INT DEFAULT 0,
-    quotes_last_30d INT DEFAULT 0,
-    quotes_last_7d INT DEFAULT 0,
-    total_quantity INT DEFAULT 0,
-    total_revenue DECIMAL(14,2) DEFAULT 0,
-    trend_direction ENUM('up', 'stable', 'down') DEFAULT 'stable',
-    trend_percent DECIMAL(5,2) DEFAULT 0,
-    last_used_at TIMESTAMP
-);
-```
-
-## Key Business Logic
-
-### 1. Part Number Parsing
-
-Extract category and model from lot_name:
-```go
-// "CPU_AMD_9654" → category="CPU", model="AMD_9654"
-// "MB_INTEL_4.Sapphire_2S" → category="MB", model="INTEL_4.Sapphire_2S"
-// "MEM_DDR5_64G_5600" → category="MEM", model="DDR5_64G_5600"
-// "GPU_NV_RTX_4090_PCIe" → category="GPU", model="NV_RTX_4090_PCIe"
-
-func ParsePartNumber(lotName string) (category, model string) {
-    parts := strings.SplitN(lotName, "_", 2)
-    if len(parts) >= 1 {
-        category = parts[0]
-    }
-    if len(parts) >= 2 {
-        model = parts[1]
-    }
-    return
-}
-```
-
-### 2. Price Calculation Methods
-
-```go
-// Median - simple median of prices in period
-func CalculateMedian(prices []float64) float64
-
-// Average - arithmetic mean
-func CalculateAverage(prices []float64) float64
-
-// Weighted Median - recent prices have higher weight (exponential decay)
-// weight = e^(-days_since_quote / decay_days)
-func CalculateWeightedMedian(prices []PricePoint, decayDays int) float64
-```
-
-### 3. Price Freshness (color coding)
-
-```go
-// Green: < 30 days AND >= 3 quotes
-// Yellow: 30-60 days OR 1-2 quotes
-// Orange: 60-90 days
-// Red: > 90 days OR no price
-
-func GetPriceFreshness(daysSinceUpdate int, quoteCount int) string {
-    if daysSinceUpdate < 30 && quoteCount >= 3 {
-        return "fresh"      // green
-    } else if daysSinceUpdate < 60 {
-        return "normal"     // yellow
-    } else if daysSinceUpdate < 90 {
-        return "stale"      // orange
-    }
-    return "critical"       // red
-}
-```
-
-### 4. Component Sorting
-
-Sort by: popularity + price freshness. Components without prices go to the bottom.
-
-```go
-// Sort score = popularity_score * 10 + freshness_bonus - no_price_penalty
-// freshness_bonus: fresh=100, normal=50, stale=10, critical=0
-// no_price_penalty: -1000 if current_price is NULL or 0
-```
-
-### 5. Alert Generation
-
-Generate alerts when:
-- **high_demand_stale_price** (CRITICAL): >= 5 quotes/month AND price > 60 days old
-- **trending_no_price** (HIGH): trend_percent > 50% AND no price set
-- **no_recent_quotes** (MEDIUM): popular component, no supplier quotes > 90 days
+**Pricelist version:** `YYYY-MM-DD-NNN` (e.g., `2024-01-31-001`)
 
 ## API Endpoints
 
-### Auth
-```
-POST /api/auth/login     → {"username", "password"} → {"token", "refresh_token"}
-POST /api/auth/logout
-POST /api/auth/refresh
-GET  /api/auth/me        → current user info
-```
-
-### Components
-```
-GET /api/components                          → list with pagination
-GET /api/components?category=CPU&vendor=AMD  → filtered
-GET /api/components/:lot_name                → single component details
-GET /api/categories                          → category list
-```
-
-### Quote Builder
-```
-POST /api/quote/validate   → {"items": [...]} → {"valid": bool, "errors": [], "warnings": []}
-POST /api/quote/calculate  → {"items": [...]} → {"items": [...], "total": 45000.00}
-```
-
-### Export
-```
-POST /api/export/csv   → {"items": [...], "name": "Config 1"} → CSV file
-POST /api/export/xlsx  → {"items": [...], "name": "Config 1"} → XLSX file
-```
-
-### Configurations
-```
-GET    /api/configs                      → list user's configurations
-POST   /api/configs                      → save new configuration
-GET    /api/configs/:uuid                → get by UUID
-PUT    /api/configs/:uuid                → update
-POST   /api/configs/:uuid/refresh-prices → refresh prices for all components
-DELETE /api/configs/:uuid                → delete
-GET    /api/configs/:uuid/export         → export as JSON
-```
-
-### Pricing Admin (requires role: pricing_admin or admin)
-```
-GET  /admin/pricing/stats                    → dashboard stats
-GET  /admin/pricing/components               → components with pricing info
-GET  /admin/pricing/components/:lot_name     → component pricing details
-POST /admin/pricing/update                   → update price method/value
-POST /admin/pricing/recalculate-all          → recalculate all prices
-
-GET  /admin/pricing/alerts                   → list alerts
-POST /admin/pricing/alerts/:id/acknowledge   → mark as seen
-POST /admin/pricing/alerts/:id/resolve       → mark as resolved
-POST /admin/pricing/alerts/:id/ignore        → dismiss alert
-```
-
-### htmx Partials
-```
-GET /partials/components?category=CPU&vendor=AMD  → HTML fragment
-GET /partials/cart                                → cart HTML
-GET /partials/summary                             → price summary HTML
-```
-
-## User Roles
-
-| Role | Permissions |
-|------|-------------|
-| viewer | View components, create quotes, export |
-| editor | + save/load configurations |
-| pricing_admin | + manage prices, view alerts |
-| admin | + manage users |
-
-## Frontend Guidelines
-
-- **Mobile-first** design
-- Use **htmx** for interactivity (hx-get, hx-post, hx-target, hx-swap)
-- Use **Tailwind CSS** via CDN
-- Minimal custom JavaScript
-- Color scheme for price freshness:
-  - `text-green-600 bg-green-50` - fresh
-  - `text-yellow-600 bg-yellow-50` - normal
-  - `text-orange-600 bg-orange-50` - stale
-  - `text-red-600 bg-red-50` - critical
+| Group | Endpoints |
+|-------|-----------|
+| Setup | GET/POST /setup, POST /setup/test |
+| Components | GET /api/components, /api/categories |
+| Pricelists | CRUD /api/pricelists, GET /latest, POST /compare |
+| Projects | CRUD /api/projects/:uuid (Phase 3) |
+| Specs | CRUD /api/specs/:uuid, POST /upgrade, GET /diff (Phase 3) |
+| Configs | POST /:uuid/refresh-prices (обновить цены из local_components) |
+| Sync | GET /status, POST /components, /pricelists, /push, /pull, /resolve-conflict |
+| Export | GET /api/specs/:uuid/export, /api/projects/:uuid/export |
 
 ## Commands
-
 ```bash
-# Run development server
-go run ./cmd/server
+# Development
+go run ./cmd/qfs                # Dev server
+make run                        # Dev server (via Makefile)
 
-# Run importer (one-time setup)
-go run ./cmd/importer
+# Production build
+make build-release              # Optimized build with version (recommended)
+VERSION=$(git describe --tags --always --dirty)
+CGO_ENABLED=0 go build -ldflags="-s -w -X main.Version=$VERSION" -o bin/qfs ./cmd/qfs
 
-# Run cron jobs manually
-go run ./cmd/cron -job=alerts          # Check and generate alerts
-go run ./cmd/cron -job=update-prices    # Recalculate all prices
-go run ./cmd/cron -job=reset-counters   # Reset usage counters
-go run ./cmd/cron -job=update-popularity # Update popularity scores
+# Cron jobs
+go run ./cmd/cron -job=cleanup-pricelists  # Remove old unused pricelists
+go run ./cmd/cron -job=update-prices       # Recalculate all prices
+go run ./cmd/cron -job=update-popularity   # Update popularity scores
 
-# Build for production
-CGO_ENABLED=0 go build -ldflags="-s -w" -o bin/quoteforge ./cmd/server
-CGO_ENABLED=0 go build -ldflags="-s -w" -o bin/quoteforge-cron ./cmd/cron
-
-# Run tests
-go test ./...
-````
-
-## Cron Jobs
-
-QuoteForge now includes automated cron jobs for maintenance tasks. These can be run using the built-in cron functionality in the Docker container.
-
-### Docker Compose Setup
-
-The Docker setup includes a dedicated cron service that runs the following jobs:
-
-- **Alerts check**: Every hour (0 * * * *)
-- **Price updates**: Daily at 2 AM (0 2 * * *)
-- **Usage counter reset**: Weekly on Sunday at 1 AM (0 1 * * 0)
-- **Popularity score updates**: Daily at 3 AM (0 3 * * *)
-
-### Manual Cron Job Execution
-
-You can also run cron jobs manually using the quoteforge-cron binary:
-
-```bash
-# Check and generate alerts
-go run ./cmd/cron -job=alerts
-
-# Recalculate all prices
-go run ./cmd/cron -job=update-prices
-
-# Reset usage counters
-go run ./cmd/cron -job=reset-counters
-
-# Update popularity scores
-go run ./cmd/cron -job=update-popularity
+# Check version
+./bin/qfs -version
 ```
 
-### Cron Job Details
-
-- **Alerts check**: Generates alerts for components with high demand and stale prices, trending components without prices, and components with no recent quotes
-- **Price updates**: Recalculates prices for all components using configured methods (median, weighted median, average)
-- **Usage counter reset**: Resets weekly and monthly usage counters for components
-- **Popularity score updates**: Recalculates popularity scores based on supplier quote activity
-
 ## Code Style
+- gofmt, structured logging (slog), wrap errors with context
+- snake_case files, PascalCase types
+- RBAC disabled: DB username = user_id via `models.EnsureDBUser()`
 
-- Use standard Go formatting (gofmt)
-- Error handling: always check errors, wrap with context
-- Logging: use structured logging (slog or zerolog)
-- Comments: in Russian or English, be consistent
-- File naming: snake_case for files, PascalCase for types
+## UI Guidelines
+- htmx (hx-get/post/target/swap), Tailwind CDN
+- Freshness colors: green (fresh) → yellow → orange → red (critical)
+- Sync status + offline indicator in header

Dockerfile

@@ -1,68 +0,0 @@
-# Build stage
-FROM golang:1.24-alpine AS builder
-
-RUN apk add --no-cache git ca-certificates tzdata
-
-WORKDIR /app
-
-# Copy go mod files first for better caching
-COPY go.mod go.sum ./
-RUN go mod download
-
-# Copy source code
-COPY . .
-
-# Build the main binary
-RUN CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build \
-    -ldflags="-s -w" \
-    -o /app/quoteforge \
-    ./cmd/server
-
-# Build the cron binary
-RUN CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build \
-    -ldflags="-s -w" \
-    -o /app/quoteforge-cron \
-    ./cmd/cron
-
-# Final stage
-FROM alpine:3.19
-
-RUN apk add --no-cache ca-certificates tzdata cron
-
-# Create non-root user
-RUN adduser -D -g '' appuser
-
-WORKDIR /app
-
-# Copy binary from builder
-COPY --from=builder /app/quoteforge .
-COPY --from=builder /app/quoteforge-cron .
-
-# Copy cron job configuration
-COPY crontab /etc/crontabs/appuser
-RUN chmod 0600 /etc/crontabs/appuser
-
-# Create log directory
-RUN mkdir -p /var/log/cron
-
-# Copy web templates and static files
-COPY --from=builder /app/web ./web
-
-# Copy migrations
-COPY --from=builder /app/migrations ./migrations
-
-# Copy example config (actual config should be mounted)
-COPY --from=builder /app/config.example.yaml ./config.example.yaml
-
-# Set ownership
-RUN chown -R appuser:appuser /app
-
-USER appuser
-
-EXPOSE 8080
-
-# Health check
-HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
-    CMD wget --no-verbose --tries=1 --spider http://localhost:8080/health || exit 1
-
-ENTRYPOINT ["/app/quoteforge"]

LOCAL_FIRST_INTEGRATION.md

@@ -0,0 +1,178 @@
+# Local-First Architecture Integration Guide
+
+## Overview
+
+QuoteForge теперь поддерживает local-first архитектуру: приложение ВСЕГДА работает с SQLite (localdb), MariaDB используется только для синхронизации.
+
+## Реализованные компоненты
+
+### 1. Конвертеры моделей (`internal/localdb/converters.go`)
+
+Конвертеры между MariaDB и SQLite моделями:
+- `ConfigurationToLocal()` / `LocalToConfiguration()`
+- `PricelistToLocal()` / `LocalToPricelist()`
+- `ComponentToLocal()` / `LocalToComponent()`
+
+### 2. LocalDB методы (`internal/localdb/localdb.go`)
+
+Добавлены методы для работы с pending changes:
+- `MarkChangesSynced(ids []int64)` - помечает изменения как синхронизированные
+- `GetPendingCount()` - возвращает количество несинхронизированных изменений
+
+### 3. Sync Service расширения (`internal/services/sync/service.go`)
+
+Новые методы:
+- `SyncPricelistsIfNeeded()` - проверяет и скачивает новые прайслисты при необходимости
+- `PushPendingChanges()` - отправляет все pending changes на сервер
+- `pushSingleChange()` - обрабатывает один pending change
+- `pushConfigurationCreate/Update/Delete()` - специфичные методы для конфигураций
+
+**ВАЖНО**: Конструктор изменен - теперь требует `ConfigurationRepository`:
+```go
+syncService := sync.NewService(pricelistRepo, configRepo, local)
+```
+
+### 4. LocalConfigurationService (`internal/services/local_configuration.go`)
+
+Новый сервис для работы с конфигурациями в local-first режиме:
+- Все операции CRUD работают через SQLite
+- Автоматически добавляет изменения в pending_changes
+- При создании конфигурации (если online) проверяет новые прайслисты
+
+```go
+localConfigService := services.NewLocalConfigurationService(
+    localDB,
+    syncService,
+    quoteService,
+    isOnlineFunc,
+)
+```
+
+### 5. Sync Handler расширения (`internal/handlers/sync.go`)
+
+Новые endpoints:
+- `POST /api/sync/push` - отправить pending changes на сервер
+- `GET /api/sync/pending/count` - получить количество pending changes
+- `GET /api/sync/pending` - получить список pending changes
+
+## Интеграция
+
+### Шаг 1: Обновить main.go
+
+```go
+// В cmd/qfs/main.go
+syncService := sync.NewService(pricelistRepo, configRepo, local)
+
+// Создать isOnline функцию
+isOnlineFunc := func() bool {
+    sqlDB, err := db.DB()
+    if err != nil {
+        return false
+    }
+    return sqlDB.Ping() == nil
+}
+
+// Создать LocalConfigurationService
+localConfigService := services.NewLocalConfigurationService(
+    local,
+    syncService,
+    quoteService,
+    isOnlineFunc,
+)
+```
+
+### Шаг 2: Обновить ConfigurationHandler
+
+Заменить `ConfigurationService` на `LocalConfigurationService` в handlers:
+
+```go
+// Было:
+configHandler := handlers.NewConfigurationHandler(configService, exportService)
+
+// Стало:
+configHandler := handlers.NewConfigurationHandler(localConfigService, exportService)
+```
+
+### Шаг 3: Добавить endpoints для sync
+
+В роутере добавить:
+```go
+syncGroup := router.Group("/api/sync")
+{
+    syncGroup.POST("/push", syncHandler.PushPendingChanges)
+    syncGroup.GET("/pending/count", syncHandler.GetPendingCount)
+    syncGroup.GET("/pending", syncHandler.GetPendingChanges)
+}
+```
+
+## Как это работает
+
+### Создание конфигурации
+
+1. Пользователь создает конфигурацию
+2. `LocalConfigurationService.Create()`:
+   - Если online → `SyncPricelistsIfNeeded()` проверяет новые прайслисты
+   - Сохраняет конфигурацию в SQLite
+   - Добавляет в `pending_changes` с operation="create"
+3. Конфигурация доступна локально сразу
+
+### Синхронизация с сервером
+
+**Manual sync:**
+```bash
+POST /api/sync/push
+```
+
+**Background sync (TODO):**
+- Периодический worker вызывает `syncService.PushPendingChanges()`
+- Проверяет online статус
+- Отправляет все pending changes на сервер
+- Удаляет успешно синхронизированные записи
+
+### Offline режим
+
+1. Все операции работают нормально через SQLite
+2. Изменения копятся в `pending_changes`
+3. При восстановлении соединения автоматически синхронизируются
+
+## Pending Changes Queue
+
+Таблица `pending_changes`:
+```go
+type PendingChange struct {
+    ID         int64     // Auto-increment
+    EntityType string    // "configuration", "project", "specification"
+    EntityUUID string    // UUID сущности
+    Operation  string    // "create", "update", "delete"
+    Payload    string    // JSON snapshot сущности
+    CreatedAt  time.Time
+    Attempts   int       // Счетчик попыток синхронизации
+    LastError  string    // Последняя ошибка синхронизации
+}
+```
+
+## TODO для Phase 2.5
+
+- [ ] Background sync worker (автоматическая синхронизация каждые N минут)
+- [ ] Conflict resolution (при конфликтах обновления)
+- [ ] UI: pending counter в header
+- [ ] UI: manual sync button
+- [ ] UI: conflict alerts
+- [ ] Retry logic для failed pending changes
+- [ ] RefreshPrices для local mode (через local_components)
+
+## Testing
+
+```bash
+# Compile
+go build ./cmd/qfs
+
+# Run
+./quoteforge
+
+# Check pending changes
+curl http://localhost:8080/api/sync/pending/count
+
+# Manual sync
+curl -X POST http://localhost:8080/api/sync/push
+```

MIGRATION_PRICE_REFRESH.md

@@ -89,7 +89,7 @@ mysql -u user -p RFQ_LOG < migrations/004_add_price_updated_at.sql
 - `internal/models/configuration.go` - добавлено поле `PriceUpdatedAt`
 - `internal/services/configuration.go` - добавлен метод `RefreshPrices()`
 - `internal/handlers/configuration.go` - добавлен обработчик `RefreshPrices()`
-- `cmd/server/main.go` - добавлен маршрут `/api/configs/:uuid/refresh-prices`
+- `cmd/qfs/main.go` - добавлен маршрут `/api/configs/:uuid/refresh-prices`
 - `web/templates/index.html` - добавлена кнопка и JavaScript функции
 - `migrations/004_add_price_updated_at.sql` - SQL миграция
 - `CLAUDE.md` - обновлена документация

Makefile

@@ -0,0 +1,97 @@
+.PHONY: build build-release clean test run version
+
+# Get version from git
+VERSION := $(shell git describe --tags --always --dirty 2>/dev/null || echo "dev")
+BUILD_TIME := $(shell date -u '+%Y-%m-%d_%H:%M:%S')
+LDFLAGS := -s -w -X main.Version=$(VERSION)
+
+# Binary name
+BINARY := qfs
+
+# Build for development (with debug info)
+build:
+	go build -o bin/$(BINARY) ./cmd/qfs
+
+# Build for release (optimized, with version)
+build-release:
+	@echo "Building $(BINARY) version $(VERSION)..."
+	CGO_ENABLED=0 go build -ldflags="$(LDFLAGS)" -o bin/$(BINARY) ./cmd/qfs
+	@echo "✓ Built: bin/$(BINARY)"
+	@./bin/$(BINARY) -version
+
+# Build release for Linux (cross-compile)
+build-linux:
+	@echo "Building $(BINARY) for Linux..."
+	CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -ldflags="$(LDFLAGS)" -o bin/$(BINARY)-linux-amd64 ./cmd/qfs
+	@echo "✓ Built: bin/$(BINARY)-linux-amd64"
+
+# Build release for macOS (cross-compile)
+build-macos:
+	@echo "Building $(BINARY) for macOS..."
+	CGO_ENABLED=0 GOOS=darwin GOARCH=amd64 go build -ldflags="$(LDFLAGS)" -o bin/$(BINARY)-darwin-amd64 ./cmd/qfs
+	CGO_ENABLED=0 GOOS=darwin GOARCH=arm64 go build -ldflags="$(LDFLAGS)" -o bin/$(BINARY)-darwin-arm64 ./cmd/qfs
+	@echo "✓ Built: bin/$(BINARY)-darwin-amd64"
+	@echo "✓ Built: bin/$(BINARY)-darwin-arm64"
+
+# Build release for Windows (cross-compile)
+build-windows:
+	@echo "Building $(BINARY) for Windows..."
+	CGO_ENABLED=0 GOOS=windows GOARCH=amd64 go build -ldflags="$(LDFLAGS)" -o bin/$(BINARY)-windows-amd64.exe ./cmd/qfs
+	@echo "✓ Built: bin/$(BINARY)-windows-amd64.exe"
+
+# Build all platforms
+build-all: build-release build-linux build-macos build-windows
+
+# Create release packages for all platforms
+release:
+	@./scripts/release.sh
+
+# Show version
+version:
+	@echo "Version: $(VERSION)"
+
+# Clean build artifacts
+clean:
+	rm -rf bin/
+	rm -f $(BINARY)
+
+# Run tests
+test:
+	go test -v ./...
+
+# Run development server
+run:
+	go run ./cmd/qfs
+
+# Run with auto-restart (requires entr: brew install entr)
+watch:
+	find . -name '*.go' | entr -r go run ./cmd/qfs
+
+# Install dependencies
+deps:
+	go mod download
+	go mod tidy
+
+# Help
+help:
+	@echo "QuoteForge Server (qfs) - Build Commands"
+	@echo ""
+	@echo "Usage: make [target]"
+	@echo ""
+	@echo "Targets:"
+	@echo "  build          Build for development (with debug info)"
+	@echo "  build-release  Build optimized release (default)"
+	@echo "  build-linux    Cross-compile for Linux"
+	@echo "  build-macos    Cross-compile for macOS (Intel + Apple Silicon)"
+	@echo "  build-windows  Cross-compile for Windows"
+	@echo "  build-all      Build for all platforms"
+	@echo "  release        Create release packages for all platforms"
+	@echo "  version        Show current version"
+	@echo "  clean          Remove build artifacts"
+	@echo "  test           Run tests"
+	@echo "  run            Run development server"
+	@echo "  watch          Run with auto-restart (requires entr)"
+	@echo "  deps           Install/update dependencies"
+	@echo "  help           Show this help"
+	@echo ""
+	@echo "Current version: $(VERSION)"

README.md

@@ -82,7 +82,7 @@ auth:
 ### 3. Миграции базы данных
 
 ```bash
-go run ./cmd/server -migrate
+go run ./cmd/qfs -migrate
 ```
 
 ### 4. Импорт метаданных компонентов
@@ -95,11 +95,27 @@ go run ./cmd/importer
 
 ```bash
 # Development
-go run ./cmd/server
+go run ./cmd/qfs
 
-# Production
-CGO_ENABLED=0 go build -ldflags="-s -w" -o bin/quoteforge ./cmd/server
-./bin/quoteforge
+# Production (with Makefile - recommended)
+make build-release    # Builds with version info
+./bin/qfs -version    # Check version
+
+# Production (manual)
+VERSION=$(git describe --tags --always --dirty)
+CGO_ENABLED=0 go build -ldflags="-s -w -X main.Version=$VERSION" -o bin/qfs ./cmd/qfs
+./bin/qfs -version
+```
+
+**Makefile команды:**
+```bash
+make build-release   # Оптимизированная сборка с версией
+make build-all       # Сборка для всех платформ (Linux, macOS, Windows)
+make build-windows   # Только для Windows
+make run             # Запуск dev сервера
+make test            # Запуск тестов
+make clean           # Очистка bin/
+make help            # Показать все команды
 ```
 
 Приложение будет доступно по адресу: http://localhost:8080
@@ -209,13 +225,13 @@ go run ./cmd/cron -job=update-popularity
 
 ```bash
 # Запуск в режиме разработки (hot reload)
-go run ./cmd/server
+go run ./cmd/qfs
 
 # Запуск тестов
 go test ./...
 
 # Сборка для Linux
-CGO_ENABLED=0 go build -ldflags="-s -w" -o bin/quoteforge ./cmd/server
+CGO_ENABLED=0 go build -ldflags="-s -w" -o bin/qfs ./cmd/qfs
 ```
 
 ## Переменные окружения

RELEASE_v0.2.6.md

@@ -0,0 +1,60 @@
+## Release v0.2.6 - Build & Release Improvements
+
+Minor release focused on developer experience and release automation.
+
+### Changes
+
+**Build System**
+- 🎯 Renamed binary from `quoteforge` to `qfs` (shorter, easier to type)
+- 🏷️ Added `-version` flag to display build version
+- 📦 Added Makefile with build targets for all platforms
+- 🚀 Added automated release script for multi-platform binaries
+
+**New Commands**
+```bash
+make build-release   # Optimized build with version info
+make build-all       # Build for Linux + macOS (Intel/ARM)
+make release         # Create release packages with checksums
+./bin/qfs -version   # Show version
+```
+
+**Release Artifacts**
+- Linux AMD64
+- macOS Intel (AMD64)
+- macOS Apple Silicon (ARM64)
+- Windows AMD64
+- SHA256 checksums
+
+### Installation
+
+Download the appropriate binary for your platform:
+```bash
+# Linux
+wget https://git.mchus.pro/mchus/QuoteForge/releases/download/v0.2.6/qfs-v0.2.6-linux-amd64.tar.gz
+tar -xzf qfs-v0.2.6-linux-amd64.tar.gz
+chmod +x qfs-linux-amd64
+./qfs-linux-amd64
+
+# macOS Intel
+curl -L -O https://git.mchus.pro/mchus/QuoteForge/releases/download/v0.2.6/qfs-v0.2.6-darwin-amd64.tar.gz
+tar -xzf qfs-v0.2.6-darwin-amd64.tar.gz
+chmod +x qfs-darwin-amd64
+./qfs-darwin-amd64
+
+# macOS Apple Silicon
+curl -L -O https://git.mchus.pro/mchus/QuoteForge/releases/download/v0.2.6/qfs-v0.2.6-darwin-arm64.tar.gz
+tar -xzf qfs-v0.2.6-darwin-arm64.tar.gz
+chmod +x qfs-darwin-arm64
+./qfs-darwin-arm64
+
+# Windows
+curl -L -O https://git.mchus.pro/mchus/QuoteForge/releases/download/v0.2.6/qfs-v0.2.6-windows-amd64.zip
+unzip qfs-v0.2.6-windows-amd64.zip
+qfs-windows-amd64.exe
+```
+
+### Breaking Changes
+None - fully backward compatible with v0.2.5
+
+### Full Changelog
+https://git.mchus.pro/mchus/QuoteForge/compare/v0.2.5...v0.2.6

RELEASE_v0.2.7.md

@@ -0,0 +1,57 @@
+## Release v0.2.7 - Windows Support & Localhost Binding
+
+Bug fix release improving Windows compatibility and default network binding.
+
+### Changes
+
+**Windows Support**
+- ✅ Fixed template loading errors on Windows
+- ✅ All file paths now use `filepath.Join` for cross-platform compatibility
+- ✅ Binary now works correctly on Windows without path errors
+
+**Localhost Binding**
+- ✅ Server now binds to `127.0.0.1` by default (instead of `0.0.0.0`)
+- ✅ Browser always opens to `http://127.0.0.1:8080`
+- ✅ Setup mode properly opens browser automatically
+- ✅ More secure default - only accessible from local machine
+
+> **Note:** To bind to all network interfaces (for network access), set `host: "0.0.0.0"` in config.yaml
+
+### Installation
+
+Download the appropriate binary for your platform:
+
+```bash
+# Linux
+wget https://git.mchus.pro/mchus/QuoteForge/releases/download/v0.2.7/qfs-v0.2.7-linux-amd64.tar.gz
+tar -xzf qfs-v0.2.7-linux-amd64.tar.gz
+chmod +x qfs-linux-amd64
+./qfs-linux-amd64
+
+# macOS Intel
+curl -L -O https://git.mchus.pro/mchus/QuoteForge/releases/download/v0.2.7/qfs-v0.2.7-darwin-amd64.tar.gz
+tar -xzf qfs-v0.2.7-darwin-amd64.tar.gz
+chmod +x qfs-darwin-amd64
+./qfs-darwin-amd64
+
+# macOS Apple Silicon
+curl -L -O https://git.mchus.pro/mchus/QuoteForge/releases/download/v0.2.7/qfs-v0.2.7-darwin-arm64.tar.gz
+tar -xzf qfs-v0.2.7-darwin-arm64.tar.gz
+chmod +x qfs-darwin-arm64
+./qfs-darwin-arm64
+
+# Windows
+# Download and extract: https://git.mchus.pro/mchus/QuoteForge/releases/download/v0.2.7/qfs-v0.2.7-windows-amd64.zip
+# Run: qfs-windows-amd64.exe
+```
+
+### Breaking Changes
+None - fully backward compatible with v0.2.6
+
+### Upgrade Notes
+- If you use config.yaml with `host: "0.0.0.0"`, the app will respect that setting
+- Default behavior now binds only to localhost for security
+- Windows users no longer need workarounds for path errors
+
+### Full Changelog
+https://git.mchus.pro/mchus/QuoteForge/compare/v0.2.6...v0.2.7

cmd/cron/main.go

@@ -3,7 +3,6 @@ package main
 import (
 	"flag"
 	"log"
-	"time"
 
 	"git.mchus.pro/mchus/quoteforge/internal/config"
 	"git.mchus.pro/mchus/quoteforge/internal/models"

cmd/migrate/main.go

@@ -0,0 +1,162 @@
+package main
+
+import (
+	"flag"
+	"fmt"
+	"log"
+	"time"
+
+	"git.mchus.pro/mchus/quoteforge/internal/config"
+	"git.mchus.pro/mchus/quoteforge/internal/localdb"
+	"git.mchus.pro/mchus/quoteforge/internal/models"
+	"gorm.io/driver/mysql"
+	"gorm.io/gorm"
+	"gorm.io/gorm/logger"
+)
+
+func main() {
+	configPath := flag.String("config", "config.yaml", "path to config file")
+	localDBPath := flag.String("localdb", "./data/settings.db", "path to local SQLite database")
+	dryRun := flag.Bool("dry-run", false, "show what would be migrated without actually doing it")
+	flag.Parse()
+
+	log.Println("QuoteForge Configuration Migration Tool")
+	log.Println("========================================")
+
+	// Load config for MariaDB connection
+	cfg, err := config.Load(*configPath)
+	if err != nil {
+		log.Fatalf("Failed to load config: %v", err)
+	}
+
+	// Connect to MariaDB
+	log.Printf("Connecting to MariaDB at %s:%d...", cfg.Database.Host, cfg.Database.Port)
+	mariaDB, err := gorm.Open(mysql.Open(cfg.Database.DSN()), &gorm.Config{
+		Logger: logger.Default.LogMode(logger.Silent),
+	})
+	if err != nil {
+		log.Fatalf("Failed to connect to MariaDB: %v", err)
+	}
+	log.Println("Connected to MariaDB")
+
+	// Initialize local SQLite
+	log.Printf("Opening local SQLite at %s...", *localDBPath)
+	local, err := localdb.New(*localDBPath)
+	if err != nil {
+		log.Fatalf("Failed to initialize local database: %v", err)
+	}
+	log.Println("Local SQLite initialized")
+
+	// Count configurations in MariaDB
+	var serverCount int64
+	if err := mariaDB.Model(&models.Configuration{}).Count(&serverCount).Error; err != nil {
+		log.Fatalf("Failed to count configurations: %v", err)
+	}
+	log.Printf("Found %d configurations in MariaDB", serverCount)
+
+	if serverCount == 0 {
+		log.Println("No configurations to migrate")
+		return
+	}
+
+	// Get all configurations from MariaDB
+	var configs []models.Configuration
+	if err := mariaDB.Preload("User").Find(&configs).Error; err != nil {
+		log.Fatalf("Failed to fetch configurations: %v", err)
+	}
+
+	// Check existing local configurations
+	localCount := local.CountConfigurations()
+	log.Printf("Found %d configurations in local SQLite", localCount)
+
+	if *dryRun {
+		log.Println("\n[DRY RUN] Would migrate the following configurations:")
+		for _, c := range configs {
+			userName := "unknown"
+			if c.User != nil {
+				userName = c.User.Username
+			}
+			log.Printf("  - %s (UUID: %s, User: %s, Items: %d)", c.Name, c.UUID, userName, len(c.Items))
+		}
+		log.Printf("\nTotal: %d configurations", len(configs))
+		return
+	}
+
+	// Migrate configurations
+	log.Println("\nMigrating configurations...")
+	migrated := 0
+	skipped := 0
+	errors := 0
+
+	for _, c := range configs {
+		// Check if already exists
+		existing, err := local.GetConfigurationByUUID(c.UUID)
+		if err == nil && existing.ID > 0 {
+			log.Printf("  SKIP: %s (already exists)", c.Name)
+			skipped++
+			continue
+		}
+
+		// Convert items
+		localItems := make(localdb.LocalConfigItems, len(c.Items))
+		for i, item := range c.Items {
+			localItems[i] = localdb.LocalConfigItem{
+				LotName:   item.LotName,
+				Quantity:  item.Quantity,
+				UnitPrice: item.UnitPrice,
+			}
+		}
+
+		// Create local configuration
+		now := time.Now()
+		localConfig := &localdb.LocalConfiguration{
+			UUID:           c.UUID,
+			ServerID:       &c.ID,
+			Name:           c.Name,
+			Items:          localItems,
+			TotalPrice:     c.TotalPrice,
+			CustomPrice:    c.CustomPrice,
+			Notes:          c.Notes,
+			IsTemplate:     c.IsTemplate,
+			ServerCount:    c.ServerCount,
+			CreatedAt:      c.CreatedAt,
+			UpdatedAt:      now,
+			SyncedAt:       &now,
+			SyncStatus:     "synced",
+			OriginalUserID: c.UserID,
+		}
+
+		if err := local.SaveConfiguration(localConfig); err != nil {
+			log.Printf("  ERROR: %s - %v", c.Name, err)
+			errors++
+			continue
+		}
+
+		log.Printf("  OK: %s (%d items)", c.Name, len(c.Items))
+		migrated++
+	}
+
+	log.Println("\n========================================")
+	log.Printf("Migration complete!")
+	log.Printf("  Migrated: %d", migrated)
+	log.Printf("  Skipped:  %d", skipped)
+	log.Printf("  Errors:   %d", errors)
+
+	// Save connection settings to local SQLite if not exists
+	if !local.HasSettings() {
+		log.Println("\nSaving connection settings to local SQLite...")
+		if err := local.SaveSettings(
+			cfg.Database.Host,
+			cfg.Database.Port,
+			cfg.Database.Name,
+			cfg.Database.User,
+			cfg.Database.Password,
+		); err != nil {
+			log.Printf("Warning: Failed to save settings: %v", err)
+		} else {
+			log.Println("Connection settings saved")
+		}
+	}
+
+	fmt.Println("\nDone! You can now run the server with: go run ./cmd/server")
+}

cmd/qfs/main.go

@@ -0,0 +1,793 @@
+package main
+
+import (
+	"context"
+	"flag"
+	"fmt"
+	"log/slog"
+	"net/http"
+	"os"
+	"os/exec"
+	"os/signal"
+	"path/filepath"
+	"runtime"
+	"strconv"
+	"syscall"
+	"time"
+
+	"github.com/gin-gonic/gin"
+	"git.mchus.pro/mchus/quoteforge/internal/config"
+	"git.mchus.pro/mchus/quoteforge/internal/db"
+	"git.mchus.pro/mchus/quoteforge/internal/handlers"
+	"git.mchus.pro/mchus/quoteforge/internal/localdb"
+	"git.mchus.pro/mchus/quoteforge/internal/middleware"
+	"git.mchus.pro/mchus/quoteforge/internal/models"
+	"git.mchus.pro/mchus/quoteforge/internal/repository"
+	"git.mchus.pro/mchus/quoteforge/internal/services"
+	"git.mchus.pro/mchus/quoteforge/internal/services/alerts"
+	"git.mchus.pro/mchus/quoteforge/internal/services/pricelist"
+	"git.mchus.pro/mchus/quoteforge/internal/services/pricing"
+	"git.mchus.pro/mchus/quoteforge/internal/services/sync"
+	"gorm.io/driver/mysql"
+	"gorm.io/gorm"
+	"gorm.io/gorm/logger"
+)
+
+const (
+	localDBPath = "./data/settings.db"
+)
+
+// Version is set via ldflags during build
+var Version = "dev"
+
+func main() {
+	configPath := flag.String("config", "config.yaml", "path to config file (optional, for server settings)")
+	migrate := flag.Bool("migrate", false, "run database migrations")
+	version := flag.Bool("version", false, "show version information")
+	flag.Parse()
+
+	// Show version if requested
+	if *version {
+		fmt.Printf("qfs version %s\n", Version)
+		os.Exit(0)
+	}
+
+	// Initialize local SQLite database (always used)
+	local, err := localdb.New(localDBPath)
+	if err != nil {
+		slog.Error("failed to initialize local database", "error", err)
+		os.Exit(1)
+	}
+
+	// Check if running in setup mode (no connection settings)
+	if !local.HasSettings() {
+		slog.Info("no database settings found, starting setup mode")
+		runSetupMode(local)
+		return
+	}
+
+	// Load config for server settings (optional)
+	cfg, err := config.Load(*configPath)
+	if err != nil {
+		// Use defaults if config file doesn't exist
+		slog.Info("config file not found, using defaults", "path", *configPath)
+		cfg = &config.Config{}
+	}
+	setConfigDefaults(cfg)
+
+	setupLogger(cfg.Logging)
+
+	// Create connection manager and try to connect immediately if settings exist
+	connMgr := db.NewConnectionManager(local)
+
+	dbUser := local.GetDBUser()
+	dbUserID := uint(1)
+
+	// Try to connect to MariaDB on startup
+	mariaDB, err := connMgr.GetDB()
+	if err != nil {
+		slog.Warn("failed to connect to MariaDB on startup, starting in offline mode", "error", err)
+		mariaDB = nil
+	} else {
+		slog.Info("successfully connected to MariaDB on startup")
+		// Ensure DB user exists and get their ID
+		if dbUserID, err = models.EnsureDBUser(mariaDB, dbUser); err != nil {
+			slog.Error("failed to ensure DB user", "error", err)
+			// Continue with default ID
+			dbUserID = uint(1)
+		}
+	}
+
+	slog.Info("starting QuoteForge server",
+		"host", cfg.Server.Host,
+		"port", cfg.Server.Port,
+		"db_user", dbUser,
+		"db_user_id", dbUserID,
+		"online", mariaDB != nil,
+	)
+
+	if *migrate {
+		if mariaDB == nil {
+			slog.Error("cannot run migrations: database not available")
+			os.Exit(1)
+		}
+		slog.Info("running database migrations...")
+		if err := models.Migrate(mariaDB); err != nil {
+			slog.Error("migration failed", "error", err)
+			os.Exit(1)
+		}
+		if err := models.SeedCategories(mariaDB); err != nil {
+			slog.Error("seeding categories failed", "error", err)
+			os.Exit(1)
+		}
+		slog.Info("migrations completed")
+	}
+
+	gin.SetMode(cfg.Server.Mode)
+	router, syncService, err := setupRouter(cfg, local, connMgr, mariaDB, dbUserID)
+	if err != nil {
+		slog.Error("failed to setup router", "error", err)
+		os.Exit(1)
+	}
+
+	// Start background sync worker (will auto-skip when offline)
+	workerCtx, workerCancel := context.WithCancel(context.Background())
+	defer workerCancel()
+
+	syncWorker := sync.NewWorker(syncService, connMgr, 5*time.Minute)
+	go syncWorker.Start(workerCtx)
+
+	srv := &http.Server{
+		Addr:         cfg.Address(),
+		Handler:      router,
+		ReadTimeout:  cfg.Server.ReadTimeout,
+		WriteTimeout: cfg.Server.WriteTimeout,
+	}
+
+	go func() {
+		slog.Info("server listening", "address", cfg.Address())
+		if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
+			slog.Error("server error", "error", err)
+			os.Exit(1)
+		}
+	}()
+
+	// Automatically open browser after server starts (with a small delay)
+	go func() {
+		time.Sleep(1 * time.Second)
+		// Always use localhost for browser, even if server binds to 0.0.0.0
+		browserURL := fmt.Sprintf("http://127.0.0.1:%d", cfg.Server.Port)
+		slog.Info("Opening browser to", "url", browserURL)
+		err := openBrowser(browserURL)
+		if err != nil {
+			slog.Warn("Failed to open browser", "error", err)
+		}
+	}()
+
+	quit := make(chan os.Signal, 1)
+	signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
+	<-quit
+
+	slog.Info("shutting down server...")
+
+	// Stop background sync worker first
+	syncWorker.Stop()
+	workerCancel()
+
+	// Then shutdown HTTP server
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	defer cancel()
+
+	if err := srv.Shutdown(ctx); err != nil {
+		slog.Error("server forced to shutdown", "error", err)
+	}
+
+	slog.Info("server stopped")
+}
+
+func setConfigDefaults(cfg *config.Config) {
+	if cfg.Server.Host == "" {
+		cfg.Server.Host = "127.0.0.1"
+	}
+	if cfg.Server.Port == 0 {
+		cfg.Server.Port = 8080
+	}
+	if cfg.Server.Mode == "" {
+		cfg.Server.Mode = "release"
+	}
+	if cfg.Server.ReadTimeout == 0 {
+		cfg.Server.ReadTimeout = 30 * time.Second
+	}
+	if cfg.Server.WriteTimeout == 0 {
+		cfg.Server.WriteTimeout = 30 * time.Second
+	}
+	if cfg.Pricing.DefaultMethod == "" {
+		cfg.Pricing.DefaultMethod = "weighted_median"
+	}
+	if cfg.Pricing.DefaultPeriodDays == 0 {
+		cfg.Pricing.DefaultPeriodDays = 90
+	}
+	if cfg.Pricing.FreshnessGreenDays == 0 {
+		cfg.Pricing.FreshnessGreenDays = 30
+	}
+	if cfg.Pricing.FreshnessYellowDays == 0 {
+		cfg.Pricing.FreshnessYellowDays = 60
+	}
+	if cfg.Pricing.FreshnessRedDays == 0 {
+		cfg.Pricing.FreshnessRedDays = 90
+	}
+	if cfg.Pricing.MinQuotesForMedian == 0 {
+		cfg.Pricing.MinQuotesForMedian = 3
+	}
+}
+
+// runSetupMode starts a minimal server that only serves the setup page
+func runSetupMode(local *localdb.LocalDB) {
+	restartSig := make(chan struct{}, 1)
+
+	// In setup mode, we don't have a connection manager yet (will restart after setup)
+	templatesPath := filepath.Join("web", "templates")
+	setupHandler, err := handlers.NewSetupHandler(local, nil, templatesPath, restartSig)
+	if err != nil {
+		slog.Error("failed to create setup handler", "error", err)
+		os.Exit(1)
+	}
+
+	gin.SetMode(gin.ReleaseMode)
+	router := gin.New()
+	router.Use(gin.Recovery())
+
+	staticPath := filepath.Join("web", "static")
+	router.Static("/static", staticPath)
+
+	// Setup routes only
+	router.GET("/", func(c *gin.Context) {
+		c.Redirect(http.StatusFound, "/setup")
+	})
+	router.GET("/setup", setupHandler.ShowSetup)
+	router.POST("/setup", setupHandler.SaveConnection)
+	router.POST("/setup/test", setupHandler.TestConnection)
+	router.GET("/setup/status", setupHandler.GetStatus)
+
+	// Health check
+	router.GET("/health", func(c *gin.Context) {
+		c.JSON(http.StatusOK, gin.H{
+			"status": "setup_required",
+			"time":   time.Now().UTC().Format(time.RFC3339),
+		})
+	})
+
+	addr := "127.0.0.1:8080"
+	slog.Info("starting setup mode server", "address", addr)
+
+	srv := &http.Server{
+		Addr:    addr,
+		Handler: router,
+	}
+
+	go func() {
+		if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
+			slog.Error("server error", "error", err)
+			os.Exit(1)
+		}
+	}()
+
+	// Open browser to setup page
+	go func() {
+		time.Sleep(1 * time.Second)
+		browserURL := "http://127.0.0.1:8080/setup"
+		slog.Info("Opening browser to setup page", "url", browserURL)
+		err := openBrowser(browserURL)
+		if err != nil {
+			slog.Warn("Failed to open browser", "error", err)
+		}
+	}()
+
+	quit := make(chan os.Signal, 1)
+	signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
+
+	select {
+	case <-quit:
+		slog.Info("setup mode server stopped")
+	case <-restartSig:
+		slog.Info("restarting application with saved settings...")
+
+		// Graceful shutdown
+		ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
+		defer cancel()
+		srv.Shutdown(ctx)
+
+		// Restart process with same arguments
+		restartProcess()
+	}
+}
+
+func setupLogger(cfg config.LoggingConfig) {
+	var level slog.Level
+	switch cfg.Level {
+	case "debug":
+		level = slog.LevelDebug
+	case "warn":
+		level = slog.LevelWarn
+	case "error":
+		level = slog.LevelError
+	default:
+		level = slog.LevelInfo
+	}
+
+	opts := &slog.HandlerOptions{Level: level}
+
+	var handler slog.Handler
+	if cfg.Format == "json" {
+		handler = slog.NewJSONHandler(os.Stdout, opts)
+	} else {
+		handler = slog.NewTextHandler(os.Stdout, opts)
+	}
+
+	slog.SetDefault(slog.New(handler))
+}
+
+func setupDatabaseFromDSN(dsn string) (*gorm.DB, error) {
+	gormLogger := logger.Default.LogMode(logger.Silent)
+
+	db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{
+		Logger: gormLogger,
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	sqlDB, err := db.DB()
+	if err != nil {
+		return nil, err
+	}
+
+	sqlDB.SetMaxOpenConns(25)
+	sqlDB.SetMaxIdleConns(5)
+	sqlDB.SetConnMaxLifetime(5 * time.Minute)
+
+	return db, nil
+}
+
+func setupRouter(cfg *config.Config, local *localdb.LocalDB, connMgr *db.ConnectionManager, mariaDB *gorm.DB, dbUserID uint) (*gin.Engine, *sync.Service, error) {
+	// mariaDB may be nil if we're in offline mode
+
+	// Repositories
+	var componentRepo *repository.ComponentRepository
+	var categoryRepo *repository.CategoryRepository
+	var priceRepo *repository.PriceRepository
+	var alertRepo *repository.AlertRepository
+	var statsRepo *repository.StatsRepository
+	var pricelistRepo *repository.PricelistRepository
+
+	// Only initialize repositories if we have a database connection
+	if mariaDB != nil {
+		componentRepo = repository.NewComponentRepository(mariaDB)
+		categoryRepo = repository.NewCategoryRepository(mariaDB)
+		priceRepo = repository.NewPriceRepository(mariaDB)
+		alertRepo = repository.NewAlertRepository(mariaDB)
+		statsRepo = repository.NewStatsRepository(mariaDB)
+		pricelistRepo = repository.NewPricelistRepository(mariaDB)
+	} else {
+		// In offline mode, we'll use nil repositories or handle them differently
+		// This is handled in the sync service and other components
+	}
+
+	// Services
+	var pricingService *pricing.Service
+	var componentService *services.ComponentService
+	var quoteService *services.QuoteService
+	var exportService *services.ExportService
+	var alertService *alerts.Service
+	var pricelistService *pricelist.Service
+	var syncService *sync.Service
+
+	// Sync service always uses ConnectionManager (works offline and online)
+	syncService = sync.NewService(connMgr, local)
+
+	if mariaDB != nil {
+		pricingService = pricing.NewService(componentRepo, priceRepo, cfg.Pricing)
+		componentService = services.NewComponentService(componentRepo, categoryRepo, statsRepo)
+		quoteService = services.NewQuoteService(componentRepo, statsRepo, pricingService)
+		exportService = services.NewExportService(cfg.Export, categoryRepo)
+		alertService = alerts.NewService(alertRepo, componentRepo, priceRepo, statsRepo, cfg.Alerts, cfg.Pricing)
+		pricelistService = pricelist.NewService(mariaDB, pricelistRepo, componentRepo)
+	} else {
+		// In offline mode, we still need to create services that don't require DB
+		pricingService = pricing.NewService(nil, nil, cfg.Pricing)
+		componentService = services.NewComponentService(nil, nil, nil)
+		quoteService = services.NewQuoteService(nil, nil, pricingService)
+		exportService = services.NewExportService(cfg.Export, nil)
+		alertService = alerts.NewService(nil, nil, nil, nil, cfg.Alerts, cfg.Pricing)
+		pricelistService = pricelist.NewService(nil, nil, nil)
+	}
+
+	// isOnline function for local-first architecture
+	isOnline := func() bool {
+		return connMgr.IsOnline()
+	}
+
+	// Local-first configuration service (replaces old ConfigurationService)
+	configService := services.NewLocalConfigurationService(local, syncService, quoteService, isOnline)
+
+	// Use filepath.Join for cross-platform path compatibility
+	templatesPath := filepath.Join("web", "templates")
+
+	// Handlers
+	componentHandler := handlers.NewComponentHandler(componentService, local)
+	quoteHandler := handlers.NewQuoteHandler(quoteService)
+	exportHandler := handlers.NewExportHandler(exportService, configService, componentService)
+	pricingHandler := handlers.NewPricingHandler(mariaDB, pricingService, alertService, componentRepo, priceRepo, statsRepo)
+	pricelistHandler := handlers.NewPricelistHandler(pricelistService, local)
+	syncHandler, err := handlers.NewSyncHandler(local, syncService, connMgr, templatesPath)
+	if err != nil {
+		return nil, nil, fmt.Errorf("creating sync handler: %w", err)
+	}
+
+	// Setup handler (for reconfiguration) - no restart signal in normal mode
+	setupHandler, err := handlers.NewSetupHandler(local, connMgr, templatesPath, nil)
+	if err != nil {
+		return nil, nil, fmt.Errorf("creating setup handler: %w", err)
+	}
+
+	// Web handler (templates)
+	webHandler, err := handlers.NewWebHandler(templatesPath, componentService)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	// Router
+	router := gin.New()
+	router.Use(gin.Recovery())
+	router.Use(requestLogger())
+	router.Use(middleware.CORS())
+	router.Use(middleware.OfflineDetector(connMgr, local))
+
+	// Static files (use filepath.Join for Windows compatibility)
+	staticPath := filepath.Join("web", "static")
+	router.Static("/static", staticPath)
+
+	// Health check
+	router.GET("/health", func(c *gin.Context) {
+		c.JSON(http.StatusOK, gin.H{
+			"status": "ok",
+			"time":   time.Now().UTC().Format(time.RFC3339),
+		})
+	})
+
+	// Restart endpoint (for development purposes)
+	router.POST("/api/restart", func(c *gin.Context) {
+		// This will cause the server to restart by exiting
+		// The restartProcess function will be called to restart the process
+		slog.Info("Restart requested via API")
+		go func() {
+			time.Sleep(100 * time.Millisecond)
+			restartProcess()
+		}()
+		c.JSON(http.StatusOK, gin.H{"message": "restarting..."})
+	})
+
+	// DB status endpoint
+	router.GET("/api/db-status", func(c *gin.Context) {
+		var lotCount, lotLogCount, metadataCount int64
+		var dbOK bool = false
+		var dbError string
+
+		// Check if connection exists (fast check, no reconnect attempt)
+		status := connMgr.GetStatus()
+		if status.IsConnected {
+			// Already connected, safe to use
+			if db, err := connMgr.GetDB(); err == nil && db != nil {
+				dbOK = true
+				db.Table("lot").Count(&lotCount)
+				db.Table("lot_log").Count(&lotLogCount)
+				db.Table("qt_lot_metadata").Count(&metadataCount)
+			}
+		} else {
+			// Not connected - don't try to reconnect on status check
+			// This prevents 3s timeout on every request
+			dbError = "Database not connected (offline mode)"
+			if status.LastError != "" {
+				dbError = status.LastError
+			}
+		}
+
+		c.JSON(http.StatusOK, gin.H{
+			"connected":      dbOK,
+			"error":          dbError,
+			"lot_count":      lotCount,
+			"lot_log_count":  lotLogCount,
+			"metadata_count": metadataCount,
+			"db_user":        local.GetDBUser(),
+		})
+	})
+
+	// Current user info (DB user, not app user)
+	router.GET("/api/current-user", func(c *gin.Context) {
+		c.JSON(http.StatusOK, gin.H{
+			"username": local.GetDBUser(),
+			"role":     "db_user",
+		})
+	})
+
+	// Setup routes (for reconfiguration)
+	router.GET("/setup", setupHandler.ShowSetup)
+	router.POST("/setup", setupHandler.SaveConnection)
+	router.POST("/setup/test", setupHandler.TestConnection)
+	router.GET("/setup/status", setupHandler.GetStatus)
+
+	// Web pages
+	router.GET("/", webHandler.Index)
+	router.GET("/configs", webHandler.Configs)
+	router.GET("/configurator", webHandler.Configurator)
+	router.GET("/pricelists", func(c *gin.Context) {
+		// Redirect to admin/pricing with pricelists tab
+		c.Redirect(http.StatusFound, "/admin/pricing?tab=pricelists")
+	})
+	router.GET("/pricelists/:id", webHandler.PricelistDetail)
+	router.GET("/admin/pricing", webHandler.AdminPricing)
+
+	// htmx partials
+	partials := router.Group("/partials")
+	{
+		partials.GET("/components", webHandler.ComponentsPartial)
+		partials.GET("/sync-status", syncHandler.SyncStatusPartial)
+	}
+
+	// API routes
+	api := router.Group("/api")
+	{
+		api.GET("/ping", func(c *gin.Context) {
+			c.JSON(http.StatusOK, gin.H{"message": "pong"})
+		})
+
+		// Components (public read)
+		components := api.Group("/components")
+		{
+			components.GET("", componentHandler.List)
+			components.GET("/:lot_name", componentHandler.Get)
+		}
+
+		// Categories (public)
+		api.GET("/categories", componentHandler.GetCategories)
+
+		// Quote (public)
+		quote := api.Group("/quote")
+		{
+			quote.POST("/validate", quoteHandler.Validate)
+			quote.POST("/calculate", quoteHandler.Calculate)
+		}
+
+		// Export (public)
+		export := api.Group("/export")
+		{
+			export.POST("/csv", exportHandler.ExportCSV)
+		}
+
+		// Pricelists (public - RBAC disabled in Phase 1-3)
+		pricelists := api.Group("/pricelists")
+		{
+			pricelists.GET("", pricelistHandler.List)
+			pricelists.GET("/can-write", pricelistHandler.CanWrite)
+			pricelists.GET("/latest", pricelistHandler.GetLatest)
+			pricelists.GET("/:id", pricelistHandler.Get)
+			pricelists.GET("/:id/items", pricelistHandler.GetItems)
+			pricelists.POST("", pricelistHandler.Create)
+			pricelists.DELETE("/:id", pricelistHandler.Delete)
+		}
+
+		// Configurations (public - RBAC disabled)
+		configs := api.Group("/configs")
+		{
+			configs.GET("", func(c *gin.Context) {
+				page, _ := strconv.Atoi(c.DefaultQuery("page", "1"))
+				perPage, _ := strconv.Atoi(c.DefaultQuery("per_page", "20"))
+
+				cfgs, total, err := configService.ListAll(page, perPage)
+				if err != nil {
+					c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+					return
+				}
+
+				c.JSON(http.StatusOK, gin.H{
+					"configurations": cfgs,
+					"total":          total,
+					"page":           page,
+					"per_page":       perPage,
+				})
+			})
+
+			configs.POST("", func(c *gin.Context) {
+				var req services.CreateConfigRequest
+				if err := c.ShouldBindJSON(&req); err != nil {
+					c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+					return
+				}
+
+				config, err := configService.Create(dbUserID, &req) // use DB user ID
+				if err != nil {
+					c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+					return
+				}
+
+				c.JSON(http.StatusCreated, config)
+			})
+
+			configs.GET("/:uuid", func(c *gin.Context) {
+				uuid := c.Param("uuid")
+				config, err := configService.GetByUUIDNoAuth(uuid)
+				if err != nil {
+					c.JSON(http.StatusNotFound, gin.H{"error": "configuration not found"})
+					return
+				}
+				c.JSON(http.StatusOK, config)
+			})
+
+			configs.PUT("/:uuid", func(c *gin.Context) {
+				uuid := c.Param("uuid")
+				var req services.CreateConfigRequest
+				if err := c.ShouldBindJSON(&req); err != nil {
+					c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+					return
+				}
+
+				config, err := configService.UpdateNoAuth(uuid, &req)
+				if err != nil {
+					c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+					return
+				}
+
+				c.JSON(http.StatusOK, config)
+			})
+
+			configs.DELETE("/:uuid", func(c *gin.Context) {
+				uuid := c.Param("uuid")
+				if err := configService.DeleteNoAuth(uuid); err != nil {
+					c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+					return
+				}
+				c.JSON(http.StatusOK, gin.H{"message": "deleted"})
+			})
+
+			configs.PATCH("/:uuid/rename", func(c *gin.Context) {
+				uuid := c.Param("uuid")
+				var req struct {
+					Name string `json:"name"`
+				}
+				if err := c.ShouldBindJSON(&req); err != nil {
+					c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+					return
+				}
+
+				config, err := configService.RenameNoAuth(uuid, req.Name)
+				if err != nil {
+					c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+					return
+				}
+
+				c.JSON(http.StatusOK, config)
+			})
+
+			configs.POST("/:uuid/clone", func(c *gin.Context) {
+				uuid := c.Param("uuid")
+				var req struct {
+					Name string `json:"name"`
+				}
+				if err := c.ShouldBindJSON(&req); err != nil {
+					c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+					return
+				}
+
+				config, err := configService.CloneNoAuth(uuid, req.Name, dbUserID)
+				if err != nil {
+					c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+					return
+				}
+
+				c.JSON(http.StatusCreated, config)
+			})
+
+			configs.POST("/:uuid/refresh-prices", func(c *gin.Context) {
+				uuid := c.Param("uuid")
+				config, err := configService.RefreshPricesNoAuth(uuid)
+				if err != nil {
+					c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+					return
+				}
+				c.JSON(http.StatusOK, config)
+			})
+		}
+
+		// Pricing admin (public - RBAC disabled)
+		pricingAdmin := api.Group("/admin/pricing")
+		{
+			pricingAdmin.GET("/stats", pricingHandler.GetStats)
+			pricingAdmin.GET("/components", pricingHandler.ListComponents)
+			pricingAdmin.GET("/components/:lot_name", pricingHandler.GetComponentPricing)
+			pricingAdmin.POST("/update", pricingHandler.UpdatePrice)
+			pricingAdmin.POST("/preview", pricingHandler.PreviewPrice)
+			pricingAdmin.POST("/recalculate-all", pricingHandler.RecalculateAll)
+
+			pricingAdmin.GET("/alerts", pricingHandler.ListAlerts)
+			pricingAdmin.POST("/alerts/:id/acknowledge", pricingHandler.AcknowledgeAlert)
+			pricingAdmin.POST("/alerts/:id/resolve", pricingHandler.ResolveAlert)
+			pricingAdmin.POST("/alerts/:id/ignore", pricingHandler.IgnoreAlert)
+		}
+
+		// Sync API (for offline mode)
+		syncAPI := api.Group("/sync")
+		{
+			syncAPI.GET("/status", syncHandler.GetStatus)
+			syncAPI.GET("/info", syncHandler.GetInfo)
+			syncAPI.POST("/components", syncHandler.SyncComponents)
+			syncAPI.POST("/pricelists", syncHandler.SyncPricelists)
+			syncAPI.POST("/all", syncHandler.SyncAll)
+			syncAPI.POST("/push", syncHandler.PushPendingChanges)
+			syncAPI.GET("/pending/count", syncHandler.GetPendingCount)
+			syncAPI.GET("/pending", syncHandler.GetPendingChanges)
+		}
+	}
+
+	return router, syncService, nil
+}
+
+// restartProcess restarts the current process with the same arguments
+func restartProcess() {
+	executable, err := os.Executable()
+	if err != nil {
+		slog.Error("failed to get executable path", "error", err)
+		os.Exit(1)
+	}
+
+	args := os.Args
+	env := os.Environ()
+
+	slog.Info("executing restart", "executable", executable, "args", args)
+
+	err = syscall.Exec(executable, args, env)
+	if err != nil {
+		slog.Error("failed to restart process", "error", err)
+		os.Exit(1)
+	}
+}
+
+func openBrowser(url string) error {
+	var cmd string
+	var args []string
+
+	switch runtime.GOOS {
+	case "windows":
+		cmd = "cmd"
+		args = []string{"/c", "start", url}
+	case "darwin":
+		cmd = "open"
+		args = []string{url}
+	default: // "linux", "freebsd", "openbsd", "netbsd"
+		cmd = "xdg-open"
+		args = []string{url}
+	}
+
+	return exec.Command(cmd, args...).Start()
+}
+
+func requestLogger() gin.HandlerFunc {
+	return func(c *gin.Context) {
+		start := time.Now()
+		path := c.Request.URL.Path
+		query := c.Request.URL.RawQuery
+
+		c.Next()
+
+		latency := time.Since(start)
+		status := c.Writer.Status()
+
+		slog.Info("request",
+			"method", c.Request.Method,
+			"path", path,
+			"query", query,
+			"status", status,
+			"latency", latency,
+			"ip", c.ClientIP(),
+		)
+	}
+}

cmd/server/main.go

@@ -1,351 +0,0 @@
-package main
-
-import (
-	"context"
-	"flag"
-	"log/slog"
-	"net/http"
-	"os"
-	"os/signal"
-	"syscall"
-	"time"
-
-	"github.com/gin-gonic/gin"
-	"git.mchus.pro/mchus/quoteforge/internal/config"
-	"git.mchus.pro/mchus/quoteforge/internal/handlers"
-	"git.mchus.pro/mchus/quoteforge/internal/middleware"
-	"git.mchus.pro/mchus/quoteforge/internal/models"
-	"git.mchus.pro/mchus/quoteforge/internal/repository"
-	"git.mchus.pro/mchus/quoteforge/internal/services"
-	"git.mchus.pro/mchus/quoteforge/internal/services/alerts"
-	"git.mchus.pro/mchus/quoteforge/internal/services/pricing"
-	"golang.org/x/crypto/bcrypt"
-	"gorm.io/driver/mysql"
-	"gorm.io/gorm"
-	"gorm.io/gorm/logger"
-)
-
-func main() {
-	configPath := flag.String("config", "config.yaml", "path to config file")
-	migrate := flag.Bool("migrate", false, "run database migrations")
-	flag.Parse()
-
-	cfg, err := config.Load(*configPath)
-	if err != nil {
-		slog.Error("failed to load config", "error", err)
-		os.Exit(1)
-	}
-
-	setupLogger(cfg.Logging)
-
-	slog.Info("starting QuoteForge server",
-		"host", cfg.Server.Host,
-		"port", cfg.Server.Port,
-		"mode", cfg.Server.Mode,
-	)
-
-	db, err := setupDatabase(cfg.Database)
-	if err != nil {
-		slog.Error("failed to connect to database", "error", err)
-		os.Exit(1)
-	}
-
-	if *migrate {
-		slog.Info("running database migrations...")
-		if err := models.Migrate(db); err != nil {
-			slog.Error("migration failed", "error", err)
-			os.Exit(1)
-		}
-		if err := models.SeedCategories(db); err != nil {
-			slog.Error("seeding categories failed", "error", err)
-			os.Exit(1)
-		}
-		// Create default admin user (admin / admin123)
-		adminHash, _ := bcrypt.GenerateFromPassword([]byte("admin123"), bcrypt.DefaultCost)
-		if err := models.SeedAdminUser(db, string(adminHash)); err != nil {
-			slog.Error("seeding admin user failed", "error", err)
-			os.Exit(1)
-		}
-		slog.Info("migrations completed")
-	}
-
-	gin.SetMode(cfg.Server.Mode)
-	router, err := setupRouter(db, cfg)
-	if err != nil {
-		slog.Error("failed to setup router", "error", err)
-		os.Exit(1)
-	}
-
-	srv := &http.Server{
-		Addr:         cfg.Address(),
-		Handler:      router,
-		ReadTimeout:  cfg.Server.ReadTimeout,
-		WriteTimeout: cfg.Server.WriteTimeout,
-	}
-
-	go func() {
-		slog.Info("server listening", "address", cfg.Address())
-		if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
-			slog.Error("server error", "error", err)
-			os.Exit(1)
-		}
-	}()
-
-	quit := make(chan os.Signal, 1)
-	signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
-	<-quit
-
-	slog.Info("shutting down server...")
-
-	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
-	defer cancel()
-
-	if err := srv.Shutdown(ctx); err != nil {
-		slog.Error("server forced to shutdown", "error", err)
-	}
-
-	slog.Info("server stopped")
-}
-
-func setupLogger(cfg config.LoggingConfig) {
-	var level slog.Level
-	switch cfg.Level {
-	case "debug":
-		level = slog.LevelDebug
-	case "warn":
-		level = slog.LevelWarn
-	case "error":
-		level = slog.LevelError
-	default:
-		level = slog.LevelInfo
-	}
-
-	opts := &slog.HandlerOptions{Level: level}
-
-	var handler slog.Handler
-	if cfg.Format == "json" {
-		handler = slog.NewJSONHandler(os.Stdout, opts)
-	} else {
-		handler = slog.NewTextHandler(os.Stdout, opts)
-	}
-
-	slog.SetDefault(slog.New(handler))
-}
-
-func setupDatabase(cfg config.DatabaseConfig) (*gorm.DB, error) {
-	gormLogger := logger.Default.LogMode(logger.Silent)
-
-	db, err := gorm.Open(mysql.Open(cfg.DSN()), &gorm.Config{
-		Logger: gormLogger,
-	})
-	if err != nil {
-		return nil, err
-	}
-
-	sqlDB, err := db.DB()
-	if err != nil {
-		return nil, err
-	}
-
-	sqlDB.SetMaxOpenConns(cfg.MaxOpenConns)
-	sqlDB.SetMaxIdleConns(cfg.MaxIdleConns)
-	sqlDB.SetConnMaxLifetime(cfg.ConnMaxLifetime)
-
-	return db, nil
-}
-
-func setupRouter(db *gorm.DB, cfg *config.Config) (*gin.Engine, error) {
-	// Repositories
-	userRepo := repository.NewUserRepository(db)
-	componentRepo := repository.NewComponentRepository(db)
-	categoryRepo := repository.NewCategoryRepository(db)
-	priceRepo := repository.NewPriceRepository(db)
-	configRepo := repository.NewConfigurationRepository(db)
-	alertRepo := repository.NewAlertRepository(db)
-	statsRepo := repository.NewStatsRepository(db)
-
-	// Services
-	authService := services.NewAuthService(userRepo, cfg.Auth)
-	pricingService := pricing.NewService(componentRepo, priceRepo, cfg.Pricing)
-	componentService := services.NewComponentService(componentRepo, categoryRepo, statsRepo)
-	quoteService := services.NewQuoteService(componentRepo, statsRepo, pricingService)
-	configService := services.NewConfigurationService(configRepo, componentRepo, quoteService)
-	exportService := services.NewExportService(cfg.Export, categoryRepo)
-	alertService := alerts.NewService(alertRepo, componentRepo, priceRepo, statsRepo, cfg.Alerts, cfg.Pricing)
-
-	// Handlers
-	authHandler := handlers.NewAuthHandler(authService, userRepo)
-	componentHandler := handlers.NewComponentHandler(componentService)
-	quoteHandler := handlers.NewQuoteHandler(quoteService)
-	configHandler := handlers.NewConfigurationHandler(configService, exportService)
-	exportHandler := handlers.NewExportHandler(exportService, configService, componentService)
-	pricingHandler := handlers.NewPricingHandler(db, pricingService, alertService, componentRepo, priceRepo, statsRepo)
-
-	// Web handler (templates)
-	webHandler, err := handlers.NewWebHandler("web/templates", componentService)
-	if err != nil {
-		return nil, err
-	}
-
-	// Router
-	router := gin.New()
-	router.Use(gin.Recovery())
-	router.Use(requestLogger())
-	router.Use(middleware.CORS())
-
-	// Static files
-	router.Static("/static", "web/static")
-
-	// Health check
-	router.GET("/health", func(c *gin.Context) {
-		c.JSON(http.StatusOK, gin.H{
-			"status": "ok",
-			"time":   time.Now().UTC().Format(time.RFC3339),
-		})
-	})
-
-	// DB status endpoint
-	router.GET("/api/db-status", func(c *gin.Context) {
-		var lotCount, lotLogCount, metadataCount int64
-		var dbOK bool = true
-		var dbError string
-
-		sqlDB, err := db.DB()
-		if err != nil {
-			dbOK = false
-			dbError = err.Error()
-		} else if err := sqlDB.Ping(); err != nil {
-			dbOK = false
-			dbError = err.Error()
-		}
-
-		db.Table("lot").Count(&lotCount)
-		db.Table("lot_log").Count(&lotLogCount)
-		db.Table("qt_lot_metadata").Count(&metadataCount)
-
-		c.JSON(http.StatusOK, gin.H{
-			"connected":      dbOK,
-			"error":          dbError,
-			"lot_count":      lotCount,
-			"lot_log_count":  lotLogCount,
-			"metadata_count": metadataCount,
-		})
-	})
-
-	// Web pages
-	router.GET("/", webHandler.Index)
-	router.GET("/login", webHandler.Login)
-	router.GET("/configs", webHandler.Configs)
-	router.GET("/configurator", webHandler.Configurator)
-	router.GET("/admin/pricing", webHandler.AdminPricing)
-
-	// htmx partials
-	partials := router.Group("/partials")
-	{
-		partials.GET("/components", webHandler.ComponentsPartial)
-	}
-
-	// API routes
-	api := router.Group("/api")
-	{
-		api.GET("/ping", func(c *gin.Context) {
-			c.JSON(http.StatusOK, gin.H{"message": "pong"})
-		})
-
-		// Auth (public)
-		auth := api.Group("/auth")
-		{
-			auth.POST("/login", authHandler.Login)
-			auth.POST("/refresh", authHandler.Refresh)
-			auth.POST("/logout", authHandler.Logout)
-			auth.GET("/me", middleware.Auth(authService), authHandler.Me)
-		}
-
-		// Components (public read, for quote builder)
-		components := api.Group("/components")
-		{
-			components.GET("", componentHandler.List)
-			components.GET("/:lot_name", componentHandler.Get)
-		}
-
-		// Categories (public)
-		api.GET("/categories", componentHandler.GetCategories)
-
-		// Quote (public, for anonymous quote building)
-		quote := api.Group("/quote")
-		{
-			quote.POST("/validate", quoteHandler.Validate)
-			quote.POST("/calculate", quoteHandler.Calculate)
-		}
-
-		// Export (public, for anonymous exports)
-		export := api.Group("/export")
-		{
-			export.POST("/csv", exportHandler.ExportCSV)
-		}
-
-		// Configurations (requires auth)
-		configs := api.Group("/configs")
-		configs.Use(middleware.Auth(authService))
-		configs.Use(middleware.RequireEditor())
-		{
-			configs.GET("", configHandler.List)
-			configs.POST("", configHandler.Create)
-			configs.GET("/:uuid", configHandler.Get)
-			configs.PUT("/:uuid", configHandler.Update)
-			configs.PATCH("/:uuid/rename", configHandler.Rename)
-			configs.POST("/:uuid/clone", configHandler.Clone)
-			configs.POST("/:uuid/refresh-prices", configHandler.RefreshPrices)
-			configs.DELETE("/:uuid", configHandler.Delete)
-			// configs.GET("/:uuid/export", configHandler.ExportJSON)
-			configs.GET("/:uuid/csv", exportHandler.ExportConfigCSV)
-			// configs.POST("/import", configHandler.ImportJSON)
-		}
-	}
-
-	// Admin routes
-	admin := router.Group("/admin")
-	admin.Use(middleware.Auth(authService))
-	{
-		// Pricing admin
-		pricingAdmin := admin.Group("/pricing")
-		pricingAdmin.Use(middleware.RequirePricingAdmin())
-		{
-			pricingAdmin.GET("/stats", pricingHandler.GetStats)
-			pricingAdmin.GET("/components", pricingHandler.ListComponents)
-			pricingAdmin.GET("/components/:lot_name", pricingHandler.GetComponentPricing)
-			pricingAdmin.POST("/update", pricingHandler.UpdatePrice)
-			pricingAdmin.POST("/preview", pricingHandler.PreviewPrice)
-			pricingAdmin.POST("/recalculate-all", pricingHandler.RecalculateAll)
-
-			pricingAdmin.GET("/alerts", pricingHandler.ListAlerts)
-			pricingAdmin.POST("/alerts/:id/acknowledge", pricingHandler.AcknowledgeAlert)
-			pricingAdmin.POST("/alerts/:id/resolve", pricingHandler.ResolveAlert)
-			pricingAdmin.POST("/alerts/:id/ignore", pricingHandler.IgnoreAlert)
-		}
-	}
-
-	return router, nil
-}
-
-func requestLogger() gin.HandlerFunc {
-	return func(c *gin.Context) {
-		start := time.Now()
-		path := c.Request.URL.Path
-		query := c.Request.URL.RawQuery
-
-		c.Next()
-
-		latency := time.Since(start)
-		status := c.Writer.Status()
-
-		slog.Info("request",
-			"method", c.Request.Method,
-			"path", path,
-			"query", query,
-			"status", status,
-			"latency", latency,
-			"ip", c.ClientIP(),
-		)
-	}
-}

config.example.yaml

@@ -2,7 +2,7 @@
 # Copy this file to config.yaml and update values
 
 server:
-  host: "0.0.0.0"
+  host: "127.0.0.1"  # Use 0.0.0.0 to listen on all interfaces
   port: 8080
   mode: "release"  # debug | release
   read_timeout: "30s"

docker-compose.yml

@@ -1,30 +0,0 @@
-version: '3.8'
-
-services:
-  quoteforge:
-    build: .
-    container_name: quoteforge
-    restart: unless-stopped
-    ports:
-      - "8080:8080"
-    volumes:
-      - ./config.yaml:/app/config.yaml:ro
-    environment:
-      - TZ=Europe/Moscow
-    healthcheck:
-      test: ["CMD", "wget", "--no-verbose", "--tries=1", "--spider", "http://localhost:8080/health"]
-      interval: 30s
-      timeout: 3s
-      retries: 3
-      start_period: 5s
-
-  quoteforge-cron:
-    build: .
-    container_name: quoteforge-cron
-    restart: unless-stopped
-    volumes:
-      - ./config.yaml:/app/config.yaml:ro
-      - ./logs:/app/logs
-    command: /usr/sbin/crond -f -l 8
-    environment:
-      - TZ=Europe/Moscow

go.mod

@@ -4,19 +4,22 @@ go 1.24.0
 
 require (
 	github.com/gin-gonic/gin v1.9.1
+	github.com/glebarez/sqlite v1.11.0
 	github.com/golang-jwt/jwt/v5 v5.3.0
 	github.com/google/uuid v1.6.0
 	golang.org/x/crypto v0.43.0
 	gopkg.in/yaml.v3 v3.0.1
 	gorm.io/driver/mysql v1.5.2
-	gorm.io/gorm v1.25.5
+	gorm.io/gorm v1.25.7
 )
 
 require (
 	github.com/bytedance/sonic v1.9.1 // indirect
 	github.com/chenzhuoyu/base64x v0.0.0-20221115062448-fe3a3abad311 // indirect
+	github.com/dustin/go-humanize v1.0.1 // indirect
 	github.com/gabriel-vasile/mimetype v1.4.2 // indirect
 	github.com/gin-contrib/sse v0.1.0 // indirect
+	github.com/glebarez/go-sqlite v1.21.2 // indirect
 	github.com/go-playground/locales v0.14.1 // indirect
 	github.com/go-playground/universal-translator v0.18.1 // indirect
 	github.com/go-playground/validator/v10 v10.14.0 // indirect
@@ -31,6 +34,7 @@ require (
 	github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
 	github.com/modern-go/reflect2 v1.0.2 // indirect
 	github.com/pelletier/go-toml/v2 v2.0.8 // indirect
+	github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec // indirect
 	github.com/stretchr/testify v1.11.1 // indirect
 	github.com/twitchyliquid64/golang-asm v0.15.1 // indirect
 	github.com/ugorji/go/codec v1.2.11 // indirect
@@ -39,4 +43,8 @@ require (
 	golang.org/x/sys v0.37.0 // indirect
 	golang.org/x/text v0.30.0 // indirect
 	google.golang.org/protobuf v1.30.0 // indirect
+	modernc.org/libc v1.22.5 // indirect
+	modernc.org/mathutil v1.5.0 // indirect
+	modernc.org/memory v1.5.0 // indirect
+	modernc.org/sqlite v1.23.1 // indirect
 )

go.sum

@@ -7,12 +7,18 @@ github.com/chenzhuoyu/base64x v0.0.0-20221115062448-fe3a3abad311/go.mod h1:b583j
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY=
+github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto=
 github.com/gabriel-vasile/mimetype v1.4.2 h1:w5qFW6JKBz9Y393Y4q372O9A7cUSequkh1Q7OhCmWKU=
 github.com/gabriel-vasile/mimetype v1.4.2/go.mod h1:zApsH/mKG4w07erKIaJPFiX0Tsq9BFQgN3qGY5GnNgA=
 github.com/gin-contrib/sse v0.1.0 h1:Y/yl/+YNO8GZSjAhjMsSuLt29uWRFHdHYUb5lYOV9qE=
 github.com/gin-contrib/sse v0.1.0/go.mod h1:RHrZQHXnP2xjPF+u1gW/2HnVO7nvIa9PG3Gm+fLHvGI=
 github.com/gin-gonic/gin v1.9.1 h1:4idEAncQnU5cB7BeOkPtxjfCSye0AAm1R0RVIqJ+Jmg=
 github.com/gin-gonic/gin v1.9.1/go.mod h1:hPrL7YrpYKXt5YId3A/Tnip5kqbEAP+KLuI3SUcPTeU=
+github.com/glebarez/go-sqlite v1.21.2 h1:3a6LFC4sKahUunAmynQKLZceZCOzUthkRkEAl9gAXWo=
+github.com/glebarez/go-sqlite v1.21.2/go.mod h1:sfxdZyhQjTM2Wry3gVYWaW072Ri1WMdWJi0k6+3382k=
+github.com/glebarez/sqlite v1.11.0 h1:wSG0irqzP6VurnMEpFGer5Li19RpIRi2qvQz++w0GMw=
+github.com/glebarez/sqlite v1.11.0/go.mod h1:h8/o8j5wiAsqSPoWELDUdJXhjAhsVliSn7bWZjOhrgQ=
 github.com/go-playground/assert/v2 v2.2.0 h1:JvknZsQTYeFEAhQwI4qEt9cyV5ONwRHC+lYKSsYSR8s=
 github.com/go-playground/assert/v2 v2.2.0/go.mod h1:VDjEfimB/XKnb+ZQfWdccd7VUvScMdVu0Titje2rxJ4=
 github.com/go-playground/locales v0.14.1 h1:EWaQ/wswjilfKLTECiXz7Rh+3BjFhfDFKv/oXslEjJA=
@@ -32,6 +38,8 @@ github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaS
 github.com/google/go-cmp v0.5.5 h1:Khx7svrCpmxxtHBq5j2mp/xVjsi8hQMfNLvJFAlrGgU=
 github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
 github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
+github.com/google/pprof v0.0.0-20221118152302-e6195bd50e26 h1:Xim43kblpZXfIBQsbuBVKCudVG457BR2GZFIz3uw3hQ=
+github.com/google/pprof v0.0.0-20221118152302-e6195bd50e26/go.mod h1:dDKJzRmX4S37WGHujM7tX//fmj1uioxKzKxz3lo4HJo=
 github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
 github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/jinzhu/inflection v1.0.0 h1:K317FqzuhWc8YvSVlFMCCUb36O/S9MCKRDI7QkRKD/E=
@@ -56,6 +64,9 @@ github.com/pelletier/go-toml/v2 v2.0.8 h1:0ctb6s9mE31h0/lhu+J6OPmVeDxJn+kYnJc2jZ
 github.com/pelletier/go-toml/v2 v2.0.8/go.mod h1:vuYfssBdrU2XDZ9bYydBu6t+6a6PYNcZljzZR9VXg+4=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/remyoudompheng/bigfft v0.0.0-20200410134404-eec4a21b6bb0/go.mod h1:qqbHyh8v60DhA7CoWK5oRCqLrMHRGoxYCSS9EjAz6Eo=
+github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec h1:W09IVJc94icq4NjY3clb7Lk8O1qJ8BdBEF8z0ibU0rE=
+github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec/go.mod h1:qqbHyh8v60DhA7CoWK5oRCqLrMHRGoxYCSS9EjAz6Eo=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
 github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
@@ -85,8 +96,9 @@ golang.org/x/sys v0.37.0 h1:fdNQudmxPjkdUTPnLn5mdQv7Zwvbvpaxqs831goi9kQ=
 golang.org/x/sys v0.37.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=
 golang.org/x/text v0.30.0 h1:yznKA/E9zq54KzlzBEAWn1NXSQ8DIp/NYMy88xJjl4k=
 golang.org/x/text v0.30.0/go.mod h1:yDdHFIX9t+tORqspjENWgzaCVXgk0yYnYuSZ8UzzBVM=
-golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543 h1:E7g+9GITq07hpfrRu66IVDexMakfv52eLZ2CXBWiKr4=
 golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 h1:go1bK/D/BFZV2I8cIQd1NKEZ+0owSTG1fDTci4IqFcE=
+golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw=
 google.golang.org/protobuf v1.30.0 h1:kPPoIgf3TsEvrm0PFe15JQ+570QVxYzEvvHqChK+cng=
 google.golang.org/protobuf v1.30.0/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I=
@@ -98,6 +110,14 @@ gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 gorm.io/driver/mysql v1.5.2 h1:QC2HRskSE75wBuOxe0+iCkyJZ+RqpudsQtqkp+IMuXs=
 gorm.io/driver/mysql v1.5.2/go.mod h1:pQLhh1Ut/WUAySdTHwBpBv6+JKcj+ua4ZFx1QQTBzb8=
 gorm.io/gorm v1.25.2-0.20230530020048-26663ab9bf55/go.mod h1:L4uxeKpfBml98NYqVqwAdmV1a2nBtAec/cf3fpucW/k=
-gorm.io/gorm v1.25.5 h1:zR9lOiiYf09VNh5Q1gphfyia1JpiClIWG9hQaxB/mls=
-gorm.io/gorm v1.25.5/go.mod h1:hbnx/Oo0ChWMn1BIhpy1oYozzpM15i4YPuHDmfYtwg8=
+gorm.io/gorm v1.25.7 h1:VsD6acwRjz2zFxGO50gPO6AkNs7KKnvfzUjHQhZDz/A=
+gorm.io/gorm v1.25.7/go.mod h1:hbnx/Oo0ChWMn1BIhpy1oYozzpM15i4YPuHDmfYtwg8=
+modernc.org/libc v1.22.5 h1:91BNch/e5B0uPbJFgqbxXuOnxBQjlS//icfQEGmvyjE=
+modernc.org/libc v1.22.5/go.mod h1:jj+Z7dTNX8fBScMVNRAYZ/jF91K8fdT2hYMThc3YjBY=
+modernc.org/mathutil v1.5.0 h1:rV0Ko/6SfM+8G+yKiyI830l3Wuz1zRutdslNoQ0kfiQ=
+modernc.org/mathutil v1.5.0/go.mod h1:mZW8CKdRPY1v87qxC/wUdX5O1qDzXMP5TH3wjfpga6E=
+modernc.org/memory v1.5.0 h1:N+/8c5rE6EqugZwHii4IFsaJ7MUhoWX07J5tC/iI5Ds=
+modernc.org/memory v1.5.0/go.mod h1:PkUhL0Mugw21sHPeskwZW4D6VscE/GQJOnIpCnW6pSU=
+modernc.org/sqlite v1.23.1 h1:nrSBg4aRQQwq59JpvGEQ15tNxoO5pX/kUjcRNwSAGQM=
+modernc.org/sqlite v1.23.1/go.mod h1:OrDj17Mggn6MhE+iPbBNf7RGKODDE9NFT0f3EwDzJqk=
 rsc.io/pdf v0.1.1/go.mod h1:n8OzWcQ6Sp37PL01nO98y4iUCRdTGarVfzxY20ICaU4=

internal/config/config.go

@@ -106,7 +106,7 @@ func Load(path string) (*Config, error) {
 
 func (c *Config) setDefaults() {
 	if c.Server.Host == "" {
-		c.Server.Host = "0.0.0.0"
+		c.Server.Host = "127.0.0.1"
 	}
 	if c.Server.Port == 0 {
 		c.Server.Port = 8080

internal/db/connection.go

@@ -0,0 +1,328 @@
+package db
+
+import (
+	"context"
+	"fmt"
+	"sync"
+	"time"
+
+	"git.mchus.pro/mchus/quoteforge/internal/localdb"
+	"gorm.io/driver/mysql"
+	"gorm.io/gorm"
+	"gorm.io/gorm/logger"
+)
+
+const (
+	defaultConnectTimeout    = 5 * time.Second
+	defaultPingInterval      = 30 * time.Second
+	defaultReconnectCooldown = 10 * time.Second
+
+	maxOpenConns    = 10
+	maxIdleConns    = 2
+	connMaxLifetime = 5 * time.Minute
+)
+
+// ConnectionStatus represents the current status of the database connection
+type ConnectionStatus struct {
+	IsConnected bool
+	LastCheck   time.Time
+	LastError   string // empty if no error
+	DSNHost     string // host:port for display (without password!)
+}
+
+// ConnectionManager manages database connections with thread-safety and connection pooling
+type ConnectionManager struct {
+	localDB    *localdb.LocalDB  // for getting DSN from settings
+	mu         sync.RWMutex      // protects db and state
+	db         *gorm.DB          // current connection (nil if not connected)
+	lastError  error             // last connection error
+	lastCheck  time.Time         // time of last check/attempt
+	connectTimeout    time.Duration  // timeout for connection (default: 5s)
+	pingInterval      time.Duration  // minimum interval between pings (default: 30s)
+	reconnectCooldown time.Duration  // pause after failed attempt (default: 10s)
+}
+
+// NewConnectionManager creates a new ConnectionManager instance
+func NewConnectionManager(localDB *localdb.LocalDB) *ConnectionManager {
+	return &ConnectionManager{
+		localDB:           localDB,
+		connectTimeout:    defaultConnectTimeout,
+		pingInterval:      defaultPingInterval,
+		reconnectCooldown: defaultReconnectCooldown,
+		db:                nil,
+		lastError:         nil,
+		lastCheck:         time.Time{},
+	}
+}
+
+// GetDB returns the current database connection, establishing it if needed
+// Thread-safe and respects connection cooldowns
+func (cm *ConnectionManager) GetDB() (*gorm.DB, error) {
+	// Handle case where localDB is nil
+	if cm.localDB == nil {
+		return nil, fmt.Errorf("local database not initialized")
+	}
+
+	// First check if we already have a valid connection
+	cm.mu.RLock()
+	if cm.db != nil {
+		// Check if connection is still valid and within ping interval
+		if time.Since(cm.lastCheck) < cm.pingInterval {
+			cm.mu.RUnlock()
+			return cm.db, nil
+		}
+	}
+	cm.mu.RUnlock()
+
+	// Upgrade to write lock
+	cm.mu.Lock()
+	defer cm.mu.Unlock()
+
+	// Double-check: someone else might have connected while we were waiting for the write lock
+	if cm.db != nil {
+		// Check if connection is still valid and within ping interval
+		if time.Since(cm.lastCheck) < cm.pingInterval {
+			return cm.db, nil
+		}
+	}
+
+	// Check if we're in cooldown period after a failed attempt
+	if cm.lastError != nil && time.Since(cm.lastCheck) < cm.reconnectCooldown {
+		return nil, cm.lastError
+	}
+
+	// Attempt to connect
+	err := cm.connect()
+	if err != nil {
+		cm.lastError = err
+		cm.lastCheck = time.Now()
+		return nil, err
+	}
+
+	// Update last check time and return success
+	cm.lastCheck = time.Now()
+	cm.lastError = nil
+	return cm.db, nil
+}
+
+// connect establishes a new database connection
+func (cm *ConnectionManager) connect() error {
+	// Get DSN from local settings
+	dsn, err := cm.localDB.GetDSN()
+	if err != nil {
+		return fmt.Errorf("getting DSN: %w", err)
+	}
+
+	// Create context with timeout
+	ctx, cancel := context.WithTimeout(context.Background(), cm.connectTimeout)
+	defer cancel()
+
+	// Open database connection
+	db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{
+		Logger: logger.Default.LogMode(logger.Silent),
+	})
+	if err != nil {
+		return fmt.Errorf("opening database connection: %w", err)
+	}
+
+	// Test the connection
+	sqlDB, err := db.DB()
+	if err != nil {
+		return fmt.Errorf("getting sql.DB: %w", err)
+	}
+
+	// Ping with timeout
+	if err = sqlDB.PingContext(ctx); err != nil {
+		return fmt.Errorf("pinging database: %w", err)
+	}
+
+	// Set connection pool settings
+	sqlDB.SetMaxOpenConns(maxOpenConns)
+	sqlDB.SetMaxIdleConns(maxIdleConns)
+	sqlDB.SetConnMaxLifetime(connMaxLifetime)
+
+	// Store the connection
+	cm.db = db
+
+	return nil
+}
+
+// IsOnline checks if the database is currently connected and responsive
+// Does not attempt to reconnect, only checks current state with caching
+func (cm *ConnectionManager) IsOnline() bool {
+	cm.mu.RLock()
+	if cm.db == nil {
+		cm.mu.RUnlock()
+		return false
+	}
+
+	// If we've checked recently, return cached result
+	if time.Since(cm.lastCheck) < cm.pingInterval {
+		cm.mu.RUnlock()
+		return true
+	}
+	cm.mu.RUnlock()
+
+	// Need to perform actual ping
+	cm.mu.Lock()
+	defer cm.mu.Unlock()
+
+	// Double-check after acquiring write lock
+	if cm.db == nil {
+		return false
+	}
+
+	// Perform ping with timeout
+	ctx, cancel := context.WithTimeout(context.Background(), cm.connectTimeout)
+	defer cancel()
+
+	sqlDB, err := cm.db.DB()
+	if err != nil {
+		cm.lastError = err
+		cm.lastCheck = time.Now()
+		cm.db = nil
+		return false
+	}
+
+	if err = sqlDB.PingContext(ctx); err != nil {
+		cm.lastError = err
+		cm.lastCheck = time.Now()
+		cm.db = nil
+		return false
+	}
+
+	// Update last check time and return success
+	cm.lastCheck = time.Now()
+	cm.lastError = nil
+	return true
+}
+
+// TryConnect forces a new connection attempt (for UI "Reconnect" button)
+// Ignores cooldown period
+func (cm *ConnectionManager) TryConnect() error {
+	cm.mu.Lock()
+	defer cm.mu.Unlock()
+
+	// Attempt to connect
+	err := cm.connect()
+	if err != nil {
+		cm.lastError = err
+		cm.lastCheck = time.Now()
+		return err
+	}
+
+	// Update last check time and clear error
+	cm.lastCheck = time.Now()
+	cm.lastError = nil
+	return nil
+}
+
+// Disconnect closes the current database connection
+func (cm *ConnectionManager) Disconnect() {
+	cm.mu.Lock()
+	defer cm.mu.Unlock()
+
+	if cm.db != nil {
+		sqlDB, err := cm.db.DB()
+		if err == nil {
+			sqlDB.Close()
+		}
+	}
+	cm.db = nil
+	cm.lastError = nil
+}
+
+// GetLastError returns the last connection error (thread-safe)
+func (cm *ConnectionManager) GetLastError() error {
+	cm.mu.RLock()
+	defer cm.mu.RUnlock()
+	return cm.lastError
+}
+
+// GetStatus returns the current connection status
+func (cm *ConnectionManager) GetStatus() ConnectionStatus {
+	cm.mu.RLock()
+	defer cm.mu.RUnlock()
+
+	status := ConnectionStatus{
+		IsConnected: cm.db != nil,
+		LastCheck:   cm.lastCheck,
+		LastError:   "",
+		DSNHost:     "",
+	}
+
+	if cm.lastError != nil {
+		status.LastError = cm.lastError.Error()
+	}
+
+	// Extract host from DSN for display
+	if cm.localDB != nil {
+		if dsn, err := cm.localDB.GetDSN(); err == nil {
+			// Parse DSN to extract host:port
+			// Format: user:password@tcp(host:port)/database?...
+			status.DSNHost = extractHostFromDSN(dsn)
+		}
+	}
+
+	return status
+}
+
+// extractHostFromDSN extracts the host:port part from a DSN string
+func extractHostFromDSN(dsn string) string {
+	// Find the tcp( part
+	tcpStart := 0
+	if tcpStart = len("tcp("); tcpStart < len(dsn) && dsn[tcpStart] == '(' {
+		// Look for the closing parenthesis
+		parenEnd := -1
+		for i := tcpStart + 1; i < len(dsn); i++ {
+			if dsn[i] == ')' {
+				parenEnd = i
+				break
+			}
+		}
+		if parenEnd != -1 {
+			// Extract host:port part between tcp( and )
+			hostPort := dsn[tcpStart+1:parenEnd]
+			return hostPort
+		}
+	}
+
+	// Fallback: try to find host:port by looking for @tcp( pattern
+	atIndex := -1
+	for i := 0; i < len(dsn)-4; i++ {
+		if dsn[i:i+4] == "@tcp" {
+			atIndex = i
+			break
+		}
+	}
+
+	if atIndex != -1 {
+		// Look for the opening parenthesis after @tcp
+		parenStart := -1
+		for i := atIndex + 4; i < len(dsn); i++ {
+			if dsn[i] == '(' {
+				parenStart = i
+				break
+			}
+		}
+
+		if parenStart != -1 {
+			// Look for the closing parenthesis
+			parenEnd := -1
+			for i := parenStart + 1; i < len(dsn); i++ {
+				if dsn[i] == ')' {
+					parenEnd = i
+					break
+				}
+			}
+
+			if parenEnd != -1 {
+				hostPort := dsn[parenStart+1:parenEnd]
+				return hostPort
+			}
+		}
+	}
+
+	// If we can't parse it, return empty string
+	return ""
+}

internal/handlers/component.go

@@ -5,16 +5,21 @@ import (
 	"strconv"
 
 	"github.com/gin-gonic/gin"
+	"git.mchus.pro/mchus/quoteforge/internal/localdb"
 	"git.mchus.pro/mchus/quoteforge/internal/repository"
 	"git.mchus.pro/mchus/quoteforge/internal/services"
 )
 
 type ComponentHandler struct {
 	componentService *services.ComponentService
+	localDB          *localdb.LocalDB
 }
 
-func NewComponentHandler(componentService *services.ComponentService) *ComponentHandler {
-	return &ComponentHandler{componentService: componentService}
+func NewComponentHandler(componentService *services.ComponentService, localDB *localdb.LocalDB) *ComponentHandler {
+	return &ComponentHandler{
+		componentService: componentService,
+		localDB:          localDB,
+	}
 }
 
 func (h *ComponentHandler) List(c *gin.Context) {
@@ -34,6 +39,40 @@ func (h *ComponentHandler) List(c *gin.Context) {
 		return
 	}
 
+	// If offline mode (empty result), fallback to local components
+	if result.Total == 0 && h.localDB != nil {
+		localFilter := localdb.ComponentFilter{
+			Category: filter.Category,
+			Search:   filter.Search,
+			HasPrice: filter.HasPrice,
+		}
+
+		offset := (page - 1) * perPage
+		localComps, total, err := h.localDB.ListComponents(localFilter, offset, perPage)
+		if err == nil && len(localComps) > 0 {
+			// Convert local components to ComponentView format
+			components := make([]services.ComponentView, len(localComps))
+			for i, lc := range localComps {
+				components[i] = services.ComponentView{
+					LotName:      lc.LotName,
+					Description:  lc.LotDescription,
+					Category:     lc.Category,
+					CategoryName: lc.Category, // No translation in local mode
+					Model:        lc.Model,
+					CurrentPrice: lc.CurrentPrice,
+				}
+			}
+
+			c.JSON(http.StatusOK, &services.ComponentListResult{
+				Components: components,
+				Total:      total,
+				Page:       page,
+				PerPage:    perPage,
+			})
+			return
+		}
+	}
+
 	c.JSON(http.StatusOK, result)
 }
 

internal/handlers/export.go

@@ -12,13 +12,13 @@ import (
 
 type ExportHandler struct {
 	exportService    *services.ExportService
-	configService    *services.ConfigurationService
+	configService    services.ConfigurationGetter
 	componentService *services.ComponentService
 }
 
 func NewExportHandler(
 	exportService *services.ExportService,
-	configService *services.ConfigurationService,
+	configService services.ConfigurationGetter,
 	componentService *services.ComponentService,
 ) *ExportHandler {
 	return &ExportHandler{

internal/handlers/pricelist.go

@@ -0,0 +1,188 @@
+package handlers
+
+import (
+	"net/http"
+	"strconv"
+
+	"github.com/gin-gonic/gin"
+	"git.mchus.pro/mchus/quoteforge/internal/localdb"
+	"git.mchus.pro/mchus/quoteforge/internal/services/pricelist"
+)
+
+type PricelistHandler struct {
+	service *pricelist.Service
+	localDB *localdb.LocalDB
+}
+
+func NewPricelistHandler(service *pricelist.Service, localDB *localdb.LocalDB) *PricelistHandler {
+	return &PricelistHandler{service: service, localDB: localDB}
+}
+
+// List returns all pricelists with pagination
+func (h *PricelistHandler) List(c *gin.Context) {
+	page, _ := strconv.Atoi(c.DefaultQuery("page", "1"))
+	perPage, _ := strconv.Atoi(c.DefaultQuery("per_page", "20"))
+
+	pricelists, total, err := h.service.List(page, perPage)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+
+	// If offline (empty list), fallback to local pricelists
+	if total == 0 && h.localDB != nil {
+		localPLs, err := h.localDB.GetLocalPricelists()
+		if err == nil && len(localPLs) > 0 {
+			// Convert to PricelistSummary format
+			summaries := make([]map[string]interface{}, len(localPLs))
+			for i, lpl := range localPLs {
+				summaries[i] = map[string]interface{}{
+					"id":          lpl.ServerID,
+					"version":     lpl.Version,
+					"created_by":  "sync",
+					"item_count":  0, // Not tracked
+					"usage_count": 0, // Not tracked in local
+					"is_active":   true,
+					"created_at":  lpl.CreatedAt,
+					"synced_from": "local",
+				}
+			}
+
+			c.JSON(http.StatusOK, gin.H{
+				"pricelists": summaries,
+				"total":      len(summaries),
+				"page":       page,
+				"per_page":   perPage,
+				"offline":    true,
+			})
+			return
+		}
+	}
+
+	c.JSON(http.StatusOK, gin.H{
+		"pricelists": pricelists,
+		"total":      total,
+		"page":       page,
+		"per_page":   perPage,
+	})
+}
+
+// Get returns a single pricelist by ID
+func (h *PricelistHandler) Get(c *gin.Context) {
+	idStr := c.Param("id")
+	id, err := strconv.ParseUint(idStr, 10, 32)
+	if err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": "invalid pricelist ID"})
+		return
+	}
+
+	pl, err := h.service.GetByID(uint(id))
+	if err != nil {
+		c.JSON(http.StatusNotFound, gin.H{"error": "pricelist not found"})
+		return
+	}
+
+	c.JSON(http.StatusOK, pl)
+}
+
+// Create creates a new pricelist from current prices
+func (h *PricelistHandler) Create(c *gin.Context) {
+	// Get the database username as the creator
+	createdBy := h.localDB.GetDBUser()
+	if createdBy == "" {
+		createdBy = "unknown"
+	}
+
+	pl, err := h.service.CreateFromCurrentPrices(createdBy)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+
+	c.JSON(http.StatusCreated, pl)
+}
+
+// Delete deletes a pricelist by ID
+func (h *PricelistHandler) Delete(c *gin.Context) {
+	idStr := c.Param("id")
+	id, err := strconv.ParseUint(idStr, 10, 32)
+	if err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": "invalid pricelist ID"})
+		return
+	}
+
+	if err := h.service.Delete(uint(id)); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+
+	c.JSON(http.StatusOK, gin.H{"message": "pricelist deleted"})
+}
+
+// GetItems returns items for a pricelist with pagination
+func (h *PricelistHandler) GetItems(c *gin.Context) {
+	idStr := c.Param("id")
+	id, err := strconv.ParseUint(idStr, 10, 32)
+	if err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": "invalid pricelist ID"})
+		return
+	}
+
+	page, _ := strconv.Atoi(c.DefaultQuery("page", "1"))
+	perPage, _ := strconv.Atoi(c.DefaultQuery("per_page", "50"))
+	search := c.Query("search")
+
+	items, total, err := h.service.GetItems(uint(id), page, perPage, search)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+
+	c.JSON(http.StatusOK, gin.H{
+		"items":    items,
+		"total":    total,
+		"page":     page,
+		"per_page": perPage,
+	})
+}
+
+// CanWrite returns whether the current user can create pricelists
+func (h *PricelistHandler) CanWrite(c *gin.Context) {
+	canWrite, debugInfo := h.service.CanWriteDebug()
+	c.JSON(http.StatusOK, gin.H{"can_write": canWrite, "debug": debugInfo})
+}
+
+// GetLatest returns the most recent active pricelist
+func (h *PricelistHandler) GetLatest(c *gin.Context) {
+	// Try to get from server first
+	pl, err := h.service.GetLatestActive()
+	if err != nil {
+		// If offline or no server pricelists, try to get from local cache
+		if h.localDB == nil {
+			c.JSON(http.StatusNotFound, gin.H{"error": "no database available"})
+			return
+		}
+		localPL, localErr := h.localDB.GetLatestLocalPricelist()
+		if localErr != nil {
+			// No local pricelists either
+			c.JSON(http.StatusNotFound, gin.H{
+				"error":       "no pricelists available",
+				"local_error": localErr.Error(),
+			})
+			return
+		}
+		// Return local pricelist
+		c.JSON(http.StatusOK, gin.H{
+			"id":          localPL.ServerID,
+			"version":     localPL.Version,
+			"created_by":  "sync",
+			"item_count":  0, // Not tracked in local pricelists
+			"is_active":   true,
+			"created_at":  localPL.CreatedAt,
+			"synced_from": "local",
+		})
+		return
+	}
+
+	c.JSON(http.StatusOK, pl)
+}

internal/handlers/pricing.go

@@ -68,6 +68,17 @@ func NewPricingHandler(
 }
 
 func (h *PricingHandler) GetStats(c *gin.Context) {
+	// Check if we're in offline mode
+	if h.statsRepo == nil || h.alertService == nil {
+		c.JSON(http.StatusOK, gin.H{
+			"new_alerts_count":    0,
+			"top_components":      []interface{}{},
+			"trending_components": []interface{}{},
+			"offline":             true,
+		})
+		return
+	}
+
 	newAlerts, _ := h.alertService.GetNewAlertsCount()
 	topComponents, _ := h.statsRepo.GetTopComponents(10)
 	trendingComponents, _ := h.statsRepo.GetTrendingComponents(10)
@@ -86,6 +97,19 @@ type ComponentWithCount struct {
 }
 
 func (h *PricingHandler) ListComponents(c *gin.Context) {
+	// Check if we're in offline mode
+	if h.componentRepo == nil {
+		c.JSON(http.StatusOK, gin.H{
+			"components": []ComponentWithCount{},
+			"total":      0,
+			"page":       1,
+			"per_page":   20,
+			"offline":    true,
+			"message":    "Управление ценами доступно только в онлайн режиме",
+		})
+		return
+	}
+
 	page, _ := strconv.Atoi(c.DefaultQuery("page", "1"))
 	perPage, _ := strconv.Atoi(c.DefaultQuery("per_page", "20"))
 
@@ -213,6 +237,15 @@ func (h *PricingHandler) expandMetaPrices(metaPrices, excludeLot string) []strin
 }
 
 func (h *PricingHandler) GetComponentPricing(c *gin.Context) {
+	// Check if we're in offline mode
+	if h.componentRepo == nil || h.pricingService == nil {
+		c.JSON(http.StatusServiceUnavailable, gin.H{
+			"error":   "Управление ценами доступно только в онлайн режиме",
+			"offline": true,
+		})
+		return
+	}
+
 	lotName := c.Param("lot_name")
 
 	component, err := h.componentRepo.GetByLotName(lotName)
@@ -248,6 +281,15 @@ type UpdatePriceRequest struct {
 }
 
 func (h *PricingHandler) UpdatePrice(c *gin.Context) {
+	// Check if we're in offline mode
+	if h.db == nil {
+		c.JSON(http.StatusServiceUnavailable, gin.H{
+			"error":   "Обновление цен доступно только в онлайн режиме",
+			"offline": true,
+		})
+		return
+	}
+
 	var req UpdatePriceRequest
 	if err := c.ShouldBindJSON(&req); err != nil {
 		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
@@ -409,6 +451,15 @@ func (h *PricingHandler) recalculateSinglePrice(lotName string) {
 }
 
 func (h *PricingHandler) RecalculateAll(c *gin.Context) {
+	// Check if we're in offline mode
+	if h.db == nil {
+		c.JSON(http.StatusServiceUnavailable, gin.H{
+			"error":   "Пересчёт цен доступен только в онлайн режиме",
+			"offline": true,
+		})
+		return
+	}
+
 	// Set headers for SSE
 	c.Header("Content-Type", "text/event-stream")
 	c.Header("Cache-Control", "no-cache")
@@ -588,6 +639,18 @@ func (h *PricingHandler) RecalculateAll(c *gin.Context) {
 }
 
 func (h *PricingHandler) ListAlerts(c *gin.Context) {
+	// Check if we're in offline mode
+	if h.db == nil {
+		c.JSON(http.StatusOK, gin.H{
+			"alerts":   []interface{}{},
+			"total":    0,
+			"page":     1,
+			"per_page": 20,
+			"offline":  true,
+		})
+		return
+	}
+
 	page, _ := strconv.Atoi(c.DefaultQuery("page", "1"))
 	perPage, _ := strconv.Atoi(c.DefaultQuery("per_page", "20"))
 
@@ -613,6 +676,15 @@ func (h *PricingHandler) ListAlerts(c *gin.Context) {
 }
 
 func (h *PricingHandler) AcknowledgeAlert(c *gin.Context) {
+	// Check if we're in offline mode
+	if h.db == nil {
+		c.JSON(http.StatusServiceUnavailable, gin.H{
+			"error":   "Управление алертами доступно только в онлайн режиме",
+			"offline": true,
+		})
+		return
+	}
+
 	id, err := strconv.ParseUint(c.Param("id"), 10, 32)
 	if err != nil {
 		c.JSON(http.StatusBadRequest, gin.H{"error": "invalid alert id"})
@@ -628,6 +700,15 @@ func (h *PricingHandler) AcknowledgeAlert(c *gin.Context) {
 }
 
 func (h *PricingHandler) ResolveAlert(c *gin.Context) {
+	// Check if we're in offline mode
+	if h.db == nil {
+		c.JSON(http.StatusServiceUnavailable, gin.H{
+			"error":   "Управление алертами доступно только в онлайн режиме",
+			"offline": true,
+		})
+		return
+	}
+
 	id, err := strconv.ParseUint(c.Param("id"), 10, 32)
 	if err != nil {
 		c.JSON(http.StatusBadRequest, gin.H{"error": "invalid alert id"})
@@ -643,6 +724,15 @@ func (h *PricingHandler) ResolveAlert(c *gin.Context) {
 }
 
 func (h *PricingHandler) IgnoreAlert(c *gin.Context) {
+	// Check if we're in offline mode
+	if h.db == nil {
+		c.JSON(http.StatusServiceUnavailable, gin.H{
+			"error":   "Управление алертами доступно только в онлайн режиме",
+			"offline": true,
+		})
+		return
+	}
+
 	id, err := strconv.ParseUint(c.Param("id"), 10, 32)
 	if err != nil {
 		c.JSON(http.StatusBadRequest, gin.H{"error": "invalid alert id"})
@@ -667,6 +757,15 @@ type PreviewPriceRequest struct {
 }
 
 func (h *PricingHandler) PreviewPrice(c *gin.Context) {
+	// Check if we're in offline mode
+	if h.db == nil {
+		c.JSON(http.StatusServiceUnavailable, gin.H{
+			"error":   "Предпросмотр цены доступен только в онлайн режиме",
+			"offline": true,
+		})
+		return
+	}
+
 	var req PreviewPriceRequest
 	if err := c.ShouldBindJSON(&req); err != nil {
 		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
@@ -708,8 +807,8 @@ func (h *PricingHandler) PreviewPrice(c *gin.Context) {
 		medianAllTime = &median
 	}
 
-	// Get quote count (from all relevant lots)
-	var quoteCount int64
+	// Get quote count (from all relevant lots) - total count
+	var quoteCountTotal int64
 	for _, lotName := range lotNames {
 		var count int64
 		if strings.HasSuffix(lotName, "*") {
@@ -718,7 +817,25 @@ func (h *PricingHandler) PreviewPrice(c *gin.Context) {
 		} else {
 			h.db.Model(&models.LotLog{}).Where("lot = ?", lotName).Count(&count)
 		}
-		quoteCount += count
+		quoteCountTotal += count
+	}
+
+	// Get quote count for specified period (if period is > 0)
+	var quoteCountPeriod int64
+	if req.PeriodDays > 0 {
+		for _, lotName := range lotNames {
+			var count int64
+			if strings.HasSuffix(lotName, "*") {
+				pattern := strings.TrimSuffix(lotName, "*") + "%"
+				h.db.Raw(`SELECT COUNT(*) FROM lot_log WHERE lot LIKE ? AND date >= DATE_SUB(NOW(), INTERVAL ? DAY)`, pattern, req.PeriodDays).Scan(&count)
+			} else {
+				h.db.Raw(`SELECT COUNT(*) FROM lot_log WHERE lot = ? AND date >= DATE_SUB(NOW(), INTERVAL ? DAY)`, lotName, req.PeriodDays).Scan(&count)
+			}
+			quoteCountPeriod += count
+		}
+	} else {
+		// If no period specified, period count equals total count
+		quoteCountPeriod = quoteCountTotal
 	}
 
 	// Get last received price (from the main lot only)
@@ -773,14 +890,15 @@ func (h *PricingHandler) PreviewPrice(c *gin.Context) {
 	}
 
 	c.JSON(http.StatusOK, gin.H{
-		"lot_name":        req.LotName,
-		"current_price":   comp.CurrentPrice,
-		"median_all_time": medianAllTime,
-		"new_price":       newPrice,
-		"quote_count":     quoteCount,
-		"manual_price":    comp.ManualPrice,
-		"last_price":      lastPrice.Price,
-		"last_price_date": lastPrice.Date,
+		"lot_name":           req.LotName,
+		"current_price":      comp.CurrentPrice,
+		"median_all_time":    medianAllTime,
+		"new_price":          newPrice,
+		"quote_count_total":  quoteCountTotal,
+		"quote_count_period": quoteCountPeriod,
+		"manual_price":       comp.ManualPrice,
+		"last_price":         lastPrice.Price,
+		"last_price_date":    lastPrice.Date,
 	})
 }
 

internal/handlers/setup.go

@@ -0,0 +1,235 @@
+package handlers
+
+import (
+	"fmt"
+	"html/template"
+	"log/slog"
+	"net/http"
+	"path/filepath"
+	"strconv"
+	"time"
+
+	"github.com/gin-gonic/gin"
+	"git.mchus.pro/mchus/quoteforge/internal/db"
+	"git.mchus.pro/mchus/quoteforge/internal/localdb"
+	"gorm.io/driver/mysql"
+	"gorm.io/gorm"
+	"gorm.io/gorm/logger"
+)
+
+type SetupHandler struct {
+	localDB    *localdb.LocalDB
+	connMgr    *db.ConnectionManager
+	templates  map[string]*template.Template
+	restartSig chan struct{}
+}
+
+func NewSetupHandler(localDB *localdb.LocalDB, connMgr *db.ConnectionManager, templatesPath string, restartSig chan struct{}) (*SetupHandler, error) {
+	funcMap := template.FuncMap{
+		"sub": func(a, b int) int { return a - b },
+		"add": func(a, b int) int { return a + b },
+	}
+
+	templates := make(map[string]*template.Template)
+
+	// Load setup template (standalone, no base needed)
+	setupPath := filepath.Join(templatesPath, "setup.html")
+	tmpl, err := template.New("").Funcs(funcMap).ParseFiles(setupPath)
+	if err != nil {
+		return nil, fmt.Errorf("parsing setup template: %w", err)
+	}
+	templates["setup.html"] = tmpl
+
+	return &SetupHandler{
+		localDB:    localDB,
+		connMgr:    connMgr,
+		templates:  templates,
+		restartSig: restartSig,
+	}, nil
+}
+
+// ShowSetup renders the database setup form
+func (h *SetupHandler) ShowSetup(c *gin.Context) {
+	c.Header("Content-Type", "text/html; charset=utf-8")
+
+	// Get existing settings if any
+	settings, _ := h.localDB.GetSettings()
+
+	data := gin.H{
+		"Settings": settings,
+	}
+
+	tmpl := h.templates["setup.html"]
+	if err := tmpl.ExecuteTemplate(c.Writer, "setup.html", data); err != nil {
+		c.String(http.StatusInternalServerError, "Template error: %v", err)
+	}
+}
+
+// TestConnection tests the database connection without saving
+func (h *SetupHandler) TestConnection(c *gin.Context) {
+	host := c.PostForm("host")
+	portStr := c.PostForm("port")
+	database := c.PostForm("database")
+	user := c.PostForm("user")
+	password := c.PostForm("password")
+
+	port := 3306
+	if p, err := strconv.Atoi(portStr); err == nil {
+		port = p
+	}
+
+	// If password is empty, try to use saved password
+	if password == "" {
+		if settings, err := h.localDB.GetSettings(); err == nil && settings != nil {
+			password = settings.PasswordEncrypted // GetSettings returns decrypted password in this field
+		}
+	}
+
+	dsn := fmt.Sprintf("%s:%s@tcp(%s:%d)/%s?charset=utf8mb4&parseTime=True&loc=Local&timeout=5s",
+		user, password, host, port, database)
+
+	db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{
+		Logger: logger.Default.LogMode(logger.Silent),
+	})
+	if err != nil {
+		c.JSON(http.StatusOK, gin.H{
+			"success": false,
+			"error":   fmt.Sprintf("Connection failed: %v", err),
+		})
+		return
+	}
+
+	sqlDB, err := db.DB()
+	if err != nil {
+		c.JSON(http.StatusOK, gin.H{
+			"success": false,
+			"error":   fmt.Sprintf("Failed to get database handle: %v", err),
+		})
+		return
+	}
+	defer sqlDB.Close()
+
+	if err := sqlDB.Ping(); err != nil {
+		c.JSON(http.StatusOK, gin.H{
+			"success": false,
+			"error":   fmt.Sprintf("Ping failed: %v", err),
+		})
+		return
+	}
+
+	// Check for required tables
+	var lotCount int64
+	if err := db.Table("lot").Count(&lotCount).Error; err != nil {
+		c.JSON(http.StatusOK, gin.H{
+			"success": false,
+			"error":   fmt.Sprintf("Table 'lot' not found or inaccessible: %v", err),
+		})
+		return
+	}
+
+	// Check write permission
+	canWrite := testWritePermission(db)
+
+	c.JSON(http.StatusOK, gin.H{
+		"success":   true,
+		"lot_count": lotCount,
+		"can_write": canWrite,
+		"message":   fmt.Sprintf("Connected successfully! Found %d components.", lotCount),
+	})
+}
+
+// SaveConnection saves the connection settings and signals restart
+func (h *SetupHandler) SaveConnection(c *gin.Context) {
+	host := c.PostForm("host")
+	portStr := c.PostForm("port")
+	database := c.PostForm("database")
+	user := c.PostForm("user")
+	password := c.PostForm("password")
+
+	port := 3306
+	if p, err := strconv.Atoi(portStr); err == nil {
+		port = p
+	}
+
+	// If password is empty, use saved password
+	if password == "" {
+		if settings, err := h.localDB.GetSettings(); err == nil && settings != nil {
+			password = settings.PasswordEncrypted // GetSettings returns decrypted password in this field
+		}
+	}
+
+	// Test connection first
+	dsn := fmt.Sprintf("%s:%s@tcp(%s:%d)/%s?charset=utf8mb4&parseTime=True&loc=Local&timeout=5s",
+		user, password, host, port, database)
+
+	db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{
+		Logger: logger.Default.LogMode(logger.Silent),
+	})
+	if err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{
+			"success": false,
+			"error":   fmt.Sprintf("Connection failed: %v", err),
+		})
+		return
+	}
+
+	sqlDB, _ := db.DB()
+	sqlDB.Close()
+
+	// Save settings
+	if err := h.localDB.SaveSettings(host, port, database, user, password); err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{
+			"success": false,
+			"error":   fmt.Sprintf("Failed to save settings: %v", err),
+		})
+		return
+	}
+
+	// Try to connect immediately to verify settings
+	if h.connMgr != nil {
+		if err := h.connMgr.TryConnect(); err != nil {
+			slog.Warn("failed to connect after saving settings", "error", err)
+		} else {
+			slog.Info("successfully connected to database after saving settings")
+		}
+	}
+
+	// Always restart to properly initialize all services with the new connection
+	c.JSON(http.StatusOK, gin.H{
+		"success": true,
+		"message": "Settings saved. Please restart the application to apply changes.",
+		"restart_required": true,
+	})
+
+	// Signal restart after response is sent (if restart signal is configured)
+	if h.restartSig != nil {
+		go func() {
+			time.Sleep(500 * time.Millisecond) // Give time for response to be sent
+			h.restartSig <- struct{}{}
+		}()
+	}
+}
+
+// GetStatus returns the current setup status
+func (h *SetupHandler) GetStatus(c *gin.Context) {
+	hasSettings := h.localDB.HasSettings()
+	c.JSON(http.StatusOK, gin.H{
+		"configured": hasSettings,
+	})
+}
+
+func testWritePermission(db *gorm.DB) bool {
+	// Simple check: try to create a temporary table and drop it
+	testTable := fmt.Sprintf("qt_write_test_%d", time.Now().UnixNano())
+
+	// Try to create a test table
+	err := db.Exec(fmt.Sprintf("CREATE TABLE %s (id INT)", testTable)).Error
+	if err != nil {
+		return false
+	}
+
+	// Drop it immediately
+	db.Exec(fmt.Sprintf("DROP TABLE %s", testTable))
+
+	return true
+}

internal/handlers/sync.go

@@ -0,0 +1,388 @@
+package handlers
+
+import (
+	"html/template"
+	"log/slog"
+	"net/http"
+	"path/filepath"
+	"time"
+
+	"github.com/gin-gonic/gin"
+	"git.mchus.pro/mchus/quoteforge/internal/db"
+	"git.mchus.pro/mchus/quoteforge/internal/localdb"
+	"git.mchus.pro/mchus/quoteforge/internal/services/sync"
+)
+
+// SyncHandler handles sync API endpoints
+type SyncHandler struct {
+	localDB     *localdb.LocalDB
+	syncService *sync.Service
+	connMgr     *db.ConnectionManager
+	tmpl        *template.Template
+}
+
+// NewSyncHandler creates a new sync handler
+func NewSyncHandler(localDB *localdb.LocalDB, syncService *sync.Service, connMgr *db.ConnectionManager, templatesPath string) (*SyncHandler, error) {
+	// Load sync_status partial template
+	partialPath := filepath.Join(templatesPath, "partials", "sync_status.html")
+	tmpl, err := template.ParseFiles(partialPath)
+	if err != nil {
+		return nil, err
+	}
+
+	return &SyncHandler{
+		localDB:     localDB,
+		syncService: syncService,
+		connMgr:     connMgr,
+		tmpl:        tmpl,
+	}, nil
+}
+
+// SyncStatusResponse represents the sync status
+type SyncStatusResponse struct {
+	LastComponentSync  *time.Time `json:"last_component_sync"`
+	LastPricelistSync  *time.Time `json:"last_pricelist_sync"`
+	IsOnline           bool       `json:"is_online"`
+	ComponentsCount    int64      `json:"components_count"`
+	PricelistsCount    int64      `json:"pricelists_count"`
+	ServerPricelists   int        `json:"server_pricelists"`
+	NeedComponentSync  bool       `json:"need_component_sync"`
+	NeedPricelistSync  bool       `json:"need_pricelist_sync"`
+}
+
+// GetStatus returns current sync status
+// GET /api/sync/status
+func (h *SyncHandler) GetStatus(c *gin.Context) {
+	// Check online status by pinging MariaDB
+	isOnline := h.checkOnline()
+
+	// Get sync times
+	lastComponentSync := h.localDB.GetComponentSyncTime()
+	lastPricelistSync := h.localDB.GetLastSyncTime()
+
+	// Get counts
+	componentsCount := h.localDB.CountLocalComponents()
+	pricelistsCount := h.localDB.CountLocalPricelists()
+
+	// Get server pricelist count if online
+	serverPricelists := 0
+	needPricelistSync := false
+	if isOnline {
+		status, err := h.syncService.GetStatus()
+		if err == nil {
+			serverPricelists = status.ServerPricelists
+			needPricelistSync = status.NeedsSync
+		}
+	}
+
+	// Check if component sync is needed (older than 24 hours)
+	needComponentSync := h.localDB.NeedComponentSync(24)
+
+	c.JSON(http.StatusOK, SyncStatusResponse{
+		LastComponentSync:  lastComponentSync,
+		LastPricelistSync:  lastPricelistSync,
+		IsOnline:           isOnline,
+		ComponentsCount:    componentsCount,
+		PricelistsCount:    pricelistsCount,
+		ServerPricelists:   serverPricelists,
+		NeedComponentSync:  needComponentSync,
+		NeedPricelistSync:  needPricelistSync,
+	})
+}
+
+// SyncResultResponse represents sync operation result
+type SyncResultResponse struct {
+	Success  bool   `json:"success"`
+	Message  string `json:"message"`
+	Synced   int    `json:"synced"`
+	Duration string `json:"duration"`
+}
+
+// SyncComponents syncs components from MariaDB to local SQLite
+// POST /api/sync/components
+func (h *SyncHandler) SyncComponents(c *gin.Context) {
+	if !h.checkOnline() {
+		c.JSON(http.StatusServiceUnavailable, gin.H{
+			"success": false,
+			"error":   "Database is offline",
+		})
+		return
+	}
+
+	// Get database connection from ConnectionManager
+	mariaDB, err := h.connMgr.GetDB()
+	if err != nil {
+		c.JSON(http.StatusServiceUnavailable, gin.H{
+			"success": false,
+			"error":   "Database connection failed: " + err.Error(),
+		})
+		return
+	}
+
+	result, err := h.localDB.SyncComponents(mariaDB)
+	if err != nil {
+		slog.Error("component sync failed", "error", err)
+		c.JSON(http.StatusInternalServerError, gin.H{
+			"success": false,
+			"error":   err.Error(),
+		})
+		return
+	}
+
+	c.JSON(http.StatusOK, SyncResultResponse{
+		Success:  true,
+		Message:  "Components synced successfully",
+		Synced:   result.TotalSynced,
+		Duration: result.Duration.String(),
+	})
+}
+
+// SyncPricelists syncs pricelists from MariaDB to local SQLite
+// POST /api/sync/pricelists
+func (h *SyncHandler) SyncPricelists(c *gin.Context) {
+	if !h.checkOnline() {
+		c.JSON(http.StatusServiceUnavailable, gin.H{
+			"success": false,
+			"error":   "Database is offline",
+		})
+		return
+	}
+
+	startTime := time.Now()
+	synced, err := h.syncService.SyncPricelists()
+	if err != nil {
+		slog.Error("pricelist sync failed", "error", err)
+		c.JSON(http.StatusInternalServerError, gin.H{
+			"success": false,
+			"error":   err.Error(),
+		})
+		return
+	}
+
+	c.JSON(http.StatusOK, SyncResultResponse{
+		Success:  true,
+		Message:  "Pricelists synced successfully",
+		Synced:   synced,
+		Duration: time.Since(startTime).String(),
+	})
+}
+
+// SyncAllResponse represents result of full sync
+type SyncAllResponse struct {
+	Success            bool   `json:"success"`
+	Message            string `json:"message"`
+	ComponentsSynced   int    `json:"components_synced"`
+	PricelistsSynced   int    `json:"pricelists_synced"`
+	Duration           string `json:"duration"`
+}
+
+// SyncAll syncs both components and pricelists
+// POST /api/sync/all
+func (h *SyncHandler) SyncAll(c *gin.Context) {
+	if !h.checkOnline() {
+		c.JSON(http.StatusServiceUnavailable, gin.H{
+			"success": false,
+			"error":   "Database is offline",
+		})
+		return
+	}
+
+	startTime := time.Now()
+	var componentsSynced, pricelistsSynced int
+
+	// Sync components
+	mariaDB, err := h.connMgr.GetDB()
+	if err != nil {
+		c.JSON(http.StatusServiceUnavailable, gin.H{
+			"success": false,
+			"error":   "Database connection failed: " + err.Error(),
+		})
+		return
+	}
+
+	compResult, err := h.localDB.SyncComponents(mariaDB)
+	if err != nil {
+		slog.Error("component sync failed during full sync", "error", err)
+		c.JSON(http.StatusInternalServerError, gin.H{
+			"success": false,
+			"error":   "Component sync failed: " + err.Error(),
+		})
+		return
+	}
+	componentsSynced = compResult.TotalSynced
+
+	// Sync pricelists
+	pricelistsSynced, err = h.syncService.SyncPricelists()
+	if err != nil {
+		slog.Error("pricelist sync failed during full sync", "error", err)
+		c.JSON(http.StatusInternalServerError, gin.H{
+			"success":          false,
+			"error":            "Pricelist sync failed: " + err.Error(),
+			"components_synced": componentsSynced,
+		})
+		return
+	}
+
+	c.JSON(http.StatusOK, SyncAllResponse{
+		Success:          true,
+		Message:          "Full sync completed successfully",
+		ComponentsSynced: componentsSynced,
+		PricelistsSynced: pricelistsSynced,
+		Duration:         time.Since(startTime).String(),
+	})
+}
+
+// checkOnline checks if MariaDB is accessible
+func (h *SyncHandler) checkOnline() bool {
+	return h.connMgr.IsOnline()
+}
+
+// PushPendingChanges pushes all pending changes to the server
+// POST /api/sync/push
+func (h *SyncHandler) PushPendingChanges(c *gin.Context) {
+	if !h.checkOnline() {
+		c.JSON(http.StatusServiceUnavailable, gin.H{
+			"success": false,
+			"error":   "Database is offline",
+		})
+		return
+	}
+
+	startTime := time.Now()
+	pushed, err := h.syncService.PushPendingChanges()
+	if err != nil {
+		slog.Error("push pending changes failed", "error", err)
+		c.JSON(http.StatusInternalServerError, gin.H{
+			"success": false,
+			"error":   err.Error(),
+		})
+		return
+	}
+
+	c.JSON(http.StatusOK, SyncResultResponse{
+		Success:  true,
+		Message:  "Pending changes pushed successfully",
+		Synced:   pushed,
+		Duration: time.Since(startTime).String(),
+	})
+}
+
+// GetPendingCount returns the number of pending changes
+// GET /api/sync/pending/count
+func (h *SyncHandler) GetPendingCount(c *gin.Context) {
+	count := h.localDB.GetPendingCount()
+	c.JSON(http.StatusOK, gin.H{
+		"count": count,
+	})
+}
+
+// GetPendingChanges returns all pending changes
+// GET /api/sync/pending
+func (h *SyncHandler) GetPendingChanges(c *gin.Context) {
+	changes, err := h.localDB.GetPendingChanges()
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{
+			"error": err.Error(),
+		})
+		return
+	}
+
+	c.JSON(http.StatusOK, gin.H{
+		"changes": changes,
+	})
+}
+
+// SyncInfoResponse represents sync information
+type SyncInfoResponse struct {
+	LastSyncAt *time.Time `json:"last_sync_at"`
+	IsOnline   bool       `json:"is_online"`
+	ErrorCount int        `json:"error_count"`
+	Errors     []SyncError `json:"errors,omitempty"`
+}
+
+// SyncError represents a sync error
+type SyncError struct {
+	Timestamp time.Time `json:"timestamp"`
+	Message   string    `json:"message"`
+}
+
+// GetInfo returns sync information for modal
+// GET /api/sync/info
+func (h *SyncHandler) GetInfo(c *gin.Context) {
+	// Check online status by pinging MariaDB
+	isOnline := h.checkOnline()
+
+	// Get sync times
+	lastPricelistSync := h.localDB.GetLastSyncTime()
+
+	// Get error count (only changes with LastError != "")
+	errorCount := int(h.localDB.CountErroredChanges())
+
+	// Get recent errors (last 10)
+	changes, err := h.localDB.GetPendingChanges()
+	if err != nil {
+		slog.Error("failed to get pending changes for sync info", "error", err)
+		// Even if we can't get changes, we can still return the error count
+		c.JSON(http.StatusOK, SyncInfoResponse{
+			LastSyncAt: lastPricelistSync,
+			IsOnline:   isOnline,
+			ErrorCount: errorCount,
+			Errors:     []SyncError{}, // Return empty errors list
+		})
+		return
+	}
+
+	var errors []SyncError
+	for _, change := range changes {
+		// Check if there's a last error and it's not empty
+		if change.LastError != "" {
+			errors = append(errors, SyncError{
+				Timestamp: change.CreatedAt,
+				Message:   change.LastError,
+			})
+		}
+	}
+
+	// Limit to last 10 errors
+	if len(errors) > 10 {
+		errors = errors[:10]
+	}
+
+	c.JSON(http.StatusOK, SyncInfoResponse{
+		LastSyncAt: lastPricelistSync,
+		IsOnline:   isOnline,
+		ErrorCount: errorCount,
+		Errors:     errors,
+	})
+}
+
+// SyncStatusPartial renders the sync status partial for htmx
+// GET /partials/sync-status
+func (h *SyncHandler) SyncStatusPartial(c *gin.Context) {
+	// Check online status from middleware
+	isOfflineValue, exists := c.Get("is_offline")
+	isOffline := false
+	if exists {
+		isOffline = isOfflineValue.(bool)
+	} else {
+		// Fallback: check directly if middleware didn't set it
+		isOffline = !h.checkOnline()
+		slog.Warn("is_offline not found in context, checking directly")
+	}
+
+	// Get pending count
+	pendingCount := h.localDB.GetPendingCount()
+
+	slog.Debug("rendering sync status", "is_offline", isOffline, "pending_count", pendingCount)
+
+	data := gin.H{
+		"IsOffline":    isOffline,
+		"PendingCount": pendingCount,
+	}
+
+	c.Header("Content-Type", "text/html; charset=utf-8")
+	if err := h.tmpl.ExecuteTemplate(c.Writer, "sync_status", data); err != nil {
+		slog.Error("failed to render sync_status template", "error", err)
+		c.String(http.StatusInternalServerError, "Template error: "+err.Error())
+	}
+}

internal/handlers/web.go

@@ -61,7 +61,7 @@ func NewWebHandler(templatesPath string, componentService *services.ComponentSer
 	basePath := filepath.Join(templatesPath, "base.html")
 
 	// Load each page template with base
-	simplePages := []string{"login.html", "configs.html", "admin_pricing.html"}
+	simplePages := []string{"login.html", "configs.html", "admin_pricing.html", "pricelists.html", "pricelist_detail.html"}
 	for _, page := range simplePages {
 		pagePath := filepath.Join(templatesPath, page)
 		tmpl, err := template.New("").Funcs(funcMap).ParseFiles(basePath, pagePath)
@@ -154,6 +154,14 @@ func (h *WebHandler) AdminPricing(c *gin.Context) {
 	h.render(c, "admin_pricing.html", gin.H{"ActivePage": "admin"})
 }
 
+func (h *WebHandler) Pricelists(c *gin.Context) {
+	h.render(c, "pricelists.html", gin.H{"ActivePage": "pricelists"})
+}
+
+func (h *WebHandler) PricelistDetail(c *gin.Context) {
+	h.render(c, "pricelist_detail.html", gin.H{"ActivePage": "pricelists"})
+}
+
 // Partials for htmx
 
 func (h *WebHandler) ComponentsPartial(c *gin.Context) {

internal/localdb/components.go

@@ -0,0 +1,410 @@
+package localdb
+
+import (
+	"fmt"
+	"log/slog"
+	"strings"
+	"time"
+
+	"gorm.io/gorm"
+)
+
+// ComponentFilter for searching with filters
+type ComponentFilter struct {
+	Category string
+	Search   string
+	HasPrice bool
+}
+
+// ComponentSyncResult contains statistics from component sync
+type ComponentSyncResult struct {
+	TotalSynced int
+	NewCount    int
+	UpdateCount int
+	Duration    time.Duration
+}
+
+// SyncComponents loads components from MariaDB (lot + qt_lot_metadata) into local_components
+func (l *LocalDB) SyncComponents(mariaDB *gorm.DB) (*ComponentSyncResult, error) {
+	startTime := time.Now()
+
+	// Query to join lot with qt_lot_metadata
+	// Use LEFT JOIN to include lots without metadata
+	type componentRow struct {
+		LotName        string
+		LotDescription string
+		Category       *string
+		Model          *string
+		CurrentPrice   *float64
+	}
+
+	var rows []componentRow
+	err := mariaDB.Raw(`
+		SELECT
+			l.lot_name,
+			l.lot_description,
+			COALESCE(c.code, SUBSTRING_INDEX(l.lot_name, '_', 1)) as category,
+			m.model,
+			m.current_price
+		FROM lot l
+		LEFT JOIN qt_lot_metadata m ON l.lot_name = m.lot_name
+		LEFT JOIN qt_categories c ON m.category_id = c.id
+		WHERE m.is_hidden = FALSE OR m.is_hidden IS NULL
+		ORDER BY l.lot_name
+	`).Scan(&rows).Error
+	if err != nil {
+		return nil, fmt.Errorf("querying components from MariaDB: %w", err)
+	}
+
+	if len(rows) == 0 {
+		slog.Warn("no components found in MariaDB")
+		return &ComponentSyncResult{
+			Duration: time.Since(startTime),
+		}, nil
+	}
+
+	// Get existing local components for comparison
+	existingMap := make(map[string]bool)
+	var existing []LocalComponent
+	if err := l.db.Find(&existing).Error; err != nil {
+		return nil, fmt.Errorf("reading existing local components: %w", err)
+	}
+	for _, c := range existing {
+		existingMap[c.LotName] = true
+	}
+
+	// Prepare components for batch insert/update
+	syncTime := time.Now()
+	components := make([]LocalComponent, 0, len(rows))
+	newCount := 0
+
+	for _, row := range rows {
+		category := ""
+		if row.Category != nil {
+			category = *row.Category
+		} else {
+			// Parse category from lot_name (e.g., "CPU_AMD_9654" -> "CPU")
+			parts := strings.SplitN(row.LotName, "_", 2)
+			if len(parts) >= 1 {
+				category = parts[0]
+			}
+		}
+
+		model := ""
+		if row.Model != nil {
+			model = *row.Model
+		}
+
+		comp := LocalComponent{
+			LotName:        row.LotName,
+			LotDescription: row.LotDescription,
+			Category:       category,
+			Model:          model,
+			CurrentPrice:   row.CurrentPrice,
+			SyncedAt:       syncTime,
+		}
+		components = append(components, comp)
+
+		if !existingMap[row.LotName] {
+			newCount++
+		}
+	}
+
+	// Use transaction for bulk upsert
+	err = l.db.Transaction(func(tx *gorm.DB) error {
+		// Delete all existing and insert new (simpler than upsert for SQLite)
+		if err := tx.Where("1=1").Delete(&LocalComponent{}).Error; err != nil {
+			return fmt.Errorf("clearing local components: %w", err)
+		}
+
+		// Batch insert
+		batchSize := 500
+		for i := 0; i < len(components); i += batchSize {
+			end := i + batchSize
+			if end > len(components) {
+				end = len(components)
+			}
+			if err := tx.CreateInBatches(components[i:end], batchSize).Error; err != nil {
+				return fmt.Errorf("inserting components batch: %w", err)
+			}
+		}
+
+		return nil
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	// Update last sync time
+	if err := l.SetComponentSyncTime(syncTime); err != nil {
+		slog.Warn("failed to update component sync time", "error", err)
+	}
+
+	result := &ComponentSyncResult{
+		TotalSynced: len(components),
+		NewCount:    newCount,
+		UpdateCount: len(components) - newCount,
+		Duration:    time.Since(startTime),
+	}
+
+	slog.Info("components synced",
+		"total", result.TotalSynced,
+		"new", result.NewCount,
+		"updated", result.UpdateCount,
+		"duration", result.Duration)
+
+	return result, nil
+}
+
+// SearchLocalComponents searches components in local cache by query string
+// Searches in lot_name, lot_description, category, and model fields
+func (l *LocalDB) SearchLocalComponents(query string, limit int) ([]LocalComponent, error) {
+	if limit <= 0 {
+		limit = 50
+	}
+
+	var components []LocalComponent
+
+	if query == "" {
+		// Return all components with limit
+		err := l.db.Order("lot_name").Limit(limit).Find(&components).Error
+		return components, err
+	}
+
+	// Search with LIKE on multiple fields
+	searchPattern := "%" + strings.ToLower(query) + "%"
+
+	err := l.db.Where(
+		"LOWER(lot_name) LIKE ? OR LOWER(lot_description) LIKE ? OR LOWER(category) LIKE ? OR LOWER(model) LIKE ?",
+		searchPattern, searchPattern, searchPattern, searchPattern,
+	).Order("lot_name").Limit(limit).Find(&components).Error
+
+	return components, err
+}
+
+// SearchLocalComponentsByCategory searches components by category and optional query
+func (l *LocalDB) SearchLocalComponentsByCategory(category string, query string, limit int) ([]LocalComponent, error) {
+	if limit <= 0 {
+		limit = 50
+	}
+
+	var components []LocalComponent
+	db := l.db.Where("LOWER(category) = ?", strings.ToLower(category))
+
+	if query != "" {
+		searchPattern := "%" + strings.ToLower(query) + "%"
+		db = db.Where(
+			"LOWER(lot_name) LIKE ? OR LOWER(lot_description) LIKE ? OR LOWER(model) LIKE ?",
+			searchPattern, searchPattern, searchPattern,
+		)
+	}
+
+	err := db.Order("lot_name").Limit(limit).Find(&components).Error
+	return components, err
+}
+
+// ListComponents returns components with filtering and pagination
+func (l *LocalDB) ListComponents(filter ComponentFilter, offset, limit int) ([]LocalComponent, int64, error) {
+	db := l.db
+
+	// Apply category filter
+	if filter.Category != "" {
+		db = db.Where("LOWER(category) = ?", strings.ToLower(filter.Category))
+	}
+
+	// Apply search filter
+	if filter.Search != "" {
+		searchPattern := "%" + strings.ToLower(filter.Search) + "%"
+		db = db.Where(
+			"LOWER(lot_name) LIKE ? OR LOWER(lot_description) LIKE ? OR LOWER(category) LIKE ? OR LOWER(model) LIKE ?",
+			searchPattern, searchPattern, searchPattern, searchPattern,
+		)
+	}
+
+	// Apply price filter
+	if filter.HasPrice {
+		db = db.Where("current_price IS NOT NULL")
+	}
+
+	// Get total count
+	var total int64
+	if err := db.Model(&LocalComponent{}).Count(&total).Error; err != nil {
+		return nil, 0, err
+	}
+
+	// Apply pagination and get results
+	var components []LocalComponent
+	if err := db.Order("lot_name").Offset(offset).Limit(limit).Find(&components).Error; err != nil {
+		return nil, 0, err
+	}
+
+	return components, total, nil
+}
+
+// GetLocalComponent returns a single component by lot_name
+func (l *LocalDB) GetLocalComponent(lotName string) (*LocalComponent, error) {
+	var component LocalComponent
+	err := l.db.Where("lot_name = ?", lotName).First(&component).Error
+	if err != nil {
+		return nil, err
+	}
+	return &component, nil
+}
+
+// GetLocalComponentCategories returns distinct categories from local components
+func (l *LocalDB) GetLocalComponentCategories() ([]string, error) {
+	var categories []string
+	err := l.db.Model(&LocalComponent{}).
+		Distinct("category").
+		Where("category != ''").
+		Order("category").
+		Pluck("category", &categories).Error
+	return categories, err
+}
+
+// CountLocalComponents returns the total number of local components
+func (l *LocalDB) CountLocalComponents() int64 {
+	var count int64
+	l.db.Model(&LocalComponent{}).Count(&count)
+	return count
+}
+
+// CountLocalComponentsByCategory returns component count by category
+func (l *LocalDB) CountLocalComponentsByCategory(category string) int64 {
+	var count int64
+	l.db.Model(&LocalComponent{}).Where("LOWER(category) = ?", strings.ToLower(category)).Count(&count)
+	return count
+}
+
+// GetComponentSyncTime returns the last component sync timestamp
+func (l *LocalDB) GetComponentSyncTime() *time.Time {
+	var setting struct {
+		Value string
+	}
+	if err := l.db.Table("app_settings").
+		Where("key = ?", "last_component_sync").
+		First(&setting).Error; err != nil {
+		return nil
+	}
+
+	t, err := time.Parse(time.RFC3339, setting.Value)
+	if err != nil {
+		return nil
+	}
+	return &t
+}
+
+// SetComponentSyncTime sets the last component sync timestamp
+func (l *LocalDB) SetComponentSyncTime(t time.Time) error {
+	return l.db.Exec(`
+		INSERT INTO app_settings (key, value, updated_at)
+		VALUES (?, ?, ?)
+		ON CONFLICT(key) DO UPDATE SET value = excluded.value, updated_at = excluded.updated_at
+	`, "last_component_sync", t.Format(time.RFC3339), time.Now().Format(time.RFC3339)).Error
+}
+
+// NeedComponentSync checks if component sync is needed (older than specified hours)
+func (l *LocalDB) NeedComponentSync(maxAgeHours int) bool {
+	syncTime := l.GetComponentSyncTime()
+	if syncTime == nil {
+		return true
+	}
+	return time.Since(*syncTime).Hours() > float64(maxAgeHours)
+}
+
+// UpdateComponentPricesFromPricelist updates current_price in local_components from pricelist items
+// This allows offline price updates using synced pricelists without MariaDB connection
+func (l *LocalDB) UpdateComponentPricesFromPricelist(pricelistID uint) (int, error) {
+	// Get all items from the specified pricelist
+	var items []LocalPricelistItem
+	if err := l.db.Where("pricelist_id = ?", pricelistID).Find(&items).Error; err != nil {
+		return 0, fmt.Errorf("fetching pricelist items: %w", err)
+	}
+
+	if len(items) == 0 {
+		slog.Warn("no items found in pricelist", "pricelist_id", pricelistID)
+		return 0, nil
+	}
+
+	// Update current_price for each component
+	updated := 0
+	err := l.db.Transaction(func(tx *gorm.DB) error {
+		for _, item := range items {
+			result := tx.Model(&LocalComponent{}).
+				Where("lot_name = ?", item.LotName).
+				Update("current_price", item.Price)
+
+			if result.Error != nil {
+				return fmt.Errorf("updating price for %s: %w", item.LotName, result.Error)
+			}
+
+			if result.RowsAffected > 0 {
+				updated++
+			}
+		}
+		return nil
+	})
+
+	if err != nil {
+		return 0, err
+	}
+
+	slog.Info("updated component prices from pricelist",
+		"pricelist_id", pricelistID,
+		"total_items", len(items),
+		"updated_components", updated)
+
+	return updated, nil
+}
+
+// EnsureComponentPricesFromPricelists loads prices from the latest pricelist into local_components
+// if no components exist or all current prices are NULL
+func (l *LocalDB) EnsureComponentPricesFromPricelists() error {
+	// Check if we have any components with prices
+	var count int64
+	if err := l.db.Model(&LocalComponent{}).Where("current_price IS NOT NULL").Count(&count).Error; err != nil {
+		return fmt.Errorf("checking component prices: %w", err)
+	}
+
+	// If we have components with prices, don't load from pricelists
+	if count > 0 {
+		return nil
+	}
+
+	// Check if we have any components at all
+	var totalComponents int64
+	if err := l.db.Model(&LocalComponent{}).Count(&totalComponents).Error; err != nil {
+		return fmt.Errorf("counting components: %w", err)
+	}
+
+	// If we have no components, we need to load them from pricelists
+	if totalComponents == 0 {
+		slog.Info("no components found in local database, loading from latest pricelist")
+		// This would typically be called from the sync service or setup process
+		// For now, we'll just return nil to indicate no action needed
+		return nil
+	}
+
+	// If we have components but no prices, we should load prices from pricelists
+	// Find the latest pricelist
+	var latestPricelist LocalPricelist
+	if err := l.db.Order("created_at DESC").First(&latestPricelist).Error; err != nil {
+		if err == gorm.ErrRecordNotFound {
+			slog.Warn("no pricelists found in local database")
+			return nil
+		}
+		return fmt.Errorf("finding latest pricelist: %w", err)
+	}
+
+	// Update prices from the latest pricelist
+	updated, err := l.UpdateComponentPricesFromPricelist(latestPricelist.ID)
+	if err != nil {
+		return fmt.Errorf("updating component prices from pricelist: %w", err)
+	}
+
+	slog.Info("loaded component prices from latest pricelist",
+		"pricelist_id", latestPricelist.ID,
+		"updated_components", updated)
+
+	return nil
+}

internal/localdb/converters.go

@@ -0,0 +1,163 @@
+package localdb
+
+import (
+	"time"
+
+	"git.mchus.pro/mchus/quoteforge/internal/models"
+)
+
+// ConfigurationToLocal converts models.Configuration to LocalConfiguration
+func ConfigurationToLocal(cfg *models.Configuration) *LocalConfiguration {
+	items := make(LocalConfigItems, len(cfg.Items))
+	for i, item := range cfg.Items {
+		items[i] = LocalConfigItem{
+			LotName:   item.LotName,
+			Quantity:  item.Quantity,
+			UnitPrice: item.UnitPrice,
+		}
+	}
+
+	local := &LocalConfiguration{
+		UUID:           cfg.UUID,
+		Name:           cfg.Name,
+		Items:          items,
+		TotalPrice:     cfg.TotalPrice,
+		CustomPrice:    cfg.CustomPrice,
+		Notes:          cfg.Notes,
+		IsTemplate:     cfg.IsTemplate,
+		ServerCount:    cfg.ServerCount,
+		PriceUpdatedAt: cfg.PriceUpdatedAt,
+		CreatedAt:      cfg.CreatedAt,
+		UpdatedAt:      time.Now(),
+		SyncStatus:     "pending",
+		OriginalUserID: cfg.UserID,
+	}
+
+	if cfg.ID > 0 {
+		serverID := cfg.ID
+		local.ServerID = &serverID
+	}
+
+	return local
+}
+
+// LocalToConfiguration converts LocalConfiguration to models.Configuration
+func LocalToConfiguration(local *LocalConfiguration) *models.Configuration {
+	items := make(models.ConfigItems, len(local.Items))
+	for i, item := range local.Items {
+		items[i] = models.ConfigItem{
+			LotName:   item.LotName,
+			Quantity:  item.Quantity,
+			UnitPrice: item.UnitPrice,
+		}
+	}
+
+	cfg := &models.Configuration{
+		UUID:           local.UUID,
+		UserID:         local.OriginalUserID,
+		Name:           local.Name,
+		Items:          items,
+		TotalPrice:     local.TotalPrice,
+		CustomPrice:    local.CustomPrice,
+		Notes:          local.Notes,
+		IsTemplate:     local.IsTemplate,
+		ServerCount:    local.ServerCount,
+		PriceUpdatedAt: local.PriceUpdatedAt,
+		CreatedAt:      local.CreatedAt,
+	}
+
+	if local.ServerID != nil {
+		cfg.ID = *local.ServerID
+	}
+
+	return cfg
+}
+
+// PricelistToLocal converts models.Pricelist to LocalPricelist
+func PricelistToLocal(pl *models.Pricelist) *LocalPricelist {
+	name := pl.Notification
+	if name == "" {
+		name = pl.Version
+	}
+
+	return &LocalPricelist{
+		ServerID:  pl.ID,
+		Version:   pl.Version,
+		Name:      name,
+		CreatedAt: pl.CreatedAt,
+		SyncedAt:  time.Now(),
+		IsUsed:    false,
+	}
+}
+
+// LocalToPricelist converts LocalPricelist to models.Pricelist
+func LocalToPricelist(local *LocalPricelist) *models.Pricelist {
+	return &models.Pricelist{
+		ID:           local.ServerID,
+		Version:      local.Version,
+		Notification: local.Name,
+		CreatedAt:    local.CreatedAt,
+		IsActive:     true,
+	}
+}
+
+// PricelistItemToLocal converts models.PricelistItem to LocalPricelistItem
+func PricelistItemToLocal(item *models.PricelistItem, localPricelistID uint) *LocalPricelistItem {
+	return &LocalPricelistItem{
+		PricelistID: localPricelistID,
+		LotName:     item.LotName,
+		Price:       item.Price,
+	}
+}
+
+// LocalToPricelistItem converts LocalPricelistItem to models.PricelistItem
+func LocalToPricelistItem(local *LocalPricelistItem, serverPricelistID uint) *models.PricelistItem {
+	return &models.PricelistItem{
+		ID:          local.ID,
+		PricelistID: serverPricelistID,
+		LotName:     local.LotName,
+		Price:       local.Price,
+	}
+}
+
+// ComponentToLocal converts models.LotMetadata to LocalComponent
+func ComponentToLocal(meta *models.LotMetadata) *LocalComponent {
+	var lotDesc string
+	var category string
+
+	if meta.Lot != nil {
+		lotDesc = meta.Lot.LotDescription
+	}
+
+	// Extract category from lot_name (e.g., "CPU_AMD_9654" -> "CPU")
+	if len(meta.LotName) > 0 {
+		for i, ch := range meta.LotName {
+			if ch == '_' {
+				category = meta.LotName[:i]
+				break
+			}
+		}
+	}
+
+	return &LocalComponent{
+		LotName:        meta.LotName,
+		LotDescription: lotDesc,
+		Category:       category,
+		Model:          meta.Model,
+		CurrentPrice:   meta.CurrentPrice,
+		SyncedAt:       time.Now(),
+	}
+}
+
+// LocalToComponent converts LocalComponent to models.LotMetadata
+func LocalToComponent(local *LocalComponent) *models.LotMetadata {
+	return &models.LotMetadata{
+		LotName:      local.LotName,
+		Model:        local.Model,
+		CurrentPrice: local.CurrentPrice,
+		Lot: &models.Lot{
+			LotName:        local.LotName,
+			LotDescription: local.LotDescription,
+		},
+	}
+}

internal/localdb/encryption.go

@@ -0,0 +1,87 @@
+package localdb
+
+import (
+	"crypto/aes"
+	"crypto/cipher"
+	"crypto/rand"
+	"crypto/sha256"
+	"encoding/base64"
+	"errors"
+	"io"
+	"os"
+)
+
+// getEncryptionKey derives a 32-byte key from environment variable or machine ID
+func getEncryptionKey() []byte {
+	key := os.Getenv("QUOTEFORGE_ENCRYPTION_KEY")
+	if key == "" {
+		// Fallback to a machine-based key (hostname + fixed salt)
+		hostname, _ := os.Hostname()
+		key = hostname + "quoteforge-salt-2024"
+	}
+	// Hash to get exactly 32 bytes for AES-256
+	hash := sha256.Sum256([]byte(key))
+	return hash[:]
+}
+
+// Encrypt encrypts plaintext using AES-256-GCM
+func Encrypt(plaintext string) (string, error) {
+	if plaintext == "" {
+		return "", nil
+	}
+
+	key := getEncryptionKey()
+	block, err := aes.NewCipher(key)
+	if err != nil {
+		return "", err
+	}
+
+	gcm, err := cipher.NewGCM(block)
+	if err != nil {
+		return "", err
+	}
+
+	nonce := make([]byte, gcm.NonceSize())
+	if _, err := io.ReadFull(rand.Reader, nonce); err != nil {
+		return "", err
+	}
+
+	ciphertext := gcm.Seal(nonce, nonce, []byte(plaintext), nil)
+	return base64.StdEncoding.EncodeToString(ciphertext), nil
+}
+
+// Decrypt decrypts ciphertext that was encrypted with Encrypt
+func Decrypt(ciphertext string) (string, error) {
+	if ciphertext == "" {
+		return "", nil
+	}
+
+	key := getEncryptionKey()
+	data, err := base64.StdEncoding.DecodeString(ciphertext)
+	if err != nil {
+		return "", err
+	}
+
+	block, err := aes.NewCipher(key)
+	if err != nil {
+		return "", err
+	}
+
+	gcm, err := cipher.NewGCM(block)
+	if err != nil {
+		return "", err
+	}
+
+	nonceSize := gcm.NonceSize()
+	if len(data) < nonceSize {
+		return "", errors.New("ciphertext too short")
+	}
+
+	nonce, ciphertextBytes := data[:nonceSize], data[nonceSize:]
+	plaintext, err := gcm.Open(nil, nonce, ciphertextBytes, nil)
+	if err != nil {
+		return "", err
+	}
+
+	return string(plaintext), nil
+}

internal/localdb/localdb.go

@@ -0,0 +1,421 @@
+package localdb
+
+import (
+	"fmt"
+	"log/slog"
+	"os"
+	"path/filepath"
+	"time"
+
+	"github.com/glebarez/sqlite"
+	"gorm.io/gorm"
+	"gorm.io/gorm/logger"
+)
+
+// ConnectionSettings stores MariaDB connection credentials
+type ConnectionSettings struct {
+	ID                uint      `gorm:"primaryKey"`
+	Host              string    `gorm:"not null"`
+	Port              int       `gorm:"not null;default:3306"`
+	Database          string    `gorm:"not null"`
+	User              string    `gorm:"not null"`
+	PasswordEncrypted string    `gorm:"not null"` // AES encrypted
+	UpdatedAt         time.Time `gorm:"autoUpdateTime"`
+}
+
+func (ConnectionSettings) TableName() string {
+	return "connection_settings"
+}
+
+// LocalDB manages the local SQLite database for settings
+type LocalDB struct {
+	db   *gorm.DB
+	path string
+}
+
+// New creates a new LocalDB instance
+func New(dbPath string) (*LocalDB, error) {
+	// Ensure directory exists
+	dir := filepath.Dir(dbPath)
+	if err := os.MkdirAll(dir, 0755); err != nil {
+		return nil, fmt.Errorf("creating data directory: %w", err)
+	}
+
+	db, err := gorm.Open(sqlite.Open(dbPath), &gorm.Config{
+		Logger: logger.Default.LogMode(logger.Silent),
+	})
+	if err != nil {
+		return nil, fmt.Errorf("opening sqlite database: %w", err)
+	}
+
+	// Auto-migrate all local tables
+	if err := db.AutoMigrate(
+		&ConnectionSettings{},
+		&LocalConfiguration{},
+		&LocalPricelist{},
+		&LocalPricelistItem{},
+		&LocalComponent{},
+		&AppSetting{},
+		&PendingChange{},
+	); err != nil {
+		return nil, fmt.Errorf("migrating sqlite database: %w", err)
+	}
+
+	slog.Info("local SQLite database initialized", "path", dbPath)
+
+	return &LocalDB{
+		db:   db,
+		path: dbPath,
+	}, nil
+}
+
+// HasSettings returns true if connection settings exist
+func (l *LocalDB) HasSettings() bool {
+	var count int64
+	l.db.Model(&ConnectionSettings{}).Count(&count)
+	return count > 0
+}
+
+// GetSettings retrieves the connection settings with decrypted password
+func (l *LocalDB) GetSettings() (*ConnectionSettings, error) {
+	var settings ConnectionSettings
+	if err := l.db.First(&settings).Error; err != nil {
+		return nil, fmt.Errorf("getting settings: %w", err)
+	}
+
+	// Decrypt password
+	password, err := Decrypt(settings.PasswordEncrypted)
+	if err != nil {
+		return nil, fmt.Errorf("decrypting password: %w", err)
+	}
+	settings.PasswordEncrypted = password // Return decrypted password in this field
+
+	return &settings, nil
+}
+
+// SaveSettings saves connection settings with encrypted password
+func (l *LocalDB) SaveSettings(host string, port int, database, user, password string) error {
+	// Encrypt password
+	encrypted, err := Encrypt(password)
+	if err != nil {
+		return fmt.Errorf("encrypting password: %w", err)
+	}
+
+	settings := ConnectionSettings{
+		ID:                1, // Always use ID=1 for single settings row
+		Host:              host,
+		Port:              port,
+		Database:          database,
+		User:              user,
+		PasswordEncrypted: encrypted,
+	}
+
+	// Upsert: create or update
+	result := l.db.Save(&settings)
+	if result.Error != nil {
+		return fmt.Errorf("saving settings: %w", result.Error)
+	}
+
+	slog.Info("connection settings saved", "host", host, "port", port, "database", database, "user", user)
+	return nil
+}
+
+// DeleteSettings removes all connection settings
+func (l *LocalDB) DeleteSettings() error {
+	return l.db.Where("1=1").Delete(&ConnectionSettings{}).Error
+}
+
+// GetDSN returns the MariaDB DSN string
+func (l *LocalDB) GetDSN() (string, error) {
+	settings, err := l.GetSettings()
+	if err != nil {
+		return "", err
+	}
+
+	// Add aggressive timeouts for offline-first architecture
+	// timeout: connection establishment timeout (3s)
+	// readTimeout: I/O read timeout (3s)
+	// writeTimeout: I/O write timeout (3s)
+	dsn := fmt.Sprintf("%s:%s@tcp(%s:%d)/%s?charset=utf8mb4&parseTime=True&loc=Local&timeout=3s&readTimeout=3s&writeTimeout=3s",
+		settings.User,
+		settings.PasswordEncrypted, // Contains decrypted password after GetSettings
+		settings.Host,
+		settings.Port,
+		settings.Database,
+	)
+
+	return dsn, nil
+}
+
+// DB returns the underlying gorm.DB for advanced operations
+func (l *LocalDB) DB() *gorm.DB {
+	return l.db
+}
+
+// Close closes the database connection
+func (l *LocalDB) Close() error {
+	sqlDB, err := l.db.DB()
+	if err != nil {
+		return err
+	}
+	return sqlDB.Close()
+}
+
+// GetDBUser returns the database username from settings
+func (l *LocalDB) GetDBUser() string {
+	settings, err := l.GetSettings()
+	if err != nil {
+		return ""
+	}
+	return settings.User
+}
+
+// Configuration methods
+
+// SaveConfiguration saves a configuration to local SQLite
+func (l *LocalDB) SaveConfiguration(config *LocalConfiguration) error {
+	return l.db.Save(config).Error
+}
+
+// GetConfigurations returns all local configurations
+func (l *LocalDB) GetConfigurations() ([]LocalConfiguration, error) {
+	var configs []LocalConfiguration
+	err := l.db.Order("created_at DESC").Find(&configs).Error
+	return configs, err
+}
+
+// GetConfigurationByUUID returns a configuration by UUID
+func (l *LocalDB) GetConfigurationByUUID(uuid string) (*LocalConfiguration, error) {
+	var config LocalConfiguration
+	err := l.db.Where("uuid = ?", uuid).First(&config).Error
+	return &config, err
+}
+
+// DeleteConfiguration deletes a configuration by UUID
+func (l *LocalDB) DeleteConfiguration(uuid string) error {
+	return l.db.Where("uuid = ?", uuid).Delete(&LocalConfiguration{}).Error
+}
+
+// CountConfigurations returns the number of local configurations
+func (l *LocalDB) CountConfigurations() int64 {
+	var count int64
+	l.db.Model(&LocalConfiguration{}).Count(&count)
+	return count
+}
+
+// Pricelist methods
+
+// GetLastSyncTime returns the last sync timestamp
+func (l *LocalDB) GetLastSyncTime() *time.Time {
+	var setting struct {
+		Value string
+	}
+	if err := l.db.Table("app_settings").
+		Where("key = ?", "last_pricelist_sync").
+		First(&setting).Error; err != nil {
+		return nil
+	}
+
+	t, err := time.Parse(time.RFC3339, setting.Value)
+	if err != nil {
+		return nil
+	}
+	return &t
+}
+
+// SetLastSyncTime sets the last sync timestamp
+func (l *LocalDB) SetLastSyncTime(t time.Time) error {
+	// Using raw SQL for upsert since SQLite doesn't have native UPSERT in all versions
+	return l.db.Exec(`
+		INSERT INTO app_settings (key, value, updated_at)
+		VALUES (?, ?, ?)
+		ON CONFLICT(key) DO UPDATE SET value = excluded.value, updated_at = excluded.updated_at
+	`, "last_pricelist_sync", t.Format(time.RFC3339), time.Now().Format(time.RFC3339)).Error
+}
+
+// CountLocalPricelists returns the number of local pricelists
+func (l *LocalDB) CountLocalPricelists() int64 {
+	var count int64
+	l.db.Model(&LocalPricelist{}).Count(&count)
+	return count
+}
+
+// GetLatestLocalPricelist returns the most recently synced pricelist
+func (l *LocalDB) GetLatestLocalPricelist() (*LocalPricelist, error) {
+	var pricelist LocalPricelist
+	if err := l.db.Order("created_at DESC").First(&pricelist).Error; err != nil {
+		return nil, err
+	}
+	return &pricelist, nil
+}
+
+// GetLocalPricelistByServerID returns a local pricelist by its server ID
+func (l *LocalDB) GetLocalPricelistByServerID(serverID uint) (*LocalPricelist, error) {
+	var pricelist LocalPricelist
+	if err := l.db.Where("server_id = ?", serverID).First(&pricelist).Error; err != nil {
+		return nil, err
+	}
+	return &pricelist, nil
+}
+
+// GetLocalPricelistByID returns a local pricelist by its local ID
+func (l *LocalDB) GetLocalPricelistByID(id uint) (*LocalPricelist, error) {
+	var pricelist LocalPricelist
+	if err := l.db.First(&pricelist, id).Error; err != nil {
+		return nil, err
+	}
+	return &pricelist, nil
+}
+
+// SaveLocalPricelist saves a pricelist to local SQLite
+func (l *LocalDB) SaveLocalPricelist(pricelist *LocalPricelist) error {
+	return l.db.Save(pricelist).Error
+}
+
+// GetLocalPricelists returns all local pricelists
+func (l *LocalDB) GetLocalPricelists() ([]LocalPricelist, error) {
+	var pricelists []LocalPricelist
+	if err := l.db.Order("created_at DESC").Find(&pricelists).Error; err != nil {
+		return nil, err
+	}
+	return pricelists, nil
+}
+
+// CountLocalPricelistItems returns the number of items for a pricelist
+func (l *LocalDB) CountLocalPricelistItems(pricelistID uint) int64 {
+	var count int64
+	l.db.Model(&LocalPricelistItem{}).Where("pricelist_id = ?", pricelistID).Count(&count)
+	return count
+}
+
+// SaveLocalPricelistItems saves pricelist items to local SQLite
+func (l *LocalDB) SaveLocalPricelistItems(items []LocalPricelistItem) error {
+	if len(items) == 0 {
+		return nil
+	}
+
+	// Batch insert
+	batchSize := 500
+	for i := 0; i < len(items); i += batchSize {
+		end := i + batchSize
+		if end > len(items) {
+			end = len(items)
+		}
+		if err := l.db.CreateInBatches(items[i:end], batchSize).Error; err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// GetLocalPricelistItems returns items for a local pricelist
+func (l *LocalDB) GetLocalPricelistItems(pricelistID uint) ([]LocalPricelistItem, error) {
+	var items []LocalPricelistItem
+	if err := l.db.Where("pricelist_id = ?", pricelistID).Find(&items).Error; err != nil {
+		return nil, err
+	}
+	return items, nil
+}
+
+// GetLocalPriceForLot returns the price for a lot from a local pricelist
+func (l *LocalDB) GetLocalPriceForLot(pricelistID uint, lotName string) (float64, error) {
+	var item LocalPricelistItem
+	if err := l.db.Where("pricelist_id = ? AND lot_name = ?", pricelistID, lotName).
+		First(&item).Error; err != nil {
+		return 0, err
+	}
+	return item.Price, nil
+}
+
+// MarkPricelistAsUsed marks a pricelist as used by a configuration
+func (l *LocalDB) MarkPricelistAsUsed(pricelistID uint, isUsed bool) error {
+	return l.db.Model(&LocalPricelist{}).Where("id = ?", pricelistID).
+		Update("is_used", isUsed).Error
+}
+
+// DeleteLocalPricelist deletes a pricelist and its items
+func (l *LocalDB) DeleteLocalPricelist(id uint) error {
+	// Delete items first
+	if err := l.db.Where("pricelist_id = ?", id).Delete(&LocalPricelistItem{}).Error; err != nil {
+		return err
+	}
+	// Delete pricelist
+	return l.db.Delete(&LocalPricelist{}, id).Error
+}
+
+// PendingChange methods
+
+// AddPendingChange adds a change to the sync queue
+func (l *LocalDB) AddPendingChange(entityType, entityUUID, operation, payload string) error {
+	change := PendingChange{
+		EntityType: entityType,
+		EntityUUID: entityUUID,
+		Operation:  operation,
+		Payload:    payload,
+		CreatedAt:  time.Now(),
+		Attempts:   0,
+	}
+	return l.db.Create(&change).Error
+}
+
+// GetPendingChanges returns all pending changes ordered by creation time
+func (l *LocalDB) GetPendingChanges() ([]PendingChange, error) {
+	var changes []PendingChange
+	err := l.db.Order("created_at ASC").Find(&changes).Error
+	return changes, err
+}
+
+// GetPendingChangesByEntity returns pending changes for a specific entity
+func (l *LocalDB) GetPendingChangesByEntity(entityType, entityUUID string) ([]PendingChange, error) {
+	var changes []PendingChange
+	err := l.db.Where("entity_type = ? AND entity_uuid = ?", entityType, entityUUID).
+		Order("created_at ASC").Find(&changes).Error
+	return changes, err
+}
+
+// DeletePendingChange removes a change from the sync queue after successful sync
+func (l *LocalDB) DeletePendingChange(id int64) error {
+	return l.db.Delete(&PendingChange{}, id).Error
+}
+
+// IncrementPendingChangeAttempts updates the attempt counter and last error
+func (l *LocalDB) IncrementPendingChangeAttempts(id int64, errorMsg string) error {
+	return l.db.Model(&PendingChange{}).Where("id = ?", id).Updates(map[string]interface{}{
+		"attempts":   gorm.Expr("attempts + 1"),
+		"last_error": errorMsg,
+	}).Error
+}
+
+// CountPendingChanges returns the total number of pending changes
+func (l *LocalDB) CountPendingChanges() int64 {
+	var count int64
+	l.db.Model(&PendingChange{}).Count(&count)
+	return count
+}
+
+// CountPendingChangesByType returns the number of pending changes by entity type
+func (l *LocalDB) CountPendingChangesByType(entityType string) int64 {
+	var count int64
+	l.db.Model(&PendingChange{}).Where("entity_type = ?", entityType).Count(&count)
+	return count
+}
+
+// CountErroredChanges returns the number of pending changes with errors
+func (l *LocalDB) CountErroredChanges() int64 {
+	var count int64
+	l.db.Model(&PendingChange{}).Where("last_error != ?", "").Count(&count)
+	return count
+}
+
+// MarkChangesSynced marks multiple pending changes as synced by deleting them
+func (l *LocalDB) MarkChangesSynced(ids []int64) error {
+	if len(ids) == 0 {
+		return nil
+	}
+	return l.db.Where("id IN ?", ids).Delete(&PendingChange{}).Error
+}
+
+// GetPendingCount returns the total number of pending changes (alias for CountPendingChanges)
+func (l *LocalDB) GetPendingCount() int64 {
+	return l.CountPendingChanges()
+}

internal/localdb/models.go

@@ -0,0 +1,139 @@
+package localdb
+
+import (
+	"database/sql/driver"
+	"encoding/json"
+	"errors"
+	"time"
+)
+
+// AppSetting stores application settings in local SQLite
+type AppSetting struct {
+	Key       string    `gorm:"primaryKey" json:"key"`
+	Value     string    `gorm:"not null" json:"value"`
+	UpdatedAt time.Time `json:"updated_at"`
+}
+
+func (AppSetting) TableName() string {
+	return "app_settings"
+}
+
+// LocalConfigItem represents an item in a configuration
+type LocalConfigItem struct {
+	LotName   string  `json:"lot_name"`
+	Quantity  int     `json:"quantity"`
+	UnitPrice float64 `json:"unit_price"`
+}
+
+// LocalConfigItems is a slice of LocalConfigItem that can be stored as JSON
+type LocalConfigItems []LocalConfigItem
+
+func (c LocalConfigItems) Value() (driver.Value, error) {
+	return json.Marshal(c)
+}
+
+func (c *LocalConfigItems) Scan(value interface{}) error {
+	if value == nil {
+		*c = make(LocalConfigItems, 0)
+		return nil
+	}
+	var bytes []byte
+	switch v := value.(type) {
+	case []byte:
+		bytes = v
+	case string:
+		bytes = []byte(v)
+	default:
+		return errors.New("type assertion failed for LocalConfigItems")
+	}
+	return json.Unmarshal(bytes, c)
+}
+
+func (c LocalConfigItems) Total() float64 {
+	var total float64
+	for _, item := range c {
+		total += item.UnitPrice * float64(item.Quantity)
+	}
+	return total
+}
+
+// LocalConfiguration stores configurations in local SQLite
+type LocalConfiguration struct {
+	ID             uint             `gorm:"primaryKey;autoIncrement" json:"id"`
+	UUID           string           `gorm:"uniqueIndex;not null" json:"uuid"`
+	ServerID       *uint            `json:"server_id"`        // ID on MariaDB server, NULL if local only
+	Name           string           `gorm:"not null" json:"name"`
+	Items          LocalConfigItems `gorm:"type:text" json:"items"` // JSON stored as text in SQLite
+	TotalPrice     *float64         `json:"total_price"`
+	CustomPrice    *float64         `json:"custom_price"`
+	Notes          string           `json:"notes"`
+	IsTemplate     bool             `gorm:"default:false" json:"is_template"`
+	ServerCount    int              `gorm:"default:1" json:"server_count"`
+	PriceUpdatedAt *time.Time       `gorm:"type:timestamp" json:"price_updated_at,omitempty"`
+	CreatedAt      time.Time        `json:"created_at"`
+	UpdatedAt      time.Time        `json:"updated_at"`
+	SyncedAt       *time.Time       `json:"synced_at"`
+	SyncStatus     string           `gorm:"default:'local'" json:"sync_status"` // 'local', 'synced', 'modified'
+	OriginalUserID uint             `json:"original_user_id"`                   // UserID from MariaDB for reference
+}
+
+func (LocalConfiguration) TableName() string {
+	return "local_configurations"
+}
+
+// LocalPricelist stores cached pricelists from server
+type LocalPricelist struct {
+	ID        uint       `gorm:"primaryKey;autoIncrement" json:"id"`
+	ServerID  uint       `gorm:"not null" json:"server_id"` // ID on MariaDB server
+	Version   string     `gorm:"uniqueIndex;not null" json:"version"`
+	Name      string     `json:"name"`
+	CreatedAt time.Time  `json:"created_at"`
+	SyncedAt  time.Time  `json:"synced_at"`
+	IsUsed    bool       `gorm:"default:false" json:"is_used"` // Used by any local configuration
+}
+
+func (LocalPricelist) TableName() string {
+	return "local_pricelists"
+}
+
+// LocalPricelistItem stores pricelist items
+type LocalPricelistItem struct {
+	ID          uint    `gorm:"primaryKey;autoIncrement" json:"id"`
+	PricelistID uint    `gorm:"not null;index" json:"pricelist_id"`
+	LotName     string  `gorm:"not null" json:"lot_name"`
+	Price       float64 `gorm:"not null" json:"price"`
+}
+
+func (LocalPricelistItem) TableName() string {
+	return "local_pricelist_items"
+}
+
+// LocalComponent stores cached components for offline search
+type LocalComponent struct {
+	LotName        string    `gorm:"primaryKey" json:"lot_name"`
+	LotDescription string    `json:"lot_description"`
+	Category       string    `json:"category"`
+	Model          string    `json:"model"`
+	CurrentPrice   *float64  `json:"current_price"`
+	SyncedAt       time.Time `json:"synced_at"`
+}
+
+func (LocalComponent) TableName() string {
+	return "local_components"
+}
+
+// PendingChange stores changes that need to be synced to the server
+type PendingChange struct {
+	ID         int64     `gorm:"primaryKey;autoIncrement" json:"id"`
+	EntityType string    `gorm:"not null;index" json:"entity_type"` // "configuration", "project", "specification"
+	EntityUUID string    `gorm:"not null;index" json:"entity_uuid"`
+	Operation  string    `gorm:"not null" json:"operation"` // "create", "update", "delete"
+	Payload    string    `gorm:"type:text" json:"payload"`  // JSON snapshot of the entity
+	CreatedAt  time.Time `gorm:"not null" json:"created_at"`
+	Attempts   int       `gorm:"default:0" json:"attempts"` // Retry count for sync
+	LastError  string    `gorm:"type:text" json:"last_error,omitempty"`
+}
+
+func (PendingChange) TableName() string {
+	return "pending_changes"
+}

internal/middleware/offline.go

@@ -0,0 +1,29 @@
+package middleware
+
+import (
+	"log/slog"
+
+	"github.com/gin-gonic/gin"
+	"git.mchus.pro/mchus/quoteforge/internal/db"
+	"git.mchus.pro/mchus/quoteforge/internal/localdb"
+)
+
+// OfflineDetector creates middleware that detects offline mode
+// Sets context values:
+//   - "is_offline" (bool) - true if MariaDB is unavailable
+//   - "localdb" (*localdb.LocalDB) - local database instance for fallback
+func OfflineDetector(connMgr *db.ConnectionManager, local *localdb.LocalDB) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		isOffline := !connMgr.IsOnline()
+
+		// Set context values for handlers
+		c.Set("is_offline", isOffline)
+		c.Set("localdb", local)
+
+		if isOffline {
+			slog.Debug("offline mode detected - MariaDB unavailable")
+		}
+
+		c.Next()
+	}
+}

internal/models/models.go

@@ -1,6 +1,11 @@
 package models
 
-import "gorm.io/gorm"
+import (
+	"log/slog"
+	"strings"
+
+	"gorm.io/gorm"
+)
 
 // AllModels returns all models for auto-migration
 func AllModels() []interface{} {
@@ -12,12 +17,28 @@ func AllModels() []interface{} {
 		&PriceOverride{},
 		&PricingAlert{},
 		&ComponentUsageStats{},
+		&Pricelist{},
+		&PricelistItem{},
 	}
 }
 
 // Migrate runs auto-migration for all QuoteForge tables
+// Handles MySQL constraint errors gracefully for existing tables
 func Migrate(db *gorm.DB) error {
-	return db.AutoMigrate(AllModels()...)
+	for _, model := range AllModels() {
+		if err := db.AutoMigrate(model); err != nil {
+			// Skip known MySQL constraint errors for existing tables
+			errStr := err.Error()
+			if strings.Contains(errStr, "Can't DROP") ||
+				strings.Contains(errStr, "Duplicate key name") ||
+				strings.Contains(errStr, "check that it exists") {
+				slog.Warn("migration warning (skipped)", "model", model, "error", errStr)
+				continue
+			}
+			return err
+		}
+	}
+	return nil
 }
 
 // SeedCategories inserts default categories if not exist
@@ -49,3 +70,35 @@ func SeedAdminUser(db *gorm.DB, passwordHash string) error {
 	}
 	return db.Create(admin).Error
 }
+
+// EnsureDBUser creates or returns the user corresponding to the database connection username.
+// This is used when RBAC is disabled - configurations are owned by the DB user.
+// Returns the user ID that should be used for all operations.
+func EnsureDBUser(db *gorm.DB, dbUsername string) (uint, error) {
+	if dbUsername == "" {
+		return 0, nil
+	}
+
+	var user User
+	err := db.Where("username = ?", dbUsername).First(&user).Error
+	if err == nil {
+		return user.ID, nil
+	}
+
+	// User doesn't exist, create it
+	user = User{
+		Username:     dbUsername,
+		Email:        dbUsername + "@db.local",
+		PasswordHash: "-", // No password - this is a DB user, not an app user
+		Role:         RoleAdmin,
+		IsActive:     true,
+	}
+
+	if err := db.Create(&user).Error; err != nil {
+		slog.Error("failed to create DB user", "username", dbUsername, "error", err)
+		return 0, err
+	}
+
+	slog.Info("created DB user for configurations", "username", dbUsername, "user_id", user.ID)
+	return user.ID, nil
+}

internal/models/pricelist.go

@@ -0,0 +1,58 @@
+package models
+
+import (
+	"time"
+)
+
+// Pricelist represents a versioned snapshot of prices
+type Pricelist struct {
+	ID           uint       `gorm:"primaryKey" json:"id"`
+	Version      string     `gorm:"size:20;uniqueIndex;not null" json:"version"` // Format: YYYY-MM-DD-NNN
+	Notification string     `gorm:"size:500" json:"notification"`                // Notification shown in configurator
+	CreatedAt    time.Time  `json:"created_at"`
+	CreatedBy    string     `gorm:"size:100" json:"created_by"`
+	IsActive     bool       `gorm:"default:true" json:"is_active"`
+	UsageCount   int        `gorm:"default:0" json:"usage_count"`
+	ExpiresAt    *time.Time `json:"expires_at"`
+	ItemCount    int        `gorm:"-" json:"item_count,omitempty"` // Virtual field for display
+}
+
+func (Pricelist) TableName() string {
+	return "qt_pricelists"
+}
+
+// PricelistItem represents a single item in a pricelist
+type PricelistItem struct {
+	ID          uint    `gorm:"primaryKey" json:"id"`
+	PricelistID uint    `gorm:"not null;index:idx_pricelist_lot" json:"pricelist_id"`
+	LotName     string  `gorm:"size:255;not null;index:idx_pricelist_lot" json:"lot_name"`
+	Price       float64 `gorm:"type:decimal(12,2);not null" json:"price"`
+	PriceMethod string  `gorm:"size:20" json:"price_method"`
+
+	// Price calculation settings (snapshot from qt_lot_metadata)
+	PricePeriodDays  int      `gorm:"default:90" json:"price_period_days"`
+	PriceCoefficient float64  `gorm:"type:decimal(5,2);default:0" json:"price_coefficient"`
+	ManualPrice      *float64 `gorm:"type:decimal(12,2)" json:"manual_price,omitempty"`
+	MetaPrices       string   `gorm:"size:1000" json:"meta_prices,omitempty"`
+
+	// Virtual fields for display
+	LotDescription string `gorm:"-" json:"lot_description,omitempty"`
+	Category       string `gorm:"-" json:"category,omitempty"`
+}
+
+func (PricelistItem) TableName() string {
+	return "qt_pricelist_items"
+}
+
+// PricelistSummary is used for list views
+type PricelistSummary struct {
+	ID           uint       `json:"id"`
+	Version      string     `json:"version"`
+	Notification string     `json:"notification"`
+	CreatedAt    time.Time  `json:"created_at"`
+	CreatedBy    string     `json:"created_by"`
+	IsActive     bool       `json:"is_active"`
+	UsageCount   int        `json:"usage_count"`
+	ExpiresAt    *time.Time `json:"expires_at"`
+	ItemCount    int64      `json:"item_count"`
+}

internal/repository/configuration.go

@@ -73,3 +73,18 @@ func (r *ConfigurationRepository) ListTemplates(offset, limit int) ([]models.Con
 
 	return configs, total, err
 }
+
+// ListAll returns all configurations without user filter
+func (r *ConfigurationRepository) ListAll(offset, limit int) ([]models.Configuration, int64, error) {
+	var configs []models.Configuration
+	var total int64
+
+	r.db.Model(&models.Configuration{}).Count(&total)
+	err := r.db.
+		Order("created_at DESC").
+		Offset(offset).
+		Limit(limit).
+		Find(&configs).Error
+
+	return configs, total, err
+}

internal/repository/pricelist.go

@@ -0,0 +1,259 @@
+package repository
+
+import (
+	"fmt"
+	"strings"
+	"time"
+
+	"git.mchus.pro/mchus/quoteforge/internal/models"
+	"gorm.io/gorm"
+)
+
+type PricelistRepository struct {
+	db *gorm.DB
+}
+
+func NewPricelistRepository(db *gorm.DB) *PricelistRepository {
+	return &PricelistRepository{db: db}
+}
+
+// List returns pricelists with pagination
+func (r *PricelistRepository) List(offset, limit int) ([]models.PricelistSummary, int64, error) {
+	var total int64
+	if err := r.db.Model(&models.Pricelist{}).Count(&total).Error; err != nil {
+		return nil, 0, fmt.Errorf("counting pricelists: %w", err)
+	}
+
+	var pricelists []models.Pricelist
+	if err := r.db.Order("created_at DESC").Offset(offset).Limit(limit).Find(&pricelists).Error; err != nil {
+		return nil, 0, fmt.Errorf("listing pricelists: %w", err)
+	}
+
+	// Get item counts for each pricelist
+	summaries := make([]models.PricelistSummary, len(pricelists))
+	for i, pl := range pricelists {
+		var itemCount int64
+		r.db.Model(&models.PricelistItem{}).Where("pricelist_id = ?", pl.ID).Count(&itemCount)
+
+		summaries[i] = models.PricelistSummary{
+			ID:           pl.ID,
+			Version:      pl.Version,
+			Notification: pl.Notification,
+			CreatedAt:    pl.CreatedAt,
+			CreatedBy:    pl.CreatedBy,
+			IsActive:     pl.IsActive,
+			UsageCount:   pl.UsageCount,
+			ExpiresAt:    pl.ExpiresAt,
+			ItemCount:    itemCount,
+		}
+	}
+
+	return summaries, total, nil
+}
+
+// GetByID returns a pricelist by ID
+func (r *PricelistRepository) GetByID(id uint) (*models.Pricelist, error) {
+	var pricelist models.Pricelist
+	if err := r.db.First(&pricelist, id).Error; err != nil {
+		return nil, fmt.Errorf("getting pricelist: %w", err)
+	}
+
+	// Get item count
+	var itemCount int64
+	r.db.Model(&models.PricelistItem{}).Where("pricelist_id = ?", id).Count(&itemCount)
+	pricelist.ItemCount = int(itemCount)
+
+	return &pricelist, nil
+}
+
+// GetByVersion returns a pricelist by version string
+func (r *PricelistRepository) GetByVersion(version string) (*models.Pricelist, error) {
+	var pricelist models.Pricelist
+	if err := r.db.Where("version = ?", version).First(&pricelist).Error; err != nil {
+		return nil, fmt.Errorf("getting pricelist by version: %w", err)
+	}
+	return &pricelist, nil
+}
+
+// GetLatestActive returns the most recent active pricelist
+func (r *PricelistRepository) GetLatestActive() (*models.Pricelist, error) {
+	var pricelist models.Pricelist
+	if err := r.db.Where("is_active = ?", true).Order("created_at DESC").First(&pricelist).Error; err != nil {
+		return nil, fmt.Errorf("getting latest pricelist: %w", err)
+	}
+	return &pricelist, nil
+}
+
+// Create creates a new pricelist
+func (r *PricelistRepository) Create(pricelist *models.Pricelist) error {
+	if err := r.db.Create(pricelist).Error; err != nil {
+		return fmt.Errorf("creating pricelist: %w", err)
+	}
+	return nil
+}
+
+// Update updates a pricelist
+func (r *PricelistRepository) Update(pricelist *models.Pricelist) error {
+	if err := r.db.Save(pricelist).Error; err != nil {
+		return fmt.Errorf("updating pricelist: %w", err)
+	}
+	return nil
+}
+
+// Delete deletes a pricelist if usage_count is 0
+func (r *PricelistRepository) Delete(id uint) error {
+	pricelist, err := r.GetByID(id)
+	if err != nil {
+		return err
+	}
+
+	if pricelist.UsageCount > 0 {
+		return fmt.Errorf("cannot delete pricelist with usage_count > 0 (current: %d)", pricelist.UsageCount)
+	}
+
+	// Delete items first
+	if err := r.db.Where("pricelist_id = ?", id).Delete(&models.PricelistItem{}).Error; err != nil {
+		return fmt.Errorf("deleting pricelist items: %w", err)
+	}
+
+	// Delete pricelist
+	if err := r.db.Delete(&models.Pricelist{}, id).Error; err != nil {
+		return fmt.Errorf("deleting pricelist: %w", err)
+	}
+
+	return nil
+}
+
+// CreateItems batch inserts pricelist items
+func (r *PricelistRepository) CreateItems(items []models.PricelistItem) error {
+	if len(items) == 0 {
+		return nil
+	}
+
+	// Use batch insert for better performance
+	batchSize := 500
+	for i := 0; i < len(items); i += batchSize {
+		end := i + batchSize
+		if end > len(items) {
+			end = len(items)
+		}
+		if err := r.db.CreateInBatches(items[i:end], batchSize).Error; err != nil {
+			return fmt.Errorf("batch inserting pricelist items: %w", err)
+		}
+	}
+	return nil
+}
+
+// GetItems returns pricelist items with pagination
+func (r *PricelistRepository) GetItems(pricelistID uint, offset, limit int, search string) ([]models.PricelistItem, int64, error) {
+	var total int64
+	query := r.db.Model(&models.PricelistItem{}).Where("pricelist_id = ?", pricelistID)
+
+	if search != "" {
+		query = query.Where("lot_name LIKE ?", "%"+search+"%")
+	}
+
+	if err := query.Count(&total).Error; err != nil {
+		return nil, 0, fmt.Errorf("counting pricelist items: %w", err)
+	}
+
+	var items []models.PricelistItem
+	if err := query.Order("lot_name").Offset(offset).Limit(limit).Find(&items).Error; err != nil {
+		return nil, 0, fmt.Errorf("listing pricelist items: %w", err)
+	}
+
+	// Enrich with lot descriptions
+	for i := range items {
+		var lot models.Lot
+		if err := r.db.Where("lot_name = ?", items[i].LotName).First(&lot).Error; err == nil {
+			items[i].LotDescription = lot.LotDescription
+		}
+		// Parse category from lot_name (e.g., "CPU_AMD_9654" -> "CPU")
+		parts := strings.SplitN(items[i].LotName, "_", 2)
+		if len(parts) >= 1 {
+			items[i].Category = parts[0]
+		}
+	}
+
+	return items, total, nil
+}
+
+// GenerateVersion generates a new version string in format YYYY-MM-DD-NNN
+func (r *PricelistRepository) GenerateVersion() (string, error) {
+	today := time.Now().Format("2006-01-02")
+
+	var count int64
+	if err := r.db.Model(&models.Pricelist{}).
+		Where("version LIKE ?", today+"%").
+		Count(&count).Error; err != nil {
+		return "", fmt.Errorf("counting today's pricelists: %w", err)
+	}
+
+	return fmt.Sprintf("%s-%03d", today, count+1), nil
+}
+
+// CanWrite checks if the current database user has INSERT permission on qt_pricelists
+func (r *PricelistRepository) CanWrite() bool {
+	canWrite, _ := r.CanWriteDebug()
+	return canWrite
+}
+
+// CanWriteDebug checks write permission and returns debug info
+// Uses raw SQL with explicit columns to avoid schema mismatch issues
+func (r *PricelistRepository) CanWriteDebug() (bool, string) {
+	// Check if table exists first
+	var count int64
+	if err := r.db.Table("qt_pricelists").Count(&count).Error; err != nil {
+		return false, fmt.Sprintf("table check failed: %v", err)
+	}
+
+	// Use raw SQL with only essential columns that always exist
+	// This avoids GORM model validation and schema mismatch issues
+	tx := r.db.Begin()
+	if tx.Error != nil {
+		return false, fmt.Sprintf("begin tx failed: %v", tx.Error)
+	}
+	defer tx.Rollback() // Always rollback - this is just a permission test
+
+	testVersion := fmt.Sprintf("test-%06d", time.Now().Unix()%1000000)
+
+	// Raw SQL insert with only core columns
+	err := tx.Exec(`
+		INSERT INTO qt_pricelists (version, created_by, is_active)
+		VALUES (?, 'system', 1)
+	`, testVersion).Error
+
+	if err != nil {
+		// Check if it's a permission error vs other errors
+		errStr := err.Error()
+		if strings.Contains(errStr, "INSERT command denied") ||
+			strings.Contains(errStr, "Access denied") {
+			return false, "no write permission"
+		}
+		return false, fmt.Sprintf("insert failed: %v", err)
+	}
+
+	return true, "ok"
+}
+
+// IncrementUsageCount increments the usage count for a pricelist
+func (r *PricelistRepository) IncrementUsageCount(id uint) error {
+	return r.db.Model(&models.Pricelist{}).Where("id = ?", id).
+		UpdateColumn("usage_count", gorm.Expr("usage_count + 1")).Error
+}
+
+// DecrementUsageCount decrements the usage count for a pricelist
+func (r *PricelistRepository) DecrementUsageCount(id uint) error {
+	return r.db.Model(&models.Pricelist{}).Where("id = ?", id).
+		UpdateColumn("usage_count", gorm.Expr("GREATEST(usage_count - 1, 0)")).Error
+}
+
+// GetExpiredUnused returns pricelists that are expired and unused
+func (r *PricelistRepository) GetExpiredUnused() ([]models.Pricelist, error) {
+	var pricelists []models.Pricelist
+	if err := r.db.Where("expires_at < ? AND usage_count = 0", time.Now()).
+		Find(&pricelists).Error; err != nil {
+		return nil, fmt.Errorf("getting expired pricelists: %w", err)
+	}
+	return pricelists, nil
+}

internal/repository/unified.go

@@ -0,0 +1,399 @@
+package repository
+
+import (
+	"encoding/json"
+	"fmt"
+	"time"
+
+	"git.mchus.pro/mchus/quoteforge/internal/localdb"
+	"git.mchus.pro/mchus/quoteforge/internal/models"
+	"gorm.io/gorm"
+)
+
+// DataSource defines the unified interface for data access
+// It abstracts whether data comes from MariaDB (online) or SQLite (offline)
+type DataSource interface {
+	// Components
+	GetComponents(filter ComponentFilter, offset, limit int) ([]models.LotMetadata, int64, error)
+	GetComponent(lotName string) (*models.LotMetadata, error)
+
+	// Configurations
+	SaveConfiguration(cfg *models.Configuration) error
+	GetConfigurations(userID uint) ([]models.Configuration, error)
+	GetConfigurationByUUID(uuid string) (*models.Configuration, error)
+	DeleteConfiguration(uuid string) error
+
+	// Pricelists (read-only in offline mode)
+	GetPricelists() ([]models.PricelistSummary, error)
+	GetPricelistByID(id uint) (*models.Pricelist, error)
+	GetPricelistItems(pricelistID uint) ([]models.PricelistItem, error)
+	GetLatestPricelist() (*models.Pricelist, error)
+}
+
+// UnifiedRepo implements DataSource with automatic online/offline switching
+type UnifiedRepo struct {
+	mariaDB  *gorm.DB
+	localDB  *localdb.LocalDB
+	isOnline bool
+}
+
+// NewUnifiedRepo creates a new unified repository
+func NewUnifiedRepo(mariaDB *gorm.DB, localDB *localdb.LocalDB, isOnline bool) *UnifiedRepo {
+	return &UnifiedRepo{
+		mariaDB:  mariaDB,
+		localDB:  localDB,
+		isOnline: isOnline,
+	}
+}
+
+// SetOnlineStatus updates the online/offline status
+func (r *UnifiedRepo) SetOnlineStatus(online bool) {
+	r.isOnline = online
+}
+
+// IsOnline returns the current online/offline status
+func (r *UnifiedRepo) IsOnline() bool {
+	return r.isOnline
+}
+
+// Component methods
+
+// GetComponents returns components from MariaDB (online) or local cache (offline)
+func (r *UnifiedRepo) GetComponents(filter ComponentFilter, offset, limit int) ([]models.LotMetadata, int64, error) {
+	if r.isOnline {
+		return r.getComponentsOnline(filter, offset, limit)
+	}
+	return r.getComponentsOffline(filter, offset, limit)
+}
+
+func (r *UnifiedRepo) getComponentsOnline(filter ComponentFilter, offset, limit int) ([]models.LotMetadata, int64, error) {
+	repo := NewComponentRepository(r.mariaDB)
+	return repo.List(filter, offset, limit)
+}
+
+func (r *UnifiedRepo) getComponentsOffline(filter ComponentFilter, offset, limit int) ([]models.LotMetadata, int64, error) {
+	var components []localdb.LocalComponent
+	query := r.localDB.DB().Model(&localdb.LocalComponent{})
+
+	// Apply filters
+	if filter.Category != "" {
+		query = query.Where("category = ?", filter.Category)
+	}
+	if filter.Search != "" {
+		search := "%" + filter.Search + "%"
+		query = query.Where("lot_name LIKE ? OR lot_description LIKE ? OR model LIKE ?", search, search, search)
+	}
+	if filter.HasPrice {
+		query = query.Where("current_price IS NOT NULL AND current_price > 0")
+	}
+
+	var total int64
+	query.Count(&total)
+
+	// Apply sorting
+	sortDir := "ASC"
+	if filter.SortDir == "desc" {
+		sortDir = "DESC"
+	}
+	switch filter.SortField {
+	case "current_price":
+		query = query.Order("current_price " + sortDir)
+	case "lot_name":
+		query = query.Order("lot_name " + sortDir)
+	default:
+		query = query.Order("lot_name ASC")
+	}
+
+	if err := query.Offset(offset).Limit(limit).Find(&components).Error; err != nil {
+		return nil, 0, fmt.Errorf("fetching offline components: %w", err)
+	}
+
+	// Convert to models.LotMetadata
+	result := make([]models.LotMetadata, len(components))
+	for i, comp := range components {
+		result[i] = models.LotMetadata{
+			LotName:      comp.LotName,
+			Model:        comp.Model,
+			CurrentPrice: comp.CurrentPrice,
+			Lot: &models.Lot{
+				LotName:        comp.LotName,
+				LotDescription: comp.LotDescription,
+			},
+		}
+	}
+
+	return result, total, nil
+}
+
+// GetComponent returns a single component by lot name
+func (r *UnifiedRepo) GetComponent(lotName string) (*models.LotMetadata, error) {
+	if r.isOnline {
+		repo := NewComponentRepository(r.mariaDB)
+		return repo.GetByLotName(lotName)
+	}
+
+	var comp localdb.LocalComponent
+	if err := r.localDB.DB().Where("lot_name = ?", lotName).First(&comp).Error; err != nil {
+		return nil, fmt.Errorf("fetching offline component: %w", err)
+	}
+
+	return &models.LotMetadata{
+		LotName:      comp.LotName,
+		Model:        comp.Model,
+		CurrentPrice: comp.CurrentPrice,
+		Lot: &models.Lot{
+			LotName:        comp.LotName,
+			LotDescription: comp.LotDescription,
+		},
+	}, nil
+}
+
+// Configuration methods
+
+// SaveConfiguration saves a configuration (online: MariaDB, offline: SQLite + pending_changes)
+func (r *UnifiedRepo) SaveConfiguration(cfg *models.Configuration) error {
+	if r.isOnline {
+		repo := NewConfigurationRepository(r.mariaDB)
+		return repo.Create(cfg)
+	}
+
+	// Offline: save to local SQLite and queue for sync
+	localCfg := &localdb.LocalConfiguration{
+		UUID:        cfg.UUID,
+		Name:        cfg.Name,
+		TotalPrice:  cfg.TotalPrice,
+		CustomPrice: cfg.CustomPrice,
+		Notes:       cfg.Notes,
+		IsTemplate:  cfg.IsTemplate,
+		ServerCount: cfg.ServerCount,
+		CreatedAt:   cfg.CreatedAt,
+		UpdatedAt:   time.Now(),
+		SyncStatus:  "pending",
+	}
+
+	// Convert items
+	localItems := make(localdb.LocalConfigItems, len(cfg.Items))
+	for i, item := range cfg.Items {
+		localItems[i] = localdb.LocalConfigItem{
+			LotName:   item.LotName,
+			Quantity:  item.Quantity,
+			UnitPrice: item.UnitPrice,
+		}
+	}
+	localCfg.Items = localItems
+
+	if err := r.localDB.SaveConfiguration(localCfg); err != nil {
+		return fmt.Errorf("saving local configuration: %w", err)
+	}
+
+	// Add to pending changes queue
+	payload, err := json.Marshal(cfg)
+	if err != nil {
+		return fmt.Errorf("marshaling configuration for sync: %w", err)
+	}
+
+	return r.localDB.AddPendingChange("configuration", cfg.UUID, "create", string(payload))
+}
+
+// GetConfigurations returns all configurations for a user
+func (r *UnifiedRepo) GetConfigurations(userID uint) ([]models.Configuration, error) {
+	if r.isOnline {
+		repo := NewConfigurationRepository(r.mariaDB)
+		configs, _, err := repo.ListByUser(userID, 0, 1000)
+		return configs, err
+	}
+
+	// Offline: get from local SQLite
+	localConfigs, err := r.localDB.GetConfigurations()
+	if err != nil {
+		return nil, fmt.Errorf("fetching local configurations: %w", err)
+	}
+
+	// Convert to models.Configuration
+	result := make([]models.Configuration, len(localConfigs))
+	for i, lc := range localConfigs {
+		items := make(models.ConfigItems, len(lc.Items))
+		for j, item := range lc.Items {
+			items[j] = models.ConfigItem{
+				LotName:   item.LotName,
+				Quantity:  item.Quantity,
+				UnitPrice: item.UnitPrice,
+			}
+		}
+
+		result[i] = models.Configuration{
+			UUID:        lc.UUID,
+			Name:        lc.Name,
+			Items:       items,
+			TotalPrice:  lc.TotalPrice,
+			CustomPrice: lc.CustomPrice,
+			Notes:       lc.Notes,
+			IsTemplate:  lc.IsTemplate,
+			ServerCount: lc.ServerCount,
+			CreatedAt:   lc.CreatedAt,
+		}
+	}
+
+	return result, nil
+}
+
+// GetConfigurationByUUID returns a configuration by UUID
+func (r *UnifiedRepo) GetConfigurationByUUID(uuid string) (*models.Configuration, error) {
+	if r.isOnline {
+		repo := NewConfigurationRepository(r.mariaDB)
+		return repo.GetByUUID(uuid)
+	}
+
+	localCfg, err := r.localDB.GetConfigurationByUUID(uuid)
+	if err != nil {
+		return nil, fmt.Errorf("fetching local configuration: %w", err)
+	}
+
+	items := make(models.ConfigItems, len(localCfg.Items))
+	for i, item := range localCfg.Items {
+		items[i] = models.ConfigItem{
+			LotName:   item.LotName,
+			Quantity:  item.Quantity,
+			UnitPrice: item.UnitPrice,
+		}
+	}
+
+	return &models.Configuration{
+		UUID:        localCfg.UUID,
+		Name:        localCfg.Name,
+		Items:       items,
+		TotalPrice:  localCfg.TotalPrice,
+		CustomPrice: localCfg.CustomPrice,
+		Notes:       localCfg.Notes,
+		IsTemplate:  localCfg.IsTemplate,
+		ServerCount: localCfg.ServerCount,
+		CreatedAt:   localCfg.CreatedAt,
+	}, nil
+}
+
+// DeleteConfiguration deletes a configuration
+func (r *UnifiedRepo) DeleteConfiguration(uuid string) error {
+	if r.isOnline {
+		// Get ID first
+		cfg, err := r.GetConfigurationByUUID(uuid)
+		if err != nil {
+			return err
+		}
+		repo := NewConfigurationRepository(r.mariaDB)
+		return repo.Delete(cfg.ID)
+	}
+
+	// Offline: delete from local and queue sync
+	if err := r.localDB.DeleteConfiguration(uuid); err != nil {
+		return fmt.Errorf("deleting local configuration: %w", err)
+	}
+
+	return r.localDB.AddPendingChange("configuration", uuid, "delete", "")
+}
+
+// Pricelist methods
+
+// GetPricelists returns all pricelists
+func (r *UnifiedRepo) GetPricelists() ([]models.PricelistSummary, error) {
+	if r.isOnline {
+		repo := NewPricelistRepository(r.mariaDB)
+		summaries, _, err := repo.List(0, 1000)
+		return summaries, err
+	}
+
+	// Offline: get from local cache
+	localPLs, err := r.localDB.GetLocalPricelists()
+	if err != nil {
+		return nil, fmt.Errorf("fetching local pricelists: %w", err)
+	}
+
+	summaries := make([]models.PricelistSummary, len(localPLs))
+	for i, pl := range localPLs {
+		itemCount := r.localDB.CountLocalPricelistItems(pl.ID)
+		summaries[i] = models.PricelistSummary{
+			ID:        pl.ServerID,
+			Version:   pl.Version,
+			CreatedAt: pl.CreatedAt,
+			ItemCount: itemCount,
+		}
+	}
+
+	return summaries, nil
+}
+
+// GetPricelistByID returns a pricelist by ID
+func (r *UnifiedRepo) GetPricelistByID(id uint) (*models.Pricelist, error) {
+	if r.isOnline {
+		repo := NewPricelistRepository(r.mariaDB)
+		return repo.GetByID(id)
+	}
+
+	// Offline: get from local cache
+	localPL, err := r.localDB.GetLocalPricelistByServerID(id)
+	if err != nil {
+		return nil, fmt.Errorf("fetching local pricelist: %w", err)
+	}
+
+	itemCount := r.localDB.CountLocalPricelistItems(localPL.ID)
+	return &models.Pricelist{
+		ID:        localPL.ServerID,
+		Version:   localPL.Version,
+		CreatedAt: localPL.CreatedAt,
+		ItemCount: int(itemCount),
+	}, nil
+}
+
+// GetPricelistItems returns items for a pricelist
+func (r *UnifiedRepo) GetPricelistItems(pricelistID uint) ([]models.PricelistItem, error) {
+	if r.isOnline {
+		repo := NewPricelistRepository(r.mariaDB)
+		items, _, err := repo.GetItems(pricelistID, 0, 100000, "")
+		return items, err
+	}
+
+	// Offline: get from local cache
+	// First find the local pricelist by server ID
+	localPL, err := r.localDB.GetLocalPricelistByServerID(pricelistID)
+	if err != nil {
+		return nil, fmt.Errorf("fetching local pricelist: %w", err)
+	}
+
+	localItems, err := r.localDB.GetLocalPricelistItems(localPL.ID)
+	if err != nil {
+		return nil, fmt.Errorf("fetching local pricelist items: %w", err)
+	}
+
+	items := make([]models.PricelistItem, len(localItems))
+	for i, item := range localItems {
+		items[i] = models.PricelistItem{
+			ID:          item.ID,
+			PricelistID: pricelistID,
+			LotName:     item.LotName,
+			Price:       item.Price,
+		}
+	}
+
+	return items, nil
+}
+
+// GetLatestPricelist returns the latest pricelist
+func (r *UnifiedRepo) GetLatestPricelist() (*models.Pricelist, error) {
+	if r.isOnline {
+		repo := NewPricelistRepository(r.mariaDB)
+		return repo.GetLatestActive()
+	}
+
+	// Offline: get from local cache
+	localPL, err := r.localDB.GetLatestLocalPricelist()
+	if err != nil {
+		return nil, fmt.Errorf("fetching latest local pricelist: %w", err)
+	}
+
+	itemCount := r.localDB.CountLocalPricelistItems(localPL.ID)
+	return &models.Pricelist{
+		ID:        localPL.ServerID,
+		Version:   localPL.Version,
+		CreatedAt: localPL.CreatedAt,
+		ItemCount: int(itemCount),
+	}, nil
+}

internal/services/component.go

@@ -1,6 +1,7 @@
 package services
 
 import (
+	"fmt"
 	"strings"
 
 	"git.mchus.pro/mchus/quoteforge/internal/models"
@@ -59,6 +60,17 @@ type ComponentView struct {
 }
 
 func (s *ComponentService) List(filter repository.ComponentFilter, page, perPage int) (*ComponentListResult, error) {
+	// If no database connection (offline mode), return empty list
+	// Components should be loaded via /api/sync/components first
+	if s.componentRepo == nil {
+		return &ComponentListResult{
+			Components: []ComponentView{},
+			Total:      0,
+			Page:       page,
+			PerPage:    perPage,
+		}, nil
+	}
+
 	if page < 1 {
 		page = 1
 	}
@@ -106,6 +118,11 @@ func (s *ComponentService) List(filter repository.ComponentFilter, page, perPage
 }
 
 func (s *ComponentService) GetByLotName(lotName string) (*ComponentView, error) {
+	// If no database connection (offline mode), return error
+	if s.componentRepo == nil {
+		return nil, fmt.Errorf("offline mode: component data not available")
+	}
+
 	c, err := s.componentRepo.GetByLotName(lotName)
 	if err != nil {
 		return nil, err
@@ -135,11 +152,20 @@ func (s *ComponentService) GetByLotName(lotName string) (*ComponentView, error)
 }
 
 func (s *ComponentService) GetCategories() ([]models.Category, error) {
+	// If no database connection (offline mode), return default categories
+	if s.categoryRepo == nil {
+		return models.DefaultCategories, nil
+	}
 	return s.categoryRepo.GetAll()
 }
 
 // ImportFromLot creates metadata entries for lots that don't have them
 func (s *ComponentService) ImportFromLot() (int, error) {
+	// If no database connection (offline mode), return error
+	if s.componentRepo == nil || s.categoryRepo == nil {
+		return 0, fmt.Errorf("offline mode: import not available")
+	}
+
 	lots, err := s.componentRepo.GetLotsWithoutMetadata()
 	if err != nil {
 		return 0, err

internal/services/configuration.go

@@ -14,6 +14,12 @@ var (
 	ErrConfigForbidden  = errors.New("access to configuration forbidden")
 )
 
+// ConfigurationGetter is an interface for services that can retrieve configurations
+// Used by handlers to work with both ConfigurationService and LocalConfigurationService
+type ConfigurationGetter interface {
+	GetByUUID(uuid string, userID uint) (*models.Configuration, error)
+}
+
 type ConfigurationService struct {
 	configRepo    *repository.ConfigurationRepository
 	componentRepo *repository.ComponentRepository
@@ -194,6 +200,149 @@ func (s *ConfigurationService) ListByUser(userID uint, page, perPage int) ([]mod
 	return s.configRepo.ListByUser(userID, offset, perPage)
 }
 
+// ListAll returns all configurations without user filter (for use when auth is disabled)
+func (s *ConfigurationService) ListAll(page, perPage int) ([]models.Configuration, int64, error) {
+	if page < 1 {
+		page = 1
+	}
+	if perPage < 1 || perPage > 100 {
+		perPage = 20
+	}
+	offset := (page - 1) * perPage
+
+	return s.configRepo.ListAll(offset, perPage)
+}
+
+// GetByUUIDNoAuth returns configuration without ownership check (for use when auth is disabled)
+func (s *ConfigurationService) GetByUUIDNoAuth(uuid string) (*models.Configuration, error) {
+	config, err := s.configRepo.GetByUUID(uuid)
+	if err != nil {
+		return nil, ErrConfigNotFound
+	}
+	return config, nil
+}
+
+// UpdateNoAuth updates configuration without ownership check
+func (s *ConfigurationService) UpdateNoAuth(uuid string, req *CreateConfigRequest) (*models.Configuration, error) {
+	config, err := s.configRepo.GetByUUID(uuid)
+	if err != nil {
+		return nil, ErrConfigNotFound
+	}
+
+	total := req.Items.Total()
+	if req.ServerCount > 1 {
+		total *= float64(req.ServerCount)
+	}
+
+	config.Name = req.Name
+	config.Items = req.Items
+	config.TotalPrice = &total
+	config.CustomPrice = req.CustomPrice
+	config.Notes = req.Notes
+	config.IsTemplate = req.IsTemplate
+	config.ServerCount = req.ServerCount
+
+	if err := s.configRepo.Update(config); err != nil {
+		return nil, err
+	}
+
+	return config, nil
+}
+
+// DeleteNoAuth deletes configuration without ownership check
+func (s *ConfigurationService) DeleteNoAuth(uuid string) error {
+	config, err := s.configRepo.GetByUUID(uuid)
+	if err != nil {
+		return ErrConfigNotFound
+	}
+	return s.configRepo.Delete(config.ID)
+}
+
+// RenameNoAuth renames configuration without ownership check
+func (s *ConfigurationService) RenameNoAuth(uuid string, newName string) (*models.Configuration, error) {
+	config, err := s.configRepo.GetByUUID(uuid)
+	if err != nil {
+		return nil, ErrConfigNotFound
+	}
+
+	config.Name = newName
+	if err := s.configRepo.Update(config); err != nil {
+		return nil, err
+	}
+
+	return config, nil
+}
+
+// CloneNoAuth clones configuration without ownership check
+func (s *ConfigurationService) CloneNoAuth(configUUID string, newName string, userID uint) (*models.Configuration, error) {
+	original, err := s.configRepo.GetByUUID(configUUID)
+	if err != nil {
+		return nil, ErrConfigNotFound
+	}
+
+	total := original.Items.Total()
+	if original.ServerCount > 1 {
+		total *= float64(original.ServerCount)
+	}
+
+	clone := &models.Configuration{
+		UUID:        uuid.New().String(),
+		UserID:      userID, // Use provided user ID
+		Name:        newName,
+		Items:       original.Items,
+		TotalPrice:  &total,
+		CustomPrice: original.CustomPrice,
+		Notes:       original.Notes,
+		IsTemplate:  false,
+		ServerCount: original.ServerCount,
+	}
+
+	if err := s.configRepo.Create(clone); err != nil {
+		return nil, err
+	}
+
+	return clone, nil
+}
+
+// RefreshPricesNoAuth refreshes prices without ownership check
+func (s *ConfigurationService) RefreshPricesNoAuth(uuid string) (*models.Configuration, error) {
+	config, err := s.configRepo.GetByUUID(uuid)
+	if err != nil {
+		return nil, ErrConfigNotFound
+	}
+
+	updatedItems := make(models.ConfigItems, len(config.Items))
+	for i, item := range config.Items {
+		metadata, err := s.componentRepo.GetByLotName(item.LotName)
+		if err != nil || metadata.CurrentPrice == nil {
+			updatedItems[i] = item
+			continue
+		}
+
+		updatedItems[i] = models.ConfigItem{
+			LotName:   item.LotName,
+			Quantity:  item.Quantity,
+			UnitPrice: *metadata.CurrentPrice,
+		}
+	}
+
+	config.Items = updatedItems
+	total := updatedItems.Total()
+	if config.ServerCount > 1 {
+		total *= float64(config.ServerCount)
+	}
+
+	config.TotalPrice = &total
+	now := time.Now()
+	config.PriceUpdatedAt = &now
+
+	if err := s.configRepo.Update(config); err != nil {
+		return nil, err
+	}
+
+	return config, nil
+}
+
 func (s *ConfigurationService) ListTemplates(page, perPage int) ([]models.Configuration, int64, error) {
 	if page < 1 {
 		page = 1

internal/services/local_configuration.go

@@ -0,0 +1,623 @@
+package services
+
+import (
+	"encoding/json"
+	"time"
+
+	"github.com/google/uuid"
+	"git.mchus.pro/mchus/quoteforge/internal/localdb"
+	"git.mchus.pro/mchus/quoteforge/internal/models"
+	"git.mchus.pro/mchus/quoteforge/internal/services/sync"
+)
+
+// LocalConfigurationService handles configurations in local-first mode
+// All operations go through SQLite, MariaDB is used only for sync
+type LocalConfigurationService struct {
+	localDB      *localdb.LocalDB
+	syncService  *sync.Service
+	quoteService *QuoteService
+	isOnline     func() bool // Function to check if we're online
+}
+
+// NewLocalConfigurationService creates a new local-first configuration service
+func NewLocalConfigurationService(
+	localDB *localdb.LocalDB,
+	syncService *sync.Service,
+	quoteService *QuoteService,
+	isOnline func() bool,
+) *LocalConfigurationService {
+	return &LocalConfigurationService{
+		localDB:      localDB,
+		syncService:  syncService,
+		quoteService: quoteService,
+		isOnline:     isOnline,
+	}
+}
+
+// Create creates a new configuration in local SQLite and queues it for sync
+func (s *LocalConfigurationService) Create(userID uint, req *CreateConfigRequest) (*models.Configuration, error) {
+	// If online, check for new pricelists first
+	if s.isOnline() {
+		if err := s.syncService.SyncPricelistsIfNeeded(); err != nil {
+			// Log but don't fail - we can still use local pricelists
+		}
+	}
+
+	total := req.Items.Total()
+	if req.ServerCount > 1 {
+		total *= float64(req.ServerCount)
+	}
+
+	cfg := &models.Configuration{
+		UUID:        uuid.New().String(),
+		UserID:      userID,
+		Name:        req.Name,
+		Items:       req.Items,
+		TotalPrice:  &total,
+		CustomPrice: req.CustomPrice,
+		Notes:       req.Notes,
+		IsTemplate:  req.IsTemplate,
+		ServerCount: req.ServerCount,
+		CreatedAt:   time.Now(),
+	}
+
+	// Convert to local model
+	localCfg := localdb.ConfigurationToLocal(cfg)
+
+	// Save to local SQLite
+	if err := s.localDB.SaveConfiguration(localCfg); err != nil {
+		return nil, err
+	}
+
+	// Add to pending sync queue
+	payload, err := json.Marshal(cfg)
+	if err != nil {
+		return nil, err
+	}
+	if err := s.localDB.AddPendingChange("configuration", cfg.UUID, "create", string(payload)); err != nil {
+		return nil, err
+	}
+
+	// Record usage stats
+	_ = s.quoteService.RecordUsage(req.Items)
+
+	return cfg, nil
+}
+
+// GetByUUID returns a configuration from local SQLite
+func (s *LocalConfigurationService) GetByUUID(uuid string, userID uint) (*models.Configuration, error) {
+	localCfg, err := s.localDB.GetConfigurationByUUID(uuid)
+	if err != nil {
+		return nil, ErrConfigNotFound
+	}
+
+	// Convert to models.Configuration
+	cfg := localdb.LocalToConfiguration(localCfg)
+
+	// Allow access if user owns config or it's a template
+	if cfg.UserID != userID && !cfg.IsTemplate {
+		return nil, ErrConfigForbidden
+	}
+
+	return cfg, nil
+}
+
+// Update updates a configuration in local SQLite and queues it for sync
+func (s *LocalConfigurationService) Update(uuid string, userID uint, req *CreateConfigRequest) (*models.Configuration, error) {
+	localCfg, err := s.localDB.GetConfigurationByUUID(uuid)
+	if err != nil {
+		return nil, ErrConfigNotFound
+	}
+
+	if localCfg.OriginalUserID != userID {
+		return nil, ErrConfigForbidden
+	}
+
+	total := req.Items.Total()
+	if req.ServerCount > 1 {
+		total *= float64(req.ServerCount)
+	}
+
+	// Update fields
+	localCfg.Name = req.Name
+	localCfg.Items = localdb.LocalConfigItems{}
+	for _, item := range req.Items {
+		localCfg.Items = append(localCfg.Items, localdb.LocalConfigItem{
+			LotName:   item.LotName,
+			Quantity:  item.Quantity,
+			UnitPrice: item.UnitPrice,
+		})
+	}
+	localCfg.TotalPrice = &total
+	localCfg.CustomPrice = req.CustomPrice
+	localCfg.Notes = req.Notes
+	localCfg.IsTemplate = req.IsTemplate
+	localCfg.ServerCount = req.ServerCount
+	localCfg.UpdatedAt = time.Now()
+	localCfg.SyncStatus = "pending"
+
+	// Save to local SQLite
+	if err := s.localDB.SaveConfiguration(localCfg); err != nil {
+		return nil, err
+	}
+
+	// Add to pending sync queue
+	cfg := localdb.LocalToConfiguration(localCfg)
+	payload, err := json.Marshal(cfg)
+	if err != nil {
+		return nil, err
+	}
+	if err := s.localDB.AddPendingChange("configuration", uuid, "update", string(payload)); err != nil {
+		return nil, err
+	}
+
+	return cfg, nil
+}
+
+// Delete deletes a configuration from local SQLite and queues it for sync
+func (s *LocalConfigurationService) Delete(uuid string, userID uint) error {
+	localCfg, err := s.localDB.GetConfigurationByUUID(uuid)
+	if err != nil {
+		return ErrConfigNotFound
+	}
+
+	if localCfg.OriginalUserID != userID {
+		return ErrConfigForbidden
+	}
+
+	// Delete from local SQLite
+	if err := s.localDB.DeleteConfiguration(uuid); err != nil {
+		return err
+	}
+
+	// Add to pending sync queue
+	if err := s.localDB.AddPendingChange("configuration", uuid, "delete", ""); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// Rename renames a configuration
+func (s *LocalConfigurationService) Rename(uuid string, userID uint, newName string) (*models.Configuration, error) {
+	localCfg, err := s.localDB.GetConfigurationByUUID(uuid)
+	if err != nil {
+		return nil, ErrConfigNotFound
+	}
+
+	if localCfg.OriginalUserID != userID {
+		return nil, ErrConfigForbidden
+	}
+
+	localCfg.Name = newName
+	localCfg.UpdatedAt = time.Now()
+	localCfg.SyncStatus = "pending"
+
+	if err := s.localDB.SaveConfiguration(localCfg); err != nil {
+		return nil, err
+	}
+
+	// Add to pending sync queue
+	cfg := localdb.LocalToConfiguration(localCfg)
+	payload, err := json.Marshal(cfg)
+	if err != nil {
+		return nil, err
+	}
+	if err := s.localDB.AddPendingChange("configuration", uuid, "update", string(payload)); err != nil {
+		return nil, err
+	}
+
+	return cfg, nil
+}
+
+// Clone clones a configuration
+func (s *LocalConfigurationService) Clone(configUUID string, userID uint, newName string) (*models.Configuration, error) {
+	original, err := s.GetByUUID(configUUID, userID)
+	if err != nil {
+		return nil, err
+	}
+
+	total := original.Items.Total()
+	if original.ServerCount > 1 {
+		total *= float64(original.ServerCount)
+	}
+
+	clone := &models.Configuration{
+		UUID:        uuid.New().String(),
+		UserID:      userID,
+		Name:        newName,
+		Items:       original.Items,
+		TotalPrice:  &total,
+		CustomPrice: original.CustomPrice,
+		Notes:       original.Notes,
+		IsTemplate:  false,
+		ServerCount: original.ServerCount,
+		CreatedAt:   time.Now(),
+	}
+
+	localCfg := localdb.ConfigurationToLocal(clone)
+	if err := s.localDB.SaveConfiguration(localCfg); err != nil {
+		return nil, err
+	}
+
+	// Add to pending sync queue
+	payload, err := json.Marshal(clone)
+	if err != nil {
+		return nil, err
+	}
+	if err := s.localDB.AddPendingChange("configuration", clone.UUID, "create", string(payload)); err != nil {
+		return nil, err
+	}
+
+	return clone, nil
+}
+
+// ListByUser returns all configurations for a user from local SQLite
+func (s *LocalConfigurationService) ListByUser(userID uint, page, perPage int) ([]models.Configuration, int64, error) {
+	// Get all local configurations
+	localConfigs, err := s.localDB.GetConfigurations()
+	if err != nil {
+		return nil, 0, err
+	}
+
+	// Filter by user
+	var userConfigs []models.Configuration
+	for _, lc := range localConfigs {
+		if lc.OriginalUserID == userID || lc.IsTemplate {
+			userConfigs = append(userConfigs, *localdb.LocalToConfiguration(&lc))
+		}
+	}
+
+	total := int64(len(userConfigs))
+
+	// Apply pagination
+	if page < 1 {
+		page = 1
+	}
+	if perPage < 1 || perPage > 100 {
+		perPage = 20
+	}
+	offset := (page - 1) * perPage
+
+	start := offset
+	if start > len(userConfigs) {
+		start = len(userConfigs)
+	}
+	end := start + perPage
+	if end > len(userConfigs) {
+		end = len(userConfigs)
+	}
+
+	return userConfigs[start:end], total, nil
+}
+
+// RefreshPrices updates all component prices in the configuration from local cache
+func (s *LocalConfigurationService) RefreshPrices(uuid string, userID uint) (*models.Configuration, error) {
+	// Get configuration from local SQLite
+	localCfg, err := s.localDB.GetConfigurationByUUID(uuid)
+	if err != nil {
+		return nil, ErrConfigNotFound
+	}
+
+	// Check ownership
+	if localCfg.OriginalUserID != userID {
+		return nil, ErrConfigForbidden
+	}
+
+	// Update prices for all items
+	updatedItems := make(localdb.LocalConfigItems, len(localCfg.Items))
+	for i, item := range localCfg.Items {
+		// Get current component price from local cache
+		component, err := s.localDB.GetLocalComponent(item.LotName)
+		if err != nil || component.CurrentPrice == nil {
+			// Keep original item if component not found or no price available
+			updatedItems[i] = item
+			continue
+		}
+
+		// Update item with current price from local cache
+		updatedItems[i] = localdb.LocalConfigItem{
+			LotName:   item.LotName,
+			Quantity:  item.Quantity,
+			UnitPrice: *component.CurrentPrice,
+		}
+	}
+
+	// Update configuration
+	localCfg.Items = updatedItems
+	total := updatedItems.Total()
+
+	// If server count is greater than 1, multiply the total by server count
+	if localCfg.ServerCount > 1 {
+		total *= float64(localCfg.ServerCount)
+	}
+
+	localCfg.TotalPrice = &total
+
+	// Set price update timestamp and mark for sync
+	now := time.Now()
+	localCfg.PriceUpdatedAt = &now
+	localCfg.UpdatedAt = now
+	localCfg.SyncStatus = "pending"
+
+	// Save to local SQLite
+	if err := s.localDB.SaveConfiguration(localCfg); err != nil {
+		return nil, err
+	}
+
+	// Add to pending sync queue
+	cfg := localdb.LocalToConfiguration(localCfg)
+	payload, err := json.Marshal(cfg)
+	if err != nil {
+		return nil, err
+	}
+	if err := s.localDB.AddPendingChange("configuration", uuid, "update", string(payload)); err != nil {
+		return nil, err
+	}
+
+	return cfg, nil
+}
+
+// GetByUUIDNoAuth returns configuration without ownership check
+func (s *LocalConfigurationService) GetByUUIDNoAuth(uuid string) (*models.Configuration, error) {
+	localCfg, err := s.localDB.GetConfigurationByUUID(uuid)
+	if err != nil {
+		return nil, ErrConfigNotFound
+	}
+	return localdb.LocalToConfiguration(localCfg), nil
+}
+
+// UpdateNoAuth updates configuration without ownership check
+func (s *LocalConfigurationService) UpdateNoAuth(uuid string, req *CreateConfigRequest) (*models.Configuration, error) {
+	localCfg, err := s.localDB.GetConfigurationByUUID(uuid)
+	if err != nil {
+		return nil, ErrConfigNotFound
+	}
+
+	total := req.Items.Total()
+	if req.ServerCount > 1 {
+		total *= float64(req.ServerCount)
+	}
+
+	localCfg.Name = req.Name
+	localCfg.Items = localdb.LocalConfigItems{}
+	for _, item := range req.Items {
+		localCfg.Items = append(localCfg.Items, localdb.LocalConfigItem{
+			LotName:   item.LotName,
+			Quantity:  item.Quantity,
+			UnitPrice: item.UnitPrice,
+		})
+	}
+	localCfg.TotalPrice = &total
+	localCfg.CustomPrice = req.CustomPrice
+	localCfg.Notes = req.Notes
+	localCfg.IsTemplate = req.IsTemplate
+	localCfg.ServerCount = req.ServerCount
+	localCfg.UpdatedAt = time.Now()
+	localCfg.SyncStatus = "pending"
+
+	if err := s.localDB.SaveConfiguration(localCfg); err != nil {
+		return nil, err
+	}
+
+	cfg := localdb.LocalToConfiguration(localCfg)
+	payload, err := json.Marshal(cfg)
+	if err != nil {
+		return nil, err
+	}
+	if err := s.localDB.AddPendingChange("configuration", uuid, "update", string(payload)); err != nil {
+		return nil, err
+	}
+
+	return cfg, nil
+}
+
+// DeleteNoAuth deletes configuration without ownership check
+func (s *LocalConfigurationService) DeleteNoAuth(uuid string) error {
+	if err := s.localDB.DeleteConfiguration(uuid); err != nil {
+		return err
+	}
+	return s.localDB.AddPendingChange("configuration", uuid, "delete", "")
+}
+
+// RenameNoAuth renames configuration without ownership check
+func (s *LocalConfigurationService) RenameNoAuth(uuid string, newName string) (*models.Configuration, error) {
+	localCfg, err := s.localDB.GetConfigurationByUUID(uuid)
+	if err != nil {
+		return nil, ErrConfigNotFound
+	}
+
+	localCfg.Name = newName
+	localCfg.UpdatedAt = time.Now()
+	localCfg.SyncStatus = "pending"
+
+	if err := s.localDB.SaveConfiguration(localCfg); err != nil {
+		return nil, err
+	}
+
+	cfg := localdb.LocalToConfiguration(localCfg)
+	payload, err := json.Marshal(cfg)
+	if err != nil {
+		return nil, err
+	}
+	if err := s.localDB.AddPendingChange("configuration", uuid, "update", string(payload)); err != nil {
+		return nil, err
+	}
+
+	return cfg, nil
+}
+
+// CloneNoAuth clones configuration without ownership check
+func (s *LocalConfigurationService) CloneNoAuth(configUUID string, newName string, userID uint) (*models.Configuration, error) {
+	original, err := s.GetByUUIDNoAuth(configUUID)
+	if err != nil {
+		return nil, err
+	}
+
+	total := original.Items.Total()
+	if original.ServerCount > 1 {
+		total *= float64(original.ServerCount)
+	}
+
+	clone := &models.Configuration{
+		UUID:        uuid.New().String(),
+		UserID:      userID,
+		Name:        newName,
+		Items:       original.Items,
+		TotalPrice:  &total,
+		CustomPrice: original.CustomPrice,
+		Notes:       original.Notes,
+		IsTemplate:  false,
+		ServerCount: original.ServerCount,
+		CreatedAt:   time.Now(),
+	}
+
+	localCfg := localdb.ConfigurationToLocal(clone)
+	if err := s.localDB.SaveConfiguration(localCfg); err != nil {
+		return nil, err
+	}
+
+	payload, err := json.Marshal(clone)
+	if err != nil {
+		return nil, err
+	}
+	if err := s.localDB.AddPendingChange("configuration", clone.UUID, "create", string(payload)); err != nil {
+		return nil, err
+	}
+
+	return clone, nil
+}
+
+// ListAll returns all configurations without user filter
+func (s *LocalConfigurationService) ListAll(page, perPage int) ([]models.Configuration, int64, error) {
+	localConfigs, err := s.localDB.GetConfigurations()
+	if err != nil {
+		return nil, 0, err
+	}
+
+	configs := make([]models.Configuration, len(localConfigs))
+	for i, lc := range localConfigs {
+		configs[i] = *localdb.LocalToConfiguration(&lc)
+	}
+
+	total := int64(len(configs))
+
+	// Apply pagination
+	if page < 1 {
+		page = 1
+	}
+	if perPage < 1 || perPage > 100 {
+		perPage = 20
+	}
+	offset := (page - 1) * perPage
+
+	start := offset
+	if start > len(configs) {
+		start = len(configs)
+	}
+	end := start + perPage
+	if end > len(configs) {
+		end = len(configs)
+	}
+
+	return configs[start:end], total, nil
+}
+
+// ListTemplates returns all template configurations
+func (s *LocalConfigurationService) ListTemplates(page, perPage int) ([]models.Configuration, int64, error) {
+	localConfigs, err := s.localDB.GetConfigurations()
+	if err != nil {
+		return nil, 0, err
+	}
+
+	var templates []models.Configuration
+	for _, lc := range localConfigs {
+		if lc.IsTemplate {
+			templates = append(templates, *localdb.LocalToConfiguration(&lc))
+		}
+	}
+
+	total := int64(len(templates))
+
+	// Apply pagination
+	if page < 1 {
+		page = 1
+	}
+	if perPage < 1 || perPage > 100 {
+		perPage = 20
+	}
+	offset := (page - 1) * perPage
+
+	start := offset
+	if start > len(templates) {
+		start = len(templates)
+	}
+	end := start + perPage
+	if end > len(templates) {
+		end = len(templates)
+	}
+
+	return templates[start:end], total, nil
+}
+
+// RefreshPricesNoAuth updates all component prices in the configuration without ownership check
+func (s *LocalConfigurationService) RefreshPricesNoAuth(uuid string) (*models.Configuration, error) {
+	// Get configuration from local SQLite
+	localCfg, err := s.localDB.GetConfigurationByUUID(uuid)
+	if err != nil {
+		return nil, ErrConfigNotFound
+	}
+
+	// Update prices for all items
+	updatedItems := make(localdb.LocalConfigItems, len(localCfg.Items))
+	for i, item := range localCfg.Items {
+		// Get current component price from local cache
+		component, err := s.localDB.GetLocalComponent(item.LotName)
+		if err != nil || component.CurrentPrice == nil {
+			// Keep original item if component not found or no price available
+			updatedItems[i] = item
+			continue
+		}
+
+		// Update item with current price from local cache
+		updatedItems[i] = localdb.LocalConfigItem{
+			LotName:   item.LotName,
+			Quantity:  item.Quantity,
+			UnitPrice: *component.CurrentPrice,
+		}
+	}
+
+	// Update configuration
+	localCfg.Items = updatedItems
+	total := updatedItems.Total()
+
+	// If server count is greater than 1, multiply the total by server count
+	if localCfg.ServerCount > 1 {
+		total *= float64(localCfg.ServerCount)
+	}
+
+	localCfg.TotalPrice = &total
+
+	// Set price update timestamp and mark for sync
+	now := time.Now()
+	localCfg.PriceUpdatedAt = &now
+	localCfg.UpdatedAt = now
+	localCfg.SyncStatus = "pending"
+
+	// Save to local SQLite
+	if err := s.localDB.SaveConfiguration(localCfg); err != nil {
+		return nil, err
+	}
+
+	// Add to pending sync queue
+	cfg := localdb.LocalToConfiguration(localCfg)
+	payload, err := json.Marshal(cfg)
+	if err != nil {
+		return nil, err
+	}
+	if err := s.localDB.AddPendingChange("configuration", uuid, "update", string(payload)); err != nil {
+		return nil, err
+	}
+
+	return cfg, nil
+}

internal/services/pricelist/service.go

@@ -0,0 +1,187 @@
+package pricelist
+
+import (
+	"fmt"
+	"log/slog"
+	"time"
+
+	"git.mchus.pro/mchus/quoteforge/internal/models"
+	"git.mchus.pro/mchus/quoteforge/internal/repository"
+	"gorm.io/gorm"
+)
+
+type Service struct {
+	repo          *repository.PricelistRepository
+	componentRepo *repository.ComponentRepository
+	db            *gorm.DB
+}
+
+func NewService(db *gorm.DB, repo *repository.PricelistRepository, componentRepo *repository.ComponentRepository) *Service {
+	return &Service{
+		repo:          repo,
+		componentRepo: componentRepo,
+		db:            db,
+	}
+}
+
+// CreateFromCurrentPrices creates a new pricelist by taking a snapshot of current prices
+func (s *Service) CreateFromCurrentPrices(createdBy string) (*models.Pricelist, error) {
+	if s.repo == nil || s.db == nil {
+		return nil, fmt.Errorf("offline mode: cannot create pricelists")
+	}
+
+	version, err := s.repo.GenerateVersion()
+	if err != nil {
+		return nil, fmt.Errorf("generating version: %w", err)
+	}
+
+	expiresAt := time.Now().AddDate(1, 0, 0) // +1 year
+
+	pricelist := &models.Pricelist{
+		Version:   version,
+		CreatedBy: createdBy,
+		IsActive:  true,
+		ExpiresAt: &expiresAt,
+	}
+
+	if err := s.repo.Create(pricelist); err != nil {
+		return nil, fmt.Errorf("creating pricelist: %w", err)
+	}
+
+	// Get all components with prices from qt_lot_metadata
+	var metadata []models.LotMetadata
+	if err := s.db.Where("current_price IS NOT NULL AND current_price > 0").Find(&metadata).Error; err != nil {
+		return nil, fmt.Errorf("getting lot metadata: %w", err)
+	}
+
+	// Create pricelist items with all price settings
+	items := make([]models.PricelistItem, 0, len(metadata))
+	for _, m := range metadata {
+		if m.CurrentPrice == nil || *m.CurrentPrice <= 0 {
+			continue
+		}
+		items = append(items, models.PricelistItem{
+			PricelistID:      pricelist.ID,
+			LotName:          m.LotName,
+			Price:            *m.CurrentPrice,
+			PriceMethod:      string(m.PriceMethod),
+			PricePeriodDays:  m.PricePeriodDays,
+			PriceCoefficient: m.PriceCoefficient,
+			ManualPrice:      m.ManualPrice,
+			MetaPrices:       m.MetaPrices,
+		})
+	}
+
+	if err := s.repo.CreateItems(items); err != nil {
+		// Clean up the pricelist if items creation fails
+		s.repo.Delete(pricelist.ID)
+		return nil, fmt.Errorf("creating pricelist items: %w", err)
+	}
+
+	pricelist.ItemCount = len(items)
+
+	slog.Info("pricelist created",
+		"id", pricelist.ID,
+		"version", pricelist.Version,
+		"items", len(items),
+		"created_by", createdBy,
+	)
+
+	return pricelist, nil
+}
+
+// List returns pricelists with pagination
+func (s *Service) List(page, perPage int) ([]models.PricelistSummary, int64, error) {
+	// If no database connection (offline mode), return empty list
+	if s.repo == nil {
+		return []models.PricelistSummary{}, 0, nil
+	}
+
+	if page < 1 {
+		page = 1
+	}
+	if perPage < 1 {
+		perPage = 20
+	}
+	offset := (page - 1) * perPage
+	return s.repo.List(offset, perPage)
+}
+
+// GetByID returns a pricelist by ID
+func (s *Service) GetByID(id uint) (*models.Pricelist, error) {
+	if s.repo == nil {
+		return nil, fmt.Errorf("offline mode: pricelist service not available")
+	}
+	return s.repo.GetByID(id)
+}
+
+// GetItems returns pricelist items with pagination
+func (s *Service) GetItems(pricelistID uint, page, perPage int, search string) ([]models.PricelistItem, int64, error) {
+	if s.repo == nil {
+		return []models.PricelistItem{}, 0, nil
+	}
+	if page < 1 {
+		page = 1
+	}
+	if perPage < 1 {
+		perPage = 50
+	}
+	offset := (page - 1) * perPage
+	return s.repo.GetItems(pricelistID, offset, perPage, search)
+}
+
+// Delete deletes a pricelist by ID
+func (s *Service) Delete(id uint) error {
+	if s.repo == nil {
+		return fmt.Errorf("offline mode: cannot delete pricelists")
+	}
+	return s.repo.Delete(id)
+}
+
+// CanWrite returns true if the user can create pricelists
+func (s *Service) CanWrite() bool {
+	if s.repo == nil {
+		return false
+	}
+	return s.repo.CanWrite()
+}
+
+// CanWriteDebug returns write permission status with debug info
+func (s *Service) CanWriteDebug() (bool, string) {
+	if s.repo == nil {
+		return false, "offline mode"
+	}
+	return s.repo.CanWriteDebug()
+}
+
+// GetLatestActive returns the most recent active pricelist
+func (s *Service) GetLatestActive() (*models.Pricelist, error) {
+	if s.repo == nil {
+		return nil, fmt.Errorf("offline mode: pricelist service not available")
+	}
+	return s.repo.GetLatestActive()
+}
+
+// CleanupExpired deletes expired and unused pricelists
+func (s *Service) CleanupExpired() (int, error) {
+	if s.repo == nil {
+		return 0, fmt.Errorf("offline mode: cleanup not available")
+	}
+
+	expired, err := s.repo.GetExpiredUnused()
+	if err != nil {
+		return 0, err
+	}
+
+	deleted := 0
+	for _, pl := range expired {
+		if err := s.repo.Delete(pl.ID); err != nil {
+			slog.Warn("failed to delete expired pricelist", "id", pl.ID, "error", err)
+			continue
+		}
+		deleted++
+	}
+
+	slog.Info("cleaned up expired pricelists", "deleted", deleted)
+	return deleted, nil
+}

internal/services/sync/service.go

@@ -0,0 +1,483 @@
+package sync
+
+import (
+	"encoding/json"
+	"fmt"
+	"log/slog"
+	"time"
+
+	"git.mchus.pro/mchus/quoteforge/internal/db"
+	"git.mchus.pro/mchus/quoteforge/internal/localdb"
+	"git.mchus.pro/mchus/quoteforge/internal/models"
+	"git.mchus.pro/mchus/quoteforge/internal/repository"
+)
+
+// Service handles synchronization between MariaDB and local SQLite
+type Service struct {
+	connMgr *db.ConnectionManager
+	localDB *localdb.LocalDB
+}
+
+// NewService creates a new sync service
+func NewService(connMgr *db.ConnectionManager, localDB *localdb.LocalDB) *Service {
+	return &Service{
+		connMgr: connMgr,
+		localDB: localDB,
+	}
+}
+
+// SyncStatus represents the current sync status
+type SyncStatus struct {
+	LastSyncAt       *time.Time `json:"last_sync_at"`
+	ServerPricelists int        `json:"server_pricelists"`
+	LocalPricelists  int        `json:"local_pricelists"`
+	NeedsSync        bool       `json:"needs_sync"`
+}
+
+// GetStatus returns the current sync status
+func (s *Service) GetStatus() (*SyncStatus, error) {
+	lastSync := s.localDB.GetLastSyncTime()
+
+	// Count server pricelists (only if already connected, don't reconnect)
+	serverCount := 0
+	connStatus := s.connMgr.GetStatus()
+	if connStatus.IsConnected {
+		if mariaDB, err := s.connMgr.GetDB(); err == nil && mariaDB != nil {
+			pricelistRepo := repository.NewPricelistRepository(mariaDB)
+			serverPricelists, _, err := pricelistRepo.List(0, 1)
+			if err == nil {
+				serverCount = len(serverPricelists)
+			}
+		}
+	}
+
+	// Count local pricelists
+	localCount := s.localDB.CountLocalPricelists()
+
+	needsSync, _ := s.NeedSync()
+
+	return &SyncStatus{
+		LastSyncAt:       lastSync,
+		ServerPricelists: serverCount,
+		LocalPricelists:  int(localCount),
+		NeedsSync:        needsSync,
+	}, nil
+}
+
+// NeedSync checks if synchronization is needed
+// Returns true if there are new pricelists on server or last sync was >1 hour ago
+func (s *Service) NeedSync() (bool, error) {
+	lastSync := s.localDB.GetLastSyncTime()
+
+	// If never synced, need sync
+	if lastSync == nil {
+		return true, nil
+	}
+
+	// If last sync was more than 1 hour ago, suggest sync
+	if time.Since(*lastSync) > time.Hour {
+		return true, nil
+	}
+
+	// Check if there are new pricelists on server (only if already connected)
+	connStatus := s.connMgr.GetStatus()
+	if !connStatus.IsConnected {
+		// If offline, can't check server, no need to sync
+		return false, nil
+	}
+
+	mariaDB, err := s.connMgr.GetDB()
+	if err != nil {
+		// If offline, can't check server, no need to sync
+		return false, nil
+	}
+
+	pricelistRepo := repository.NewPricelistRepository(mariaDB)
+	latestServer, err := pricelistRepo.GetLatestActive()
+	if err != nil {
+		// If no pricelists on server, no need to sync
+		return false, nil
+	}
+
+	latestLocal, err := s.localDB.GetLatestLocalPricelist()
+	if err != nil {
+		// No local pricelists, need to sync
+		return true, nil
+	}
+
+	// If server has newer pricelist, need sync
+	if latestServer.ID != latestLocal.ServerID {
+		return true, nil
+	}
+
+	return false, nil
+}
+
+// SyncPricelists synchronizes all active pricelists from server to local SQLite
+func (s *Service) SyncPricelists() (int, error) {
+	slog.Info("starting pricelist sync")
+
+	// Get database connection
+	mariaDB, err := s.connMgr.GetDB()
+	if err != nil {
+		return 0, fmt.Errorf("database not available: %w", err)
+	}
+
+	// Create repository
+	pricelistRepo := repository.NewPricelistRepository(mariaDB)
+
+	// Get all active pricelists from server (up to 100)
+	serverPricelists, _, err := pricelistRepo.List(0, 100)
+	if err != nil {
+		return 0, fmt.Errorf("getting server pricelists: %w", err)
+	}
+
+	synced := 0
+	var latestLocalID uint
+	for _, pl := range serverPricelists {
+		// Check if pricelist already exists locally
+		existing, _ := s.localDB.GetLocalPricelistByServerID(pl.ID)
+		if existing != nil {
+			// Already synced, track latest
+			latestLocalID = existing.ID
+			continue
+		}
+
+		// Create local pricelist
+		localPL := &localdb.LocalPricelist{
+			ServerID:  pl.ID,
+			Version:   pl.Version,
+			Name:      pl.Notification, // Using notification as name
+			CreatedAt: pl.CreatedAt,
+			SyncedAt:  time.Now(),
+			IsUsed:    false,
+		}
+
+		if err := s.localDB.SaveLocalPricelist(localPL); err != nil {
+			slog.Warn("failed to save local pricelist", "version", pl.Version, "error", err)
+			continue
+		}
+
+		// Sync items for the newly created pricelist
+		itemCount, err := s.SyncPricelistItems(localPL.ID)
+		if err != nil {
+			slog.Warn("failed to sync pricelist items", "version", pl.Version, "error", err)
+			// Continue even if items sync fails - we have the pricelist metadata
+		} else {
+			slog.Debug("synced pricelist with items", "version", pl.Version, "items", itemCount)
+		}
+
+		latestLocalID = localPL.ID
+		synced++
+	}
+
+	// Update component prices from latest pricelist
+	if latestLocalID > 0 {
+		updated, err := s.localDB.UpdateComponentPricesFromPricelist(latestLocalID)
+		if err != nil {
+			slog.Warn("failed to update component prices from pricelist", "error", err)
+		} else {
+			slog.Info("updated component prices from latest pricelist", "updated", updated)
+		}
+	}
+
+	// Update last sync time
+	s.localDB.SetLastSyncTime(time.Now())
+
+	slog.Info("pricelist sync completed", "synced", synced, "total", len(serverPricelists))
+	return synced, nil
+}
+
+// SyncPricelistItems synchronizes items for a specific pricelist
+func (s *Service) SyncPricelistItems(localPricelistID uint) (int, error) {
+	// Get local pricelist
+	localPL, err := s.localDB.GetLocalPricelistByID(localPricelistID)
+	if err != nil {
+		return 0, fmt.Errorf("getting local pricelist: %w", err)
+	}
+
+	// Check if items already exist
+	existingCount := s.localDB.CountLocalPricelistItems(localPricelistID)
+	if existingCount > 0 {
+		slog.Debug("pricelist items already synced", "pricelist_id", localPricelistID, "count", existingCount)
+		return int(existingCount), nil
+	}
+
+	// Get database connection
+	mariaDB, err := s.connMgr.GetDB()
+	if err != nil {
+		return 0, fmt.Errorf("database not available: %w", err)
+	}
+
+	// Create repository
+	pricelistRepo := repository.NewPricelistRepository(mariaDB)
+
+	// Get items from server
+	serverItems, _, err := pricelistRepo.GetItems(localPL.ServerID, 0, 10000, "")
+	if err != nil {
+		return 0, fmt.Errorf("getting server pricelist items: %w", err)
+	}
+
+	// Convert and save locally
+	localItems := make([]localdb.LocalPricelistItem, len(serverItems))
+	for i, item := range serverItems {
+		localItems[i] = localdb.LocalPricelistItem{
+			PricelistID: localPricelistID,
+			LotName:     item.LotName,
+			Price:       item.Price,
+		}
+	}
+
+	if err := s.localDB.SaveLocalPricelistItems(localItems); err != nil {
+		return 0, fmt.Errorf("saving local pricelist items: %w", err)
+	}
+
+	slog.Info("synced pricelist items", "pricelist_id", localPricelistID, "items", len(localItems))
+	return len(localItems), nil
+}
+
+// SyncPricelistItemsByServerID syncs items for a pricelist by its server ID
+func (s *Service) SyncPricelistItemsByServerID(serverPricelistID uint) (int, error) {
+	localPL, err := s.localDB.GetLocalPricelistByServerID(serverPricelistID)
+	if err != nil {
+		return 0, fmt.Errorf("local pricelist not found for server ID %d", serverPricelistID)
+	}
+	return s.SyncPricelistItems(localPL.ID)
+}
+
+// GetLocalPriceForLot returns the price for a lot from a local pricelist
+func (s *Service) GetLocalPriceForLot(localPricelistID uint, lotName string) (float64, error) {
+	return s.localDB.GetLocalPriceForLot(localPricelistID, lotName)
+}
+
+// GetPricelistForOffline returns a pricelist suitable for offline use
+// If items are not synced, it will sync them first
+func (s *Service) GetPricelistForOffline(serverPricelistID uint) (*localdb.LocalPricelist, error) {
+	// Ensure pricelist is synced
+	localPL, err := s.localDB.GetLocalPricelistByServerID(serverPricelistID)
+	if err != nil {
+		// Try to sync pricelists first
+		if _, err := s.SyncPricelists(); err != nil {
+			return nil, fmt.Errorf("syncing pricelists: %w", err)
+		}
+
+		// Try again
+		localPL, err = s.localDB.GetLocalPricelistByServerID(serverPricelistID)
+		if err != nil {
+			return nil, fmt.Errorf("pricelist not found on server: %w", err)
+		}
+	}
+
+	// Ensure items are synced
+	if _, err := s.SyncPricelistItems(localPL.ID); err != nil {
+		return nil, fmt.Errorf("syncing pricelist items: %w", err)
+	}
+
+	return localPL, nil
+}
+
+// SyncPricelistsIfNeeded checks for new pricelists and syncs if needed
+// This should be called before creating a new configuration when online
+func (s *Service) SyncPricelistsIfNeeded() error {
+	needSync, err := s.NeedSync()
+	if err != nil {
+		slog.Warn("failed to check if sync needed", "error", err)
+		return nil // Don't fail on check error
+	}
+
+	if !needSync {
+		slog.Debug("pricelists are up to date, no sync needed")
+		return nil
+	}
+
+	slog.Info("new pricelists detected, syncing...")
+	_, err = s.SyncPricelists()
+	if err != nil {
+		return fmt.Errorf("syncing pricelists: %w", err)
+	}
+
+	return nil
+}
+
+// PushPendingChanges pushes all pending changes to the server
+func (s *Service) PushPendingChanges() (int, error) {
+	changes, err := s.localDB.GetPendingChanges()
+	if err != nil {
+		return 0, fmt.Errorf("getting pending changes: %w", err)
+	}
+
+	if len(changes) == 0 {
+		slog.Debug("no pending changes to push")
+		return 0, nil
+	}
+
+	slog.Info("pushing pending changes", "count", len(changes))
+	pushed := 0
+	var syncedIDs []int64
+
+	for _, change := range changes {
+		err := s.pushSingleChange(&change)
+		if err != nil {
+			slog.Warn("failed to push change", "id", change.ID, "type", change.EntityType, "operation", change.Operation, "error", err)
+			// Increment attempts
+			s.localDB.IncrementPendingChangeAttempts(change.ID, err.Error())
+			continue
+		}
+
+		syncedIDs = append(syncedIDs, change.ID)
+		pushed++
+	}
+
+	// Mark synced changes as complete by deleting them
+	if len(syncedIDs) > 0 {
+		if err := s.localDB.MarkChangesSynced(syncedIDs); err != nil {
+			slog.Error("failed to mark changes as synced", "error", err)
+		}
+	}
+
+	slog.Info("pending changes pushed", "pushed", pushed, "failed", len(changes)-pushed)
+	return pushed, nil
+}
+
+// pushSingleChange pushes a single pending change to the server
+func (s *Service) pushSingleChange(change *localdb.PendingChange) error {
+	switch change.EntityType {
+	case "configuration":
+		return s.pushConfigurationChange(change)
+	default:
+		return fmt.Errorf("unknown entity type: %s", change.EntityType)
+	}
+}
+
+// pushConfigurationChange pushes a configuration change to the server
+func (s *Service) pushConfigurationChange(change *localdb.PendingChange) error {
+	switch change.Operation {
+	case "create":
+		return s.pushConfigurationCreate(change)
+	case "update":
+		return s.pushConfigurationUpdate(change)
+	case "delete":
+		return s.pushConfigurationDelete(change)
+	default:
+		return fmt.Errorf("unknown operation: %s", change.Operation)
+	}
+}
+
+// pushConfigurationCreate creates a configuration on the server
+func (s *Service) pushConfigurationCreate(change *localdb.PendingChange) error {
+	var cfg models.Configuration
+	if err := json.Unmarshal([]byte(change.Payload), &cfg); err != nil {
+		return fmt.Errorf("unmarshaling configuration: %w", err)
+	}
+
+	// Get database connection
+	mariaDB, err := s.connMgr.GetDB()
+	if err != nil {
+		return fmt.Errorf("database not available: %w", err)
+	}
+
+	// Create repository
+	configRepo := repository.NewConfigurationRepository(mariaDB)
+
+	// Create on server
+	if err := configRepo.Create(&cfg); err != nil {
+		return fmt.Errorf("creating configuration on server: %w", err)
+	}
+
+	// Update local configuration with server ID
+	localCfg, err := s.localDB.GetConfigurationByUUID(cfg.UUID)
+	if err == nil {
+		serverID := cfg.ID
+		localCfg.ServerID = &serverID
+		localCfg.SyncStatus = "synced"
+		s.localDB.SaveConfiguration(localCfg)
+	}
+
+	slog.Info("configuration created on server", "uuid", cfg.UUID, "server_id", cfg.ID)
+	return nil
+}
+
+// pushConfigurationUpdate updates a configuration on the server
+func (s *Service) pushConfigurationUpdate(change *localdb.PendingChange) error {
+	var cfg models.Configuration
+	if err := json.Unmarshal([]byte(change.Payload), &cfg); err != nil {
+		return fmt.Errorf("unmarshaling configuration: %w", err)
+	}
+
+	// Get database connection
+	mariaDB, err := s.connMgr.GetDB()
+	if err != nil {
+		return fmt.Errorf("database not available: %w", err)
+	}
+
+	// Create repository
+	configRepo := repository.NewConfigurationRepository(mariaDB)
+
+	// Ensure we have a server ID before updating
+	// If the payload doesn't have ID, get it from local configuration
+	if cfg.ID == 0 {
+		localCfg, err := s.localDB.GetConfigurationByUUID(cfg.UUID)
+		if err != nil {
+			return fmt.Errorf("getting local configuration: %w", err)
+		}
+
+		if localCfg.ServerID == nil {
+			// Configuration hasn't been synced yet, try to find it on server by UUID
+			serverCfg, err := configRepo.GetByUUID(cfg.UUID)
+			if err != nil {
+				return fmt.Errorf("configuration not yet synced to server: %w", err)
+			}
+			cfg.ID = serverCfg.ID
+
+			// Update local with server ID
+			serverID := serverCfg.ID
+			localCfg.ServerID = &serverID
+			s.localDB.SaveConfiguration(localCfg)
+		} else {
+			cfg.ID = *localCfg.ServerID
+		}
+	}
+
+	// Update on server
+	if err := configRepo.Update(&cfg); err != nil {
+		return fmt.Errorf("updating configuration on server: %w", err)
+	}
+
+	// Update local sync status
+	localCfg, err := s.localDB.GetConfigurationByUUID(cfg.UUID)
+	if err == nil {
+		localCfg.SyncStatus = "synced"
+		s.localDB.SaveConfiguration(localCfg)
+	}
+
+	slog.Info("configuration updated on server", "uuid", cfg.UUID)
+	return nil
+}
+
+// pushConfigurationDelete deletes a configuration from the server
+func (s *Service) pushConfigurationDelete(change *localdb.PendingChange) error {
+	// Get database connection
+	mariaDB, err := s.connMgr.GetDB()
+	if err != nil {
+		return fmt.Errorf("database not available: %w", err)
+	}
+
+	// Create repository
+	configRepo := repository.NewConfigurationRepository(mariaDB)
+
+	// Get the configuration from server by UUID to get the ID
+	cfg, err := configRepo.GetByUUID(change.EntityUUID)
+	if err != nil {
+		// Already deleted or not found, consider it successful
+		slog.Warn("configuration not found on server, considering delete successful", "uuid", change.EntityUUID)
+		return nil
+	}
+
+	// Delete from server
+	if err := configRepo.Delete(cfg.ID); err != nil {
+		return fmt.Errorf("deleting configuration from server: %w", err)
+	}
+
+	slog.Info("configuration deleted from server", "uuid", change.EntityUUID)
+	return nil
+}

internal/services/sync/worker.go

@@ -0,0 +1,89 @@
+package sync
+
+import (
+	"context"
+	"log/slog"
+	"time"
+
+	"git.mchus.pro/mchus/quoteforge/internal/db"
+)
+
+// Worker performs background synchronization at regular intervals
+type Worker struct {
+	service  *Service
+	connMgr  *db.ConnectionManager
+	interval time.Duration
+	logger   *slog.Logger
+	stopCh   chan struct{}
+}
+
+// NewWorker creates a new background sync worker
+func NewWorker(service *Service, connMgr *db.ConnectionManager, interval time.Duration) *Worker {
+	return &Worker{
+		service:  service,
+		connMgr:  connMgr,
+		interval: interval,
+		logger:   slog.Default(),
+		stopCh:   make(chan struct{}),
+	}
+}
+
+// isOnline checks if the database connection is available
+func (w *Worker) isOnline() bool {
+	return w.connMgr.IsOnline()
+}
+
+// Start begins the background sync loop in a goroutine
+func (w *Worker) Start(ctx context.Context) {
+	w.logger.Info("starting background sync worker", "interval", w.interval)
+
+	ticker := time.NewTicker(w.interval)
+	defer ticker.Stop()
+
+	// Run once immediately
+	w.runSync()
+
+	for {
+		select {
+		case <-ctx.Done():
+			w.logger.Info("background sync worker stopped by context")
+			return
+		case <-w.stopCh:
+			w.logger.Info("background sync worker stopped")
+			return
+		case <-ticker.C:
+			w.runSync()
+		}
+	}
+}
+
+// Stop gracefully stops the worker
+func (w *Worker) Stop() {
+	w.logger.Info("stopping background sync worker")
+	close(w.stopCh)
+}
+
+// runSync performs a single sync iteration
+func (w *Worker) runSync() {
+	// Check if online
+	if !w.isOnline() {
+		w.logger.Debug("offline, skipping background sync")
+		return
+	}
+
+	// Push pending changes first
+	pushed, err := w.service.PushPendingChanges()
+	if err != nil {
+		w.logger.Warn("background sync: failed to push pending changes", "error", err)
+	} else if pushed > 0 {
+		w.logger.Info("background sync: pushed pending changes", "count", pushed)
+	}
+
+	// Then check for new pricelists
+	err = w.service.SyncPricelistsIfNeeded()
+	if err != nil {
+		w.logger.Warn("background sync: failed to sync pricelists", "error", err)
+	}
+
+	w.logger.Info("background sync cycle completed")
+}

scripts/release.sh

@@ -0,0 +1,100 @@
+#!/bin/bash
+set -e
+
+# QuoteForge Release Build Script
+# Creates binaries for all platforms and packages them for release
+
+# Colors
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+NC='\033[0m' # No Color
+
+# Get version from git
+VERSION=$(git describe --tags --always --dirty 2>/dev/null || echo "dev")
+if [[ $VERSION == *"dirty"* ]]; then
+    echo -e "${RED}✗ Error: Working directory has uncommitted changes${NC}"
+    echo "  Commit your changes first"
+    exit 1
+fi
+
+echo -e "${GREEN}Building QuoteForge version: ${VERSION}${NC}"
+echo ""
+
+# Create release directory
+RELEASE_DIR="releases/${VERSION}"
+mkdir -p "${RELEASE_DIR}"
+
+# Build for all platforms
+echo -e "${YELLOW}→ Building binaries...${NC}"
+make build-all
+
+# Package binaries with checksums
+echo ""
+echo -e "${YELLOW}→ Creating release packages...${NC}"
+
+# Linux AMD64
+if [ -f "bin/qfs-linux-amd64" ]; then
+    cd bin
+    tar -czf "../${RELEASE_DIR}/qfs-${VERSION}-linux-amd64.tar.gz" qfs-linux-amd64
+    cd ..
+    echo -e "${GREEN}  ✓ qfs-${VERSION}-linux-amd64.tar.gz${NC}"
+fi
+
+# macOS Intel
+if [ -f "bin/qfs-darwin-amd64" ]; then
+    cd bin
+    tar -czf "../${RELEASE_DIR}/qfs-${VERSION}-darwin-amd64.tar.gz" qfs-darwin-amd64
+    cd ..
+    echo -e "${GREEN}  ✓ qfs-${VERSION}-darwin-amd64.tar.gz${NC}"
+fi
+
+# macOS Apple Silicon
+if [ -f "bin/qfs-darwin-arm64" ]; then
+    cd bin
+    tar -czf "../${RELEASE_DIR}/qfs-${VERSION}-darwin-arm64.tar.gz" qfs-darwin-arm64
+    cd ..
+    echo -e "${GREEN}  ✓ qfs-${VERSION}-darwin-arm64.tar.gz${NC}"
+fi
+
+# Windows AMD64
+if [ -f "bin/qfs-windows-amd64.exe" ]; then
+    cd bin
+    zip -q "../${RELEASE_DIR}/qfs-${VERSION}-windows-amd64.zip" qfs-windows-amd64.exe
+    cd ..
+    echo -e "${GREEN}  ✓ qfs-${VERSION}-windows-amd64.zip${NC}"
+fi
+
+# Generate checksums
+echo ""
+echo -e "${YELLOW}→ Generating checksums...${NC}"
+cd "${RELEASE_DIR}"
+shasum -a 256 *.tar.gz *.zip > SHA256SUMS.txt 2>/dev/null || shasum -a 256 * | grep -v SHA256SUMS > SHA256SUMS.txt
+cd ../..
+echo -e "${GREEN}  ✓ SHA256SUMS.txt${NC}"
+
+# List release files
+echo ""
+echo -e "${GREEN}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
+echo -e "${GREEN}Release ${VERSION} built successfully!${NC}"
+echo -e "${GREEN}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
+echo ""
+echo "Files in ${RELEASE_DIR}:"
+ls -lh "${RELEASE_DIR}"
+echo ""
+
+# Show next steps
+echo -e "${YELLOW}Next steps:${NC}"
+echo "  1. Create git tag:"
+echo "     git tag -a ${VERSION} -m \"Release ${VERSION}\""
+echo ""
+echo "  2. Push tag to remote:"
+echo "     git push origin ${VERSION}"
+echo ""
+echo "  3. Create release on git.mchus.pro:"
+echo "     - Go to: https://git.mchus.pro/mchus/QuoteForge/releases"
+echo "     - Click 'New Release'"
+echo "     - Select tag: ${VERSION}"
+echo "     - Upload files from: ${RELEASE_DIR}/"
+echo ""
+echo -e "${GREEN}Done!${NC}"

web/templates/admin_pricing.html

@@ -9,6 +9,7 @@
             <div class="flex gap-4">
                 <button onclick="loadTab('alerts')" id="btn-alerts" class="text-blue-600 font-medium">Алерты</button>
                 <button onclick="loadTab('components')" id="btn-components" class="text-gray-600">Компоненты</button>
+                <button onclick="loadTab('pricelists')" id="btn-pricelists" class="text-gray-600">Прайслисты</button>
                 <button onclick="loadTab('all-configs')" id="btn-all-configs" class="text-gray-600 hidden">Все конфигурации</button>
             </div>
             <button onclick="recalculateAll()" id="btn-recalc" class="px-3 py-1 bg-green-600 text-white text-sm rounded hover:bg-green-700">
@@ -53,6 +54,60 @@
             <div class="text-center py-8 text-gray-500">Загрузка...</div>
         </div>
 
+        <!-- Pricelists Tab Content (hidden by default) -->
+        <div id="pricelists-tab-content" class="hidden">
+            <div class="flex justify-between items-center mb-4">
+                <h2 class="text-xl font-semibold">Прайслисты</h2>
+                <div id="pricelists-create-btn-container"></div>
+            </div>
+
+            <div class="bg-white rounded-lg shadow overflow-hidden">
+                <table class="min-w-full divide-y divide-gray-200">
+                    <thead class="bg-gray-50">
+                        <tr>
+                            <th class="px-6 py-3 text-left text-xs font-medium text-gray-500 uppercase">Версия</th>
+                            <th class="px-6 py-3 text-left text-xs font-medium text-gray-500 uppercase">Дата</th>
+                            <th class="px-6 py-3 text-left text-xs font-medium text-gray-500 uppercase">Автор</th>
+                            <th class="px-6 py-3 text-center text-xs font-medium text-gray-500 uppercase">Позиций</th>
+                            <th class="px-6 py-3 text-center text-xs font-medium text-gray-500 uppercase">Исп.</th>
+                            <th class="px-6 py-3 text-center text-xs font-medium text-gray-500 uppercase">Статус</th>
+                            <th class="px-6 py-3 text-right text-xs font-medium text-gray-500 uppercase">Действия</th>
+                        </tr>
+                    </thead>
+                    <tbody id="pricelists-body" class="bg-white divide-y divide-gray-200">
+                        <tr>
+                            <td colspan="7" class="px-6 py-4 text-center text-gray-500">Загрузка...</td>
+                        </tr>
+                    </tbody>
+                </table>
+            </div>
+
+            <div id="pricelists-pagination" class="flex justify-center space-x-2 mt-4"></div>
+        </div>
+
+        <!-- Create Modal -->
+        <div id="pricelists-create-modal" class="fixed inset-0 bg-black bg-opacity-50 hidden items-center justify-center z-50">
+            <div class="bg-white rounded-lg p-6 max-w-md w-full mx-4">
+                <h2 class="text-xl font-bold mb-4">Создать прайслист</h2>
+                <p class="text-sm text-gray-600 mb-4">
+                    Будет создан снимок текущих цен из базы данных.<br>
+                    Автор прайслиста: <span id="pricelists-db-username" class="font-medium">загрузка...</span>
+                </p>
+                <form id="pricelists-create-form" class="space-y-4">
+                    <div class="flex justify-end space-x-3">
+                        <button type="button" onclick="closePricelistsCreateModal()"
+                                class="px-4 py-2 text-gray-700 border border-gray-300 rounded-md hover:bg-gray-50">
+                            Отмена
+                        </button>
+                        <button type="submit"
+                                class="px-4 py-2 bg-blue-600 text-white rounded-md hover:bg-blue-700">
+                            Создать
+                        </button>
+                    </div>
+                </form>
+            </div>
+        </div>
+
         <!-- Pagination -->
         <div id="pagination" class="flex justify-between items-center mt-4 pt-4 border-t hidden">
             <span id="page-info" class="text-sm text-gray-600"></span>
@@ -157,6 +212,10 @@ let currentSearch = '';
 let componentsCache = [];
 let sortField = 'popularity_score';
 let sortDir = 'desc';
+let pricelistsPage = 1;
+let pricelistsCanWrite = false;
+let isCreatingPricelist = false;
+let cachedDbUsername = null;
 
 async function loadTab(tab) {
     currentTab = tab;
@@ -166,6 +225,7 @@ async function loadTab(tab) {
 
     document.getElementById('btn-alerts').className = tab === 'alerts' ? 'text-blue-600 font-medium' : 'text-gray-600';
     document.getElementById('btn-components').className = tab === 'components' ? 'text-blue-600 font-medium' : 'text-gray-600';
+    document.getElementById('btn-pricelists').className = tab === 'pricelists' ? 'text-blue-600 font-medium' : 'text-gray-600';
     document.getElementById('btn-all-configs').className = tab === 'all-configs' ? 'text-blue-600 font-medium' : 'text-gray-600 hidden';
 
     // Show/hide elements based on tab
@@ -173,35 +233,42 @@ async function loadTab(tab) {
         document.getElementById('search-bar').className = 'mb-4';
         document.getElementById('pagination').className = 'flex justify-between items-center mt-4 pt-4 border-t';
         document.getElementById('btn-all-configs').className = 'text-gray-600 hidden'; // Hide this tab for components
+        document.getElementById('pricelists-tab-content').className = 'hidden';
+        document.getElementById('tab-content').className = '';
     } else if (tab === 'all-configs') {
         document.getElementById('search-bar').className = 'mb-4 hidden'; // Hide search for all configs
         document.getElementById('pagination').className = 'flex justify-between items-center mt-4 pt-4 border-t'; // Show pagination
         document.getElementById('btn-all-configs').className = 'text-blue-600 font-medium'; // Show this tab for all configs
+        document.getElementById('pricelists-tab-content').className = 'hidden';
+        document.getElementById('tab-content').className = '';
+    } else if (tab === 'pricelists') {
+        document.getElementById('search-bar').className = 'mb-4 hidden';
+        document.getElementById('pagination').className = 'hidden';
+        document.getElementById('btn-all-configs').className = 'text-gray-600 hidden';
+        document.getElementById('pricelists-tab-content').className = '';
+        document.getElementById('tab-content').className = 'hidden';
+        // Load pricelists when pricelists tab is selected
+        checkPricelistWritePermission();
+        loadPricelists(1);
     } else {
         document.getElementById('search-bar').className = 'mb-4 hidden';
         document.getElementById('pagination').className = 'hidden';
         document.getElementById('btn-all-configs').className = 'text-gray-600 hidden';
+        document.getElementById('pricelists-tab-content').className = 'hidden';
+        document.getElementById('tab-content').className = '';
     }
 
-    await loadData();
+    if (tab !== 'pricelists') {
+        await loadData();
+    }
 }
 
 async function loadData() {
-    const token = localStorage.getItem('token');
-    if (!token) {
-        window.location.href = '/login';
-        return;
-    }
-
     document.getElementById('tab-content').innerHTML = '<div class="text-center py-8 text-gray-500">Загрузка...</div>';
 
     try {
         if (currentTab === 'alerts') {
-            const resp = await fetch('/admin/pricing/alerts?per_page=100', {
-                headers: {'Authorization': 'Bearer ' + token}
-            });
-            if (resp.status === 401) { logout(); return; }
-            if (resp.status === 403) { window.location.href = '/'; return; }
+            const resp = await fetch('/api/admin/pricing/alerts?per_page=100');
             const data = await resp.json();
             renderAlerts(data.alerts || []);
         } else if (currentTab === 'all-configs') {
@@ -210,17 +277,13 @@ async function loadData() {
             if (currentSearch) {
                 url += '&search=' + encodeURIComponent(currentSearch);
             }
-            const resp = await fetch(url, {
-                headers: {'Authorization': 'Bearer ' + token}
-            });
-            if (resp.status === 401) { logout(); return; }
-            if (resp.status === 403) { window.location.href = '/'; return; }
+            const resp = await fetch(url);
             const data = await resp.json();
             totalPages = Math.ceil(data.total / perPage);
             renderAllConfigs(data.configurations || []);
             updatePagination(data.total);
         } else {
-            let url = '/admin/pricing/components?page=' + currentPage + '&per_page=' + perPage;
+            let url = '/api/admin/pricing/components?page=' + currentPage + '&per_page=' + perPage;
             if (currentSearch) {
                 url += '&search=' + encodeURIComponent(currentSearch);
             }
@@ -230,10 +293,7 @@ async function loadData() {
             if (sortDir) {
                 url += '&dir=' + encodeURIComponent(sortDir);
             }
-            const resp = await fetch(url, {
-                headers: {'Authorization': 'Bearer ' + token}
-            });
-            if (resp.status === 401) { logout(); return; }
+            const resp = await fetch(url);
             const data = await resp.json();
             totalPages = Math.ceil(data.total / perPage);
             componentsCache = data.components || [];
@@ -471,9 +531,6 @@ function onMethodChange() {
 }
 
 async function fetchPreview() {
-    const token = localStorage.getItem('token');
-    if (!token) return;
-
     const lotName = document.getElementById('modal-lot-name').value;
     const method = document.getElementById('modal-method').value;
     const periodDays = parseInt(document.getElementById('modal-period').value) || 0;
@@ -490,10 +547,9 @@ async function fetchPreview() {
     }
 
     try {
-        const resp = await fetch('/admin/pricing/preview', {
+        const resp = await fetch('/api/admin/pricing/preview', {
             method: 'POST',
             headers: {
-                'Authorization': 'Bearer ' + token,
                 'Content-Type': 'application/json'
             },
             body: JSON.stringify({
@@ -508,8 +564,6 @@ async function fetchPreview() {
             })
         });
 
-        if (resp.status === 401) { logout(); return; }
-
         if (resp.ok) {
             const data = await resp.json();
 
@@ -537,8 +591,21 @@ async function fetchPreview() {
             document.getElementById('modal-new-price').textContent =
                 data.new_price ? '$' + parseFloat(data.new_price).toFixed(2) : '—';
 
-            // Update quote count
-            document.getElementById('modal-quote-count').textContent = data.quote_count || 0;
+            // Update quote count with new format "N (всего: M)"
+            let quoteCountText = '';
+            if (data.quote_count_period !== undefined && data.quote_count_total !== undefined) {
+                if (data.quote_count_period === data.quote_count_total) {
+                    // If period count equals total count, just show the total
+                    quoteCountText = data.quote_count_total;
+                } else {
+                    // Show both counts in format "N (всего: M)"
+                    quoteCountText = data.quote_count_period + ' (всего: ' + data.quote_count_total + ')';
+                }
+            } else {
+                // Fallback for older API responses
+                quoteCountText = data.quote_count || 0;
+            }
+            document.getElementById('modal-quote-count').textContent = quoteCountText;
         }
     } catch(e) {
         console.error('Preview fetch error:', e);
@@ -584,12 +651,6 @@ function debounceFetchPreview() {
 }
 
 async function savePrice() {
-    const token = localStorage.getItem('token');
-    if (!token) {
-        window.location.href = '/login';
-        return;
-    }
-
     const lotName = document.getElementById('modal-lot-name').value;
     const method = document.getElementById('modal-method').value;
     const periodDaysStr = document.getElementById('modal-period').value;
@@ -630,17 +691,14 @@ async function savePrice() {
     }
 
     try {
-        const resp = await fetch('/admin/pricing/update', {
+        const resp = await fetch('/api/admin/pricing/update', {
             method: 'POST',
             headers: {
-                'Authorization': 'Bearer ' + token,
                 'Content-Type': 'application/json'
             },
             body: JSON.stringify(body)
         });
 
-        if (resp.status === 401) { logout(); return; }
-
         if (resp.ok) {
             closeModal();
             loadData();
@@ -683,12 +741,6 @@ function processMetaPrices(metaPrices, originalLotName) {
 }
 
 function recalculateAll() {
-    const token = localStorage.getItem('token');
-    if (!token) {
-        window.location.href = '/login';
-        return;
-    }
-
     const btn = document.getElementById('btn-recalc');
     const progressContainer = document.getElementById('progress-container');
     const progressBar = document.getElementById('progress-bar');
@@ -707,9 +759,8 @@ function recalculateAll() {
     progressStats.textContent = 'Подготовка...';
 
     // Use fetch with streaming for SSE
-    fetch('/admin/pricing/recalculate-all', {
-        method: 'POST',
-        headers: {'Authorization': 'Bearer ' + token}
+    fetch('/api/admin/pricing/recalculate-all', {
+        method: 'POST'
     }).then(response => {
         const reader = response.body.getReader();
         const decoder = new TextDecoder();
@@ -842,7 +893,10 @@ function renderAllConfigs(configs) {
 }
 
 document.addEventListener('DOMContentLoaded', () => {
-    loadTab('alerts');
+    // Check URL params for initial tab
+    const urlParams = new URLSearchParams(window.location.search);
+    const initialTab = urlParams.get('tab') || 'alerts';
+    loadTab(initialTab);
 
     // Add event listeners for preview updates
     document.getElementById('modal-period').addEventListener('change', fetchPreview);
@@ -850,6 +904,217 @@ document.addEventListener('DOMContentLoaded', () => {
     document.getElementById('modal-manual-price').addEventListener('input', debounceFetchPreview);
     document.getElementById('modal-meta-prices').addEventListener('input', debounceFetchPreview);
 });
+
+// Pricelists functions
+let canWrite = false;
+
+async function checkPricelistWritePermission() {
+    try {
+        const resp = await fetch('/api/pricelists/can-write');
+        const data = await resp.json();
+        pricelistsCanWrite = data.can_write;
+
+        if (pricelistsCanWrite) {
+            document.getElementById('pricelists-create-btn-container').innerHTML = `
+                <button onclick="openPricelistsCreateModal()" class="px-4 py-2 bg-blue-600 text-white rounded-md hover:bg-blue-700">
+                    Создать прайслист
+                </button>
+            `;
+        }
+    } catch (e) {
+        console.error('Failed to check pricelist write permission:', e);
+    }
+}
+
+async function loadPricelists(page = 1) {
+    pricelistsPage = page;
+    try {
+        const resp = await fetch(`/api/pricelists?page=${page}&per_page=20`);
+        const data = await resp.json();
+
+        renderPricelists(data.pricelists || []);
+        renderPricelistsPagination(data.total, data.page, data.per_page);
+    } catch (e) {
+        document.getElementById('pricelists-body').innerHTML = `
+            <tr>
+                <td colspan="7" class="px-6 py-4 text-center text-red-500">
+                    Ошибка загрузки: ${e.message}
+                </td>
+            </tr>
+        `;
+        // Hide pagination when there's an error
+        document.getElementById('pricelists-pagination').innerHTML = '';
+    }
+}
+
+function renderPricelists(pricelists) {
+    if (pricelists.length === 0) {
+        document.getElementById('pricelists-body').innerHTML = `
+            <tr>
+                <td colspan="7" class="px-6 py-4 text-center text-gray-500">
+                    Прайслисты не найдены. ${pricelistsCanWrite ? 'Создайте первый прайслист.' : ''}
+                </td>
+            </tr>
+        `;
+        return;
+    }
+
+    const html = pricelists.map(pl => {
+        const date = new Date(pl.created_at).toLocaleDateString('ru-RU');
+        const statusClass = pl.is_active ? 'bg-green-100 text-green-800' : 'bg-gray-100 text-gray-800';
+        const statusText = pl.is_active ? 'Активен' : 'Неактивен';
+
+        let actions = `<a href="/pricelists/${pl.id}" class="text-blue-600 hover:text-blue-800 text-sm">Просмотр</a>`;
+        if (pricelistsCanWrite && pl.usage_count === 0) {
+            actions += ` <button onclick="deletePricelist(${pl.id})" class="text-red-600 hover:text-red-800 text-sm ml-2">Удалить</button>`;
+        }
+
+        return `
+            <tr class="hover:bg-gray-50">
+                <td class="px-6 py-4 whitespace-nowrap">
+                    <span class="font-mono text-sm">${pl.version}</span>
+                </td>
+                <td class="px-6 py-4 whitespace-nowrap text-sm text-gray-500">${date}</td>
+                <td class="px-6 py-4 whitespace-nowrap text-sm text-gray-500">${pl.created_by || '-'}</td>
+                <td class="px-6 py-4 whitespace-nowrap text-center text-sm">${pl.item_count}</td>
+                <td class="px-6 py-4 whitespace-nowrap text-center text-sm">${pl.usage_count}</td>
+                <td class="px-6 py-4 whitespace-nowrap text-center">
+                    <span class="px-2 py-1 text-xs rounded-full ${statusClass}">${statusText}</span>
+                </td>
+                <td class="px-6 py-4 whitespace-nowrap text-right">${actions}</td>
+            </tr>
+        `;
+    }).join('');
+
+    document.getElementById('pricelists-body').innerHTML = html;
+}
+
+function renderPricelistsPagination(total, page, perPage) {
+    const totalPages = Math.ceil(total / perPage);
+    if (totalPages <= 1) {
+        document.getElementById('pricelists-pagination').innerHTML = '';
+        return;
+    }
+
+    let html = '';
+    for (let i = 1; i <= totalPages; i++) {
+        const activeClass = i === page ? 'bg-blue-600 text-white' : 'bg-white text-gray-700 hover:bg-gray-50';
+        html += `<button onclick="loadPricelists(${i})" class="px-3 py-1 rounded border ${activeClass}">${i}</button>`;
+    }
+
+    document.getElementById('pricelists-pagination').innerHTML = html;
+}
+
+async function loadPricelistsDbUsername() {
+    if (cachedDbUsername) {
+        document.getElementById('pricelists-db-username').textContent = cachedDbUsername;
+        return;
+    }
+
+    try {
+        const resp = await fetch('/api/current-user');
+        const data = await resp.json();
+        cachedDbUsername = data.username || 'неизвестно';
+        document.getElementById('pricelists-db-username').textContent = cachedDbUsername;
+    } catch (e) {
+        document.getElementById('pricelists-db-username').textContent = 'неизвестно';
+    }
+}
+
+function openPricelistsCreateModal() {
+    document.getElementById('pricelists-create-modal').classList.remove('hidden');
+    document.getElementById('pricelists-create-modal').classList.add('flex');
+    loadPricelistsDbUsername();
+}
+
+function closePricelistsCreateModal() {
+    document.getElementById('pricelists-create-modal').classList.add('hidden');
+    document.getElementById('pricelists-create-modal').classList.remove('flex');
+}
+
+async function checkOnlineStatus() {
+    try {
+        const resp = await fetch('/api/db-status');
+        const data = await resp.json();
+        return data.connected === true;
+    } catch(e) {
+        return false;
+    }
+}
+
+async function createPricelist() {
+    // Check if online before creating
+    const isOnline = await checkOnlineStatus();
+    if (!isOnline) {
+        throw new Error('Создание прайслистов доступно только в онлайн режиме');
+    }
+
+    const resp = await fetch('/api/pricelists', {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json'
+        },
+        body: JSON.stringify({})
+    });
+
+    if (!resp.ok) {
+        const data = await resp.json();
+        throw new Error(data.error || 'Failed to create pricelist');
+    }
+
+    return await resp.json();
+}
+
+async function deletePricelist(id) {
+    // Check if online before deleting
+    const isOnline = await checkOnlineStatus();
+    if (!isOnline) {
+        showToast('Удаление прайслистов доступно только в онлайн режиме', 'error');
+        return;
+    }
+
+    if (!confirm('Удалить этот прайслист?')) return;
+
+    try {
+        const resp = await fetch(`/api/pricelists/${id}`, {
+            method: 'DELETE'
+        });
+
+        if (!resp.ok) {
+            const data = await resp.json();
+            throw new Error(data.error || 'Failed to delete');
+        }
+
+        showToast('Прайслист удален', 'success');
+        loadPricelists(pricelistsPage);
+    } catch (e) {
+        showToast('Ошибка: ' + e.message, 'error');
+    }
+}
+
+document.getElementById('pricelists-create-form').addEventListener('submit', async function(e) {
+    e.preventDefault();
+
+    if (isCreatingPricelist) return; // protection from double-submit
+    isCreatingPricelist = true;
+
+    const submitBtn = this.querySelector('button[type="submit"]');
+    submitBtn.disabled = true;
+    submitBtn.textContent = 'Создание...';
+
+    try {
+        const pl = await createPricelist();
+        closePricelistsCreateModal();
+        showToast(`Прайслист ${pl.version} создан (${pl.item_count} позиций)`, 'success');
+        loadPricelists(1);
+    } catch (e) {
+        showToast('Ошибка: ' + e.message, 'error');
+    } finally {
+        isCreatingPricelist = false;
+        submitBtn.disabled = false;
+        submitBtn.textContent = 'Создать';
+    }
+});
 </script>
 {{end}}
 

web/templates/base.html

@@ -19,18 +19,20 @@
                 <div class="flex items-center space-x-8">
                     <a href="/" class="text-xl font-bold text-blue-600">QuoteForge</a>
                     <div class="hidden md:flex space-x-4">
-                        <a href="/configs" class="text-gray-600 hover:text-gray-900 px-3 py-2 text-sm" id="nav-configs" style="display:none;">Мои конфигурации</a>
-                        <a href="/admin/pricing" class="text-gray-600 hover:text-gray-900 px-3 py-2 text-sm" id="nav-admin" style="display:none;">Цены</a>
+                        <a href="/configurator" class="text-gray-600 hover:text-gray-900 px-3 py-2 text-sm">Конфигуратор</a>
+                        <a id="admin-pricing-link" href="/admin/pricing" class="text-gray-600 hover:text-gray-900 px-3 py-2 text-sm">Администратор цен</a>
+                        <a href="/setup" class="text-gray-600 hover:text-gray-900 px-3 py-2 text-sm">Настройки</a>
                     </div>
                 </div>
-                <div class="flex items-center">
-                    <div id="user-logged-out">
-                        <a href="/login" class="text-blue-600 hover:text-blue-800 text-sm">Войти</a>
-                    </div>
-                    <div id="user-logged-in" class="hidden">
-                        <span id="user-name" class="text-sm text-gray-700 mr-3"></span>
-                        <button onclick="logout()" class="text-red-600 hover:text-red-800 text-sm">Выйти</button>
+                <div class="flex items-center space-x-4">
+                    <!-- Sync Status Indicator (htmx-powered) -->
+                    <div id="sync-status"
+                         class="flex items-center gap-3 text-sm"
+                         hx-get="/partials/sync-status"
+                         hx-trigger="load, refresh from:body, every 30s"
+                         hx-swap="innerHTML">
                     </div>
+                    <span id="db-user" class="text-sm text-gray-600"></span>
                 </div>
             </div>
         </div>
@@ -42,6 +44,52 @@
 
     <div id="toast" class="fixed bottom-4 right-4 z-50"></div>
 
+    <!-- Sync Info Modal -->
+    <div id="sync-modal" class="fixed inset-0 bg-black bg-opacity-50 flex items-center justify-center z-50 hidden">
+        <div class="bg-white rounded-lg shadow-xl max-w-md w-full mx-4">
+            <div class="p-6">
+                <div class="flex justify-between items-center mb-4">
+                    <h3 class="text-lg font-medium text-gray-900">Информация о синхронизации</h3>
+                    <button onclick="closeSyncModal()" class="text-gray-400 hover:text-gray-500">
+                        <svg class="w-6 h-6" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+                            <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M6 18L18 6M6 6l12 12"></path>
+                        </svg>
+                    </button>
+                </div>
+
+                <div class="space-y-4">
+                    <div>
+                        <h4 class="font-medium text-gray-900">Статус БД</h4>
+                        <p id="modal-db-status" class="text-sm text-gray-600">Проверка...</p>
+                    </div>
+
+                    <div>
+                        <h4 class="font-medium text-gray-900">Количество ошибок</h4>
+                        <p id="modal-error-count" class="text-sm text-gray-600">0</p>
+                    </div>
+
+                    <div>
+                        <h4 class="font-medium text-gray-900">Последняя синхронизация</h4>
+                        <p id="modal-last-sync" class="text-sm text-gray-600">-</p>
+                    </div>
+
+                    <div>
+                        <h4 class="font-medium text-gray-900">Список ошибок</h4>
+                        <div id="modal-errors-list" class="mt-2 text-sm text-gray-600 max-h-40 overflow-y-auto">
+                            <p>Нет ошибок</p>
+                        </div>
+                    </div>
+                </div>
+
+                <div class="mt-6 flex justify-end">
+                    <button onclick="closeSyncModal()" class="px-4 py-2 bg-gray-600 text-white rounded-md hover:bg-gray-700">
+                        Закрыть
+                    </button>
+                </div>
+            </div>
+        </div>
+    </div>
+
     <footer class="fixed bottom-0 left-0 right-0 bg-gray-800 text-gray-300 text-xs py-1 px-4">
         <div class="max-w-7xl mx-auto flex justify-between">
             <span id="db-status">БД: проверка...</span>
@@ -50,33 +98,6 @@
     </footer>
 
     <script>
-        function initAuth() {
-            const token = localStorage.getItem('token');
-            const user = localStorage.getItem('user');
-
-            if (token && user) {
-                try {
-                    const userData = JSON.parse(user);
-                    document.getElementById('user-logged-out').classList.add('hidden');
-                    document.getElementById('user-logged-in').classList.remove('hidden');
-                    document.getElementById('user-name').textContent = userData.username;
-                    document.getElementById('nav-configs').style.display = 'block';
-                    if (userData.role === 'admin' || userData.role === 'pricing_admin') {
-                        document.getElementById('nav-admin').style.display = 'block';
-                    }
-                } catch(e) {
-                    logout();
-                }
-            }
-        }
-
-        function logout() {
-            localStorage.removeItem('token');
-            localStorage.removeItem('refresh_token');
-            localStorage.removeItem('user');
-            window.location.href = '/';
-        }
-
         function showToast(msg, type) {
             const colors = { success: 'bg-green-500', error: 'bg-red-500', info: 'bg-blue-500' };
             const el = document.getElementById('toast');
@@ -84,15 +105,128 @@
             setTimeout(() => el.innerHTML = '', 3000);
         }
 
+        // Open sync modal
+        function openSyncModal() {
+            const modal = document.getElementById('sync-modal');
+            if (modal) {
+                modal.classList.remove('hidden');
+                // Load sync info when modal opens
+                loadSyncInfo();
+            }
+        }
+
+        // Close sync modal
+        function closeSyncModal() {
+            const modal = document.getElementById('sync-modal');
+            if (modal) {
+                modal.classList.add('hidden');
+            }
+        }
+
+        // Load sync info for modal
+        async function loadSyncInfo() {
+            try {
+                const resp = await fetch('/api/sync/info');
+                const data = await resp.json();
+
+                document.getElementById('modal-db-status').textContent = data.is_online ? 'Подключено' : 'Отключено';
+                document.getElementById('modal-error-count').textContent = data.error_count;
+
+                if (data.last_sync_at) {
+                    const date = new Date(data.last_sync_at);
+                    document.getElementById('modal-last-sync').textContent = date.toLocaleString('ru-RU');
+                } else {
+                    document.getElementById('modal-last-sync').textContent = 'Нет данных';
+                }
+
+                // Load error list
+                const errorsList = document.getElementById('modal-errors-list');
+                if (data.errors && data.errors.length > 0) {
+                    errorsList.innerHTML = data.errors.map(error =>
+                        `<div class="mb-1"><span class="font-medium">${error.timestamp}</span>: ${error.message}</div>`
+                    ).join('');
+                } else {
+                    errorsList.innerHTML = '<p>Нет ошибок</p>';
+                }
+            } catch(e) {
+                console.error('Failed to load sync info:', e);
+                document.getElementById('modal-db-status').textContent = 'Ошибка загрузки';
+                document.getElementById('modal-error-count').textContent = '0';
+                document.getElementById('modal-last-sync').textContent = '-';
+                document.getElementById('modal-errors-list').innerHTML = '<p>Ошибка загрузки данных</p>';
+            }
+        }
+
+        // Event delegation for sync dropdown and actions
+        document.addEventListener('DOMContentLoaded', function() {
+            checkDbStatus();
+            checkWritePermission();
+        });
+
+        // Event delegation for sync actions
+        document.body.addEventListener('click', function(e) {
+            // Handle sync button click (full sync only)
+            const syncButton = e.target.closest('#sync-button');
+            if (syncButton) {
+                e.stopPropagation();
+                const button = syncButton;
+
+                // Add loading state
+                const originalHTML = button.innerHTML;
+                button.disabled = true;
+                button.innerHTML = '<svg class="animate-spin w-4 h-4 inline mr-2" fill="none" viewBox="0 0 24 24"><circle class="opacity-25" cx="12" cy="12" r="10" stroke="currentColor" stroke-width="4"></circle><path class="opacity-75" fill="currentColor" d="M4 12a8 8 0 018-8V0C5.373 0 0 5.373 0 12h4zm2 5.291A7.962 7.962 0 014 12H0c0 3.042 1.135 5.824 3 7.938l3-2.647z"></path></svg>';
+
+                fullSync(button, originalHTML);
+            }
+        });
+
+        // Refactored sync action function to reduce duplication
+        async function syncAction(endpoint, successMessage, button, originalHTML) {
+            try {
+                const resp = await fetch(endpoint, { method: 'POST' });
+                const data = await resp.json();
+
+                if (data.success) {
+                    showToast(successMessage, 'success');
+                    // Update last sync time - removed since dropdown is gone
+                    // loadLastSyncTime();
+                } else {
+                    showToast('Ошибка: ' + (data.error || 'неизвестная ошибка'), 'error');
+                }
+
+                htmx.trigger('#sync-status', 'refresh');
+            } catch (error) {
+                showToast('Ошибка: ' + error.message, 'error');
+            } finally {
+                // Reset button state
+                if (button) {
+                    button.disabled = false;
+                    button.innerHTML = originalHTML;
+                }
+            }
+        }
+
+        function pushPendingChanges(button, originalHTML) {
+            syncAction('/api/sync/push', 'Изменения синхронизированы', button, originalHTML);
+        }
+
+        function fullSync(button, originalHTML) {
+            syncAction('/api/sync/all', 'Полная синхронизация завершена', button, originalHTML);
+        }
+
         async function checkDbStatus() {
             try {
                 const resp = await fetch('/api/db-status');
                 const data = await resp.json();
                 const statusEl = document.getElementById('db-status');
                 const countsEl = document.getElementById('db-counts');
+                const userEl = document.getElementById('db-user');
 
                 if (data.connected) {
                     statusEl.innerHTML = '<span class="text-green-400">БД: подключено</span>';
+                    if (data.db_user) {
+                        userEl.innerHTML = '<span class="text-gray-500">@</span>' + data.db_user;
+                    }
                 } else {
                     statusEl.innerHTML = '<span class="text-red-400">БД: ошибка - ' + data.error + '</span>';
                 }
@@ -103,10 +237,36 @@
             }
         }
 
-        document.addEventListener('DOMContentLoaded', function() {
-            initAuth();
-            checkDbStatus();
-        });
+        // Admin pricing link is now always visible
+        // Write permission is checked at operation time (create/delete)
+        async function checkWritePermission() {
+            // No longer needed - link always visible in offline-first mode
+            // Operations will check online status when executed
+        }
+
+        // Load last sync time for dropdown (removed since dropdown is gone)
+        // async function loadLastSyncTime() {
+        //     try {
+        //         const resp = await fetch('/api/sync/status');
+        //         const data = await resp.json();
+        //         if (data.last_pricelist_sync) {
+        //             const date = new Date(data.last_pricelist_sync);
+        //             document.getElementById('last-sync-time').textContent = date.toLocaleString('ru-RU');
+        //         } else {
+        //             document.getElementById('last-sync-time').textContent = 'Нет данных';
+        //         }
+        //     } catch(e) {
+        //         console.error('Failed to load last sync time:', e);
+        //     }
+        // }
+
+        // Call functions immediately to ensure they run even before DOMContentLoaded
+        // This ensures username and admin link are visible ASAP
+        checkDbStatus();
+        checkWritePermission();
+
+        // Load last sync time - removed since dropdown is gone
+        // document.addEventListener('DOMContentLoaded', loadLastSyncTime);
     </script>
 </body>
 </html>

web/templates/configs.html

@@ -10,6 +10,15 @@
         </button>
     </div>
 
+    <div id="pricelist-badge" class="mt-4 text-sm text-gray-600 hidden">
+        <span class="bg-blue-100 text-blue-800 px-2 py-1 rounded-full">
+            <svg class="w-4 h-4 inline mr-1" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+                <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M9 12h6m-6 4h6m2 5H7a2 2 0 01-2-2V5a2 2 0 012-2h5.586a1 1 0 01.707.293l5.414 5.414a1 1 0 01.293.707V19a2 2 0 01-2 2z"></path>
+            </svg>
+            Активный прайслист: <span id="pricelist-version">-</span>
+        </span>
+    </div>
+
     <div id="configs-list">
         <div class="text-center py-8 text-gray-500">Загрузка...</div>
     </div>
@@ -99,38 +108,10 @@
 </div>
 
 <script>
-async function loadConfigs() {
-    const token = localStorage.getItem('token');
-
-    if (!token) {
-        document.getElementById('configs-list').innerHTML =
-            '<div class="bg-white rounded-lg shadow p-8 text-center"><a href="/login" class="text-blue-600">Войдите для просмотра</a></div>';
-        return;
-    }
-
-    try {
-        const resp = await fetch('/api/configs', {
-            headers: {'Authorization': 'Bearer ' + token}
-        });
-
-        if (resp.status === 401) {
-            logout();
-            return;
-        }
-
-        if (resp.status === 403) {
-            document.getElementById('configs-list').innerHTML =
-                '<div class="bg-white rounded-lg shadow p-8 text-center text-red-600">Нет доступа</div>';
-            return;
-        }
-
-        const data = await resp.json();
-        renderConfigs(data.configurations || []);
-    } catch(e) {
-        document.getElementById('configs-list').innerHTML =
-            '<div class="bg-white rounded-lg shadow p-8 text-center text-red-600">Ошибка загрузки</div>';
-    }
-}
+// Pagination state
+let currentPage = 1;
+let totalPages = 1;
+let perPage = 20;
 
 function renderConfigs(configs) {
     if (configs.length === 0) {
@@ -198,20 +179,13 @@ function escapeHtml(text) {
 
 async function deleteConfig(uuid) {
     if (!confirm('Удалить?')) return;
-    const token = localStorage.getItem('token');
     await fetch('/api/configs/' + uuid, {
-        method: 'DELETE',
-        headers: {'Authorization': 'Bearer ' + token}
+        method: 'DELETE'
     });
     loadConfigs();
 }
 
 function openRenameModal(uuid, currentName) {
-    const token = localStorage.getItem('token');
-    if (!token) {
-        window.location.href = '/login';
-        return;
-    }
     document.getElementById('rename-uuid').value = uuid;
     document.getElementById('rename-input').value = currentName;
     document.getElementById('rename-modal').classList.remove('hidden');
@@ -226,7 +200,6 @@ function closeRenameModal() {
 }
 
 async function renameConfig() {
-    const token = localStorage.getItem('token');
     const uuid = document.getElementById('rename-uuid').value;
     const name = document.getElementById('rename-input').value.trim();
 
@@ -239,17 +212,11 @@ async function renameConfig() {
         const resp = await fetch('/api/configs/' + uuid + '/rename', {
             method: 'PATCH',
             headers: {
-                'Authorization': 'Bearer ' + token,
                 'Content-Type': 'application/json'
             },
             body: JSON.stringify({ name: name })
         });
 
-        if (resp.status === 401) {
-            logout();
-            return;
-        }
-
         if (!resp.ok) {
             const err = await resp.json();
             alert('Ошибка: ' + (err.error || 'Не удалось переименовать'));
@@ -264,11 +231,6 @@ async function renameConfig() {
 }
 
 function openCloneModal(uuid, currentName) {
-    const token = localStorage.getItem('token');
-    if (!token) {
-        window.location.href = '/login';
-        return;
-    }
     document.getElementById('clone-uuid').value = uuid;
     document.getElementById('clone-input').value = currentName + ' (копия)';
     document.getElementById('clone-modal').classList.remove('hidden');
@@ -283,7 +245,6 @@ function closeCloneModal() {
 }
 
 async function cloneConfig() {
-    const token = localStorage.getItem('token');
     const uuid = document.getElementById('clone-uuid').value;
     const name = document.getElementById('clone-input').value.trim();
 
@@ -296,17 +257,11 @@ async function cloneConfig() {
         const resp = await fetch('/api/configs/' + uuid + '/clone', {
             method: 'POST',
             headers: {
-                'Authorization': 'Bearer ' + token,
                 'Content-Type': 'application/json'
             },
             body: JSON.stringify({ name: name })
         });
 
-        if (resp.status === 401) {
-            logout();
-            return;
-        }
-
         if (!resp.ok) {
             const err = await resp.json();
             alert('Ошибка: ' + (err.error || 'Не удалось скопировать'));
@@ -321,11 +276,6 @@ async function cloneConfig() {
 }
 
 function openCreateModal() {
-    const token = localStorage.getItem('token');
-    if (!token) {
-        window.location.href = '/login';
-        return;
-    }
     document.getElementById('opportunity-number').value = '';
     document.getElementById('create-modal').classList.remove('hidden');
     document.getElementById('create-modal').classList.add('flex');
@@ -338,7 +288,6 @@ function closeCreateModal() {
 }
 
 async function createConfig() {
-    const token = localStorage.getItem('token');
     const name = document.getElementById('opportunity-number').value.trim();
 
     if (!name) {
@@ -350,7 +299,6 @@ async function createConfig() {
         const resp = await fetch('/api/configs', {
             method: 'POST',
             headers: {
-                'Authorization': 'Bearer ' + token,
                 'Content-Type': 'application/json'
             },
             body: JSON.stringify({
@@ -361,11 +309,6 @@ async function createConfig() {
             })
         });
 
-        if (resp.status === 401) {
-            logout();
-            return;
-        }
-
         if (!resp.ok) {
             const err = await resp.json();
             alert('Ошибка: ' + (err.error || 'Не удалось создать'));
@@ -421,11 +364,6 @@ document.getElementById('clone-input').addEventListener('keydown', function(e) {
     }
 });
 
-// Pagination functions
-let currentPage = 1;
-let totalPages = 1;
-let perPage = 20;
-
 function prevPage() {
     if (currentPage > 1) {
         currentPage--;
@@ -451,27 +389,12 @@ function updatePagination(total) {
 
 // Load configs with pagination
 async function loadConfigs() {
-    const token = localStorage.getItem('token');
-
-    if (!token) {
-        document.getElementById('configs-list').innerHTML =
-            '<div class="bg-white rounded-lg shadow p-8 text-center"><a href="/login" class="text-blue-600">Войдите для просмотра</a></div>';
-        return;
-    }
-
     try {
-        const resp = await fetch('/api/configs?page=' + currentPage + '&per_page=' + perPage, {
-            headers: {'Authorization': 'Bearer ' + token}
-        });
+        const resp = await fetch('/api/configs?page=' + currentPage + '&per_page=' + perPage);
 
-        if (resp.status === 401) {
-            logout();
-            return;
-        }
-
-        if (resp.status === 403) {
+        if (!resp.ok) {
             document.getElementById('configs-list').innerHTML =
-                '<div class="bg-white rounded-lg shadow p-8 text-center text-red-600">Нет доступа</div>';
+                '<div class="bg-white rounded-lg shadow p-8 text-center text-red-600">Ошибка загрузки</div>';
             return;
         }
 
@@ -484,7 +407,39 @@ async function loadConfigs() {
     }
 }
 
-document.addEventListener('DOMContentLoaded', loadConfigs);
+document.addEventListener('DOMContentLoaded', function() {
+    loadConfigs();
+
+    // Load latest pricelist version for badge
+    loadLatestPricelistVersion();
+});
+
+async function loadLatestPricelistVersion() {
+    try {
+        const resp = await fetch('/api/pricelists/latest');
+        if (resp.ok) {
+            const pricelist = await resp.json();
+            document.getElementById('pricelist-version').textContent = pricelist.version;
+            document.getElementById('pricelist-badge').classList.remove('hidden');
+        } else if (resp.status === 404) {
+            // No active pricelist (normal in offline mode or when not synced)
+            document.getElementById('pricelist-version').textContent = 'Не загружен';
+            document.getElementById('pricelist-badge').classList.remove('hidden');
+            document.getElementById('pricelist-badge').classList.add('bg-gray-100', 'text-gray-600');
+        } else {
+            // Real error
+            document.getElementById('pricelist-version').textContent = 'Ошибка загрузки';
+            document.getElementById('pricelist-badge').classList.remove('hidden');
+            document.getElementById('pricelist-badge').classList.add('bg-red-100', 'text-red-800');
+        }
+    } catch(e) {
+        // Network error or other exception
+        console.error('Failed to load pricelist version:', e);
+        document.getElementById('pricelist-version').textContent = 'Не доступен';
+        document.getElementById('pricelist-badge').classList.remove('hidden');
+        document.getElementById('pricelist-badge').classList.add('bg-gray-100', 'text-gray-600');
+    }
+}
 </script>
 {{end}}
 

web/templates/index.html

@@ -269,9 +269,8 @@ async function loadCategoriesFromAPI() {
 
 // Initialize
 document.addEventListener('DOMContentLoaded', async function() {
-    const token = localStorage.getItem('token');
-
-    if (!token || !configUUID) {
+    // RBAC disabled - no token check required
+    if (!configUUID) {
         window.location.href = '/configs';
         return;
     }
@@ -280,16 +279,9 @@ document.addEventListener('DOMContentLoaded', async function() {
     await loadCategoriesFromAPI();
 
     try {
-        const resp = await fetch('/api/configs/' + configUUID, {
-            headers: {'Authorization': 'Bearer ' + token}
-        });
+        const resp = await fetch('/api/configs/' + configUUID);
 
-        if (resp.status === 401) {
-            window.location.href = '/login';
-            return;
-        }
-
-        if (resp.status === 403 || resp.status === 404) {
+        if (resp.status === 404) {
             showToast('Конфигурация не найдена', 'error');
             window.location.href = '/configs';
             return;
@@ -1119,8 +1111,8 @@ function triggerAutoSave() {
 }
 
 async function saveConfig(showNotification = true) {
-    const token = localStorage.getItem('token');
-    if (!token || !configUUID) return;
+    // RBAC disabled - no token check required
+    if (!configUUID) return;
 
     // Get custom price if set
     const customPriceInput = document.getElementById('custom-price-input');
@@ -1134,7 +1126,6 @@ async function saveConfig(showNotification = true) {
         const resp = await fetch('/api/configs/' + configUUID, {
             method: 'PUT',
             headers: {
-                'Authorization': 'Bearer ' + token,
                 'Content-Type': 'application/json'
             },
             body: JSON.stringify({
@@ -1146,11 +1137,6 @@ async function saveConfig(showNotification = true) {
             })
         });
 
-        if (resp.status === 401) {
-            window.location.href = '/login';
-            return;
-        }
-
         if (!resp.ok) {
             if (showNotification) {
                 showToast('Ошибка сохранения', 'error');
@@ -1308,23 +1294,17 @@ async function exportCSVWithCustomPrice() {
 }
 
 async function refreshPrices() {
-    const token = localStorage.getItem('token');
-    if (!token || !configUUID) return;
+    // RBAC disabled - no token check required
+    if (!configUUID) return;
 
     try {
         const resp = await fetch('/api/configs/' + configUUID + '/refresh-prices', {
             method: 'POST',
             headers: {
-                'Authorization': 'Bearer ' + token,
                 'Content-Type': 'application/json'
             }
         });
 
-        if (resp.status === 401) {
-            window.location.href = '/login';
-            return;
-        }
-
         if (!resp.ok) {
             showToast('Ошибка обновления цен', 'error');
             return;

web/templates/partials/sync_status.html

@@ -0,0 +1,37 @@
+{{define "sync_status"}}
+<div class="flex items-center gap-2 relative">
+    {{if .IsOffline}}
+    <span class="flex items-center gap-1 text-red-600 cursor-pointer" title="Offline" onclick="openSyncModal()">
+        <svg class="w-4 h-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+            <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M12 9v2m0 4h.01m-6.938 4h13.856c1.54 0 2.502-1.667 1.732-3L13.732 4c-.77-1.333-2.694-1.333-3.464 0L3.34 16c-.77 1.333.192 3 1.732 3z"></path>
+        </svg>
+    </span>
+    {{else}}
+    <span class="flex items-center gap-1 text-green-600 cursor-pointer" title="Online" onclick="openSyncModal()">
+        <svg class="w-4 h-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+            <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M9 12l2 2 4-4m6 2a9 9 0 11-18 0 9 9 0 0118 0z"></path>
+        </svg>
+    </span>
+    {{end}}
+
+    {{if gt .PendingCount 0}}
+    <span class="bg-yellow-100 text-yellow-800 px-2 py-0.5 rounded-full text-xs font-medium flex items-center gap-1 cursor-pointer" onclick="openSyncModal()">
+        <svg class="w-3 h-3" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+            <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M12 9v2m0 4h.01m-6.938 4h13.856c1.54 0 2.502-1.667 1.732-3L13.732 4c-.77-1.333-2.694-1.333-3.464 0L3.34 16c-.77 1.333.192 3 1.732 3z"></path>
+        </svg>
+        {{.PendingCount}}
+    </span>
+    {{end}}
+
+    <!-- Sync button (full sync only) -->
+    <div class="relative">
+        <button id="sync-button"
+                aria-label="Синхронизация"
+                class="text-gray-600 hover:text-gray-800 text-xs flex items-center gap-1">
+            <svg class="w-4 h-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+                <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M4 4v5h.582m15.356 2A8.001 8.001 0 004.582 9m0 0H9m11 11v-5h-.581m0 0a8.003 8.003 0 01-15.357-2m15.357 2H15"></path>
+            </svg>
+        </button>
+    </div>
+</div>
+{{end}}

web/templates/pricelist_detail.html

@@ -0,0 +1,270 @@
+{{define "title"}}Прайслист - QuoteForge{{end}}
+
+{{define "content"}}
+<div class="space-y-6">
+    <div class="flex items-center space-x-4">
+        <a href="/pricelists" class="text-gray-500 hover:text-gray-700">
+            <svg class="w-5 h-5" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+                <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M15 19l-7-7 7-7"></path>
+            </svg>
+        </a>
+        <h1 id="page-title" class="text-2xl font-bold text-gray-900">Загрузка...</h1>
+    </div>
+
+    <div id="pricelist-info" class="bg-white rounded-lg shadow p-6">
+        <div id="pl-notification" class="hidden mb-4 p-3 bg-yellow-50 border border-yellow-200 rounded-lg text-yellow-800"></div>
+        <div class="grid grid-cols-2 md:grid-cols-4 gap-4">
+            <div>
+                <p class="text-sm text-gray-500">Версия</p>
+                <p id="pl-version" class="font-mono">-</p>
+            </div>
+            <div>
+                <p class="text-sm text-gray-500">Дата создания</p>
+                <p id="pl-date">-</p>
+            </div>
+            <div>
+                <p class="text-sm text-gray-500">Автор</p>
+                <p id="pl-author">-</p>
+            </div>
+            <div>
+                <p class="text-sm text-gray-500">Позиций</p>
+                <p id="pl-items">-</p>
+            </div>
+            <div>
+                <p class="text-sm text-gray-500">Использований</p>
+                <p id="pl-usage">-</p>
+            </div>
+            <div>
+                <p class="text-sm text-gray-500">Статус</p>
+                <p id="pl-status">-</p>
+            </div>
+            <div>
+                <p class="text-sm text-gray-500">Истекает</p>
+                <p id="pl-expires">-</p>
+            </div>
+        </div>
+    </div>
+
+    <div class="bg-white rounded-lg shadow overflow-hidden">
+        <div class="p-4 border-b">
+            <input type="text" id="search-input" placeholder="Поиск по артикулу..."
+                   class="w-full md:w-64 px-3 py-2 border border-gray-300 rounded-md focus:outline-none focus:ring-2 focus:ring-blue-500">
+        </div>
+
+        <table class="min-w-full divide-y divide-gray-200">
+            <thead class="bg-gray-50">
+                <tr>
+                    <th class="px-6 py-3 text-left text-xs font-medium text-gray-500 uppercase">Артикул</th>
+                    <th class="px-6 py-3 text-left text-xs font-medium text-gray-500 uppercase">Категория</th>
+                    <th class="px-6 py-3 text-left text-xs font-medium text-gray-500 uppercase">Описание</th>
+                    <th class="px-6 py-3 text-right text-xs font-medium text-gray-500 uppercase">Цена, $</th>
+                    <th class="px-6 py-3 text-left text-xs font-medium text-gray-500 uppercase">Настройки</th>
+                </tr>
+            </thead>
+            <tbody id="items-body" class="bg-white divide-y divide-gray-200">
+                <tr>
+                    <td colspan="5" class="px-6 py-4 text-center text-gray-500">Загрузка...</td>
+                </tr>
+            </tbody>
+        </table>
+
+        <div id="items-pagination" class="p-4 border-t flex justify-between items-center">
+            <span id="items-info" class="text-sm text-gray-500"></span>
+            <div id="items-pages" class="space-x-2"></div>
+        </div>
+    </div>
+</div>
+
+<script>
+    const pricelistId = window.location.pathname.split('/').pop();
+    let currentPage = 1;
+    let searchQuery = '';
+    let searchTimeout = null;
+
+    async function loadPricelistInfo() {
+        try {
+            const resp = await fetch(`/api/pricelists/${pricelistId}`);
+            if (!resp.ok) throw new Error('Pricelist not found');
+
+            const pl = await resp.json();
+
+            document.getElementById('page-title').textContent = `Прайслист ${pl.version}`;
+            document.getElementById('pl-version').textContent = pl.version;
+            document.getElementById('pl-date').textContent = new Date(pl.created_at).toLocaleDateString('ru-RU');
+            document.getElementById('pl-author').textContent = pl.created_by || '-';
+            document.getElementById('pl-items').textContent = pl.item_count;
+            document.getElementById('pl-usage').textContent = pl.usage_count;
+
+            // Show notification if present and pricelist is active
+            const notificationEl = document.getElementById('pl-notification');
+            if (pl.notification && pl.is_active) {
+                notificationEl.textContent = pl.notification;
+                notificationEl.classList.remove('hidden');
+            } else {
+                notificationEl.classList.add('hidden');
+            }
+
+            const statusClass = pl.is_active ? 'text-green-600' : 'text-gray-600';
+            document.getElementById('pl-status').innerHTML = `<span class="${statusClass}">${pl.is_active ? 'Активен' : 'Неактивен'}</span>`;
+
+            if (pl.expires_at) {
+                document.getElementById('pl-expires').textContent = new Date(pl.expires_at).toLocaleDateString('ru-RU');
+            } else {
+                document.getElementById('pl-expires').textContent = '-';
+            }
+        } catch (e) {
+            document.getElementById('page-title').textContent = 'Ошибка';
+            showToast('Прайслист не найден', 'error');
+        }
+    }
+
+    async function loadItems(page = 1) {
+        currentPage = page;
+        try {
+            let url = `/api/pricelists/${pricelistId}/items?page=${page}&per_page=50`;
+            if (searchQuery) {
+                url += `&search=${encodeURIComponent(searchQuery)}`;
+            }
+
+            const resp = await fetch(url);
+            const data = await resp.json();
+
+            renderItems(data.items || []);
+            renderItemsPagination(data.total, data.page, data.per_page);
+        } catch (e) {
+            document.getElementById('items-body').innerHTML = `
+                <tr>
+                    <td colspan="5" class="px-6 py-4 text-center text-red-500">
+                        Ошибка загрузки: ${e.message}
+                    </td>
+                </tr>
+            `;
+        }
+    }
+
+    function formatPriceSettings(item) {
+        // Format price settings to match admin pricing interface style
+        let settings = [];
+        const hasManualPrice = item.manual_price && item.manual_price > 0;
+        const hasMeta = item.meta_prices && item.meta_prices.trim() !== '';
+
+        // Method indicator
+        if (hasManualPrice) {
+            settings.push('<span class="text-orange-600 font-medium">РУЧН</span>');
+        } else if (item.price_method === 'average') {
+            settings.push('Сред');
+        } else {
+            settings.push('Мед');
+        }
+
+        // Period (only if not manual price)
+        if (!hasManualPrice) {
+            const period = item.price_period_days !== undefined && item.price_period_days !== null ? item.price_period_days : 90;
+            if (period === 7) settings.push('1н');
+            else if (period === 30) settings.push('1м');
+            else if (period === 90) settings.push('3м');
+            else if (period === 365) settings.push('1г');
+            else if (period === 0) settings.push('все');
+            else settings.push(period + 'д');
+        }
+
+        // Coefficient
+        if (item.price_coefficient && item.price_coefficient !== 0) {
+            settings.push((item.price_coefficient > 0 ? '+' : '') + item.price_coefficient + '%');
+        }
+
+        // Meta article indicator
+        if (hasMeta) {
+            settings.push('<span class="text-purple-600 font-medium">МЕТА</span>');
+        }
+
+        return settings.join(' | ') || '-';
+    }
+
+    function renderItems(items) {
+        if (items.length === 0) {
+            document.getElementById('items-body').innerHTML = `
+                <tr>
+                    <td colspan="5" class="px-6 py-4 text-center text-gray-500">
+                        ${searchQuery ? 'Ничего не найдено' : 'Позиции не найдены'}
+                    </td>
+                </tr>
+            `;
+            return;
+        }
+
+        const html = items.map(item => {
+            const price = item.price.toLocaleString('en-US', { minimumFractionDigits: 2, maximumFractionDigits: 2 });
+            const description = item.lot_description || '-';
+            const truncatedDesc = description.length > 60 ? description.substring(0, 60) + '...' : description;
+
+            return `
+                <tr class="hover:bg-gray-50">
+                    <td class="px-6 py-3 whitespace-nowrap">
+                        <span class="font-mono text-sm">${item.lot_name}</span>
+                    </td>
+                    <td class="px-6 py-3 whitespace-nowrap">
+                        <span class="px-2 py-1 text-xs bg-gray-100 rounded">${item.category || '-'}</span>
+                    </td>
+                    <td class="px-6 py-3 text-sm text-gray-500" title="${description}">${truncatedDesc}</td>
+                    <td class="px-6 py-3 whitespace-nowrap text-right font-mono">${price}</td>
+                    <td class="px-6 py-3 whitespace-nowrap text-sm"><span class="text-xs bg-gray-100 px-2 py-1 rounded">${formatPriceSettings(item)}</span></td>
+                </tr>
+            `;
+        }).join('');
+
+        document.getElementById('items-body').innerHTML = html;
+    }
+
+    function renderItemsPagination(total, page, perPage) {
+        const totalPages = Math.ceil(total / perPage);
+        const start = (page - 1) * perPage + 1;
+        const end = Math.min(page * perPage, total);
+
+        document.getElementById('items-info').textContent = `${start}-${end} из ${total}`;
+
+        if (totalPages <= 1) {
+            document.getElementById('items-pages').innerHTML = '';
+            return;
+        }
+
+        let html = '';
+
+        // Previous button
+        if (page > 1) {
+            html += `<button onclick="loadItems(${page - 1})" class="px-2 py-1 text-sm text-gray-600 hover:text-gray-900">&larr;</button>`;
+        }
+
+        // Page numbers (show max 5 pages)
+        const startPage = Math.max(1, page - 2);
+        const endPage = Math.min(totalPages, startPage + 4);
+
+        for (let i = startPage; i <= endPage; i++) {
+            const activeClass = i === page ? 'bg-blue-600 text-white' : 'bg-white text-gray-700 hover:bg-gray-50';
+            html += `<button onclick="loadItems(${i})" class="px-3 py-1 text-sm rounded border ${activeClass}">${i}</button>`;
+        }
+
+        // Next button
+        if (page < totalPages) {
+            html += `<button onclick="loadItems(${page + 1})" class="px-2 py-1 text-sm text-gray-600 hover:text-gray-900">&rarr;</button>`;
+        }
+
+        document.getElementById('items-pages').innerHTML = html;
+    }
+
+    document.getElementById('search-input').addEventListener('input', function(e) {
+        clearTimeout(searchTimeout);
+        searchTimeout = setTimeout(() => {
+            searchQuery = e.target.value.trim();
+            loadItems(1);
+        }, 300);
+    });
+
+    document.addEventListener('DOMContentLoaded', function() {
+        loadPricelistInfo();
+        loadItems(1);
+    });
+</script>
+{{end}}
+
+{{template "base" .}}

web/templates/pricelists.html

@@ -0,0 +1,234 @@
+{{define "title"}}Прайслисты - QuoteForge{{end}}
+
+{{define "content"}}
+<div class="space-y-6">
+    <div class="flex justify-between items-center">
+        <h1 class="text-2xl font-bold text-gray-900">Прайслисты</h1>
+        <div id="create-btn-container"></div>
+    </div>
+
+    <div class="bg-white rounded-lg shadow overflow-hidden">
+        <table class="min-w-full divide-y divide-gray-200">
+            <thead class="bg-gray-50">
+                <tr>
+                    <th class="px-6 py-3 text-left text-xs font-medium text-gray-500 uppercase">Версия</th>
+                    <th class="px-6 py-3 text-left text-xs font-medium text-gray-500 uppercase">Дата</th>
+                    <th class="px-6 py-3 text-left text-xs font-medium text-gray-500 uppercase">Автор</th>
+                    <th class="px-6 py-3 text-center text-xs font-medium text-gray-500 uppercase">Позиций</th>
+                    <th class="px-6 py-3 text-center text-xs font-medium text-gray-500 uppercase">Исп.</th>
+                    <th class="px-6 py-3 text-center text-xs font-medium text-gray-500 uppercase">Статус</th>
+                    <th class="px-6 py-3 text-right text-xs font-medium text-gray-500 uppercase">Действия</th>
+                </tr>
+            </thead>
+            <tbody id="pricelists-body" class="bg-white divide-y divide-gray-200">
+                <tr>
+                    <td colspan="7" class="px-6 py-4 text-center text-gray-500">Загрузка...</td>
+                </tr>
+            </tbody>
+        </table>
+    </div>
+
+    <div id="pagination" class="flex justify-center space-x-2"></div>
+</div>
+
+<!-- Create Modal -->
+<div id="create-modal" class="fixed inset-0 bg-black bg-opacity-50 hidden items-center justify-center z-50">
+    <div class="bg-white rounded-lg p-6 max-w-md w-full mx-4">
+        <h2 class="text-xl font-bold mb-4">Создать прайслист</h2>
+        <p class="text-sm text-gray-600 mb-4">
+            Будет создан снимок текущих цен из базы данных.<br>
+            Автор прайслиста: <span id="db-username" class="font-medium">загрузка...</span>
+        </p>
+        <form id="create-form" class="space-y-4">
+            <div class="flex justify-end space-x-3">
+                <button type="button" onclick="closeCreateModal()"
+                        class="px-4 py-2 text-gray-700 border border-gray-300 rounded-md hover:bg-gray-50">
+                    Отмена
+                </button>
+                <button type="submit"
+                        class="px-4 py-2 bg-blue-600 text-white rounded-md hover:bg-blue-700">
+                    Создать
+                </button>
+            </div>
+        </form>
+    </div>
+</div>
+
+<script>
+    let canWrite = false;
+    let currentPage = 1;
+
+    async function checkPricelistWritePermission() {
+        try {
+            const resp = await fetch('/api/pricelists/can-write');
+            const data = await resp.json();
+            canWrite = data.can_write;
+
+            if (canWrite) {
+                document.getElementById('create-btn-container').innerHTML = `
+                    <button onclick="openCreateModal()" class="px-4 py-2 bg-blue-600 text-white rounded-md hover:bg-blue-700">
+                        Создать прайслист
+                    </button>
+                `;
+            }
+        } catch (e) {
+            console.error('Failed to check pricelist write permission:', e);
+        }
+    }
+
+    async function loadPricelists(page = 1) {
+        currentPage = page;
+        try {
+            const resp = await fetch(`/api/pricelists?page=${page}&per_page=20`);
+            const data = await resp.json();
+
+            renderPricelists(data.pricelists || []);
+            renderPagination(data.total, data.page, data.per_page);
+        } catch (e) {
+            document.getElementById('pricelists-body').innerHTML = `
+                <tr>
+                    <td colspan="7" class="px-6 py-4 text-center text-red-500">
+                        Ошибка загрузки: ${e.message}
+                    </td>
+                </tr>
+            `;
+        }
+    }
+
+    function renderPricelists(pricelists) {
+        if (pricelists.length === 0) {
+            document.getElementById('pricelists-body').innerHTML = `
+                <tr>
+                    <td colspan="7" class="px-6 py-4 text-center text-gray-500">
+                        Прайслисты не найдены. ${canWrite ? 'Создайте первый прайслист.' : ''}
+                    </td>
+                </tr>
+            `;
+            return;
+        }
+
+        const html = pricelists.map(pl => {
+            const date = new Date(pl.created_at).toLocaleDateString('ru-RU');
+            const statusClass = pl.is_active ? 'bg-green-100 text-green-800' : 'bg-gray-100 text-gray-800';
+            const statusText = pl.is_active ? 'Активен' : 'Неактивен';
+
+            let actions = `<a href="/pricelists/${pl.id}" class="text-blue-600 hover:text-blue-800 text-sm">Просмотр</a>`;
+            if (canWrite && pl.usage_count === 0) {
+                actions += ` <button onclick="deletePricelist(${pl.id})" class="text-red-600 hover:text-red-800 text-sm ml-2">Удалить</button>`;
+            }
+
+            return `
+                <tr class="hover:bg-gray-50">
+                    <td class="px-6 py-4 whitespace-nowrap">
+                        <span class="font-mono text-sm">${pl.version}</span>
+                    </td>
+                    <td class="px-6 py-4 whitespace-nowrap text-sm text-gray-500">${date}</td>
+                    <td class="px-6 py-4 whitespace-nowrap text-sm text-gray-500">${pl.created_by || '-'}</td>
+                    <td class="px-6 py-4 whitespace-nowrap text-center text-sm">${pl.item_count}</td>
+                    <td class="px-6 py-4 whitespace-nowrap text-center text-sm">${pl.usage_count}</td>
+                    <td class="px-6 py-4 whitespace-nowrap text-center">
+                        <span class="px-2 py-1 text-xs rounded-full ${statusClass}">${statusText}</span>
+                    </td>
+                    <td class="px-6 py-4 whitespace-nowrap text-right">${actions}</td>
+                </tr>
+            `;
+        }).join('');
+
+        document.getElementById('pricelists-body').innerHTML = html;
+    }
+
+    function renderPagination(total, page, perPage) {
+        const totalPages = Math.ceil(total / perPage);
+        if (totalPages <= 1) {
+            document.getElementById('pagination').innerHTML = '';
+            return;
+        }
+
+        let html = '';
+        for (let i = 1; i <= totalPages; i++) {
+            const activeClass = i === page ? 'bg-blue-600 text-white' : 'bg-white text-gray-700 hover:bg-gray-50';
+            html += `<button onclick="loadPricelists(${i})" class="px-3 py-1 rounded border ${activeClass}">${i}</button>`;
+        }
+
+        document.getElementById('pagination').innerHTML = html;
+    }
+
+    async function loadDbUsername() {
+        try {
+            const resp = await fetch('/api/current-user');
+            const data = await resp.json();
+            document.getElementById('db-username').textContent = data.username || 'неизвестно';
+        } catch (e) {
+            document.getElementById('db-username').textContent = 'неизвестно';
+        }
+    }
+
+    function openCreateModal() {
+        document.getElementById('create-modal').classList.remove('hidden');
+        document.getElementById('create-modal').classList.add('flex');
+        loadDbUsername();
+    }
+
+    function closeCreateModal() {
+        document.getElementById('create-modal').classList.add('hidden');
+        document.getElementById('create-modal').classList.remove('flex');
+    }
+
+    async function createPricelist() {
+        const resp = await fetch('/api/pricelists', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify({})
+        });
+
+        if (!resp.ok) {
+            const data = await resp.json();
+            throw new Error(data.error || 'Failed to create pricelist');
+        }
+
+        return await resp.json();
+    }
+
+    async function deletePricelist(id) {
+        if (!confirm('Удалить этот прайслист?')) return;
+
+        try {
+            const resp = await fetch(`/api/pricelists/${id}`, {
+                method: 'DELETE'
+            });
+
+            if (!resp.ok) {
+                const data = await resp.json();
+                throw new Error(data.error || 'Failed to delete');
+            }
+
+            showToast('Прайслист удален', 'success');
+            loadPricelists(currentPage);
+        } catch (e) {
+            showToast('Ошибка: ' + e.message, 'error');
+        }
+    }
+
+    document.getElementById('create-form').addEventListener('submit', async function(e) {
+        e.preventDefault();
+
+        try {
+            const pl = await createPricelist();
+            closeCreateModal();
+            showToast(`Прайслист ${pl.version} создан (${pl.item_count} позиций)`, 'success');
+            loadPricelists(1);
+        } catch (e) {
+            showToast('Ошибка: ' + e.message, 'error');
+        }
+    });
+
+    document.addEventListener('DOMContentLoaded', function() {
+        checkPricelistWritePermission();
+        loadPricelists(1);
+    });
+</script>
+{{end}}
+
+{{template "base" .}}

web/templates/setup.html

@@ -0,0 +1,201 @@
+{{define "setup.html"}}
+<!DOCTYPE html>
+<html lang="ru">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>QuoteForge - Настройка подключения</title>
+    <script src="https://cdn.tailwindcss.com"></script>
+</head>
+<body class="bg-gray-100 min-h-screen flex items-center justify-center">
+    <div class="max-w-md w-full mx-4">
+        <div class="bg-white rounded-lg shadow-lg p-8">
+            <div class="text-center mb-8">
+                <h1 class="text-2xl font-bold text-blue-600">QuoteForge</h1>
+                <p class="text-gray-600 mt-2">Настройка подключения к базе данных</p>
+            </div>
+
+            <form id="setup-form" class="space-y-4">
+                <div>
+                    <label class="block text-sm font-medium text-gray-700 mb-1">Хост сервера</label>
+                    <input type="text" name="host" id="host"
+                           value="{{if .Settings}}{{.Settings.Host}}{{else}}localhost{{end}}"
+                           class="w-full px-3 py-2 border border-gray-300 rounded-md focus:outline-none focus:ring-2 focus:ring-blue-500"
+                           placeholder="localhost или IP-адрес">
+                </div>
+
+                <div>
+                    <label class="block text-sm font-medium text-gray-700 mb-1">Порт</label>
+                    <input type="number" name="port" id="port"
+                           value="{{if .Settings}}{{.Settings.Port}}{{else}}3306{{end}}"
+                           class="w-full px-3 py-2 border border-gray-300 rounded-md focus:outline-none focus:ring-2 focus:ring-blue-500"
+                           placeholder="3306">
+                </div>
+
+                <div>
+                    <label class="block text-sm font-medium text-gray-700 mb-1">База данных</label>
+                    <input type="text" name="database" id="database"
+                           value="{{if .Settings}}{{.Settings.Database}}{{else}}RFQ_LOG{{end}}"
+                           class="w-full px-3 py-2 border border-gray-300 rounded-md focus:outline-none focus:ring-2 focus:ring-blue-500"
+                           placeholder="RFQ_LOG">
+                </div>
+
+                <div>
+                    <label class="block text-sm font-medium text-gray-700 mb-1">Пользователь</label>
+                    <input type="text" name="user" id="user"
+                           value="{{if .Settings}}{{.Settings.User}}{{end}}"
+                           class="w-full px-3 py-2 border border-gray-300 rounded-md focus:outline-none focus:ring-2 focus:ring-blue-500"
+                           placeholder="username">
+                </div>
+
+                <div>
+                    <label class="block text-sm font-medium text-gray-700 mb-1">Пароль</label>
+                    <input type="password" name="password" id="password"
+                           class="w-full px-3 py-2 border border-gray-300 rounded-md focus:outline-none focus:ring-2 focus:ring-blue-500"
+                           placeholder="{{if .Settings}}********{{else}}password{{end}}">
+                    {{if .Settings}}
+                    <p class="text-xs text-gray-500 mt-1">Оставьте пустым, чтобы сохранить текущий пароль</p>
+                    {{end}}
+                </div>
+
+                <div id="status" class="hidden p-3 rounded-md text-sm"></div>
+
+                <div class="flex space-x-3 pt-4">
+                    {{if .Settings}}
+                    <a href="/"
+                       class="flex-1 px-4 py-2 bg-gray-100 text-gray-700 rounded-md hover:bg-gray-200 transition text-center">
+                        Назад
+                    </a>
+                    {{end}}
+                    <button type="button" onclick="testConnection()"
+                            class="flex-1 px-4 py-2 bg-gray-100 text-gray-700 rounded-md hover:bg-gray-200 transition">
+                        Проверить
+                    </button>
+                    <button type="submit"
+                            class="flex-1 px-4 py-2 bg-blue-600 text-white rounded-md hover:bg-blue-700 transition">
+                        Сохранить
+                    </button>
+                </div>
+            </form>
+        </div>
+
+        <p class="text-center text-gray-500 text-sm mt-4">
+            QuoteForge v1.0 - Конфигуратор серверов
+        </p>
+    </div>
+
+    <script>
+        function showStatus(message, type) {
+            const status = document.getElementById('status');
+            status.classList.remove('hidden', 'bg-green-100', 'text-green-800', 'bg-red-100', 'text-red-800', 'bg-blue-100', 'text-blue-800', 'bg-yellow-100', 'text-yellow-800');
+
+            if (type === 'success') {
+                status.classList.add('bg-green-100', 'text-green-800');
+            } else if (type === 'error') {
+                status.classList.add('bg-red-100', 'text-red-800');
+            } else if (type === 'warning') {
+                status.classList.add('bg-yellow-100', 'text-yellow-800');
+            } else {
+                status.classList.add('bg-blue-100', 'text-blue-800');
+            }
+
+            status.textContent = message;
+        }
+
+        async function testConnection() {
+            showStatus('Проверка подключения...', 'info');
+
+            const formData = new FormData(document.getElementById('setup-form'));
+
+            try {
+                const resp = await fetch('/setup/test', {
+                    method: 'POST',
+                    body: formData
+                });
+                const data = await resp.json();
+
+                if (data.success) {
+                    let msg = data.message;
+                    if (data.can_write) {
+                        msg += ' Права на запись: есть.';
+                    } else {
+                        msg += ' Права на запись: только чтение.';
+                    }
+                    showStatus(msg, 'success');
+                } else {
+                    showStatus(data.error, 'error');
+                }
+            } catch (e) {
+                showStatus('Ошибка сети: ' + e.message, 'error');
+            }
+        }
+
+        async function checkServerReady() {
+            let attempts = 0;
+            const maxAttempts = 30; // 30 seconds max
+
+            const checkInterval = setInterval(async () => {
+                attempts++;
+                try {
+                    const resp = await fetch('/health', { method: 'GET' });
+                    const data = await resp.json();
+
+                    // Check if we're out of setup mode
+                    if (data.status === 'ok') {
+                        clearInterval(checkInterval);
+                        showStatus('✓ Приложение запущено! Перенаправление...', 'success');
+                        setTimeout(() => {
+                            window.location.href = '/';
+                        }, 1000);
+                    }
+                } catch (e) {
+                    // Server still restarting, continue polling
+                    if (attempts >= maxAttempts) {
+                        clearInterval(checkInterval);
+                        showStatus('Сервер не отвечает. Обновите страницу вручную.', 'error');
+                    }
+                }
+            }, 1000); // Check every second
+        }
+
+        document.getElementById('setup-form').addEventListener('submit', async function(e) {
+            e.preventDefault();
+            showStatus('Сохранение настроек...', 'info');
+
+            const formData = new FormData(this);
+
+            try {
+                const resp = await fetch('/setup', {
+                    method: 'POST',
+                    body: formData
+                });
+                const data = await resp.json();
+
+                if (data.success) {
+                    showStatus('✓ ' + data.message, 'success');
+
+                    // Check if restart is required
+                    if (data.restart_required) {
+                        // In normal mode, restart must be done manually
+                        setTimeout(() => {
+                            showStatus('⚠️ Пожалуйста, перезапустите приложение вручную для применения изменений', 'warning');
+                        }, 2000);
+                    } else {
+                        // In setup mode, auto-restart is happening
+                        setTimeout(() => {
+                            showStatus('✓ Настройки сохранены. Проверка подключения...', 'success');
+                            // Poll until server is back
+                            checkServerReady();
+                        }, 2000);
+                    }
+                } else {
+                    showStatus(data.error, 'error');
+                }
+            } catch (e) {
+                showStatus('Ошибка сети: ' + e.message, 'error');
+            }
+        });
+    </script>
+</body>
+</html>
+{{end}}