poniższa dokomentacja powstała w oparciu o plik: todo.md pierwotny szkic znajdueje sie w pliku: rpi_3_chat_stack_with_caddy.md poniżej dokumentacja, stanowiąca zarys projektu do wygenerowania:

Mova to lekka, uniwersalna warstwa komunikacji łącząca frontend, backend, urządzenia IoT, systemy embedowane i modele LLM. Umożliwia wymianę komend shell, akcji formularzy, logów, metadanych audio/video oraz dowolnego kodu JavaScript w przeglądarce. Kluczowe cechy:

• Zastępuje Socket.IO i WebRTC Data Channels jednym, spójnym protokołem RPC/HTTP/WebSocket/MQTT
• Obsługuje środowiska od prostych aplikacji webowych po mikrokontrolery (Raspberry Pi, RP2040, Arduino)
• Pliki SVG służą jako kontener aplikacji PWA z osadzonymi metadanymi i skryptem JS SDK
• Offline buffer w LocalStorage i synchronizacja z MQTT lub bazą danych (SQLite/Postgres)
• Modularne adaptery: HTTP, WebSocket, MQTT, SSH, gRPC
• CLI mova z komendami do wykonywania shell, publikowania logów, listowania i filtrowania zdarzeń
• Nowa komenda mova http pozwala zdalnie wykonywać kod JS w oknie przeglądarki z SDK

mova/
│
├── cli/
│   ├── mova.py                # Główny skrypt CLI w Pythonie
│   ├── commands/
│   │   ├── shell.py           # Obsługa komend shell
│   │   ├── log.py             # Komendy logowania (info, warning, error)
│   │   └── http.py            # Komenda HTTP do JS-exec
│   └── config.py              # Parsowanie konfiguracji JSON/YAML
│
├── server/
│   ├── app.py                 # Serwer RPC/HTTP/WebSocket
│   ├── rpc.py                 # Logika RPC i routing
│   ├── mqtt_adapter.py        # Adapter MQTT (publish/subscribe)
│   └── storage/
│       ├── storage.py         # Abstrakcja bazy danych (SQLite/Postgres)
│       └── local_storage.py   # LocalStorage fallback dla offline
│
├── sdk/
│   ├── mova-sdk.js            # Klient JS do osadzenia w HTML/SVG
│   ├── handlers.js            # Handler HTTP-exec, shell, log
│   └── README.md              # Instrukcja integracji SDK w frontend
│
├── svg/
│   ├── app.svg                # Szablon SVG kontenera aplikacji
│   └── metadata.json          # Przykładowe metadane osadzone w SVG
│
├── examples/
│   ├── frontend/
│   │   └── index.svg          # Przykład chatu SVG z SDK
│   ├── backend/
│   │   └── diagnostic.py      # Demo diagnostyki z SQLite
│   └── iot/
│       └── rpi_demo.py        # Demo shell na Raspberry Pi
│
├── config/
│   ├── default.json           # Domyślna konfiguracja pakietu
│   └── filters.yaml           # Przykładowy DSL do filtrowania logów
│
├── docs/
│   ├── architecture.md        # Opis architektury i diagramy ASCII/Mermaid
│   ├── getting_started.md     # Instrukcja uruchomienia i użycia
│   └── development.md         # Wytyczne rozwoju, TODO i roadmapa
│
├── tests/
│   ├── test_cli.py            # Testy jednostkowe CLI
│   ├── test_server.py         # Testy logiki serwera RPC
│   └── test_sdk.js            # Testy integracyjne SDK
│
├── Dockerfile                 # Definicja obrazu Docker
├── docker-compose.yml         # Kompozycja Ollama, MQTT, Mova
├── pyproject.toml             # Konfiguracja paczki Python
└── package.json               # Konfiguracja paczki Node.js

Główne przesłanie: Mova dostarcza uniwersalną, lekką i konfigurowalną warstwę komunikacji między frontendem, backendem, sprzętem IoT i LLM, eliminując złożoność ręcznego łączenia Socket.IO, WebRTC, SSH, MQTT lub RPC.

1. Cel i zakres

   • Komunikacja usług ↔ LLM ↔ użytkownik
   • Zastąpienie Socket.IO + WebRTC Data Channels
   • Obsługa od jednego noda do rozbudowanej architektury (web, backend, firmware, IoT)
   • Przesyłanie akcji formularzy, komend shell i metadanych (logi, adnotacje audio/video)
   • Format kontenera: plik SVG z osadzonymi danymi i skryptem JS

2. Komponenty

   • Rdzeń (Python/C) – serwer RPC + broker komunikacji
   • SDK JS – integracja w przeglądarce, nasłuchiwanie i modyfikacja DOM SVG
   • CLI (mova) – wygodne wywoływanie komend shell, logowanie i publikowanie MQTT
   • Kontener SVG – aplikacja PWA + metadane + logika JS

3. Architektura

   • Konfiguracja JSON/YAML definiująca źródła logów, brokerów, magazyn danych
   • Wybór kontenera danych: LocalStorage (frontend) ⟷ SQLite/PostgreSQL (backend)
   • Modularne adaptery: MQTT, WebSocket, HTTP, SSH, gRPC

4. Przykładowy przepływ

   1. Użytkownik wpisuje komendę w konsoli przeglądarki (JS SDK nasłuchuje)
   2. SDK wysyła request do usługi mova (HTTP/WebSocket)
   3. Usługa wykonuje komendę shell lub wywołanie LLM (np. Ollama Mistral 7B)
   4. Wynik opakowywany w strukturę JSON i wstrzykiwany do pliku SVG (DOM)
   5. SVG renderuje nowy interfejs, użytkownik widzi odpowiedź i kontynuuje interakcję

1. Zainstalować Dockera i Python 3.11+
2. Pobrać repozytorium i wejść do katalogu projektu
3. Uruchomić:

   docker compose up -

Uruchamia Ollama Mistral 7B, serwis mova i przykładowe MQTT

make server && make demo-all && make demo-advanced

📊 Available frontend applications: • http://localhost:8094/examples/frontend/index.svg - SVG Chat Interface • http://localhost:8094/examples/frontend/real-time-chat.html - Real-time Chat App • http://localhost:8094/examples/frontend/iot-monitoring-dashboard.html - IoT Dashboard • http://localhost:8094/examples/frontend/system-analytics-dashboard.html - Analytics Dashboard • http://localhost:8094/examples/frontend/rss-dashboard.html - RSS Dashboard • http://localhost:8094/examples/frontend/integration-test.html - SDK Integration Tests • http://localhost:8094/sdk/mova-sdk.js - Dynamic Mova SDK

1. Dołączyć mova-sdk.js w pliku HTML zawierającym <object type="image/svg+xml" data="app.svg"></object>
2. Skonfigurować połączenie:

   Mova.init({
     serverUrl: 'http://localhost:8080',
     broker: { type: 'mqtt', url: 'ws://localhost:1883' }
   });
   Mova.on('command', cmd => console.log('Otrzymano:', cmd));

3. Wysłanie komendy:

   Mova.send({ type: 'shell', payload: 'ls -la /' });

1. Instalacja:

   pip install mova

2. Przykłady:

   mova shell "docker ps"
   mova list error --last 5m
   mova info "Test log"
   mova warning --mqtt-broker localhost:1883 --mqtt-topic logs "Ostrzeżenie MQTT"

mova read all --last 1h --limit 10

# Podstawowe komendy z filtrowaniem czasowym
mova read error --last 10m     # Błędy z ostatnich 10 minut  
mova read info --last 1h       # Info z ostatniej godziny
mova read all --last 30s       # Wszystkie z ostatnich 30 sekund

# Tryb ciągłego monitorowania 
mova read all --watch          # Monitoring w czasie rzeczywistym
mova read error --watch --interval 5  # Co 5 sekund

# Zaawansowane filtrowanie
mova read info --service "web-server" --last 2h
mova read all --format json --limit 100
mova read warning --format detailed --last 1d

 ┌─────────────┐      HTTP/WebSocket      ┌──────────────┐
 │  Frontend   │ ⇄──────────────────────>│   Mova RPC   │
 │ (JS SDK +   │                        │  Server      │
 │  SVG PWA)   │                        └──────┬───────┘
 └─────────────┘                               │
                                               │ Shell / LLM
                                           ┌───▼────────┐
                                           │  System &  │
                                           │  Ollama    │
                                           └────────────┘

flowchart LR
  A[Przeglądarka<br/>JS SDK + SVG] -- HTTP --> B[Mova RPC Server]
  B -- shell/LLM --> C[System / Ollama]
  B -- MQTT --> D[Broker MQTT]
  B -- DB --> E[SQLite/Postgres]

# w konsoli przeglądarki
mova shell "echo 'Witaj z MOVA!'"

• SVG nasłuchuje odpowiedzi i dynamicznie zmienia DOM, wyświetlając przycisk „Restartuj” po wykryciu błędu.

Mova.init({ broker: { url: 'ws://brak', fallback: 'localStorage' } });
console.log('Test');

• console.log automatycznie przechwycone i zapisane w LocalStorage, wysłane do brokera po przywróceniu połączenia.

mova shell "docker-compose restart"
mova list info --service webapp --last 10m

• Automatyczne filtrowanie i przekierowanie logów do SQLite, z możliwością wyświetlenia w przeglądarce.

• Zero-config: wykrywanie źródeł logów (JS console, syslog, Docker) bez konfiguracji
• Dekoratory Python:

  @mova.log(service='api')
  def fetch_data(): pass

• Moduł wyszukiwania: prosty DSL w YAML do filtracji i triggerów:

  filters:
    - source: 'error'
      contains: 'timeout'
      action: notify

• Pluginy: dodanie głosowego logowania (ASR → tekst → Mova)
• Monitoring stron: prosty watcher HTTP, sygnalizujący zmiany w logach Mova

1. Ukończyć moduły pakietów: Python, Node.js, PHP
2. Napisać adapter MQTT + WebSocket + HTTP
3. Przygotować 3 demo:
   • Frontend chat SVG
   • Backend diagnostyka z SQLite
   • IoT (Raspberry Pi) → shell
4. Ujednolicić konfigurację (JSON/YAML)
5. Rozbudować DSL filtrowania i wyszukiwania logów
6. Stworzyć pełną dokumentację i tutorial video

Mova łączy w sobie elastyczność i prostotę, zapewniając modułową warstwę komunikacji dla dowolnych środowisk – od przeglądarki po mikrokontrolery.

Dodanie do narzędzia mova możliwości wykonywania fragmentów kodu JavaScript bezpośrednio w oknie przeglądarki posiadającej załadowany klient SDK JS Mova.

1. W pliku CLI (cli.py / mova.js) dodać nową komendę http:

   mova http [--port <port>] <adres> "<kod_js>"

2. Komenda otwiera połączenie HTTP do serwera Mova na wskazanym porcie i wysyła wiadomość z typem http-exec.
3. Po stronie SDK JS dodać handler:

   Mova.on('http-exec', ({ payload }) => {
     try {
       new Function(payload)();
     } catch (e) {
       console.error('Błąd wykonania:', e);
     }
   });

4. Umożliwi to zdalne wywołanie dowolnego kodu JS w oknie przeglądarki.

W terminalu uruchom:

mova http --port 8081 localhost "console.log('Witaj z MOVA!'); alert('treść komunikatu');"

• --port 8081 – numer portu, na którym działa serwer Mova
• localhost – adres hosta ze stroną zawierającą mova-sdk.js i SVG PWA
• Wysłany kod JS wyświetli w konsoli komunikat i wywoła okienko alert w przeglądarce

• Dodano komendę http do CLI Mova
• Zdefiniowano format wiadomości http-exec
• Rozszerzono SDK JS o obsługę wykonywania przekazanego kodu
• Przykład:

  mova http --port 8081 localhost "console.log('Witaj z MOVA!'); alert('treść komunikatu');"