release: bump version to 0.0.1.6

android/android/app/build.gradle

@@ -80,7 +80,7 @@ android {
         minSdkVersion rootProject.ext.minSdkVersion
         targetSdkVersion rootProject.ext.targetSdkVersion
         versionCode 1
-        versionName "1.0"
+        versionName "0.0.1.6"
         // Fallback fuer Libraries mit Product Flavors
         missingDimensionStrategy 'react-native-camera', 'general'
     }

android/android/app/build/intermediates/incremental/packageRelease/tmp/release/dex-renamer-state.txt

@@ -1,4 +1,4 @@
-#Sun Mar 29 12:50:35 CEST 2026
+#Sun Mar 29 13:21:34 CEST 2026
 base.2=/home/duffy/Dokumente/programmierung/ARIA-AGENT/android/android/app/build/intermediates/dex/release/mergeDexRelease/classes2.dex
 path.2=classes2.dex
 base.1=/home/duffy/Dokumente/programmierung/ARIA-AGENT/android/android/app/build/intermediates/global_synthetics_dex/release/classes.dex

android/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aria-cockpit",
-  "version": "0.1.0",
+  "version": "0.0.1.6",
   "private": true,
   "scripts": {
     "android": "react-native run-android",

android/src/screens/ChatScreen.tsx

@@ -125,7 +125,30 @@ const ChatScreen: React.FC = () => {
         isInitialLoad.current = false;
       }
     };
-    loadMessages();
+    loadMessages().then(async () => {
+      // Auto-Re-Download: fehlende Anhänge vom Server nachladen (wenn aktiviert)
+      const autoDownload = await AsyncStorage.getItem('aria_auto_download');
+      if (autoDownload === 'false') return;
+      setTimeout(() => {
+        setMessages(prev => {
+          const missing: {id: string, serverPath: string}[] = [];
+          for (const msg of prev) {
+            for (const att of msg.attachments || []) {
+              if (att.serverPath && !att.uri) {
+                missing.push({ id: msg.id, serverPath: att.serverPath });
+              }
+            }
+          }
+          if (missing.length > 0) {
+            console.log(`[Chat] ${missing.length} fehlende Anhaenge — lade nach...`);
+            for (const m of missing) {
+              rvs.send('file_request' as any, { serverPath: m.serverPath, requestId: m.id });
+            }
+          }
+          return prev;
+        });
+      }, 2000); // Warten bis RVS verbunden ist
+    });
   }, []);
 
   // RVS-Nachrichten abonnieren
@@ -165,27 +188,23 @@ const ChatScreen: React.FC = () => {
         return;
       }
 
-      // STT-Ergebnis: Spracheingabe-Placeholder mit transkribiertem Text ersetzen
-      if (message.type === 'stt_result') {
-        const sttText = (message.payload.text as string) || '';
-        if (sttText) {
-          setMessages(prev => prev.map(m =>
-            m.sender === 'user' && m.text.includes('Spracheingabe wird verarbeitet')
-              ? { ...m, text: sttText }
-              : m
-          ));
-        } else {
-          // Keine Sprache erkannt — Placeholder entfernen
-          setMessages(prev => prev.filter(m =>
-            !(m.sender === 'user' && m.text.includes('Spracheingabe wird verarbeitet'))
-          ));
-        }
-        return;
-      }
-
       if (message.type === 'chat') {
-        // Nur Nachrichten von ARIA anzeigen — eigene Nachrichten werden lokal hinzugefuegt
         const sender = (message.payload.sender as string) || '';
+
+        // STT-Ergebnis: Transkribierten Text in die Sprach-Bubble schreiben
+        if (sender === 'stt') {
+          const sttText = (message.payload.text as string) || '';
+          if (sttText) {
+            setMessages(prev => prev.map(m =>
+              m.sender === 'user' && m.text.includes('Spracheingabe wird verarbeitet')
+                ? { ...m, text: `\uD83C\uDFA4 ${sttText}` }
+                : m
+            ));
+          }
+          return;
+        }
+
+        // Eigene Nachrichten ignorieren (werden lokal hinzugefuegt)
         if (sender === 'user' || sender === 'diagnostic') return;
 
         const text = (message.payload.text as string) || '';
@@ -282,20 +301,34 @@ const ChatScreen: React.FC = () => {
     }
   }, [wakeWordActive]);
 
-  // Chat-Verlauf in AsyncStorage speichern (letzte N Nachrichten)
+  // Chat-Verlauf in AsyncStorage speichern (debounced, nur nach initialem Laden)
+  const saveTimer = useRef<ReturnType<typeof setTimeout> | null>(null);
   useEffect(() => {
     if (messages.length === 0 || isInitialLoad.current) return;
-    // Nur file:// URIs speichern, data: URIs rausfiltern (zu gross)
-    const toStore = messages.slice(-MAX_STORED_MESSAGES).map(msg => ({
-      ...msg,
-      attachments: msg.attachments?.map(att => ({
-        ...att,
-        uri: att.uri?.startsWith('file://') ? att.uri : undefined,
-      })),
-    }));
-    AsyncStorage.setItem(CHAT_STORAGE_KEY, JSON.stringify(toStore)).catch(err =>
-      console.error('[Chat] Fehler beim Speichern:', err),
-    );
+    // Debounce: 1s warten damit persistAttachment fertig werden kann
+    if (saveTimer.current) clearTimeout(saveTimer.current);
+    saveTimer.current = setTimeout(() => {
+      const toStore = messages.slice(-MAX_STORED_MESSAGES).map(msg => ({
+        ...msg,
+        attachments: msg.attachments?.map(att => ({
+          ...att,
+          // Nur file:// URIs speichern, data: URIs rausfiltern (zu gross fuer AsyncStorage)
+          uri: att.uri?.startsWith('file://') ? att.uri : undefined,
+        })),
+      }));
+      const json = JSON.stringify(toStore);
+      // Sicherheitscheck: nicht speichern wenn >4MB (AsyncStorage Limit)
+      if (json.length > 4 * 1024 * 1024) {
+        console.warn('[Chat] Speicher zu gross, kuerze auf 100 Nachrichten');
+        const shortened = JSON.stringify(toStore.slice(-100));
+        AsyncStorage.setItem(CHAT_STORAGE_KEY, shortened).catch(() => {});
+      } else {
+        AsyncStorage.setItem(CHAT_STORAGE_KEY, json).catch(err =>
+          console.error('[Chat] Speichern fehlgeschlagen:', err),
+        );
+      }
+    }, 1000);
+    return () => { if (saveTimer.current) clearTimeout(saveTimer.current); };
   }, [messages]);
 
   // Auto-Scroll wird ueber onContentSizeChange der FlatList gesteuert

android/src/screens/SettingsScreen.tsx

@@ -18,6 +18,7 @@ import {
 } from 'react-native';
 import AsyncStorage from '@react-native-async-storage/async-storage';
 import RNFS from 'react-native-fs';
+import DocumentPicker from 'react-native-document-picker';
 import rvs, { ConnectionState, RVSMessage, ConnectionConfig, ConnectionLogEntry } from '../services/rvs';
 import ModeSelector from '../components/ModeSelector';
 import QRScanner from '../components/QRScanner';
@@ -68,6 +69,7 @@ const SettingsScreen: React.FC = () => {
   const [events, setEvents] = useState<EventEntry[]>([]);
   const [connLog, setConnLog] = useState<ConnectionLogEntry[]>(rvs.getConnectionLog());
   const [storagePath, setStoragePath] = useState(DEFAULT_STORAGE_PATH);
+  const [autoDownload, setAutoDownload] = useState(true);
   const [storageSize, setStorageSize] = useState('...');
   const [editingPath, setEditingPath] = useState(false);
   const [tempPath, setTempPath] = useState('');
@@ -82,10 +84,13 @@ const SettingsScreen: React.FC = () => {
       setManualPort(String(config.port));
       setManualToken(config.token);
     }
-    // Speicherpfad laden
+    // Speicherpfad + Auto-Download laden
     AsyncStorage.getItem(STORAGE_PATH_KEY).then(saved => {
       if (saved) setStoragePath(saved);
     });
+    AsyncStorage.getItem('aria_auto_download').then(saved => {
+      if (saved !== null) setAutoDownload(saved === 'true');
+    });
   }, []);
 
   // Speichergroesse berechnen
@@ -115,28 +120,39 @@ const SettingsScreen: React.FC = () => {
     Alert.alert('Gespeichert', `Neuer Speicherort:\n${clean}\n\nWird ab der naechsten Nachricht verwendet.`);
   }, []);
 
-  const storagePaths = [
-    { label: 'App-intern (Standard)', path: DEFAULT_STORAGE_PATH },
-    { label: 'Externer Speicher', path: '/storage/emulated/0/ARIA/attachments' },
-    { label: 'SD-Karte', path: '/storage/sdcard1/ARIA/attachments' },
-    { label: 'Downloads', path: '/storage/emulated/0/Download/ARIA' },
-  ];
-
   const showPathPicker = useCallback(() => {
-    const options = storagePaths.map(p => p.label);
-    options.push('Eigenen Pfad eingeben');
-    options.push('Abbrechen');
-
     Alert.alert(
       'Speicherort waehlen',
       'Wo sollen Anhaenge gespeichert werden?',
       [
-        ...storagePaths.map(p => ({
-          text: p.label,
-          onPress: () => saveStoragePath(p.path),
-        })),
         {
-          text: 'Eigenen Pfad eingeben',
+          text: 'Ordner auswaehlen...',
+          onPress: async () => {
+            try {
+              const result = await DocumentPicker.pickDirectory();
+              if (result?.uri) {
+                // SAF URI decodieren (content://com.android.externalstorage...)
+                const decoded = decodeURIComponent(result.uri);
+                // Versuche einen lesbaren Pfad zu extrahieren
+                const match = decoded.match(/primary[:%]3A(.+)/);
+                const readablePath = match
+                  ? `/storage/emulated/0/${match[1].replace(/%2F|%3A/g, '/')}`
+                  : decoded;
+                saveStoragePath(readablePath);
+              }
+            } catch (e: any) {
+              if (!DocumentPicker.isCancel(e)) {
+                Alert.alert('Fehler', 'Ordnerauswahl fehlgeschlagen');
+              }
+            }
+          },
+        },
+        {
+          text: 'App-intern (Standard)',
+          onPress: () => saveStoragePath(DEFAULT_STORAGE_PATH),
+        },
+        {
+          text: 'Pfad manuell eingeben',
           onPress: () => { setTempPath(storagePath); setEditingPath(true); },
         },
         { text: 'Abbrechen', style: 'cancel' as const },
@@ -429,10 +445,29 @@ const SettingsScreen: React.FC = () => {
       {/* === Speicher === */}
       <Text style={styles.sectionTitle}>Anhang-Speicher</Text>
       <View style={styles.card}>
+        <View style={styles.toggleRow}>
+          <View style={styles.toggleInfo}>
+            <Text style={styles.toggleLabel}>Auto-Download</Text>
+            <Text style={styles.toggleHint}>
+              Fehlende Anhaenge beim App-Start automatisch vom Server laden
+            </Text>
+          </View>
+          <Switch
+            value={autoDownload}
+            onValueChange={(val) => {
+              setAutoDownload(val);
+              AsyncStorage.setItem('aria_auto_download', String(val));
+            }}
+            trackColor={{ false: '#2A2A3E', true: '#0096FF' }}
+            thumbColor={autoDownload ? '#FFFFFF' : '#666680'}
+          />
+        </View>
+
+        <View style={{height: 16}} />
         <Text style={styles.toggleLabel}>Lokaler Speicherort</Text>
         <Text style={styles.toggleHint}>
           Hier werden Bilder und Dateien aus dem Chat gespeichert.
-          Bei geloeschtem Cache werden Anhaenge automatisch ueber RVS neu geladen.
+          {autoDownload ? ' Fehlende Dateien werden automatisch nachgeladen.' : ' Fehlende Dateien koennen per Tippen geladen werden.'}
         </Text>
 
         {editingPath ? (
@@ -566,7 +601,7 @@ const SettingsScreen: React.FC = () => {
       <Text style={styles.sectionTitle}>{'\u00DC'}ber</Text>
       <View style={styles.card}>
         <Text style={styles.aboutTitle}>ARIA Cockpit</Text>
-        <Text style={styles.aboutVersion}>Version 0.1.0 (Alpha)</Text>
+        <Text style={styles.aboutVersion}>Version 0.0.1.6 </Text>
         <Text style={styles.aboutInfo}>
           Stefans Kommandozentrale f{'\u00FC'}r ARIA.{'\n'}
           Gebaut mit React Native + TypeScript.

bridge/aria_bridge.py

@@ -896,7 +896,7 @@ class ARIABridge:
         """Sendet Heartbeats an den RVS damit die Verbindung offen bleibt."""
         while True:
             await asyncio.sleep(25)
-            if self.ws_rvs and self.ws_rvs.open:
+            if self.ws_rvs:
                 try:
                     await self.ws_rvs.send(json.dumps({
                         "type": "heartbeat",
@@ -925,7 +925,10 @@ class ARIABridge:
         payload = message.get("payload", {})
 
         if msg_type == "chat":
-            # Text von der App → an aria-core
+            # Nur User-Nachrichten weiterleiten — ARIA/Diagnostic-Antworten ignorieren (sonst Loop!)
+            sender = payload.get("sender", "")
+            if sender in ("aria", "diagnostic", "stt"):
+                return
             text = payload.get("text", "")
             if text:
                 logger.info("[rvs] App-Chat: '%s'", text[:80])
@@ -977,17 +980,21 @@ class ARIABridge:
                     f.write(base64.b64decode(file_b64))
                 size_kb = len(file_b64) // 1365
                 logger.info("[rvs] Bild gespeichert: %s (%dKB)", file_path, size_kb)
-                # App informieren wo die Datei liegt (fuer Re-Download)
-                await self._send_to_rvs({
-                    "type": "file_saved",
-                    "payload": {"name": file_name, "serverPath": file_path, "mimeType": file_type},
-                    "timestamp": int(asyncio.get_event_loop().time() * 1000),
-                })
+                # ERST an aria-core senden (wichtigster Schritt)
                 text = (f"Stefan hat dir ein Bild geschickt: {file_name}"
                         f"{f' ({width}x{height}px)' if width else ''}"
                         f", {size_kb}KB."
                         f" Das Bild liegt unter: {file_path}")
                 await self.send_to_core(text, source="app-file")
+                # Dann App informieren (optional, darf nicht crashen)
+                try:
+                    await self._send_to_rvs({
+                        "type": "file_saved",
+                        "payload": {"name": file_name, "serverPath": file_path, "mimeType": file_type},
+                        "timestamp": int(asyncio.get_event_loop().time() * 1000),
+                    })
+                except Exception as e:
+                    logger.warning("[rvs] file_saved konnte nicht an App gesendet werden: %s", e)
             elif file_b64:
                 # Andere Datei in Shared Volume speichern
                 safe_name = f"file_{int(asyncio.get_event_loop().time())}_{file_name.replace('/', '_')}"
@@ -996,15 +1003,19 @@ class ARIABridge:
                     f.write(base64.b64decode(file_b64))
                 size_kb = len(file_b64) // 1365
                 logger.info("[rvs] Datei gespeichert: %s (%dKB)", file_path, size_kb)
-                await self._send_to_rvs({
-                    "type": "file_saved",
-                    "payload": {"name": file_name, "serverPath": file_path, "mimeType": file_type},
-                    "timestamp": int(asyncio.get_event_loop().time() * 1000),
-                })
+                # ERST an aria-core senden
                 text = (f"Stefan hat dir eine Datei geschickt: {file_name}"
                         f" ({file_type}, {size_kb}KB)."
                         f" Die Datei liegt unter: {file_path}")
                 await self.send_to_core(text, source="app-file")
+                try:
+                    await self._send_to_rvs({
+                        "type": "file_saved",
+                        "payload": {"name": file_name, "serverPath": file_path, "mimeType": file_type},
+                        "timestamp": int(asyncio.get_event_loop().time() * 1000),
+                    })
+                except Exception as e:
+                    logger.warning("[rvs] file_saved konnte nicht an App gesendet werden: %s", e)
             else:
                 text = f"Stefan hat eine Datei gesendet ({file_name}, {file_type}) aber die Daten sind leer angekommen."
                 await self.send_to_core(text, source="app-file")
@@ -1096,34 +1107,23 @@ class ARIABridge:
 
             if text.strip():
                 logger.info("[rvs] STT Ergebnis: '%s'", text[:80])
-                # STT-Ergebnis zurueck an die App senden (zur Anzeige, nicht nochmal verarbeiten)
+                # ERST an aria-core senden (wichtigster Schritt)
+                await self.send_to_core(text, source="app-voice")
+                # STT-Text an RVS senden (fuer Anzeige in App + Diagnostic)
+                # sender="stt" damit Bridge es ignoriert (kein Loop)
                 try:
                     await self._send_to_rvs({
-                        "type": "stt_result",
+                        "type": "chat",
                         "payload": {
                             "text": text,
-                            "sender": "user",
+                            "sender": "stt",
                         },
                         "timestamp": int(asyncio.get_event_loop().time() * 1000),
                     })
                 except Exception as e:
-                    logger.warning("[rvs] STT-Ergebnis konnte nicht an App gesendet werden: %s", e)
-                # Text trotzdem an aria-core senden
-                await self.send_to_core(text, source="app-voice")
+                    logger.warning("[rvs] STT-Text konnte nicht an RVS gesendet werden: %s", e)
             else:
                 logger.info("[rvs] Keine Sprache erkannt — ignoriert")
-                try:
-                    await self._send_to_rvs({
-                        "type": "stt_result",
-                        "payload": {
-                            "text": "",
-                            "error": "Keine Sprache erkannt",
-                            "sender": "user",
-                        },
-                        "timestamp": int(asyncio.get_event_loop().time() * 1000),
-                    })
-                except Exception as e:
-                    logger.warning("[rvs] STT-Fehler konnte nicht an App gesendet werden: %s", e)
 
         except Exception:
             logger.exception("[rvs] Audio-Verarbeitung fehlgeschlagen")
@@ -1138,13 +1138,13 @@ class ARIABridge:
 
     async def _send_to_rvs(self, message: dict) -> None:
         """Sendet eine Nachricht an die App (via RVS)."""
-        if self.ws_rvs is None or not self.ws_rvs.open:
+        if self.ws_rvs is None:
             return
 
         try:
             await self.ws_rvs.send(json.dumps(message))
         except Exception:
-            logger.exception("[rvs] Sendefehler")
+            logger.warning("[rvs] Sendefehler — RVS nicht erreichbar")
 
     # ── Log-Streaming an die App ─────────────────────────────
 

diagnostic/index.html

@@ -196,7 +196,10 @@
   <!-- Chat Test -->
   <div class="grid">
     <div class="card full">
-      <h2>Chat Test</h2>
+      <div style="display:flex;align-items:center;justify-content:space-between;margin-bottom:8px;">
+        <h2 style="margin:0;">Chat Test</h2>
+        <button class="btn secondary" onclick="toggleChatFullscreen()" id="btn-chat-fs" style="padding:4px 10px;font-size:11px;">Vollbild</button>
+      </div>
       <div class="chat-box" id="chat-box"></div>
       <div class="input-row">
         <input type="text" id="chat-input" placeholder="Nachricht an ARIA...">
@@ -206,6 +209,20 @@
     </div>
   </div>
 
+  <!-- Chat Vollbild Modal -->
+  <div id="chat-fullscreen" style="display:none;position:fixed;top:0;left:0;width:100vw;height:100vh;background:#0D0D1A;z-index:1000;padding:16px;flex-direction:column;">
+    <div style="display:flex;align-items:center;justify-content:space-between;margin-bottom:12px;">
+      <h2 style="margin:0;color:#0096FF;">ARIA Chat</h2>
+      <button class="btn secondary" onclick="toggleChatFullscreen()" style="padding:6px 14px;">Schliessen</button>
+    </div>
+    <div id="chat-box-fs" class="chat-box" style="flex:1;max-height:none;min-height:0;overflow-y:auto;"></div>
+    <div class="input-row" style="margin-top:8px;">
+      <input type="text" id="chat-input-fs" placeholder="Nachricht an ARIA..." onkeydown="if(event.key==='Enter'){testGatewayFS();event.preventDefault();}">
+      <button class="btn" onclick="testGatewayFS()">Gateway senden</button>
+      <button class="btn" onclick="testRVSFS()">Via RVS senden</button>
+    </div>
+  </div>
+
   <!-- Session + Brain Viewer -->
   <div class="grid" style="grid-template-columns: 1fr 1fr;">
     <div class="card">
@@ -503,7 +520,8 @@
           const p = msg.msg.payload || {};
           const sender = p.sender || '?';
           const chatType = (sender === 'aria') ? 'received' : 'sent';
-          addChat(chatType, p.text || '?', `via RVS (${sender})`);
+          const label = sender === 'stt' ? '\uD83C\uDFA4 Spracheingabe' : `via RVS (${sender})`;
+          addChat(chatType, p.text || '?', label);
           return;
         }
         if (msg.type === 'proxy_result') {
@@ -856,15 +874,60 @@
     }
 
     function addChat(type, text, meta) {
-      const el = document.createElement('div');
-      el.className = `chat-msg ${type}`;
       const escaped = escapeHtml(text);
-      const linked = linkifyText(escaped);
-      el.innerHTML = `${linked}<div class="meta">${escapeHtml(meta)} — ${new Date().toLocaleTimeString('de-DE')}</div>`;
-      chatBox.appendChild(el);
-      chatBox.scrollTop = chatBox.scrollHeight;
+      let linked = linkifyText(escaped);
+      // /shared/uploads/ Pfade als Inline-Bilder anzeigen
+      linked = linked.replace(/\/shared\/uploads\/[^\s<"]+\.(jpg|jpeg|png|gif)/gi, (match) => {
+        return `<a href="${match}" target="_blank">${match}</a><img src="${match}" class="chat-media" onclick="openLightbox('image','${match}')" onerror="this.style.display='none'">`;
+      });
+      const html = `${linked}<div class="meta">${escapeHtml(meta)} — ${new Date().toLocaleTimeString('de-DE')}</div>`;
+      // In beide Chat-Boxen schreiben (normal + Vollbild)
+      for (const box of [chatBox, document.getElementById('chat-box-fs')]) {
+        if (!box) continue;
+        const el = document.createElement('div');
+        el.className = `chat-msg ${type}`;
+        el.innerHTML = html;
+        box.appendChild(el);
+        box.scrollTop = box.scrollHeight;
+      }
     }
 
+    let chatFullscreen = false;
+    function toggleChatFullscreen() {
+      const modal = document.getElementById('chat-fullscreen');
+      chatFullscreen = !chatFullscreen;
+      if (chatFullscreen) {
+        modal.style.display = 'flex';
+        // Chat-Inhalt synchronisieren
+        const fsBox = document.getElementById('chat-box-fs');
+        fsBox.innerHTML = chatBox.innerHTML;
+        fsBox.scrollTop = fsBox.scrollHeight;
+        document.getElementById('chat-input-fs').focus();
+      } else {
+        modal.style.display = 'none';
+      }
+    }
+    function testGatewayFS() {
+      const input = document.getElementById('chat-input-fs');
+      const text = input.value.trim();
+      if (!text) return;
+      addChat('sent', text, 'Gateway direkt');
+      send({ action: 'test_gateway', text });
+      input.value = '';
+    }
+    function testRVSFS() {
+      const input = document.getElementById('chat-input-fs');
+      const text = input.value.trim();
+      if (!text) return;
+      addChat('sent', text, 'via RVS');
+      send({ action: 'test_rvs', text });
+      input.value = '';
+    }
+    // Escape schliesst Vollbild-Chat
+    document.addEventListener('keydown', (e) => {
+      if (e.key === 'Escape' && chatFullscreen) toggleChatFullscreen();
+    });
+
     function openLightbox(mediaType, url) {
       const lb = document.getElementById('lightbox');
       if (mediaType === 'video') {

diagnostic/server.js

@@ -945,6 +945,28 @@ const server = http.createServer((req, res) => {
   } else if (req.url === "/api/session") {
     res.writeHead(200, { "Content-Type": "application/json" });
     res.end(JSON.stringify({ sessionKey: activeSessionKey }));
+  } else if (req.url.startsWith("/shared/")) {
+    // Dateien aus Shared Volume ausliefern (Bilder, Uploads)
+    const filePath = decodeURIComponent(req.url);
+    const safePath = path.resolve(filePath);
+    if (!safePath.startsWith("/shared/")) {
+      res.writeHead(403);
+      res.end("Forbidden");
+      return;
+    }
+    try {
+      if (!fs.existsSync(safePath)) { res.writeHead(404); res.end("Not Found"); return; }
+      const ext = path.extname(safePath).toLowerCase();
+      const mimeTypes = { ".jpg": "image/jpeg", ".jpeg": "image/jpeg", ".png": "image/png", ".gif": "image/gif",
+                          ".pdf": "application/pdf", ".txt": "text/plain", ".json": "application/json" };
+      const contentType = mimeTypes[ext] || "application/octet-stream";
+      const data = fs.readFileSync(safePath);
+      res.writeHead(200, { "Content-Type": contentType, "Content-Length": data.length });
+      res.end(data);
+    } catch (err) {
+      res.writeHead(500);
+      res.end("Error");
+    }
   } else {
     res.writeHead(404);
     res.end("Not Found");

docker-compose.yml

@@ -99,6 +99,7 @@ services:
     volumes:
       - /var/run/docker.sock:/var/run/docker.sock:ro
       - ./aria-data/config/diag-state:/data           # Persistenter State (aktive Session etc.)
+      - aria-shared:/shared:ro                        # Shared Volume (Uploads lesen fuer Vorschau)
     environment:
       - ARIA_AUTH_TOKEN=${ARIA_AUTH_TOKEN:-}
       - PROXY_URL=http://proxy:3456

release.sh

@@ -51,8 +51,30 @@ fi
 echo -e "  ${GREEN}✓${NC} Login erfolgreich"
 echo ""
 
+# ── Versionsnummern aktualisieren ─────────────
+echo -e "${GREEN}[1/5] Versionsnummern auf $VERSION setzen...${NC}"
+
+# package.json
+sed -i "s/\"version\": \"[^\"]*\"/\"version\": \"$VERSION\"/" android/package.json
+echo -e "  ${GREEN}✓${NC} package.json → $VERSION"
+
+# build.gradle: versionName + versionCode (aus Major.Minor.Patch berechnen)
+MAJOR=$(echo "$VERSION" | cut -d. -f1)
+MINOR=$(echo "$VERSION" | cut -d. -f2)
+PATCH=$(echo "$VERSION" | cut -d. -f3)
+VERSION_CODE=$((MAJOR * 10000 + MINOR * 100 + PATCH))
+sed -i "s/versionName \"[^\"]*\"/versionName \"$VERSION\"/" android/android/app/build.gradle
+sed -i "s/versionCode [0-9]*/versionCode $VERSION_CODE/" android/android/app/build.gradle
+echo -e "  ${GREEN}✓${NC} build.gradle → versionName $VERSION, versionCode $VERSION_CODE"
+
+# SettingsScreen: Anzeige-Version
+sed -i "s/Version [0-9][0-9]*\.[0-9][0-9]*\.[0-9][0-9]* [^<]*/Version $VERSION /" android/src/screens/SettingsScreen.tsx
+echo -e "  ${GREEN}✓${NC} SettingsScreen → Version $VERSION"
+
+echo ""
+
 # ── APK bauen ─────────────────────────────────
-echo -e "${GREEN}[1/4] APK bauen...${NC}"
+echo -e "${GREEN}[2/5] APK bauen...${NC}"
 cd android
 ./build.sh release
 cd ..
@@ -70,7 +92,11 @@ echo -e "  ${GREEN}✓${NC} APK gebaut ($APK_SIZE)"
 echo ""
 
 # ── Git Tag ───────────────────────────────────
-echo -e "${GREEN}[2/4] Git Tag $TAG...${NC}"
+echo -e "${GREEN}[3/5] Git Tag $TAG...${NC}"
+
+# Versions-Aenderungen committen
+git add android/package.json android/android/app/build.gradle android/src/screens/SettingsScreen.tsx
+git commit -m "release: bump version to $VERSION" 2>/dev/null || echo -e "  ${YELLOW}Keine Aenderungen zum Committen${NC}"
 
 if git rev-parse "$TAG" &>/dev/null; then
     echo -e "  ${YELLOW}Tag $TAG existiert bereits — überspringe${NC}"
@@ -79,7 +105,7 @@ else
     echo -e "  ${GREEN}✓${NC} Tag $TAG erstellt"
 fi
 
-git push origin "$TAG"
+git push origin main "$TAG"
 echo -e "  ${GREEN}✓${NC} Tag gepusht"
 echo ""
 
@@ -102,7 +128,7 @@ fi
 RELEASE_BODY_ESCAPED=$(printf '%s' "$RELEASE_BODY" | python3 -c 'import sys,json; print(json.dumps(sys.stdin.read()))' 2>/dev/null || printf '"%s"' "$RELEASE_BODY" | sed 's/"/\\"/g')
 
 # ── Gitea Release erstellen ───────────────────
-echo -e "${GREEN}[3/4] Gitea Release erstellen...${NC}"
+echo -e "${GREEN}[4/5] Gitea Release erstellen...${NC}"
 
 RELEASE_RESPONSE=$(curl -s -X POST \
     "$GITEA_URL/api/v1/repos/$GITEA_REPO/releases" \
@@ -127,7 +153,7 @@ echo -e "  ${GREEN}✓${NC} Release #$RELEASE_ID erstellt"
 echo ""
 
 # ── APK hochladen ─────────────────────────────
-echo -e "${GREEN}[4/4] APK hochladen...${NC}"
+echo -e "${GREEN}[5/5] APK hochladen...${NC}"
 
 UPLOAD_RESPONSE=$(curl -s -X POST \
     "$GITEA_URL/api/v1/repos/$GITEA_REPO/releases/$RELEASE_ID/assets?name=$APK_NAME" \

rvs/server.js

@@ -9,6 +9,7 @@ const MAX_SESSIONS = parseInt(process.env.MAX_SESSIONS || "10", 10);
 // Erlaubte Nachrichtentypen — alles andere wird verworfen
 const ALLOWED_TYPES = new Set([
   "chat", "audio", "file", "location", "mode", "log", "event", "heartbeat",
+  "file_request", "file_response", "file_saved", "stt_result",
 ]);
 
 // Token-Raum: token -> { clients: Set<ws> }