fix: server restart crash + bundle WebView2 offline for stripped Windows

Server restart (os error 98):
- Replace broken oneshot shutdown with CancellationToken in server.rs
  The TCP accept loop now exits immediately on cancel(), dropping the
  TcpListener and releasing port 24800 right away. Previously the
  _shutdown_rx was dropped on creation so cancel() was a no-op and
  the socket stayed open forever.
- cmd_start_server auto-stops any existing server before starting a
  new one — "Start Server" always works, no manual stop required.

WebView2 on stripped Windows (Windows Lite, no Microsoft services):
- Add webviewInstallMode offlineInstaller at bundle.windows level.
  The full WebView2 runtime is now bundled in the NSIS .exe installer.
  No internet, no Microsoft account, no pre-installed WebView2 needed.
- Update NSIS hook to reflect offline bundling (no download warning).

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

Author: KaiCreates

CHANGELOG.md

@@ -7,6 +7,19 @@ Versions follow [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ---
 
+## [1.0.2] — 2026-03-07
+
+### Fixed
+
+**Windows/Linux — Server restart (os error 98 "Address already in use"):**
+- Stopping and restarting the server showed "Address already in use" error — the TCP accept loop held port 24800 open indefinitely because the shutdown signal was never delivered (the oneshot receiver was immediately dropped). Replaced the broken oneshot with a `CancellationToken`; the TCP loop now exits and drops the `TcpListener` the instant `Stop Server` is clicked, releasing the port immediately.
+- `Start Server` now auto-stops any previously running server instead of returning "Server already running" — clicking Start Server always works even if a prior session wasn't explicitly stopped.
+
+**Windows — WebView2 required even on stripped Windows (Windows Lite, etc.):**
+- The app required WebView2 to be pre-installed or downloaded from the internet, breaking on lightweight/locked-down Windows installations. Switched NSIS installer to `offlineInstaller` mode — the full WebView2 runtime is now bundled inside the `.exe` installer (~150 MB total). No internet connection, no Microsoft services, and no manual WebView2 installation required.
+
+---
+
 ## [1.0.1] — 2026-03-07
 
 ### Fixed

package.json

@@ -1,7 +1,7 @@
 {
   "name": "inputsync",
   "private": true,
-  "version": "1.0.1",
+  "version": "1.0.2",
   "type": "module",
   "scripts": {
     "dev": "vite",

src-tauri/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "inputsync"
-version = "1.0.1"
+version = "1.0.2"
 description = "InputSync - Software KVM Switch"
 authors = ["InputSync"]
 edition = "2021"

src-tauri/nsis/installer-hooks.nsi

@@ -1,9 +1,10 @@
 ; InputSync NSIS installer hooks
-; Called by Tauri's generated NSIS installer at key lifecycle points.
 
-; ── Check if WebView2 is already installed ──────────────────────────────────
+; ── Pre-install: inform user if WebView2 will be installed ──────────────────
+; With offlineInstaller mode, WebView2 is bundled — no download needed.
+; This hook just sets user expectations if WebView2 isn't already present.
 !macro NSIS_HOOK_PREINSTALL
-  ; Check per-machine WebView2 (GUID for Edge WebView2 Runtime)
+  ; Check per-machine WebView2 (written by EdgeUpdate, a 32-bit service)
   ReadRegStr $0 HKLM \
     "SOFTWARE\WOW6432Node\Microsoft\EdgeUpdate\Clients\{F3017226-FE2A-4295-8BDF-00C3A9A7E4C5}" \
     "pv"
@@ -15,17 +16,16 @@
     "pv"
   StrCmp $0 "" 0 WebView2Found
 
-  ; WebView2 not found — warn user before download begins
+  ; WebView2 not found — bundled installer will handle it (no download needed)
   MessageBox MB_ICONINFORMATION|MB_OK \
     "InputSync requires the Microsoft Edge WebView2 Runtime.$\r$\n$\r$\n\
-It was not found on this machine, so the installer will download and install it now (~100 MB).$\r$\n$\r$\n\
-This may take a few minutes depending on your internet connection.$\r$\n\
-The installer is NOT frozen — please wait.$\r$\n$\r$\n\
+The runtime is bundled with this installer and will be set up automatically.$\r$\n\
+No internet connection is required.$\r$\n$\r$\n\
 Click OK to continue." \
     /SD IDOK
   Goto WebView2Done
 
   WebView2Found:
-    ; Already installed — nothing to do
+    ; Already installed — nothing extra to do
   WebView2Done:
 !macroend

src-tauri/src/commands.rs

@@ -20,13 +20,19 @@ pub struct StartServerResult {
 }
 
 /// Start the server: generate session code, bind ports, start input capture.
+/// If a server is already running it is stopped automatically before the new
+/// one starts — no "address already in use" error on restart.
 #[tauri::command]
 pub async fn cmd_start_server(state: State<'_, SharedState>) -> Result<StartServerResult, String> {
     let mut locked = state.lock().await;
 
-    if locked.server.is_some() {
-        return Err("Server already running".into());
+    // Auto-stop any existing server so the user can restart cleanly.
+    if let Some(srv) = locked.server.take() {
+        drop(srv.capture_handle);
+        srv.handle.shutdown(); // cancels TCP loop → port 24800 released immediately
+        log::info!("Previous server stopped before restart");
     }
+
     if locked.client.is_some() {
         return Err("Cannot start server while connected as client".into());
     }

src-tauri/src/network/server.rs

@@ -1,12 +1,14 @@
 /// Fix #5: client_count tracked via Arc<AtomicUsize> shared with ServerState
-/// Fix #6: Shutdown propagates through oneshot; TCP loop breaks on socket error
+/// Fix #6: Shutdown via CancellationToken — TCP accept loop cancels cleanly,
+///         releasing the port so a new server can bind immediately after stop.
 use anyhow::{bail, Result};
 use std::net::SocketAddr;
 use std::sync::Arc;
 use std::sync::atomic::{AtomicUsize, Ordering};
 use tokio::io::{AsyncReadExt, AsyncWriteExt};
 use tokio::net::{TcpListener, TcpStream, UdpSocket};
-use tokio::sync::{mpsc, oneshot, Mutex};
+use tokio::sync::{mpsc, Mutex};
+use tokio_util::sync::CancellationToken;
 
 use crate::core::crypto::{combine_nonces, derive_session_key, EphemeralKeypair, SessionCipher};
 use crate::core::protocol::{
@@ -24,12 +26,14 @@ struct ConnectedClient {
 }
 
 pub struct ServerHandle {
-    shutdown_tx: oneshot::Sender<()>,
+    cancel: CancellationToken,
 }
 
 impl ServerHandle {
+    /// Cancel all server tasks. The TCP listener is dropped immediately,
+    /// releasing port 24800 so a new server can bind right away.
     pub fn shutdown(self) {
-        let _ = self.shutdown_tx.send(());
+        self.cancel.cancel();
     }
 }
 
@@ -38,7 +42,7 @@ pub async fn start_server(
     input_rx: mpsc::Receiver<InputPacket>,          // bounded channel
     client_count: Arc<AtomicUsize>,                 // shared with ServerState
 ) -> Result<ServerHandle> {
-    let (shutdown_tx, _shutdown_rx) = oneshot::channel::<()>();
+    let cancel = CancellationToken::new();
 
     let tcp_listener = TcpListener::bind(format!("0.0.0.0:{}", SERVER_TCP_PORT)).await?;
     let udp_socket = Arc::new(UdpSocket::bind(format!("0.0.0.0:{}", SERVER_UDP_PORT)).await?);
@@ -53,39 +57,51 @@ pub async fn start_server(
     let session_code = Arc::new(session_code);
 
     // ── TCP accept loop ────────────────────────────────────────────────────
+    // When cancel fires, the loop breaks and tcp_listener is dropped here,
+    // immediately releasing port 24800 for a new server start.
     let clients_tcp = clients.clone();
     let code_clone = session_code.clone();
     let count_tcp = client_count.clone();
+    let cancel_tcp = cancel.clone();
     tokio::spawn(async move {
         loop {
-            match tcp_listener.accept().await {
-                Ok((stream, addr)) => {
-                    log::info!("Incoming connection from {}", addr);
-                    let clients = clients_tcp.clone();
-                    let code = code_clone.clone();
-                    let count = count_tcp.clone();
-                    tokio::spawn(async move {
-                        match handle_client_handshake(stream, addr, code, clients.clone()).await {
-                            Ok(()) => {
-                                // Client cleanly disconnected; remove and decrement
-                                count.fetch_sub(1, Ordering::Relaxed);
-                                log::info!("Client {} session ended", addr);
-                            }
-                            Err(e) => {
-                                log::warn!("Handshake/session failed for {}: {}", addr, e);
-                            }
-                        }
-                    });
-                }
-                Err(e) => {
-                    log::error!("TCP accept error: {}", e);
+            tokio::select! {
+                biased;
+                _ = cancel_tcp.cancelled() => {
+                    log::info!("TCP accept loop stopped, port {} released", SERVER_TCP_PORT);
                     break;
                 }
+                result = tcp_listener.accept() => {
+                    match result {
+                        Ok((stream, addr)) => {
+                            log::info!("Incoming connection from {}", addr);
+                            let clients = clients_tcp.clone();
+                            let code = code_clone.clone();
+                            let count = count_tcp.clone();
+                            tokio::spawn(async move {
+                                match handle_client_handshake(stream, addr, code, clients.clone()).await {
+                                    Ok(()) => {
+                                        count.fetch_sub(1, Ordering::Relaxed);
+                                        log::info!("Client {} session ended", addr);
+                                    }
+                                    Err(e) => {
+                                        log::warn!("Handshake/session failed for {}: {}", addr, e);
+                                    }
+                                }
+                            });
+                        }
+                        Err(e) => {
+                            log::error!("TCP accept error: {}", e);
+                            break;
+                        }
+                    }
+                }
             }
         }
     });
 
     // ── UDP broadcast loop ─────────────────────────────────────────────────
+    // Stops naturally when input_tx (held by ServerState) is dropped.
     let udp = udp_socket.clone();
     let clients_udp = clients.clone();
     let mut input_rx = input_rx;
@@ -109,7 +125,7 @@ pub async fn start_server(
         log::info!("UDP broadcast loop exiting (input channel closed)");
     });
 
-    Ok(ServerHandle { shutdown_tx })
+    Ok(ServerHandle { cancel })
 }
 
 /// Runs the full handshake, then keeps TCP alive until client disconnects.

src-tauri/tauri.conf.json

@@ -1,7 +1,7 @@
 {
   "identifier": "com.inputsync.app",
   "productName": "InputSync",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "build": {
     "frontendDist": "../dist",
     "devUrl": "http://localhost:1420",
@@ -59,6 +59,9 @@
       "certificateThumbprint": null,
       "digestAlgorithm": "sha256",
       "timestampUrl": "",
+      "webviewInstallMode": {
+        "type": "offlineInstaller"
+      },
       "wix": {
         "language": "en-US"
       },
@@ -67,7 +70,6 @@
           "English"
         ],
         "displayLanguageSelector": false,
-        "minimumWebview2Version": "2.0.0",
         "installerHooks": "nsis/installer-hooks.nsi"
       }
     }