release: v2.1.0

chore: add ws dependency for remote control
Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
2026-03-12 07:20:07 +01:00 · 2026-03-12 07:19:38 +01:00 · 2026-03-12 06:58:29 +01:00 · 2026-03-12 06:56:47 +01:00 · 2026-03-12 06:56:09 +01:00 · 2026-03-12 06:54:51 +01:00
11 changed files with 792 additions and 5 deletions
--- a/lib/config-store.js
+++ b/lib/config-store.js
@ -75,6 +75,12 @@ const DEFAULTS = {
      delaySec: 3,
      autoStart: true,
      hosters: []              // pre-selected hosters, empty = ask via modal
    },
    remote: {
      enabled: false,
      port: 9100,
      token: '',
      allowInput: true
    }
  },
  history: []
--- a/lib/remote-capture-preload.js
+++ b/lib/remote-capture-preload.js
@ -0,0 +1,20 @@
 const { contextBridge, ipcRenderer } = require('electron');
 contextBridge.exposeInMainWorld('capture', {
  // Get capture source ID from main process (desktopCapturer runs in main)
  getSourceId: () => ipcRenderer.invoke('remote:get-capture-source-id'),
  // Signaling: receive offer/ICE from main process (relayed from dashboard)
  onSignaling: (callback) => {
    ipcRenderer.on('remote:signaling-to-capture', (_event, data) => callback(data));
  },
  // Signaling: send answer/ICE back to main process (relayed to dashboard)
  sendSignaling: (data) => ipcRenderer.send('remote:signaling-from-capture', data),
  // Input: forward input events from DataChannel to main process
  sendInput: (data) => ipcRenderer.send('remote:input-event', data),
  // Notify main process of client connection/disconnection
  notifyClientCount: (count) => ipcRenderer.send('remote:client-count', count)
 });
--- a/lib/remote-capture.html
+++ b/lib/remote-capture.html
@ -0,0 +1,124 @@
 <!DOCTYPE html>
 <html>
 <head><title>Remote Capture</title></head>
 <body>
 <script>
 // Maps clientId -> { pc: RTCPeerConnection, dc: RTCDataChannel }
 const clients = new Map();
 let captureStream = null;
 async function getCaptureStream() {
  if (captureStream) return captureStream;
  // desktopCapturer runs in main process (Electron 33+), we get the source ID via IPC
  const sourceId = await window.capture.getSourceId();
  if (!sourceId) throw new Error('No capture source ID from main process');
  captureStream = await navigator.mediaDevices.getUserMedia({
    audio: false,
    video: {
      mandatory: {
        chromeMediaSource: 'desktop',
        chromeMediaSourceId: sourceId,
        minWidth: 1280,
        maxWidth: 1920,
        minHeight: 720,
        maxHeight: 1080,
        maxFrameRate: 30
      }
    }
  });
  return captureStream;
 }
 async function handleOffer(clientId, offer, role) {
  const stream = await getCaptureStream();
  const pc = new RTCPeerConnection({ iceServers: [] });
  clients.set(clientId, { pc, role });
  // Add video tracks
  for (const track of stream.getTracks()) {
    pc.addTrack(track, stream);
  }
  // Handle DataChannel from dashboard (dashboard creates it as offerer)
  pc.ondatachannel = (event) => {
    const dc = event.channel;
    clients.get(clientId).dc = dc;
    dc.onmessage = (msg) => {
      try {
        const input = JSON.parse(msg.data);
        input.clientId = clientId;
        input.role = role;
        window.capture.sendInput(input);
      } catch {}
    };
  };
  // ICE candidates
  pc.onicecandidate = (event) => {
    if (event.candidate) {
      window.capture.sendSignaling({
        type: 'ice-candidate',
        clientId,
        candidate: event.candidate
      });
    }
  };
  pc.onconnectionstatechange = () => {
    if (pc.connectionState === 'disconnected' || pc.connectionState === 'failed') {
      removeClient(clientId);
    }
  };
  await pc.setRemoteDescription(new RTCSessionDescription(offer));
  const answer = await pc.createAnswer();
  await pc.setLocalDescription(answer);
  window.capture.sendSignaling({
    type: 'answer',
    clientId,
    answer: pc.localDescription
  });
  window.capture.notifyClientCount(clients.size);
 }
 function handleIceCandidate(clientId, candidate) {
  const client = clients.get(clientId);
  if (client && client.pc) {
    client.pc.addIceCandidate(new RTCIceCandidate(candidate)).catch(() => {});
  }
 }
 function removeClient(clientId) {
  const client = clients.get(clientId);
  if (client) {
    if (client.dc) client.dc.close();
    client.pc.close();
    clients.delete(clientId);
    window.capture.notifyClientCount(clients.size);
  }
 }
 // Listen for signaling messages from main process
 window.capture.onSignaling((data) => {
  switch (data.type) {
    case 'offer':
      handleOffer(data.clientId, data.offer, data.role).catch(err => {
        console.error('Failed to handle offer:', err);
      });
      break;
    case 'ice-candidate':
      handleIceCandidate(data.clientId, data.candidate);
      break;
    case 'client-disconnected':
      removeClient(data.clientId);
      break;
  }
 });
 </script>
 </body>
 </html>
--- a/lib/remote-server.js
+++ b/lib/remote-server.js
@ -0,0 +1,171 @@
 const { WebSocketServer } = require('ws');
 const crypto = require('crypto');
 class RemoteServer {
  constructor() {
    this._wss = null;
    this._clients = new Map(); // ws -> { id, role, authenticated }
    this._config = null;
    this._failedAttempts = new Map(); // ip -> { count, blockedUntil }
  }
  start(opts) {
    return new Promise((resolve, reject) => {
      this._config = opts;
      this._wss = new WebSocketServer({ port: opts.port }, () => {
        resolve();
      });
      this._wss.on('error', (err) => {
        reject(err);
      });
      this._wss.on('connection', (ws, req) => {
        this._handleConnection(ws, req);
      });
    });
  }
  stop() {
    if (this._wss) {
      for (const [ws] of this._clients) {
        ws.close(1000, 'Server shutting down');
      }
      this._clients.clear();
      this._wss.close();
      this._wss = null;
    }
  }
  getClientCount() {
    let count = 0;
    for (const [, client] of this._clients) {
      if (client.authenticated) count++;
    }
    return count;
  }
  getPort() {
    if (this._wss && this._wss.address()) {
      return this._wss.address().port;
    }
    return null;
  }
  _handleConnection(ws, req) {
    const ip = req.socket.remoteAddress || 'unknown';
    if (this._isBlocked(ip)) {
      ws.close(4003, 'Too many failed attempts');
      return;
    }
    const clientId = crypto.randomUUID();
    this._clients.set(ws, { id: clientId, role: null, authenticated: false });
    let authReceived = false;
    const authTimeout = setTimeout(() => {
      if (!authReceived) {
        ws.close(4001, 'Auth timeout');
        this._clients.delete(ws);
      }
    }, 5000);
    ws.on('message', (raw) => {
      let msg;
      try { msg = JSON.parse(raw); } catch { return; }
      const client = this._clients.get(ws);
      if (!client) return;
      if (!client.authenticated) {
        authReceived = true;
        clearTimeout(authTimeout);
        if (msg.type === 'auth' && msg.token === this._config.token) {
          client.authenticated = true;
          client.role = msg.role || 'viewer';
          ws.send(JSON.stringify({ type: 'auth-ok', clientId }));
          if (this.getClientCount() === 1) {
            this._config.onCreateCaptureWindow();
          }
        } else {
          this._recordFailedAttempt(ip);
          ws.close(4002, 'Invalid token');
          this._clients.delete(ws);
        }
        return;
      }
      if (msg.type === 'offer' || msg.type === 'ice-candidate') {
        msg.clientId = client.id;
        msg.role = client.role;
        this._config.onSignalingToCapture(msg);
      }
    });
    ws.on('close', () => {
      clearTimeout(authTimeout);
      const client = this._clients.get(ws);
      const wasAuthenticated = client && client.authenticated;
      this._clients.delete(ws);
      if (wasAuthenticated) {
        this._config.onSignalingToCapture({
          type: 'client-disconnected',
          clientId: client.id
        });
        if (this.getClientCount() === 0) {
          this._config.onDestroyCaptureWindow();
        }
      }
    });
    ws.on('error', () => {
      this._clients.delete(ws);
    });
  }
  sendToClient(clientId, data) {
    for (const [ws, client] of this._clients) {
      if (client.id === clientId && client.authenticated) {
        ws.send(JSON.stringify(data));
        break;
      }
    }
  }
  broadcast(data) {
    const msg = JSON.stringify(data);
    for (const [ws, client] of this._clients) {
      if (client.authenticated && ws.readyState === 1) {
        ws.send(msg);
      }
    }
  }
  _isBlocked(ip) {
    const entry = this._failedAttempts.get(ip);
    if (!entry) return false;
    if (entry.blockedUntil && Date.now() < entry.blockedUntil) return true;
    if (entry.blockedUntil && Date.now() >= entry.blockedUntil) {
      this._failedAttempts.delete(ip);
      return false;
    }
    return false;
  }
  _recordFailedAttempt(ip) {
    const entry = this._failedAttempts.get(ip) || { count: 0, blockedUntil: null };
    entry.count++;
    if (entry.count >= 5) {
      entry.blockedUntil = Date.now() + 60000;
    }
    this._failedAttempts.set(ip, entry);
  }
 }
 module.exports = RemoteServer;
--- a/main.js
+++ b/main.js
@ -11,6 +11,7 @@ const DoodstreamUploader = require('./lib/doodstream-upload');
 const { checkForUpdate, installUpdate, abortUpdate } = require('./lib/updater');
 const backupCrypto = require('./lib/backup-crypto');
 const FolderMonitor = require('./lib/folder-monitor');
 const RemoteServer = require('./lib/remote-server');
 let mainWindow;
 let dropTargetWindow = null;
@ -18,6 +19,8 @@ let tray = null;
 const configStore = new ConfigStore(app);
 let uploadManager = null;
 let folderMonitor = new FolderMonitor();
 let remoteServer = null;
 let captureWindow = null;
 const HEALTH_CHECK_TIMEOUT = 25000;
 // --- Debug logging (writes to upload-debug.log next to the app) ---
@ -488,6 +491,18 @@ app.whenReady().then(() => {
    debugLog(`folder-monitor auto-start failed: ${err.message}`);
  }
  // Auto-start remote server if enabled
  try {
    const remoteConfig = configStore.load().globalSettings && configStore.load().globalSettings.remote;
    if (remoteConfig && remoteConfig.enabled) {
      startRemoteServer().catch(err => {
        debugLog(`remote-server auto-start failed: ${err.message}`);
      });
    }
  } catch (err) {
    debugLog(`remote-server auto-start failed: ${err.message}`);
  }
  // Auto-show drop target if enabled
  try {
    const dtConfig = configStore.load();
@ -517,6 +532,10 @@ app.on('window-all-closed', () => {
 app.on('before-quit', () => {
  try { folderMonitor.stop(); } catch {}
  try {
    if (remoteServer) { remoteServer.stop(); remoteServer = null; }
    destroyCaptureWindow();
  } catch {}
  destroyDropTargetWindow();
 });
@ -891,6 +910,204 @@ ipcMain.handle('folder-monitor:select-folder', async () => {
  return result.filePaths[0];
 });
 // --- Remote Control ---
 function generateToken() {
  const crypto = require('crypto');
  return crypto.randomBytes(32).toString('hex');
 }
 function createCaptureWindow() {
  if (captureWindow && !captureWindow.isDestroyed()) return;
  captureWindow = new BrowserWindow({
    show: false,
    webPreferences: {
      contextIsolation: true,
      nodeIntegration: false,
      preload: path.join(__dirname, 'lib', 'remote-capture-preload.js')
    }
  });
  captureWindow.loadFile(path.join(__dirname, 'lib', 'remote-capture.html'));
  // Crash recovery: if hidden window closes unexpectedly while clients connected, recreate it
  captureWindow.on('closed', () => {
    captureWindow = null;
    if (remoteServer && remoteServer.getClientCount() > 0) {
      debugLog('remote: capture window crashed, recreating...');
      createCaptureWindow();
    }
  });
 }
 function destroyCaptureWindow() {
  if (captureWindow && !captureWindow.isDestroyed()) {
    captureWindow.close();
    captureWindow = null;
  }
 }
 async function startRemoteServer() {
  if (remoteServer) {
    remoteServer.stop();
    remoteServer = null;
  }
  const config = configStore.load();
  const remote = config.globalSettings && config.globalSettings.remote;
  if (!remote || !remote.enabled) return;
  let token = remote.token;
  if (!token) {
    token = generateToken();
    const gs = { ...config.globalSettings, remote: { ...remote, token } };
    await configStore.save({ globalSettings: gs });
  }
  remoteServer = new RemoteServer();
  await remoteServer.start({
    port: remote.port || 9100,
    token,
    allowInput: remote.allowInput !== false,
    mainWindow,
    onSignalingToCapture: (data) => {
      if (captureWindow && !captureWindow.isDestroyed()) {
        captureWindow.webContents.send('remote:signaling-to-capture', data);
      }
    },
    onCreateCaptureWindow: () => createCaptureWindow(),
    onDestroyCaptureWindow: () => destroyCaptureWindow()
  });
  debugLog(`remote-server started on port ${remoteServer.getPort()}`);
 }
 // IPC: Signaling from capture window back to dashboard client
 ipcMain.on('remote:signaling-from-capture', (_event, data) => {
  if (remoteServer && data.clientId) {
    remoteServer.sendToClient(data.clientId, data);
  }
 });
 // IPC: Input events from capture window
 ipcMain.on('remote:input-event', (_event, data) => {
  if (!mainWindow || mainWindow.isDestroyed()) return;
  const config = configStore.load();
  const remote = config.globalSettings && config.globalSettings.remote;
  if (!remote || !remote.allowInput) return;
  if (data.role !== 'admin') return;
  const bounds = mainWindow.getContentBounds();
  const x = Math.round((data.x || 0) * bounds.width);
  const y = Math.round((data.y || 0) * bounds.height);
  switch (data.type) {
    case 'mousemove':
      mainWindow.webContents.sendInputEvent({ type: 'mouseMove', x, y });
      break;
    case 'mousedown':
      mainWindow.webContents.sendInputEvent({
        type: 'mouseDown', x, y,
        button: data.button === 'right' ? 'right' : 'left',
        clickCount: 1
      });
      break;
    case 'mouseup':
      mainWindow.webContents.sendInputEvent({
        type: 'mouseUp', x, y,
        button: data.button === 'right' ? 'right' : 'left',
        clickCount: 1
      });
      break;
    case 'scroll':
      mainWindow.webContents.sendInputEvent({
        type: 'mouseWheel', x, y,
        deltaX: data.deltaX || 0,
        deltaY: data.deltaY || 0
      });
      break;
    case 'keydown':
      mainWindow.webContents.sendInputEvent({
        type: 'keyDown',
        keyCode: data.key,
        modifiers: buildModifiers(data)
      });
      if (data.key.length === 1) {
        mainWindow.webContents.sendInputEvent({
          type: 'char',
          keyCode: data.key,
          modifiers: buildModifiers(data)
        });
      }
      break;
    case 'keyup':
      mainWindow.webContents.sendInputEvent({
        type: 'keyUp',
        keyCode: data.key,
        modifiers: buildModifiers(data)
      });
      break;
  }
 });
 function buildModifiers(data) {
  const mods = [];
  if (data.shift) mods.push('shift');
  if (data.ctrl) mods.push('control');
  if (data.alt) mods.push('alt');
  return mods;
 }
 // IPC: Get capture source ID (desktopCapturer must run in main process in Electron 33+)
 ipcMain.handle('remote:get-capture-source-id', async () => {
  if (!mainWindow || mainWindow.isDestroyed()) return null;
  const { desktopCapturer } = require('electron');
  const sources = await desktopCapturer.getSources({ types: ['window'] });
  const title = mainWindow.getTitle();
  const source = sources.find(s => s.name === title);
  return source ? source.id : null;
 });
 // IPC: Client count updates from capture window
 ipcMain.on('remote:client-count', (_event, count) => {
  if (mainWindow && !mainWindow.isDestroyed()) {
    mainWindow.webContents.send('remote:client-count', count);
  }
 });
 // IPC: Remote settings
 ipcMain.handle('remote:get-settings', () => {
  const config = configStore.load();
  return config.globalSettings && config.globalSettings.remote || {};
 });
 ipcMain.handle('remote:save-settings', async (_event, remoteSettings) => {
  const config = configStore.load();
  const gs = { ...config.globalSettings, remote: remoteSettings };
  await configStore.save({ globalSettings: gs });
  if (remoteSettings.enabled) {
    await startRemoteServer();
  } else if (remoteServer) {
    remoteServer.stop();
    remoteServer = null;
    destroyCaptureWindow();
    debugLog('remote-server stopped');
  }
  return true;
 });
 ipcMain.handle('remote:generate-token', () => {
  return generateToken();
 });
 ipcMain.handle('remote:status', () => {
  return {
    running: !!remoteServer,
    port: remoteServer ? remoteServer.getPort() : null,
    clientCount: remoteServer ? remoteServer.getClientCount() : 0
  };
 });
 // --- Always on top ---
 ipcMain.handle('set-always-on-top', async (_event, value) => {
  if (mainWindow && !mainWindow.isDestroyed()) {
--- a/package-lock.json
+++ b/package-lock.json
@ -1,15 +1,16 @@
 {
  "name": "multi-hoster-uploader",
-  "version": "1.8.6",
+  "version": "2.0.6",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
    "": {
      "name": "multi-hoster-uploader",
-      "version": "1.8.6",
+      "version": "2.0.6",
      "dependencies": {
        "chokidar": "^3.6.0",
-        "undici": "^7.16.0"
+        "undici": "^7.16.0",
        "ws": "^8.19.0"
      },
      "devDependencies": {
        "electron": "^33.0.0",
@ -5433,6 +5434,27 @@
      "dev": true,
      "license": "ISC"
    },
    "node_modules/ws": {
      "version": "8.19.0",
      "resolved": "https://registry.npmjs.org/ws/-/ws-8.19.0.tgz",
      "integrity": "sha512-blAT2mjOEIi0ZzruJfIhb3nps74PRWTCz1IjglWEEpQl5XS/UNama6u2/rjFkDDouqr4L67ry+1aGIALViWjDg==",
      "license": "MIT",
      "engines": {
        "node": ">=10.0.0"
      },
      "peerDependencies": {
        "bufferutil": "^4.0.1",
        "utf-8-validate": ">=5.0.2"
      },
      "peerDependenciesMeta": {
        "bufferutil": {
          "optional": true
        },
        "utf-8-validate": {
          "optional": true
        }
      }
    },
    "node_modules/xmlbuilder": {
      "version": "15.1.1",
      "resolved": "https://registry.npmjs.org/xmlbuilder/-/xmlbuilder-15.1.1.tgz",
--- a/package.json
+++ b/package.json
@ -1,6 +1,6 @@
 {
  "name": "multi-hoster-uploader",
-  "version": "2.0.6",
+  "version": "2.1.0",
  "description": "Upload files to doodstream, voe, vidmoly, byse simultaneously",
  "main": "main.js",
  "scripts": {
@ -12,7 +12,8 @@
  },
  "dependencies": {
    "chokidar": "^3.6.0",
-    "undici": "^7.16.0"
+    "undici": "^7.16.0",
    "ws": "^8.19.0"
  },
  "devDependencies": {
    "electron": "^33.0.0",
--- a/preload.js
+++ b/preload.js
@ -93,6 +93,15 @@ contextBridge.exposeInMainWorld('api', {
  onShutdownCountdown: (callback) => {
    ipcRenderer.on('shutdown-countdown', (_event, data) => callback(data));
  },
  // Remote Control
  remoteGetSettings: () => ipcRenderer.invoke('remote:get-settings'),
  remoteSaveSettings: (settings) => ipcRenderer.invoke('remote:save-settings', settings),
  remoteGenerateToken: () => ipcRenderer.invoke('remote:generate-token'),
  remoteStatus: () => ipcRenderer.invoke('remote:status'),
  onRemoteClientCount: (callback) => {
    ipcRenderer.on('remote:client-count', (_event, count) => callback(count));
  },
  // File path from drag & drop (Electron 33+ compatible)
  getPathForFile: (file) => webUtils.getPathForFile(file),
  removeAllListeners: () => {
@ -105,5 +114,6 @@ contextBridge.exposeInMainWorld('api', {
    ipcRenderer.removeAllListeners('folder-monitor:new-files');
    ipcRenderer.removeAllListeners('drop-target:files');
    ipcRenderer.removeAllListeners('account-switched');
    ipcRenderer.removeAllListeners('remote:client-count');
  }
 });
--- a/renderer/app.js
+++ b/renderer/app.js
@ -2023,6 +2023,97 @@ function renderSettings() {
    }
  });
  // --- Remote Control Panel ---
  const remoteSettings = globalSettings.remote || {};
  const remotePanel = document.createElement('div');
  remotePanel.className = 'hoster-settings-panel';
  remotePanel.innerHTML = `
    <div class="hoster-panel-header" data-hoster="remote">
      <span class="panel-arrow">&#9654;</span>
      <span class="panel-title">Fernsteuerung</span>
      <span class="panel-status${remoteSettings.enabled ? ' active' : ''}" id="remoteStatusBadge">${remoteSettings.enabled ? 'Aktiv' : 'Inaktiv'}</span>
    </div>
    <div class="hoster-panel-body" data-panel="remote" style="display:none">
      <div class="settings-section-label">Server</div>
      <div class="settings-grid-mini">
        <div class="settings-row checkbox-row">
          <label>Aktiviert</label>
          <input type="checkbox" class="settings-autosave" id="remoteEnabledInput" ${remoteSettings.enabled ? 'checked' : ''}>
        </div>
        <div class="settings-row checkbox-row">
          <label>Input erlauben</label>
          <input type="checkbox" class="settings-autosave" id="remoteAllowInputInput" ${remoteSettings.allowInput !== false ? 'checked' : ''}>
        </div>
      </div>
      <div class="settings-row">
        <label>Port</label>
        <input type="number" class="hs-input settings-autosave" id="remotePortInput" value="${remoteSettings.port || 9100}" min="1024" max="65535" style="width:100px">
      </div>
      <div class="settings-row">
        <label>API-Token</label>
        <input type="text" class="key-input" id="remoteTokenInput" value="${remoteSettings.token || ''}" readonly style="flex:1">
        <button class="btn btn-xs btn-secondary" id="remoteCopyTokenBtn" title="Kopieren">Kopieren</button>
        <button class="btn btn-xs btn-secondary" id="remoteRegenerateTokenBtn" title="Neu generieren">Neu</button>
      </div>
      <div class="settings-section-label">Status</div>
      <div class="settings-row">
        <span id="remoteConnectionStatus" style="color:#94a3b8">Prüfe...</span>
      </div>
    </div>
  `;
  container.appendChild(remotePanel);
  // Toggle remote panel
  remotePanel.querySelector('.hoster-panel-header').addEventListener('click', () => {
    const body = remotePanel.querySelector('.hoster-panel-body');
    const arrow = remotePanel.querySelector('.panel-arrow');
    const isOpen = body.style.display !== 'none';
    body.style.display = isOpen ? 'none' : 'block';
    arrow.innerHTML = isOpen ? '&#9654;' : '&#9660;';
  });
  // Copy token
  document.getElementById('remoteCopyTokenBtn').addEventListener('click', async () => {
    const token = document.getElementById('remoteTokenInput').value;
    if (token) {
      await window.api.copyToClipboard(token);
      document.getElementById('remoteCopyTokenBtn').textContent = 'Kopiert!';
      setTimeout(() => { document.getElementById('remoteCopyTokenBtn').textContent = 'Kopieren'; }, 1500);
    }
  });
  // Regenerate token
  document.getElementById('remoteRegenerateTokenBtn').addEventListener('click', async () => {
    const newToken = await window.api.remoteGenerateToken();
    document.getElementById('remoteTokenInput').value = newToken;
    scheduleSettingsSave();
  });
  // Update status
  window.api.remoteStatus().then(status => {
    const el = document.getElementById('remoteConnectionStatus');
    if (!el) return;
    if (status.running) {
      el.textContent = `Aktiv auf Port ${status.port} — ${status.clientCount} Client(s) verbunden`;
      el.style.color = '#10b981';
    } else {
      el.textContent = 'Nicht aktiv';
      el.style.color = '#94a3b8';
    }
  }).catch(() => {});
  // Live client count updates
  window.api.onRemoteClientCount((count) => {
    const el = document.getElementById('remoteConnectionStatus');
    if (el && el.style.color === 'rgb(16, 185, 129)') {
      window.api.remoteStatus().then(status => {
        if (status.running) {
          el.textContent = `Aktiv auf Port ${status.port} — ${status.clientCount} Client(s) verbunden`;
        }
      }).catch(() => {});
    }
  });
  // --- Backup Panel ---
  const backupPanel = document.createElement('div');
  backupPanel.className = 'hoster-settings-panel';
@ -2190,6 +2281,12 @@ async function saveSettings(options = {}) {
      delaySec: Math.max(1, parseInt(document.getElementById('fmDelaySecInput')?.value || '3', 10) || 3),
      autoStart: !!document.getElementById('fmAutoStartInput')?.checked,
      hosters: Array.from(document.querySelectorAll('.fm-hoster-checkbox:checked')).map(el => el.dataset.fmHoster)
    },
    remote: {
      enabled: !!document.getElementById('remoteEnabledInput')?.checked,
      port: Math.max(1024, Math.min(65535, parseInt(document.getElementById('remotePortInput')?.value || '9100', 10) || 9100)),
      token: (document.getElementById('remoteTokenInput')?.value || '').trim(),
      allowInput: !!document.getElementById('remoteAllowInputInput')?.checked
    }
  };
@ -2241,6 +2338,31 @@ async function saveSettings(options = {}) {
    if (badge) { badge.textContent = 'Inaktiv'; badge.className = 'panel-status'; }
  }
  // Start/stop remote server based on settings
  const remoteSettings = globalSettings.remote;
  const remoteBadge = document.getElementById('remoteStatusBadge');
  if (remoteSettings) {
    try {
      await window.api.remoteSaveSettings(remoteSettings);
      if (remoteBadge) {
        remoteBadge.textContent = remoteSettings.enabled ? 'Aktiv' : 'Inaktiv';
        remoteBadge.className = `panel-status${remoteSettings.enabled ? ' active' : ''}`;
      }
      // Update status display
      const status = await window.api.remoteStatus();
      const statusEl = document.getElementById('remoteConnectionStatus');
      if (statusEl) {
        if (status.running) {
          statusEl.textContent = `Aktiv auf Port ${status.port} — ${status.clientCount} Client(s) verbunden`;
          statusEl.style.color = '#10b981';
        } else {
          statusEl.textContent = 'Nicht aktiv';
          statusEl.style.color = '#94a3b8';
        }
      }
    } catch {}
  }
  const feedback = document.getElementById('saveFeedback');
  feedback.textContent = feedbackText;
  setTimeout(() => {
--- a/tests/remote-config.test.js
+++ b/tests/remote-config.test.js
@ -0,0 +1,53 @@
 const { describe, it } = require('node:test');
 const assert = require('node:assert');
 const path = require('path');
 const fs = require('fs');
 const os = require('os');
 // Minimal app mock for ConfigStore
 function createTestConfigStore() {
  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'mhu-test-'));
  const mockApp = {
    isPackaged: false,
    getPath: (name) => tmpDir,
    getPath: () => tmpDir
  };
  const ConfigStore = require('../lib/config-store');
  const store = new ConfigStore(mockApp);
  store.filePath = path.join(tmpDir, 'test-config.json');
  return { store, tmpDir };
 }
 describe('remote config defaults', () => {
  it('should include remote settings in defaults', () => {
    const { store } = createTestConfigStore();
    const config = store.load();
    const remote = config.globalSettings.remote;
    assert.strictEqual(remote.enabled, false);
    assert.strictEqual(remote.port, 9100);
    assert.strictEqual(typeof remote.token, 'string');
    assert.strictEqual(remote.token, '');
    assert.strictEqual(remote.allowInput, true);
  });
  it('should deep-merge remote settings with existing config', async () => {
    const { store } = createTestConfigStore();
    // Save config with partial remote settings
    await store.save({
      globalSettings: {
        remote: { enabled: true, port: 9200 }
      }
    });
    const config = store.load();
    const remote = config.globalSettings.remote;
    // Saved values preserved
    assert.strictEqual(remote.enabled, true);
    assert.strictEqual(remote.port, 9200);
    // Defaults merged in
    assert.strictEqual(remote.allowInput, true);
    assert.strictEqual(remote.token, '');
  });
 });
--- a/tests/remote-server.test.js
+++ b/tests/remote-server.test.js
@ -0,0 +1,41 @@
 const { describe, it, beforeEach, afterEach } = require('node:test');
 const assert = require('node:assert');
 // Test the module can be required and has the expected API
 describe('RemoteServer', () => {
  it('should export a class with start/stop methods', () => {
    const RemoteServer = require('../lib/remote-server');
    assert.strictEqual(typeof RemoteServer, 'function');
    assert.strictEqual(typeof RemoteServer.prototype.start, 'function');
    assert.strictEqual(typeof RemoteServer.prototype.stop, 'function');
    assert.strictEqual(typeof RemoteServer.prototype.getClientCount, 'function');
  });
  it('should start and stop without errors', async () => {
    const RemoteServer = require('../lib/remote-server');
    const server = new RemoteServer();
    // Mock mainWindow
    const mockMainWindow = {
      isDestroyed: () => false,
      getTitle: () => 'Test Window',
      getContentBounds: () => ({ x: 0, y: 0, width: 1920, height: 1080 }),
      webContents: {
        sendInputEvent: () => {}
      }
    };
    await server.start({
      port: 0, // random available port
      token: 'test-token-123',
      allowInput: true,
      mainWindow: mockMainWindow,
      onSignalingToCapture: () => {},
      onCreateCaptureWindow: () => {},
      onDestroyCaptureWindow: () => {}
    });
    assert.strictEqual(server.getClientCount(), 0);
    server.stop();
  });
 });
Author	SHA1	Message	Date
Administrator	7b9362756d	release: v2.1.0	2026-03-12 07:20:07 +01:00
Administrator	ad9b866afe	chore: add ws dependency for remote control Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>	2026-03-12 07:19:38 +01:00
Administrator	f13bf7f5bc	feat(remote): add Fernsteuerung settings panel with token management and status display Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>	2026-03-12 06:58:29 +01:00
Administrator	d1513a58b3	feat(remote): wire up remote server, capture window, and IPC handlers in main process Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>	2026-03-12 06:56:47 +01:00
Administrator	90bb298dbe	feat(remote): add remote control bridge methods to preload	2026-03-12 06:56:09 +01:00
Administrator	9fa047b399	feat(remote): add WebSocket server with auth, signaling relay, and rate limiting Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>	2026-03-12 06:54:51 +01:00
Administrator	c2932a1577	feat(remote): add remote control defaults to config store Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>	2026-03-12 06:54:46 +01:00
Administrator	92e94b1e8a	feat: add remote-capture preload and HTML for WebRTC screen sharing Adds the hidden BrowserWindow assets for remote desktop streaming: - lib/remote-capture-preload.js: IPC bridge for desktopCapturer source ID, WebRTC signaling relay, input event forwarding, and client count tracking - lib/remote-capture.html: WebRTC logic handling multiple concurrent clients via RTCPeerConnection, stream capture via getUserMedia with desktop source ID, and DataChannel input forwarding Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>	2026-03-12 06:54:07 +01:00