Add RdpSessionBackend test coverage (#1)

RdpSessionBackend can't reasonably get the same fixture-driven
state-machine tests SshSessionBackend got: it's driven by FreeRDP's own
event loop and a raw worker thread against a real freerdp_connect(), not
a QProcess we can point at a stand-in binary. What it does have is a
large amount of pure, regression-prone logic -- exactly the kind that
already caused a real historical bug here (the X11-keycode/PC-AT-scancode
mixup fixed in Milestone 7) -- so that's what gets covered instead.

Twelve functions promoted from free functions / private members to
public statics purely so tests can call them without a live connection:
security-mode/performance-profile normalization, the HiDPI scale-value
mapping, desktop-size clamping, both scancode-mapping functions, and the
five FreeRDP error-code interpretation functions. UINT32 is surfaced as
quint32 in the public signatures to keep FreeRDP/WinPR types out of the
header, matching how rdp_freerdp* is already only forward-declared there.

27 test cases, including a couple of direct regression guards: verifying
scancodeFromNativeScanCode() is a faithful passthrough to FreeRDP's X11
table (not a reimplementation), and that it does NOT reproduce the old
"X11 keycode treated as PC/AT scancode" bug for a documented example key.

This closes out #1's originally scoped work (CTest wiring, ProfileRepository,
SshSessionBackend, RdpSessionBackend coverage). Deeper state-machine
coverage for the two session backends remains future work if ever needed,
but isn't blocking here.

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

.gitignore

@@ -1 +1,5 @@
 /build/
+/dist/
+/.flatpak-builder/
+/build-doc-tool/
+/docs/USER_GUIDE.pdf

CMakeLists.txt

@@ -1,6 +1,6 @@
 cmake_minimum_required(VERSION 3.21)
 
-project(OrbitHub VERSION 0.1.0 LANGUAGES CXX)
+project(OrbitHub VERSION 2026.9.15 LANGUAGES CXX)
 
 set(CMAKE_CXX_STANDARD 17)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
@@ -10,10 +10,23 @@ set(CMAKE_AUTOMOC ON)
 set(CMAKE_AUTOUIC ON)
 set(CMAKE_AUTORCC ON)
 
+include(GNUInstallDirs)
+
 find_package(Qt6 6.2 REQUIRED COMPONENTS Widgets Sql)
 
 qt_standard_project_setup()
 
+option(ORBITHUB_BUILD_TESTS "Build unit tests (requires Qt6::Test)" ON)
+if(ORBITHUB_BUILD_TESTS)
+    find_package(Qt6 6.2 QUIET COMPONENTS Test)
+    if(TARGET Qt6::Test)
+        enable_testing()
+    else()
+        message(STATUS "Qt6::Test not found -- skipping unit tests (set ORBITHUB_BUILD_TESTS=OFF to silence this)")
+        set(ORBITHUB_BUILD_TESTS OFF)
+    endif()
+endif()
+
 add_subdirectory(third_party/KodoTerm)
 
 if(NOT EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/third_party/FreeRDP/CMakeLists.txt")
@@ -40,7 +53,8 @@ set(CHANNEL_DISP ON CACHE BOOL "" FORCE)
 set(CHANNEL_DISP_CLIENT ON CACHE BOOL "" FORCE)
 set(CHANNEL_AINPUT OFF CACHE BOOL "" FORCE)
 set(CHANNEL_AUDIN OFF CACHE BOOL "" FORCE)
-set(CHANNEL_CLIPRDR OFF CACHE BOOL "" FORCE)
+set(CHANNEL_CLIPRDR ON CACHE BOOL "" FORCE)
+set(CHANNEL_CLIPRDR_CLIENT ON CACHE BOOL "" FORCE)
 set(CHANNEL_DRIVE OFF CACHE BOOL "" FORCE)
 set(CHANNEL_ECHO OFF CACHE BOOL "" FORCE)
 set(CHANNEL_ENCOMSP OFF CACHE BOOL "" FORCE)
@@ -75,9 +89,12 @@ set(WITH_WINPR_TOOLS OFF CACHE BOOL "" FORCE)
 
 add_subdirectory(third_party/FreeRDP EXCLUDE_FROM_ALL)
 
-add_executable(orbithub
+set(ORBITHUB_SOURCES
     src/about_dialog.cpp
     src/about_dialog.h
+    src/user_guide_dialog.cpp
+    src/user_guide_dialog.h
+    docs/user_guide.qrc
     src/app_icon.cpp
     src/app_icon.h
     src/main.cpp
@@ -108,8 +125,27 @@ add_executable(orbithub
     src/unsupported_session_backend.h
 )
 
+if(WIN32)
+    list(APPEND ORBITHUB_SOURCES packaging/windows/orbithub.rc)
+endif()
+
+if(APPLE)
+    list(APPEND ORBITHUB_SOURCES packaging/macos/orbithub.icns)
+    set_source_files_properties(packaging/macos/orbithub.icns PROPERTIES
+        MACOSX_PACKAGE_LOCATION "Resources"
+    )
+    set(MACOSX_BUNDLE_ICON_FILE orbithub.icns)
+    set(MACOSX_BUNDLE_BUNDLE_NAME "OrbitHub")
+    set(MACOSX_BUNDLE_GUI_IDENTIFIER "org.darksingularity.OrbitHub")
+    set(MACOSX_BUNDLE_BUNDLE_VERSION "${PROJECT_VERSION}")
+    set(MACOSX_BUNDLE_SHORT_VERSION_STRING "${PROJECT_VERSION}")
+endif()
+
+add_executable(orbithub WIN32 MACOSX_BUNDLE ${ORBITHUB_SOURCES})
+
 target_link_libraries(orbithub PRIVATE Qt6::Widgets Qt6::Sql)
 target_link_libraries(orbithub PRIVATE KodoTerm::KodoTerm)
+target_compile_definitions(orbithub PRIVATE ORBITHUB_VERSION_STRING="${PROJECT_VERSION}")
 if(TARGET freerdp AND TARGET winpr)
     target_compile_definitions(orbithub PRIVATE ORBITHUB_HAS_FREERDP)
     target_include_directories(orbithub PRIVATE
@@ -126,4 +162,128 @@ else()
     message(FATAL_ERROR "Vendored FreeRDP targets were not produced as expected.")
 endif()
 
-install(TARGETS orbithub RUNTIME DESTINATION bin)
+# Qt loads platform integration and SQL driver plugins dynamically at
+# runtime (QFactoryLoader), so they never appear in orbithub.exe's import
+# table. vcpkg's automatic DLL deployment only follows the import table, so
+# these plugins have to be copied out explicitly or the app fails to start
+# with "Could not find the Qt platform plugin" / "can not load requested
+# driver 'QSQLITE'".
+if(WIN32)
+    if(TARGET Qt6::QWindowsIntegrationPlugin)
+        add_custom_command(TARGET orbithub POST_BUILD
+            COMMAND ${CMAKE_COMMAND} -E make_directory
+                "$<TARGET_FILE_DIR:orbithub>/platforms"
+            COMMAND ${CMAKE_COMMAND} -E copy_if_different
+                "$<TARGET_FILE:Qt6::QWindowsIntegrationPlugin>"
+                "$<TARGET_FILE_DIR:orbithub>/platforms/"
+            COMMENT "Deploying Qt Windows platform plugin"
+        )
+        install(FILES "$<TARGET_FILE:Qt6::QWindowsIntegrationPlugin>"
+            DESTINATION "${CMAKE_INSTALL_BINDIR}/platforms"
+        )
+    endif()
+
+    if(TARGET Qt6::QSQLiteDriverPlugin)
+        add_custom_command(TARGET orbithub POST_BUILD
+            COMMAND ${CMAKE_COMMAND} -E make_directory
+                "$<TARGET_FILE_DIR:orbithub>/sqldrivers"
+            COMMAND ${CMAKE_COMMAND} -E copy_if_different
+                "$<TARGET_FILE:Qt6::QSQLiteDriverPlugin>"
+                "$<TARGET_FILE_DIR:orbithub>/sqldrivers/"
+            COMMENT "Deploying Qt SQLite driver plugin"
+        )
+        install(FILES "$<TARGET_FILE:Qt6::QSQLiteDriverPlugin>"
+            DESTINATION "${CMAKE_INSTALL_BINDIR}/sqldrivers"
+        )
+
+        # vcpkg's qtbase[sql-sqlite] links the plugin against vcpkg's own
+        # shared sqlite3 port rather than bundling SQLite into the plugin,
+        # so the plugin fails to load ("can not load requested driver
+        # 'QSQLITE'") unless sqlite3.dll also ships next to the executable.
+        find_file(ORBITHUB_SQLITE3_DLL
+            NAMES sqlite3.dll
+            PATHS ${CMAKE_PREFIX_PATH}
+            PATH_SUFFIXES bin
+        )
+        if(ORBITHUB_SQLITE3_DLL)
+            add_custom_command(TARGET orbithub POST_BUILD
+                COMMAND ${CMAKE_COMMAND} -E copy_if_different
+                    "${ORBITHUB_SQLITE3_DLL}"
+                    "$<TARGET_FILE_DIR:orbithub>/"
+                COMMENT "Deploying sqlite3.dll (Qt SQLite plugin dependency)"
+            )
+            install(FILES "${ORBITHUB_SQLITE3_DLL}" DESTINATION "${CMAKE_INSTALL_BINDIR}")
+        endif()
+    endif()
+endif()
+
+if(APPLE)
+    # Mirrors macdeployqt's own layout for Qt frameworks: dylibs live in
+    # Contents/Frameworks inside the bundle, found via @executable_path
+    # (the macOS/dyld equivalent of Linux's $ORIGIN token, which dyld
+    # does not understand).
+    set_target_properties(orbithub PROPERTIES
+        INSTALL_RPATH "@executable_path/../Frameworks"
+        INSTALL_RPATH_USE_LINK_PATH ON
+    )
+else()
+    set_target_properties(orbithub PROPERTIES
+        BUILD_RPATH_USE_ORIGIN ON
+        INSTALL_RPATH "$ORIGIN/../${CMAKE_INSTALL_LIBDIR}/orbithub"
+        INSTALL_RPATH_USE_LINK_PATH ON
+    )
+endif()
+
+install(TARGETS orbithub
+    RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+    BUNDLE DESTINATION .
+)
+
+if(APPLE)
+    set(ORBITHUB_PRIVATE_LIB_DESTINATION "OrbitHub.app/Contents/Frameworks")
+else()
+    set(ORBITHUB_PRIVATE_LIB_DESTINATION "${CMAKE_INSTALL_LIBDIR}/orbithub")
+endif()
+set(ORBITHUB_RUNTIME_TARGETS KodoTerm freerdp winpr)
+if(TARGET freerdp-client)
+    list(APPEND ORBITHUB_RUNTIME_TARGETS freerdp-client)
+endif()
+foreach(runtime_target IN LISTS ORBITHUB_RUNTIME_TARGETS)
+    if(TARGET ${runtime_target})
+        install(TARGETS ${runtime_target}
+            RUNTIME DESTINATION ${ORBITHUB_PRIVATE_LIB_DESTINATION}
+            LIBRARY DESTINATION ${ORBITHUB_PRIVATE_LIB_DESTINATION}
+            ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+        )
+    endif()
+endforeach()
+
+install(FILES
+    packaging/linux/org.darksingularity.OrbitHub.desktop
+    DESTINATION ${CMAKE_INSTALL_DATADIR}/applications
+)
+foreach(icon_size IN ITEMS 16 24 32 48 64 128 256)
+    install(FILES
+        packaging/linux/icons/${icon_size}x${icon_size}/apps/org.darksingularity.OrbitHub.png
+        DESTINATION ${CMAKE_INSTALL_DATADIR}/icons/hicolor/${icon_size}x${icon_size}/apps
+    )
+endforeach()
+install(FILES
+    packaging/linux/org.darksingularity.OrbitHub.metainfo.xml
+    DESTINATION ${CMAKE_INSTALL_DATADIR}/metainfo
+)
+install(FILES LICENSE
+    DESTINATION ${CMAKE_INSTALL_DATADIR}/licenses/org.darksingularity.OrbitHub
+)
+install(FILES third_party/FreeRDP/LICENSE
+    DESTINATION ${CMAKE_INSTALL_DATADIR}/licenses/org.darksingularity.OrbitHub
+    RENAME LICENSE-FreeRDP
+)
+install(FILES third_party/KodoTerm/LICENSE
+    DESTINATION ${CMAKE_INSTALL_DATADIR}/licenses/org.darksingularity.OrbitHub
+    RENAME LICENSE-KodoTerm
+)
+
+if(ORBITHUB_BUILD_TESTS)
+    add_subdirectory(tests)
+endif()

README.md

@@ -13,15 +13,35 @@ Supported target platforms:
 
 OrbitHub is in active development.
 
-- Milestones completed: M0-M5 and M8
-- Current milestone: Milestone 9 (Packaging and Distribution)
+- Milestones completed: M0-M5, and M7-M9
+- Current milestone: Milestone 10 (v1.0 Stabilization)
 - Deferred milestone: Milestone 6 (VNC Fully Working)
-- Latest checkpoint tag: `v0-m8-wip1`
+- Latest checkpoint tag: `v2026.9.15`
 - VNC implementation milestone (M6) is currently deferred
 
 Progress and milestone details:
 - [docs/PROGRESS.md](docs/PROGRESS.md)
 
+Latest release (installers for Windows, Linux, and macOS):
+- [v2026.9.15](https://git.darksingularity.org/DarkSingularity/orbithub/releases/tag/v2026.9.15)
+
+User Guide:
+- [docs/USER_GUIDE.md](docs/USER_GUIDE.md) (also available as a PDF attached to each release, and in-app via `Help -> User Guide`)
+
+## Screenshots
+
+![Profile list with folders](docs/images/screenshot-profiles.png)
+
+Profiles organized into folders, with protocol, host, and tags shown at a glance. (Sample data shown; not real hosts.)
+
+![Active SSH terminal session](docs/images/screenshot-ssh-session.png)
+
+An interactive SSH terminal session in a tab, with the event log below.
+
+![Active RDP session](docs/images/screenshot-rdp-session.png)
+
+An embedded RDP session in a tab.
+
 ## Implemented Features
 
 ### Profile Management
@@ -84,6 +104,35 @@ cmake --build build
 ./build/orbithub
 ```
 
+## Packaging
+
+Detailed packaging instructions for all platforms:
+- [docs/BUILDING.md](docs/BUILDING.md)
+
+Linux (`.deb`):
+
+```bash
+./packaging/linux/build-deb.sh
+```
+
+Linux (Flatpak):
+
+```bash
+./packaging/flatpak/build-flatpak.sh
+```
+
+Windows (Inno Setup installer):
+
+```powershell
+.\packaging\windows\build-installer.ps1
+```
+
+macOS (`.dmg`):
+
+```bash
+./packaging/macos/build-dmg.sh
+```
+
 ## Dependencies
 
 Core dependencies:

docs/BUILDING.md

@@ -2,6 +2,14 @@
 
 Run all commands from the repository root unless noted.
 
+## Requirements
+
+Minimum toolchain requirements on all platforms:
+- CMake 3.21+
+- C++17 compiler toolchain
+- Qt 6.2+ with `Widgets` and `Sql` modules (dynamic linking)
+- OpenSSH client available on `PATH` (required for SSH sessions)
+
 ## Linux (Ubuntu / Mint)
 
 ```bash
@@ -9,9 +17,9 @@ sudo apt update
 sudo apt install -y \
   build-essential cmake ninja-build git pkg-config \
   qt6-base-dev qt6-base-dev-tools qt6-tools-dev qt6-tools-dev-tools \
-  openssh-client
+  openssh-client libssl-dev zlib1g-dev
 
-cmake -S . -B build -G Ninja
+cmake -S . -B build -G Ninja -DCMAKE_BUILD_TYPE=Release
 cmake --build build
 ./build/orbithub
 ```
@@ -21,39 +29,130 @@ cmake --build build
 ```bash
 xcode-select --install
 brew update
-brew install cmake ninja pkg-config qt@6 openssh
+brew install cmake ninja pkg-config qt@6 openssh openssl@3
 
-cmake -S . -B build -G Ninja -DCMAKE_PREFIX_PATH="$(brew --prefix qt@6)"
+cmake -S . -B build -G Ninja \
+  -DCMAKE_BUILD_TYPE=Release \
+  -DCMAKE_PREFIX_PATH="$(brew --prefix qt@6);$(brew --prefix openssl@3)"
 cmake --build build
-./build/orbithub
+open build/orbithub.app
 ```
 
 ## Windows 11 (PowerShell + MSVC + vcpkg)
 
+Install required software:
+
 ```powershell
 winget install -e --id Git.Git
 winget install -e --id Kitware.CMake
 winget install -e --id Ninja-build.Ninja
 Add-WindowsCapability -Online -Name OpenSSH.Client~~~~0.0.1.0
 winget install -e --id Microsoft.VisualStudio.2022.BuildTools `
-  --override "--quiet --wait --norestart --add Microsoft.VisualStudio.Workload.VCTools"
+  --override "--quiet --wait --norestart --add Microsoft.VisualStudio.Workload.VCTools --add Microsoft.VisualStudio.Component.Windows11SDK.22621"
 ```
 
-Open a new terminal after installs, then:
+Install dependencies via vcpkg:
 
 ```powershell
 git clone https://github.com/microsoft/vcpkg C:\dev\vcpkg
 C:\dev\vcpkg\bootstrap-vcpkg.bat
-C:\dev\vcpkg\vcpkg.exe install qtbase:x64-windows
-
-cmake -S . -B build -G Ninja `
-  -DCMAKE_TOOLCHAIN_FILE=C:/dev/vcpkg/scripts/buildsystems/vcpkg.cmake
-cmake --build build
-.\build\orbithub.exe
+C:\dev\vcpkg\vcpkg.exe install qtbase:x64-windows openssl:x64-windows zlib:x64-windows
 ```
 
+Open `x64 Native Tools Command Prompt for VS 2022` (or Developer PowerShell), then build:
+
+```powershell
+cmake -S . -B build -G Ninja `
+  -DCMAKE_BUILD_TYPE=Release `
+  -DCMAKE_TOOLCHAIN_FILE=C:/dev/vcpkg/scripts/buildsystems/vcpkg.cmake `
+  -DVCPKG_TARGET_TRIPLET=x64-windows
+cmake --build build
+```
+
+Run (ensures DLL paths from vcpkg are present):
+
+```powershell
+C:\dev\vcpkg\vcpkg.exe env --triplet x64-windows -- .\build\orbithub.exe
+```
+
+If you already have `Qt 6` from the Qt installer and do not want vcpkg Qt, you can point CMake at that Qt install with `-DCMAKE_PREFIX_PATH=...`, but you still need compatible `OpenSSL` and `zlib` development libraries for the embedded FreeRDP build.
+
 ## Notes
 
-- OrbitHub currently requires Qt6 Widgets and CMake 3.21+.
-- Milestone 3 SSH sessions require an `ssh` client available on `PATH`.
+- OrbitHub builds vendored `KodoTerm`, `libvterm`, and `FreeRDP` from `third_party/`.
 - If Qt is installed in a custom location, pass `-DCMAKE_PREFIX_PATH=/path/to/Qt/6.x.x/<toolchain>` to CMake.
+- Build output executable:
+  - Linux: `build/orbithub`
+  - macOS: `build/orbithub.app` (a proper app bundle, launch with `open build/orbithub.app`)
+  - Windows: `build\\orbithub.exe`
+
+## Linux Packaging
+
+Build a Debian package (`.deb`) from the current Linux build:
+
+```bash
+./packaging/linux/build-deb.sh
+```
+
+Output path:
+- `dist/orbithub_<version>_<arch>.deb`
+
+Build a Flatpak bundle:
+
+```bash
+sudo apt-get install -y flatpak flatpak-builder
+./packaging/flatpak/build-flatpak.sh
+```
+
+Output path:
+- `dist/flatpak/org.darksingularity.OrbitHub.flatpak`
+
+## Windows Packaging
+
+Requires [Inno Setup 6](https://jrsoftware.org/isinfo.php) (`winget install -e --id JRSoftware.InnoSetup`).
+
+From a configured and built `build\` directory (see Windows build steps above):
+
+```powershell
+.\packaging\windows\build-installer.ps1
+```
+
+Output path:
+- `dist\windows\OrbitHub-Setup-<version>.exe`
+
+## macOS Packaging
+
+Requires `qt@6` from Homebrew (for `macdeployqt`). For a custom volume icon on
+the `.dmg`, also install `SetFile` (via Xcode's "Additional Tools", from
+[developer.apple.com/download/all](https://developer.apple.com/download/all))
+or `brew install fileicon` — packaging still works without either, just with
+the generic disk image icon.
+
+```bash
+./packaging/macos/build-dmg.sh
+```
+
+This runs `cmake --install`, then `macdeployqt` to bundle Qt frameworks and
+plugins into the `.app`, then re-signs the bundle (ad hoc, since there is no
+Developer ID certificate) so it passes macOS's launch-time code-integrity
+check. The result is unsigned/unnotarized, so first launch requires
+right-click → **Open** to bypass Gatekeeper's unidentified-developer warning.
+
+Output path:
+- `dist/macos/OrbitHub-<version>.dmg`
+
+## User Guide PDF
+
+The in-app User Guide (`Help -> User Guide`) is built from
+`docs/USER_GUIDE.md` and embedded into the app at compile time — no extra
+step needed for that. A standalone PDF version is generated separately by a
+small tool (kept out of the main app's dependencies, since it needs
+`Qt6::PrintSupport`):
+
+```bash
+./packaging/docs/build-user-guide-pdf.sh
+```
+
+Output path:
+- `docs/USER_GUIDE.pdf` (not committed to git — a release asset, like the
+  platform installers)

docs/FLATHUB.md

@@ -0,0 +1,100 @@
+# Flathub Submission Readiness
+
+Tracks OrbitHub's readiness for submission to Flathub. This is a separate
+checklist from `docs/PROGRESS.md`'s development milestones, since Flathub
+submission is an external process with its own requirements.
+
+## Status
+
+| Item | Status |
+|---|---|
+| Production manifest with pinned, reproducible git source | Done — `packaging/flatpak/flathub/org.darksingularity.OrbitHub.yml`; commit pin updated at each tagged release |
+| `flathub.json` for build settings (`only-arches`, etc.) | Done — `packaging/flatpak/flathub/flathub.json` |
+| Offline build (no network fetches during build) | Verified — no `FetchContent`/`ExternalProject`/`curl`/`wget` in CMake; all vendored deps committed in `third_party/`; confirmed with a real `flatpak-builder` build |
+| SSH client available inside the sandbox | Verified — provided by the `org.kde.Platform` runtime base, no packaging needed |
+| `--filesystem=home` removed | Done — narrowed to `--filesystem=~/.ssh` (read-write, needed for `known_hosts` and SSH config) |
+| SSH known-hosts trust persists with narrowed permissions | Verified in sandbox against real infrastructure |
+| RDP works with zero filesystem permission | Verified — FreeRDP's cert trust store lives outside the sandboxed home path concerns entirely (see below) |
+| Private-key/export file pickers use the desktop portal | **Verified interactively** — `QFileDialog`'s Browse button correctly opens the native GTK portal chooser ("Select Private Key"), which can browse the full filesystem via user consent regardless of the sandbox's static `~/.ssh`-only grant |
+| Current, supported KDE runtime | Verified — upgraded to `6.11` (linter's recommended latest); confirmed the app still builds and launches against it |
+| Desktop entry validates | Verified |
+| Application icon validates | Verified — PNGs at all standard hicolor sizes, matching the real app icon |
+| MetaInfo/AppStream validates | Verified via both `appstreamcli validate` and Flathub's own `flatpak-builder-lint appstream` (0 errors either way) |
+| Screenshots present | Done — profiles view, active SSH session, active RDP session, all captured against real (test) infrastructure |
+| Release information present | Done — `<releases>` block with `v2026.9.8` (add an entry per future tagged release) |
+| Developer/project URLs present | Done — homepage, bugtracker, vcs-browser, developer block |
+| Architecture support decided | `x86_64` only (no ARM hardware available to test FreeRDP/WinPR on aarch64), set via `flathub.json`'s `only-arches` |
+| Flathub manifest linter passes | One expected finding remains: `finish-args-ssh-filesystem-access` (see below) — everything else passes, including `only-arches` placement and runtime-version currency |
+| AppStream linter passes | Passing (both `appstreamcli validate` and `flatpak-builder-lint appstream`) |
+| Clean install works without host dependencies | Verified via local `.flatpak` bundle install and launch, on both KDE 6.10 and 6.11 runtimes |
+| Bundled-dependency license files installed per Flathub's `$FLATPAK_ID` convention | Partially done — path fixed from `share/licenses/orbithub` to the required `share/licenses/org.darksingularity.OrbitHub`; FreeRDP's and KodoTerm's `LICENSE` files now installed there too. **`libvterm`'s vendored copy has no `LICENSE`/`COPYING` file at all** — needs to be pulled from upstream and added as `third_party/libvterm/LICENSE` before submission (README claims MIT; not verified against an actual license file in-tree) |
+
+## ⚠️ Not yet addressed: Generative AI disclosure policy is a real acceptance risk, not a checklist item
+
+See the dedicated section below — unlike everything else on this page, this
+isn't something more packaging work resolves.
+
+### `finish-args-ssh-filesystem-access` — expected, needs a submission-time justification
+
+Flathub's linter flags *any* `~/.ssh` filesystem grant by policy — it's not a
+bug in this manifest, it's a deliberate prompt for the submitter to justify
+the access during PR review. Checked the linter's own exceptions list:
+several existing SSH-client apps already have this exact permission approved
+with justifications like *"Read-only access to ~/.ssh is required to load
+SSH keys for connecting to devices over SSH"* and *"Needed to manage SSH keys
+and configurations for connections"* — OrbitHub's case is the same pattern
+(read-write, specifically for `known_hosts` persistence and default identity
+file discovery). Include a similar justification in the submission PR.
+
+## ⚠️ Not yet addressed: Generative AI disclosure policy
+
+Flathub's [Generative AI policy](https://docs.flathub.org/docs/for-app-authors/requirements#generative-ai-policy)
+requires submitters to disclose "any AI-generated code, documentation,
+packaging, or other material" included in the app or its Flathub packaging,
+identifying "the affected parts and approximate extent." This is not a
+formality — it's evaluated at reviewer discretion, and reviewers may reject
+"based on the extent or role of generated material."
+
+OrbitHub's development has used Claude Code extensively — the app's C++
+source, this Flatpak packaging (manifest, metainfo, build scripts), and this
+tracking doc itself. Every commit in this repository carries a
+`Co-Authored-By: Claude Sonnet 5` trailer, which is itself effectively an
+existing disclosure trail. An honest submission disclosure needs to reflect
+that extent truthfully — not a token "some AI assistance was used" note.
+
+The same policy also prohibits AI tools from opening or automating the
+submission PR itself, or generating its commit messages, description, or
+review replies. **This means the actual submission PR — including its AI
+disclosure — has to be written and opened by a human, not drafted by
+Claude.** Not done, and not something this repo's tooling should attempt.
+
+This is a real acceptance risk that no amount of technical packaging work
+resolves — it's a policy/reviewer-discretion matter, separate from every
+other item on this page.
+
+## Related finding (not a packaging blocker)
+
+During permission-narrowing research, RDP certificate verification was found
+to be completely disabled (`IgnoreCertificate=TRUE`, all server certificates
+silently accepted including *changed* ones). This has been fixed separately
+in `src/rdp_session_backend.cpp` — FreeRDP's own trust-on-first-use
+certificate store is now used, matching SSH's known-hosts model. Not a
+Flathub-specific issue, but worth noting since it was found in the course of
+this work.
+
+## Explicitly out of scope for this repo
+
+- Opening the actual submission PR against `github.com/flathub/flathub` —
+  requires the maintainer's GitHub identity, done outside this repo, and per
+  the Generative AI policy above must be written by a human, not drafted here.
+- ARM64 build/testing — no hardware available.
+- Flathub's post-acceptance developer-verification step — done via
+  Flathub's own website after acceptance, using DNS control of
+  `darksingularity.org`.
+
+## Files
+
+- Dev manifest (local iteration, `type: dir`): `packaging/flatpak/org.darksingularity.OrbitHub.yml`
+- Flathub submission manifest (pinned `type: git`): `packaging/flatpak/flathub/org.darksingularity.OrbitHub.yml`
+- AppStream metainfo: `packaging/linux/org.darksingularity.OrbitHub.metainfo.xml`
+- Desktop entry: `packaging/linux/org.darksingularity.OrbitHub.desktop`

docs/PROGRESS.md

@@ -115,12 +115,40 @@ Planned Scope:
 
 ## Milestone 7 - Cross-Platform Protocol Hardening
 
-Status: Planned
+Status: Completed
 
-Planned Scope:
-- Validate SSH/RDP/VNC workflows on Windows, Linux, and macOS
-- Fix platform-specific runtime/process/auth issues
-- Add repeatable protocol validation checklist/scripts
+Delivered:
+- Validated SSH and RDP workflows on Linux, macOS, and Windows 11 (VNC is out
+  of scope while Milestone 6 remains deferred)
+- Windows: validated the full `docs/BUILDING.md` toolchain end-to-end
+  (Git/CMake/Ninja/VS Build Tools with the C++ workload/vcpkg for
+  Qt6-OpenSSL-zlib); documented a VS Build Tools installer gotcha where the
+  actual compiler is a "recommended", not "required", component of the
+  VCTools workload
+- Fixed RDP keyboard input misreading punctuation keys on Linux (X11 keycode
+  numbering was being treated as a PC/AT scancode; now uses FreeRDP's
+  authoritative X11-keycode-to-scancode table)
+- Added RDP clipboard sync (bidirectional, plain text) and RDP cursor/pointer
+  shape sync (resize handles, text I-beam, etc. instead of a static arrow)
+- Fixed Tab/Shift+Tab being intercepted by local UI focus navigation instead
+  of reaching SSH/RDP sessions
+- Fixed RDP key auto-repeat being dropped, so holding a key only ever sent a
+  single keystroke to the remote machine
+- Windows-specific RDP fixes: a crash on every connect attempt (FreeRDP's
+  signal-handling critical section was never initialized) and a host
+  resolution failure on every connect, including literal IP addresses
+  (Winsock was never initialized via `WSAStartup`)
+- Windows: automatic build-time deployment of Qt's platform/SQL-driver
+  plugins and their runtime DLL dependencies, and marked the executable as a
+  GUI (`WIN32`) app to remove a stray console window behind the UI
+- Windows and macOS: proper native app icon embedding (Windows `.rc`/`.ico`
+  resource; macOS `.app` bundle with `.icns`), replacing the generic default
+  icon previously shown for the built executable/bundle
+- macOS: fixed Edit/New Profile dialog form fields collapsing to `sizeHint`
+  width due to the platform-default `QFormLayout` field growth policy
+
+Git:
+- Tag: Pending user approval (`v0-m7-done`)
 
 ## Milestone 8 - Profile and Session UX Completion
 
@@ -149,12 +177,32 @@ Git:
 
 ## Milestone 9 - Packaging and Distribution
 
-Status: Planned
+Status: Completed
 
-Planned Scope:
-- Build distributable artifacts for Windows/Linux/macOS
-- Document runtime dependencies and install prerequisites
-- Add reproducible release packaging steps/scripts
+Delivered:
+- Linux `.deb` (`packaging/linux/build-deb.sh`) and Flatpak (`packaging/flatpak/build-flatpak.sh`) packages, both verified installed and launched with working SSH/RDP
+- Renamed the app's reverse-DNS identity from `io.orbithub.OrbitHub` to `org.darksingularity.OrbitHub` (desktop file, AppStream metainfo, Flatpak manifest, macOS bundle identifier) to reflect a domain actually owned by the project
+- Fixed Linux taskbar/panel pin matching (`StartupWMClass`) so a pinned launcher merges with its running window instead of creating a duplicate entry
+- Replaced the stale, mismatched hand-authored launcher SVG with PNG icons rendered directly from the app's own `createOrbitHubAppIcon()` at each hicolor theme size
+- Windows installer via Inno Setup (`packaging/windows/orbithub.iss`, `packaging/windows/build-installer.ps1`), verified installed silently and launched cleanly with no crash events
+- macOS `.dmg` via `cmake --install` + `macdeployqt` + `hdiutil` (`packaging/macos/build-dmg.sh`), verified installed and launched after fixing:
+  - a launch crash caused by `macdeployqt` invalidating the code signature (fixed with ad hoc re-signing)
+  - a missing-library crash caused by the Linux-only `$ORIGIN` rpath token and vendored dylibs installing outside the `.app` bundle (fixed with `APPLE`-specific `@executable_path`/`Contents/Frameworks` layout)
+  - the dmg showing the generic disk icon instead of the app icon
+- README and `docs/BUILDING.md` Packaging sections documented for all three platforms
+
+Validation:
+- All three installers built, installed, and launched successfully with working SSH/RDP sessions
+- Code signing is ad hoc only (no purchased Apple Developer ID or Windows code-signing certificate), so macOS Gatekeeper and Windows SmartScreen still show first-run warnings by design
+
+Git:
+- Tag: `v0-m9-done`
+- Release: [v2026.9.8](https://git.darksingularity.org/DarkSingularity/orbithub/releases/tag/v2026.9.8) (`v2026.9.8` tag, installers for Windows/Linux/macOS)
+- Release: [v2026.9.8.2](https://git.darksingularity.org/DarkSingularity/orbithub/releases/tag/v2026.9.8.2) — same-day patch fixing RDP TLS certificate verification (was fully disabled) and preparing Flatpak packaging for Flathub submission
+- Release: [v2026.9.8.3](https://git.darksingularity.org/DarkSingularity/orbithub/releases/tag/v2026.9.8.3) — same-day patch adding an in-app User Guide and standalone User Guide PDF
+- Release: [v2026.9.14](https://git.darksingularity.org/DarkSingularity/orbithub/releases/tag/v2026.9.14) — fixes distorted RDP text on HiDPI monitors and reduces RDP resize-related display glitches
+- Release: [v2026.9.14.2](https://git.darksingularity.org/DarkSingularity/orbithub/releases/tag/v2026.9.14.2) — same-day patch fixing RDP display corruption (missing/misplaced taskbar) after resizing the session window (the client never resized its own display buffer for channel-driven RDP resizes)
+- Release: [v2026.9.15](https://git.darksingularity.org/DarkSingularity/orbithub/releases/tag/v2026.9.15) — adds Import/Export for profile lists (File menu)
 
 ## Milestone 10 - v1.0 Stabilization
 

docs/USER_GUIDE.md

@@ -0,0 +1,230 @@
+## Introduction
+
+OrbitHub is a native desktop application for organizing connection profiles
+and launching SSH and RDP sessions from one place, in a single tabbed
+window. It runs on Windows, Linux, and macOS.
+
+This guide covers everyday use: creating and organizing profiles,
+connecting over SSH and RDP, managing active sessions, and what to do when
+something goes wrong. It does not cover installation or building from
+source — see the project's `README.md` and `docs/BUILDING.md` for that.
+
+VNC support is planned but not yet implemented; profiles can be tagged for
+it, but connecting will show an "unsupported protocol" message for now.
+
+## Getting Started
+
+When OrbitHub opens, you land on the **Profiles** tab — a searchable,
+sortable list of every connection you've saved. Two toolbar controls in
+the top-right change how that list is presented:
+
+- **View**: `List` shows every profile in one flat table; `Folders` groups
+  them into the folder tree you've organized them into.
+- **Sort**: orders the list by Name, Protocol, or Host.
+
+Along the top of the window, a **Search** box filters by name, host,
+folder path, or tag as you type, and **Protocol**/**Tag** dropdowns narrow
+the list further. These filters, plus your last view mode and sort order,
+are remembered the next time you open OrbitHub.
+
+Along the bottom of the Profiles tab: **New**, **Edit**, and **Delete**
+buttons for managing the selected profile. The same actions are available
+by right-clicking a profile or folder, and from the **File** menu (`New
+Profile`, `New Folder`).
+
+To connect, double-click a profile, or select it and press the connect
+control — this opens a new tab for that session and connects
+automatically.
+
+## Managing Profiles
+
+A profile stores everything needed to reach one remote host. Open **New**
+(or **Edit** on an existing profile) to fill in:
+
+- **Name** — a label for the profile; shown on its tab and in the list.
+- **Host** — hostname or IP address.
+- **Port** — defaults to `22` for SSH, `3389` for RDP.
+- **Username** — the account to log in as.
+- **Domain** — Windows domain for RDP logins (leave blank for local/
+  workgroup accounts or SSH profiles).
+- **Tags** — free-form, comma-separated labels for filtering and grouping
+  (e.g. `prod, linux, db`).
+- **Folder** — where the profile lives in the Folders view.
+- **Protocol** — `SSH`, `RDP`, or `VNC` (VNC is accepted but not yet
+  connectable — see Introduction).
+
+Fields below Protocol change based on what you pick:
+
+**SSH**: **Auth Mode** (`Password` or `Private Key`), and if Private Key,
+a **Private Key** file path with a **Browse** button, plus **Known Hosts**
+policy — see [Connecting via SSH](#connecting-via-ssh) for what each
+policy means.
+
+**RDP**: **RDP Security** and **RDP Performance** — see
+[Connecting via RDP](#connecting-via-rdp).
+
+Passwords are never saved in the profile — OrbitHub asks for them each
+time you connect (unless you've set up private-key SSH auth, which needs
+no password to be entered per-connection if the key itself has none).
+
+## Organizing Profiles
+
+As your profile list grows, two independent tools keep it manageable:
+
+**Folders.** Switch the Profiles tab to `Folders` view to see profiles
+grouped into a tree. Create a folder from the **File** menu or by
+right-clicking in the tree (`New Folder`), and drag any profile onto a
+folder to move it there. Folders can nest inside other folders.
+
+**Tags.** Tags are independent of folders — a profile can be in one folder
+but carry several tags (e.g. `prod`, `linux`, `db` all at once). Use the
+**Tag** filter dropdown in the toolbar to instantly narrow the list to
+everything sharing a tag, regardless of which folder it's filed under.
+
+Combine both with the **Search** box (matches name, host, folder path, or
+tags) and the **Sort** control (Name / Protocol / Host) to find what you
+need quickly even with a large profile list.
+
+## Connecting via SSH
+
+Double-clicking an SSH profile opens a new tab with an embedded, fully
+interactive terminal — type directly into it as you would any terminal
+emulator. A **theme** selector lets you switch between `Dark`, `Light`,
+and `Solarized Dark`; your choice is remembered for future sessions.
+
+**Authentication.** Set in the profile itself:
+- **Password** — OrbitHub prompts for a password each time you connect.
+  It is never stored.
+- **Private Key** — point at a key file (via the profile's Browse button);
+  no password prompt unless the key itself is passphrase-protected.
+
+**Known Hosts policy.** This controls how OrbitHub reacts to a server's
+SSH host key — the mechanism that protects against a different machine
+silently impersonating a host you've connected to before:
+
+| Policy | Behavior |
+|---|---|
+| `Ask` | Prompts you to confirm trust the first time a host is seen, and on any later change. Recommended default. |
+| `Accept-new` | Silently trusts a host the first time it's seen, but still stops and warns if a previously-trusted host's key later changes. |
+| `Strict` | Never trusts an unknown host automatically — the connection fails until you've manually confirmed the host key some other way. |
+| `Ignore` | Skips host-key checking entirely. Only use this for throwaway/test environments — it removes protection against on-path attacks. |
+
+Trusted host keys are recorded in your system's normal SSH `known_hosts`
+file (the same one the `ssh` command line tool uses), so trust decisions
+made through OrbitHub or a terminal `ssh` session carry over to each
+other.
+
+## Connecting via RDP
+
+RDP sessions render in an embedded display surface inside the tab — no
+external RDP client window opens. Keyboard and mouse input go straight to
+the remote desktop while the tab has focus, and resizing the OrbitHub
+window renegotiates the remote resolution to match. Clipboard content
+syncs between your machine and the remote session automatically.
+
+**Authentication** uses the profile's Username/Domain fields; OrbitHub
+prompts for the password at connect time.
+
+**RDP Security** controls which transport-security layer is used to
+negotiate the connection:
+
+| Mode | Behavior |
+|---|---|
+| `Negotiate` | Lets the client and server agree on the strongest mutually-supported option automatically. Recommended default. |
+| `NLA` | Requires Network Level Authentication (credentials verified before a full session starts) — the modern standard for current Windows versions. |
+| `TLS` | Requires TLS-only security, without NLA. |
+| `RDP` | The legacy RDP-native security layer, for older servers that don't support TLS/NLA. |
+
+**RDP Performance** trades visual fidelity for responsiveness:
+`Balanced` (default), `Best Quality`, `Best Performance`, or
+`Auto Detect` (adapts based on the detected connection).
+
+**Server certificate verification.** The first time you connect to an RDP
+host, OrbitHub trusts and remembers its TLS certificate — the same
+trust-on-first-use model SSH uses for host keys. If that certificate ever
+changes on a later connection, OrbitHub refuses the connection rather than
+connecting anyway, since a changed certificate can mean either a
+legitimate server certificate renewal or an active
+machine-in-the-middle presenting a different one. The event log (see
+below) shows the specific fingerprints involved. If the change is
+expected — you rotated the server's certificate yourself — reconnecting
+after clearing the old entry from FreeRDP's certificate store will trust
+the new one.
+
+## Managing Sessions
+
+Every open connection lives in its own tab in the same window, alongside
+the Profiles tab. A tab's title and a colored state indicator show
+whether it's connecting, connected, disconnected, or failed. Closing a
+tab disconnects that session; opening a profile again starts a fresh one.
+
+Each session tab includes a collapsible **event log** beneath the
+connection surface — a timestamped record of connection state changes,
+warnings, and errors for that session. Controls above the log let you:
+
+- **Show/Hide Events** — collapse the panel when you don't need it.
+- **Filter** — a text box to search event text, and an `All` /
+  `Warnings` / `Errors` severity dropdown to narrow what's shown.
+- **Export Events** — save the current session's full event log to a
+  file, useful when reporting a connection problem.
+- **Clear Events** — empty the log for that tab.
+
+## Settings & Preferences
+
+OrbitHub remembers your preferences across restarts without any separate
+settings screen — they're saved automatically as you use the app:
+
+- Profile list: search text, view mode (List/Folders), Protocol/Tag
+  filters, and sort order.
+- Session tabs: terminal theme choice, and whether the events panel is
+  shown or hidden for new tabs.
+
+Profile data itself (names, hosts, tags, folder structure, and so on) is
+stored in a local SQLite database — see the README for its exact path on
+your platform. Passwords are never part of that stored data.
+
+## Troubleshooting
+
+**"Host could not be resolved"** — the hostname in the profile can't be
+looked up by DNS. Check for typos, or try the host's IP address directly
+to confirm whether it's a DNS problem or something else.
+
+**SSH connection fails immediately, no prompt** — double-check the
+profile's Port (default `22`) and that a firewall or network path isn't
+blocking that port from your machine.
+
+**RDP: "Authentication failed. Check username and password."** — confirm
+Username and Domain are correct for the target server; some servers
+require the domain to be set explicitly even for local accounts.
+
+**RDP: "RDP security negotiation failed. Try a different RDP security
+mode."** — the server doesn't support the security mode selected in the
+profile. Try `Negotiate` first, or a more specific mode if you know what
+the server requires.
+
+**RDP: connection refused with a certificate-changed message** — see
+[Connecting via RDP](#connecting-via-rdp) above; this is expected,
+protective behavior, not a bug, whenever a previously-trusted server's
+certificate is replaced.
+
+**SSH: connection hangs at "Ask" waiting for host-key trust** — check
+that policy's behavior under
+[Connecting via SSH](#connecting-via-ssh); switching to `Accept-new` avoids
+the prompt for genuinely new hosts while still protecting against a later
+key change.
+
+If none of this covers what you're seeing, a session's exported event log
+(see Managing Sessions) is the most useful thing to include when asking
+for help or filing an issue.
+
+## About & Support
+
+OrbitHub is open source under the MIT license. Source code, issue
+tracking, and releases are hosted at
+[git.darksingularity.org/DarkSingularity/orbithub](https://git.darksingularity.org/DarkSingularity/orbithub).
+
+For a list of bundled third-party libraries and their licenses, see
+**Help → About OrbitHub** inside the app.
+
+To report a bug or request a feature, open an issue at
+[git.darksingularity.org/DarkSingularity/orbithub/issues](https://git.darksingularity.org/DarkSingularity/orbithub/issues).

docs/user_guide.qrc

@@ -0,0 +1,5 @@
+<RCC>
+  <qresource prefix="/docs">
+    <file>USER_GUIDE.md</file>
+  </qresource>
+</RCC>

packaging/docs/build-user-guide-pdf.sh

@@ -0,0 +1,15 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)"
+BUILD_DIR="${1:-$ROOT_DIR/build-doc-tool}"
+OUTPUT_PATH="${2:-$ROOT_DIR/docs/USER_GUIDE.pdf}"
+
+cmake -S "$ROOT_DIR/tools/user-guide-pdf" -B "$BUILD_DIR" -G Ninja
+cmake --build "$BUILD_DIR"
+
+QT_QPA_PLATFORM=offscreen "$BUILD_DIR/user-guide-pdf" \
+    "$ROOT_DIR/docs/USER_GUIDE.md" \
+    "$OUTPUT_PATH"
+
+echo "Created $OUTPUT_PATH"

packaging/flatpak/build-flatpak.sh

@@ -0,0 +1,26 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)"
+MANIFEST="$ROOT_DIR/packaging/flatpak/org.darksingularity.OrbitHub.yml"
+DIST_DIR="${1:-$ROOT_DIR/dist/flatpak}"
+BUILD_DIR="$DIST_DIR/build"
+REPO_DIR="$DIST_DIR/repo"
+BUNDLE="$DIST_DIR/org.darksingularity.OrbitHub.flatpak"
+
+if ! command -v flatpak-builder >/dev/null 2>&1; then
+  echo "flatpak-builder is required. Install it first:" >&2
+  echo "  sudo apt-get install -y flatpak-builder" >&2
+  exit 1
+fi
+
+mkdir -p "$DIST_DIR"
+
+flatpak-builder \
+  --force-clean \
+  --repo="$REPO_DIR" \
+  "$BUILD_DIR" \
+  "$MANIFEST"
+
+flatpak build-bundle "$REPO_DIR" "$BUNDLE" org.darksingularity.OrbitHub
+echo "Created $BUNDLE"

packaging/flatpak/flathub/flathub.json

@@ -0,0 +1,3 @@
+{
+    "only-arches": ["x86_64"]
+}

packaging/flatpak/flathub/org.darksingularity.OrbitHub.yml

@@ -0,0 +1,23 @@
+app-id: org.darksingularity.OrbitHub
+runtime: org.kde.Platform
+runtime-version: "6.11"
+sdk: org.kde.Sdk
+command: orbithub
+finish-args:
+  - --share=network
+  - --share=ipc
+  - --socket=fallback-x11
+  - --socket=wayland
+  - --device=dri
+  - --filesystem=~/.ssh
+modules:
+  - name: orbithub
+    buildsystem: cmake-ninja
+    builddir: true
+    config-opts:
+      - -DCMAKE_BUILD_TYPE=Release
+    sources:
+      - type: git
+        url: https://git.darksingularity.org/DarkSingularity/orbithub.git
+        tag: v2026.9.15
+        commit: dffca3afef80b5a3ca4832e0b7f748775cb90328

packaging/flatpak/org.darksingularity.OrbitHub.yml

@@ -0,0 +1,21 @@
+app-id: org.darksingularity.OrbitHub
+runtime: org.kde.Platform
+runtime-version: "6.11"
+sdk: org.kde.Sdk
+command: orbithub
+finish-args:
+  - --share=network
+  - --share=ipc
+  - --socket=fallback-x11
+  - --socket=wayland
+  - --device=dri
+  - --filesystem=~/.ssh
+modules:
+  - name: orbithub
+    buildsystem: cmake-ninja
+    builddir: true
+    config-opts:
+      - -DCMAKE_BUILD_TYPE=Release
+    sources:
+      - type: dir
+        path: ../..

packaging/linux/build-deb.sh

@@ -0,0 +1,74 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)"
+BUILD_DIR="${1:-$ROOT_DIR/build}"
+DIST_DIR="${2:-$ROOT_DIR/dist}"
+STAGE_DIR="$DIST_DIR/deb-staging"
+PKG_ROOT="$STAGE_DIR/orbithub"
+
+if [[ ! -f "$BUILD_DIR/CMakeCache.txt" ]]; then
+  echo "Build directory not configured: $BUILD_DIR" >&2
+  echo "Run: cmake -S \"$ROOT_DIR\" -B \"$BUILD_DIR\" -G Ninja" >&2
+  exit 1
+fi
+
+mkdir -p "$DIST_DIR"
+rm -rf "$STAGE_DIR"
+mkdir -p "$PKG_ROOT/DEBIAN"
+
+# Read VERSION only after the build (which reconfigures CMakeCache.txt if
+# CMakeLists.txt changed since the build dir was last configured) --
+# reading it beforehand risks packaging a stale version string.
+cmake --build "$BUILD_DIR" -j
+
+VERSION="$(sed -n 's/^CMAKE_PROJECT_VERSION:STATIC=//p' "$BUILD_DIR/CMakeCache.txt" | head -n1)"
+ARCH="$(dpkg --print-architecture)"
+
+if [[ -z "$VERSION" ]]; then
+  echo "Unable to determine project version from $BUILD_DIR/CMakeCache.txt" >&2
+  exit 1
+fi
+
+cmake --install "$BUILD_DIR" --prefix "$PKG_ROOT/usr"
+
+cat > "$PKG_ROOT/DEBIAN/control" <<EOF
+Package: orbithub
+Version: ${VERSION}
+Section: net
+Priority: optional
+Architecture: ${ARCH}
+Maintainer: OrbitHub Maintainers <maintainers@orbithub.local>
+Depends: libc6, libstdc++6, libqt6core6, libqt6gui6, libqt6widgets6, libqt6sql6, libssl3, zlib1g, openssh-client
+Description: OrbitHub remote session manager
+ OrbitHub is a native desktop application for managing connection profiles
+ and opening SSH and RDP sessions in a tabbed interface.
+EOF
+
+cat > "$PKG_ROOT/DEBIAN/postinst" <<'EOF'
+#!/bin/sh
+set -e
+if command -v update-desktop-database >/dev/null 2>&1; then
+  update-desktop-database -q /usr/share/applications || true
+fi
+if command -v gtk-update-icon-cache >/dev/null 2>&1; then
+  gtk-update-icon-cache -q /usr/share/icons/hicolor || true
+fi
+EOF
+chmod 0755 "$PKG_ROOT/DEBIAN/postinst"
+
+cat > "$PKG_ROOT/DEBIAN/postrm" <<'EOF'
+#!/bin/sh
+set -e
+if command -v update-desktop-database >/dev/null 2>&1; then
+  update-desktop-database -q /usr/share/applications || true
+fi
+if command -v gtk-update-icon-cache >/dev/null 2>&1; then
+  gtk-update-icon-cache -q /usr/share/icons/hicolor || true
+fi
+EOF
+chmod 0755 "$PKG_ROOT/DEBIAN/postrm"
+
+OUTPUT_DEB="$DIST_DIR/orbithub_${VERSION}_${ARCH}.deb"
+fakeroot dpkg-deb --build "$PKG_ROOT" "$OUTPUT_DEB" >/dev/null
+echo "Created $OUTPUT_DEB"

packaging/linux/org.darksingularity.OrbitHub.desktop

@@ -0,0 +1,12 @@
+[Desktop Entry]
+Type=Application
+Version=1.0
+Name=OrbitHub
+GenericName=Remote Session Manager
+Comment=Manage SSH and RDP sessions in one native app
+Exec=orbithub
+Icon=org.darksingularity.OrbitHub
+Terminal=false
+StartupWMClass=OrbitHub
+Categories=Network;RemoteAccess;Utility;
+StartupNotify=true

packaging/linux/org.darksingularity.OrbitHub.metainfo.xml

@@ -0,0 +1,71 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<component type="desktop-application">
+  <id>org.darksingularity.OrbitHub</id>
+  <name>OrbitHub</name>
+  <summary>Unified remote session manager for SSH and RDP</summary>
+  <metadata_license>MIT</metadata_license>
+  <project_license>MIT</project_license>
+  <description>
+    <p>OrbitHub is a native desktop app for organizing connection profiles and launching SSH and RDP sessions in one tabbed interface.</p>
+  </description>
+  <launchable type="desktop-id">org.darksingularity.OrbitHub.desktop</launchable>
+  <url type="homepage">https://git.darksingularity.org/DarkSingularity/orbithub</url>
+  <url type="bugtracker">https://git.darksingularity.org/DarkSingularity/orbithub/issues</url>
+  <url type="vcs-browser">https://git.darksingularity.org/DarkSingularity/orbithub</url>
+  <developer id="org.darksingularity">
+    <name>DarkSingularity</name>
+  </developer>
+  <provides>
+    <binary>orbithub</binary>
+  </provides>
+  <content_rating type="oars-1.1" />
+  <screenshots>
+    <screenshot type="default">
+      <caption>Profiles organized into folders</caption>
+      <image>https://git.darksingularity.org/DarkSingularity/orbithub/raw/branch/main/docs/images/screenshot-profiles.png</image>
+    </screenshot>
+    <screenshot>
+      <caption>Active SSH terminal session</caption>
+      <image>https://git.darksingularity.org/DarkSingularity/orbithub/raw/branch/main/docs/images/screenshot-ssh-session.png</image>
+    </screenshot>
+    <screenshot>
+      <caption>Active RDP session</caption>
+      <image>https://git.darksingularity.org/DarkSingularity/orbithub/raw/branch/main/docs/images/screenshot-rdp-session.png</image>
+    </screenshot>
+  </screenshots>
+  <releases>
+    <release version="2026.9.15" date="2026-09-15">
+      <url>https://git.darksingularity.org/DarkSingularity/orbithub/releases/tag/v2026.9.15</url>
+      <description>
+        <p>Adds Import/Export for profile lists (File menu).</p>
+      </description>
+    </release>
+    <release version="2026.9.14.2" date="2026-09-14">
+      <url>https://git.darksingularity.org/DarkSingularity/orbithub/releases/tag/v2026.9.14.2</url>
+      <description>
+        <p>Fixes RDP display corruption (missing/misplaced taskbar, stale composited content) after resizing the session window.</p>
+      </description>
+    </release>
+    <release version="2026.9.14" date="2026-09-14">
+      <url>https://git.darksingularity.org/DarkSingularity/orbithub/releases/tag/v2026.9.14</url>
+      <description>
+        <p>Fixes distorted RDP text on HiDPI monitors, and reduces RDP resize-related display glitches.</p>
+      </description>
+    </release>
+    <release version="2026.9.8.3" date="2026-09-08">
+      <url>https://git.darksingularity.org/DarkSingularity/orbithub/releases/tag/v2026.9.8.3</url>
+      <description>
+        <p>Adds an in-app User Guide (Help -> User Guide) and a standalone User Guide PDF.</p>
+      </description>
+    </release>
+    <release version="2026.9.8.2" date="2026-09-08">
+      <url>https://git.darksingularity.org/DarkSingularity/orbithub/releases/tag/v2026.9.8.2</url>
+      <description>
+        <p>Fixes RDP connections silently accepting any server TLS certificate, including changed ones. Certificates are now verified with trust-on-first-use, matching SSH's known-hosts behavior.</p>
+      </description>
+    </release>
+    <release version="2026.9.8" date="2026-09-08">
+      <url>https://git.darksingularity.org/DarkSingularity/orbithub/releases/tag/v2026.9.8</url>
+    </release>
+  </releases>
+</component>

packaging/macos/build-dmg.sh

@@ -0,0 +1,104 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)"
+BUILD_DIR="${1:-$ROOT_DIR/build}"
+DIST_DIR="${2:-$ROOT_DIR/dist/macos}"
+STAGE_DIR="$DIST_DIR/dmg-staging"
+INSTALL_PREFIX="$DIST_DIR/install"
+APP_BUNDLE="OrbitHub.app"
+
+if [[ ! -f "$BUILD_DIR/CMakeCache.txt" ]]; then
+  echo "Build directory not configured: $BUILD_DIR" >&2
+  echo "Run: cmake -S \"$ROOT_DIR\" -B \"$BUILD_DIR\" -G Ninja" >&2
+  exit 1
+fi
+
+MACDEPLOYQT="$(brew --prefix qt@6)/bin/macdeployqt"
+if [[ ! -x "$MACDEPLOYQT" ]]; then
+  echo "macdeployqt not found at $MACDEPLOYQT" >&2
+  echo "Install it: brew install qt@6" >&2
+  exit 1
+fi
+
+mkdir -p "$DIST_DIR"
+rm -rf "$STAGE_DIR" "$INSTALL_PREFIX"
+mkdir -p "$STAGE_DIR"
+
+# Read VERSION only after the build (which reconfigures CMakeCache.txt if
+# CMakeLists.txt changed since the build dir was last configured) --
+# reading it beforehand risks packaging a stale version string.
+cmake --build "$BUILD_DIR" -j
+
+VERSION="$(sed -n 's/^CMAKE_PROJECT_VERSION:STATIC=//p' "$BUILD_DIR/CMakeCache.txt" | head -n1)"
+if [[ -z "$VERSION" ]]; then
+  echo "Unable to determine project version from $BUILD_DIR/CMakeCache.txt" >&2
+  exit 1
+fi
+
+cmake --install "$BUILD_DIR" --prefix "$INSTALL_PREFIX"
+
+if [[ ! -d "$INSTALL_PREFIX/$APP_BUNDLE" ]]; then
+  echo "Expected app bundle not found: $INSTALL_PREFIX/$APP_BUNDLE" >&2
+  exit 1
+fi
+
+"$MACDEPLOYQT" "$INSTALL_PREFIX/$APP_BUNDLE"
+
+# macdeployqt rewrites library load paths after bundling Qt, which
+# invalidates any prior signature. Re-sign (ad hoc, since we have no
+# Developer ID certificate) so the app passes macOS's code-integrity
+# check at launch. Without this, launching fails with a generic
+# "cannot be opened because of a problem" crash-reporter dialog rather
+# than the milder unidentified-developer Gatekeeper prompt.
+codesign --force --deep --sign - "$INSTALL_PREFIX/$APP_BUNDLE"
+
+cp -R "$INSTALL_PREFIX/$APP_BUNDLE" "$STAGE_DIR/$APP_BUNDLE"
+ln -s /Applications "$STAGE_DIR/Applications"
+cp "$ROOT_DIR/packaging/macos/orbithub.icns" "$STAGE_DIR/.VolumeIcon.icns"
+
+OUTPUT_DMG="$DIST_DIR/OrbitHub-${VERSION}.dmg"
+RW_DMG="$DIST_DIR/OrbitHub-rw.dmg"
+rm -f "$OUTPUT_DMG" "$RW_DMG"
+
+hdiutil create -volname "OrbitHub" -srcfolder "$STAGE_DIR" -ov -format UDRW "$RW_DMG"
+
+# Setting the volume's icon requires flipping a Finder attribute bit,
+# which needs SetFile (from Xcode's "Additional Tools", not the base
+# Command Line Tools) or the fileicon brew formula. Neither is
+# guaranteed to be installed, so this step degrades gracefully: the
+# dmg is still produced either way, just without a custom icon if no
+# tool is available.
+ICON_TOOL=""
+if command -v SetFile >/dev/null 2>&1; then
+  ICON_TOOL="SetFile"
+elif [[ -x /Library/Developer/CommandLineTools/usr/bin/SetFile ]]; then
+  ICON_TOOL="/Library/Developer/CommandLineTools/usr/bin/SetFile"
+elif command -v fileicon >/dev/null 2>&1; then
+  ICON_TOOL="fileicon"
+fi
+
+if [[ -n "$ICON_TOOL" ]]; then
+  MOUNT_DIR="$(mktemp -d)"
+  hdiutil attach "$RW_DMG" -mountpoint "$MOUNT_DIR" -nobrowse -quiet
+
+  if [[ "$ICON_TOOL" == "fileicon" ]]; then
+    fileicon set "$MOUNT_DIR" "$ROOT_DIR/packaging/macos/orbithub.icns" >/dev/null
+  else
+    "$ICON_TOOL" -a V "$MOUNT_DIR/.VolumeIcon.icns"
+    "$ICON_TOOL" -a C "$MOUNT_DIR"
+  fi
+
+  hdiutil detach "$MOUNT_DIR" -quiet
+  rmdir "$MOUNT_DIR" 2>/dev/null || true
+else
+  echo "Note: SetFile/fileicon not found, dmg will use the generic disk icon." >&2
+  echo "  Install one to get a custom volume icon:" >&2
+  echo "    brew install fileicon" >&2
+  echo "  or download 'Additional Tools for Xcode' from developer.apple.com/download/all" >&2
+fi
+
+hdiutil convert "$RW_DMG" -format UDZO -ov -o "$OUTPUT_DMG"
+rm -f "$RW_DMG"
+
+echo "Created $OUTPUT_DMG"

packaging/windows/build-installer.ps1

@@ -0,0 +1,36 @@
+param(
+    [string]$BuildDir = "$PSScriptRoot\..\..\build",
+    [string]$DistDir = "$PSScriptRoot\..\..\dist\windows"
+)
+
+$ErrorActionPreference = "Stop"
+
+$cacheFile = Join-Path $BuildDir "CMakeCache.txt"
+if (-not (Test-Path $cacheFile)) {
+    throw "Build directory not configured: $BuildDir (run cmake -S . -B build first)"
+}
+
+$versionLine = Select-String -Path $cacheFile -Pattern '^CMAKE_PROJECT_VERSION:STATIC=(.*)$'
+if (-not $versionLine) {
+    throw "Unable to determine project version from $cacheFile"
+}
+$version = $versionLine.Matches[0].Groups[1].Value
+
+$isccCandidates = @(
+    "C:\Program Files (x86)\Inno Setup 6\ISCC.exe",
+    "C:\Program Files\Inno Setup 6\ISCC.exe",
+    "$env:LOCALAPPDATA\Programs\Inno Setup 6\ISCC.exe"
+)
+$iscc = $isccCandidates | Where-Object { Test-Path $_ } | Select-Object -First 1
+if (-not $iscc) {
+    throw "Inno Setup compiler (ISCC.exe) not found. Install it: winget install -e --id JRSoftware.InnoSetup"
+}
+
+New-Item -ItemType Directory -Force -Path $DistDir | Out-Null
+
+& $iscc "/DMyAppVersion=$version" "$PSScriptRoot\orbithub.iss"
+if ($LASTEXITCODE -ne 0) {
+    throw "ISCC.exe failed with exit code $LASTEXITCODE"
+}
+
+Write-Output "Created $DistDir\OrbitHub-Setup-$version.exe"

packaging/windows/orbithub.iss

@@ -0,0 +1,46 @@
+#ifndef MyAppVersion
+#define MyAppVersion "0.0.0"
+#endif
+
+#define MyAppName "OrbitHub"
+#define MyAppPublisher "OrbitHub Maintainers"
+#define MyAppExeName "orbithub.exe"
+#define MyBuildDir "..\..\build"
+
+[Setup]
+AppId={{6B2E0B8F-2C6D-4E7C-9C36-6C6C9C6F6C1A}
+AppName={#MyAppName}
+AppVersion={#MyAppVersion}
+AppPublisher={#MyAppPublisher}
+DefaultDirName={autopf}\{#MyAppName}
+DefaultGroupName={#MyAppName}
+UninstallDisplayIcon={app}\{#MyAppExeName}
+OutputDir=..\..\dist\windows
+OutputBaseFilename=OrbitHub-Setup-{#MyAppVersion}
+Compression=lzma2
+SolidCompression=yes
+ArchitecturesAllowed=x64compatible
+ArchitecturesInstallIn64BitMode=x64compatible
+SetupIconFile=orbithub.ico
+WizardStyle=modern
+DisableProgramGroupPage=yes
+
+[Languages]
+Name: "english"; MessagesFile: "compiler:Default.isl"
+
+[Tasks]
+Name: "desktopicon"; Description: "Create a &desktop shortcut"; GroupDescription: "Additional icons:"; Flags: unchecked
+
+[Files]
+Source: "{#MyBuildDir}\{#MyAppExeName}"; DestDir: "{app}"; Flags: ignoreversion
+Source: "{#MyBuildDir}\*.dll"; DestDir: "{app}"; Flags: ignoreversion
+Source: "{#MyBuildDir}\platforms\*"; DestDir: "{app}\platforms"; Flags: ignoreversion recursesubdirs
+Source: "{#MyBuildDir}\sqldrivers\*"; DestDir: "{app}\sqldrivers"; Flags: ignoreversion recursesubdirs
+
+[Icons]
+Name: "{group}\{#MyAppName}"; Filename: "{app}\{#MyAppExeName}"
+Name: "{group}\Uninstall {#MyAppName}"; Filename: "{uninstallexe}"
+Name: "{autodesktop}\{#MyAppName}"; Filename: "{app}\{#MyAppExeName}"; Tasks: desktopicon
+
+[Run]
+Filename: "{app}\{#MyAppExeName}"; Description: "Launch {#MyAppName}"; Flags: nowait postinstall skipifsilent

packaging/windows/orbithub.rc

@@ -0,0 +1 @@
+1 ICON "orbithub.ico"

src/about_dialog.cpp

@@ -8,6 +8,31 @@
 #include <QTextBrowser>
 #include <QVBoxLayout>
 
+namespace {
+// palette(mid) is meant for 3D bevel/shadow decoration, not text — it has
+// poor contrast against the window background in dark themes (barely
+// legible). Blend the widget's actual text and window colors instead, so
+// the result is reliably readable — de-emphasized relative to full-strength
+// text, but never low-contrast — in either a light or dark theme.
+QColor mutedTextColor(const QWidget* widget)
+{
+    const QPalette pal = widget->palette();
+    const QColor text = pal.color(QPalette::WindowText);
+    const QColor background = pal.color(QPalette::Window);
+    constexpr qreal kTextWeight = 0.65;
+
+    auto blend = [kTextWeight](int textChannel, int backgroundChannel) {
+        return qBound(0,
+                      qRound(textChannel * kTextWeight + backgroundChannel * (1.0 - kTextWeight)),
+                      255);
+    };
+
+    return QColor(blend(text.red(), background.red()),
+                  blend(text.green(), background.green()),
+                  blend(text.blue(), background.blue()));
+}
+}
+
 AboutDialog::AboutDialog(QWidget* parent) : QDialog(parent)
 {
     setWindowTitle(QStringLiteral("About OrbitHub"));
@@ -34,7 +59,7 @@ AboutDialog::AboutDialog(QWidget* parent) : QDialog(parent)
         QStringLiteral("Unified remote session manager for SSH, RDP, and VNC workflows."),
         this);
     subtitle->setWordWrap(true);
-    subtitle->setStyleSheet(QStringLiteral("color: palette(mid);"));
+    subtitle->setStyleSheet(QStringLiteral("color: %1;").arg(mutedTextColor(this).name()));
 
     const QString version = QCoreApplication::applicationVersion().trimmed().isEmpty()
         ? QStringLiteral("Development build")
@@ -42,7 +67,7 @@ AboutDialog::AboutDialog(QWidget* parent) : QDialog(parent)
     auto* buildLine = new QLabel(
         QStringLiteral("Version: %1 | Qt runtime linked dynamically").arg(version),
         this);
-    buildLine->setStyleSheet(QStringLiteral("color: palette(mid);"));
+    buildLine->setStyleSheet(QStringLiteral("color: %1;").arg(mutedTextColor(this).name()));
 
     titleColumn->addWidget(title);
     titleColumn->addWidget(subtitle);

src/main.cpp

@@ -1,5 +1,5 @@
 #include "app_icon.h"
-#include "profiles_window.h"
+#include "session_window.h"
 
 #include <QApplication>
 
@@ -10,9 +10,12 @@ int main(int argc, char* argv[])
     QApplication app(argc, argv);
     app.setOrganizationName(QStringLiteral("FireBugIT"));
     app.setApplicationName(QStringLiteral("OrbitHub"));
+#ifdef ORBITHUB_VERSION_STRING
+    app.setApplicationVersion(QStringLiteral(ORBITHUB_VERSION_STRING));
+#endif
     app.setWindowIcon(createOrbitHubAppIcon());
 
-    ProfilesWindow window;
+    SessionWindow window;
     window.show();
 
     return app.exec();

src/profile_dialog.cpp

@@ -71,6 +71,9 @@ ProfileDialog::ProfileDialog(QWidget* parent)
 
     auto* layout = new QVBoxLayout(this);
     auto* form = new QFormLayout();
+    form->setFieldGrowthPolicy(QFormLayout::ExpandingFieldsGrow);
+    form->setFormAlignment(Qt::AlignLeft | Qt::AlignTop);
+    form->setLabelAlignment(Qt::AlignRight);
 
     m_nameInput->setPlaceholderText(QStringLiteral("Production Bastion"));
     m_hostInput->setPlaceholderText(QStringLiteral("example.internal"));

src/profile_repository.cpp

@@ -9,7 +9,11 @@
 #include <QVariant>
 #include <QStringList>
 
+#include <atomic>
+
 namespace {
+std::atomic<int> g_testConnectionCounter{0};
+
 QString buildDatabasePath()
 {
     QString appDataPath = QStandardPaths::writableLocation(QStandardPaths::AppDataLocation);
@@ -176,7 +180,7 @@ void bindProfileFields(QSqlQuery& query, const Profile& profile)
                              : QStringLiteral("Negotiate"));
     query.addBindValue(isRdp ? normalizedRdpPerformanceProfile(profile.rdpPerformanceProfile)
                              : QStringLiteral("Balanced"));
-    query.addBindValue(normalizedTags(profile.tags));
+    query.addBindValue(nonNullTrimmed(normalizedTags(profile.tags)));
 }
 
 Profile profileFromQuery(const QSqlQuery& query)
@@ -259,6 +263,16 @@ ProfileRepository::ProfileRepository() : m_connectionName(QStringLiteral("orbith
     }
 }
 
+ProfileRepository::ProfileRepository(const QString& databasePathOverride)
+    : m_connectionName(QStringLiteral("orbithub_test_%1")
+                            .arg(g_testConnectionCounter.fetch_add(1))),
+      m_databasePathOverride(databasePathOverride)
+{
+    if (!initializeDatabase()) {
+        QSqlDatabase::removeDatabase(m_connectionName);
+    }
+}
+
 ProfileRepository::~ProfileRepository()
 {
     if (QSqlDatabase::contains(m_connectionName)) {
@@ -332,6 +346,123 @@ bool ProfileRepository::createFolder(const QString& folderPath) const
     return true;
 }
 
+// Deleting a folder never destroys profiles: everything directly inside it
+// (profiles and subfolders alike) is shifted up to take the deleted
+// folder's place, exactly as if that one path segment had been removed
+// from each of their paths. This is the least-surprising behavior for what
+// is fundamentally just an organizational label, not a container that owns
+// its contents.
+bool ProfileRepository::deleteFolder(const QString& folderPath) const
+{
+    if (!QSqlDatabase::contains(m_connectionName)) {
+        return false;
+    }
+
+    const QString normalized = normalizedFolderPath(folderPath);
+    if (normalized.isEmpty()) {
+        setLastError(QStringLiteral("Folder path is required."));
+        return false;
+    }
+
+    setLastError(QString());
+
+    QString parentPath;
+    const int lastSlash = normalized.lastIndexOf(QChar::fromLatin1('/'));
+    if (lastSlash >= 0) {
+        parentPath = normalized.left(lastSlash);
+    }
+
+    const QString prefix = normalized + QStringLiteral("/");
+    auto remap = [&](const QString& oldPath) {
+        if (oldPath == normalized) {
+            return nonNullTrimmed(parentPath);
+        }
+        const QString remainder = oldPath.mid(prefix.length());
+        return nonNullTrimmed(parentPath.isEmpty() ? remainder
+                                                    : parentPath + QStringLiteral("/") + remainder);
+    };
+
+    QSqlDatabase database = QSqlDatabase::database(m_connectionName);
+    if (!database.transaction()) {
+        setLastError(database.lastError().text());
+        return false;
+    }
+
+    // Reassign affected profiles. Matching is done in C++ (not SQL LIKE)
+    // so a folder name containing '%' or '_' can't be misinterpreted as a
+    // wildcard.
+    QSqlQuery selectProfiles(database);
+    if (!selectProfiles.exec(QStringLiteral("SELECT id, folder_path FROM profiles"))) {
+        setLastError(selectProfiles.lastError().text());
+        database.rollback();
+        return false;
+    }
+    std::vector<std::pair<qint64, QString>> profileUpdates;
+    while (selectProfiles.next()) {
+        const QString path = normalizedFolderPath(selectProfiles.value(1).toString());
+        if (path == normalized || path.startsWith(prefix)) {
+            profileUpdates.emplace_back(selectProfiles.value(0).toLongLong(), remap(path));
+        }
+    }
+    for (const auto& [id, newPath] : profileUpdates) {
+        QSqlQuery update(database);
+        update.prepare(QStringLiteral("UPDATE profiles SET folder_path = ? WHERE id = ?"));
+        update.addBindValue(newPath);
+        update.addBindValue(id);
+        if (!update.exec()) {
+            setLastError(update.lastError().text());
+            database.rollback();
+            return false;
+        }
+    }
+
+    // Reassign (or drop, for the folder itself) affected explicit folder
+    // markers the same way.
+    QSqlQuery selectFolders(database);
+    if (!selectFolders.exec(QStringLiteral("SELECT path FROM profile_folders"))) {
+        setLastError(selectFolders.lastError().text());
+        database.rollback();
+        return false;
+    }
+    QStringList affectedFolders;
+    while (selectFolders.next()) {
+        const QString path = normalizedFolderPath(selectFolders.value(0).toString());
+        if (path == normalized || path.startsWith(prefix)) {
+            affectedFolders.push_back(path);
+        }
+    }
+    for (const QString& oldPath : affectedFolders) {
+        QSqlQuery remove(database);
+        remove.prepare(QStringLiteral("DELETE FROM profile_folders WHERE path = ?"));
+        remove.addBindValue(oldPath);
+        if (!remove.exec()) {
+            setLastError(remove.lastError().text());
+            database.rollback();
+            return false;
+        }
+
+        const QString newPath = remap(oldPath);
+        if (oldPath != normalized && !newPath.isEmpty()) {
+            QSqlQuery insert(database);
+            insert.prepare(QStringLiteral("INSERT OR IGNORE INTO profile_folders(path) VALUES (?)"));
+            insert.addBindValue(newPath);
+            if (!insert.exec()) {
+                setLastError(insert.lastError().text());
+                database.rollback();
+                return false;
+            }
+        }
+    }
+
+    if (!database.commit()) {
+        setLastError(database.lastError().text());
+        database.rollback();
+        return false;
+    }
+
+    return true;
+}
+
 std::vector<Profile> ProfileRepository::listProfiles(const QString& searchQuery,
                                                      ProfileSortOrder sortOrder) const
 {
@@ -485,7 +616,8 @@ bool ProfileRepository::deleteProfile(qint64 id) const
 bool ProfileRepository::initializeDatabase()
 {
     QSqlDatabase database = QSqlDatabase::addDatabase(QStringLiteral("QSQLITE"), m_connectionName);
-    database.setDatabaseName(buildDatabasePath());
+    database.setDatabaseName(
+        m_databasePathOverride.isEmpty() ? buildDatabasePath() : m_databasePathOverride);
 
     if (!database.open()) {
         m_initError = database.lastError().text();

src/profile_repository.h

@@ -35,6 +35,9 @@ class ProfileRepository
 {
 public:
     ProfileRepository();
+    // databasePathOverride lets tests point the repository at an isolated,
+    // disposable SQLite file instead of the real app-data location.
+    explicit ProfileRepository(const QString& databasePathOverride);
     ~ProfileRepository();
 
     QString initError() const;
@@ -44,6 +47,7 @@ public:
                                       ProfileSortOrder sortOrder = ProfileSortOrder::NameAsc) const;
     std::vector<QString> listFolders() const;
     bool createFolder(const QString& folderPath) const;
+    bool deleteFolder(const QString& folderPath) const;
     std::optional<Profile> getProfile(qint64 id) const;
     std::optional<Profile> createProfile(const Profile& profile) const;
     bool updateProfile(const Profile& profile) const;
@@ -51,6 +55,7 @@ public:
 
 private:
     QString m_connectionName;
+    QString m_databasePathOverride;
     QString m_initError;
     mutable QString m_lastError;
 

src/profiles_window.cpp

@@ -1,27 +1,28 @@
 #include "profiles_window.h"
 
-#include "about_dialog.h"
 #include "profile_dialog.h"
 #include "profile_repository.h"
 #include "profiles_tree_widget.h"
-#include "session_window.h"
 
 #include <QAction>
 #include <QAbstractItemView>
 #include <QComboBox>
+#include <QFile>
+#include <QFileDialog>
 #include <QHeaderView>
 #include <QHBoxLayout>
+#include <QJsonArray>
+#include <QJsonDocument>
+#include <QJsonObject>
 #include <QLabel>
 #include <QLineEdit>
 #include <QInputDialog>
 #include <QMenu>
-#include <QMenuBar>
 #include <QMessageBox>
 #include <QPushButton>
 #include <QSet>
 #include <QSettings>
 #include <QSignalBlocker>
-#include <QApplication>
 #include <QStringList>
 #include <QStyle>
 #include <QTreeWidget>
@@ -89,10 +90,57 @@ bool profileHasTag(const Profile& profile, const QString& requestedTag)
 
     return false;
 }
+
+constexpr int kProfileExportFormatVersion = 1;
+
+QJsonObject profileToJson(const Profile& profile)
+{
+    QJsonObject object;
+    object.insert(QStringLiteral("name"), profile.name);
+    object.insert(QStringLiteral("host"), profile.host);
+    object.insert(QStringLiteral("port"), profile.port);
+    object.insert(QStringLiteral("username"), profile.username);
+    object.insert(QStringLiteral("domain"), profile.domain);
+    object.insert(QStringLiteral("folderPath"), profile.folderPath);
+    object.insert(QStringLiteral("protocol"), profile.protocol);
+    object.insert(QStringLiteral("authMode"), profile.authMode);
+    object.insert(QStringLiteral("privateKeyPath"), profile.privateKeyPath);
+    object.insert(QStringLiteral("knownHostsPolicy"), profile.knownHostsPolicy);
+    object.insert(QStringLiteral("rdpSecurityMode"), profile.rdpSecurityMode);
+    object.insert(QStringLiteral("rdpPerformanceProfile"), profile.rdpPerformanceProfile);
+    object.insert(QStringLiteral("tags"), profile.tags);
+    return object;
+}
+
+// Deliberately excludes id (import always creates new rows -- an imported
+// profile's id has no meaning in the destination database) and any
+// credential material (none is ever persisted on Profile in the first
+// place, see ProfileRepository).
+Profile profileFromJson(const QJsonObject& object)
+{
+    Profile profile;
+    profile.name = object.value(QStringLiteral("name")).toString();
+    profile.host = object.value(QStringLiteral("host")).toString();
+    profile.port = object.value(QStringLiteral("port")).toInt(22);
+    profile.username = object.value(QStringLiteral("username")).toString();
+    profile.domain = object.value(QStringLiteral("domain")).toString();
+    profile.folderPath = object.value(QStringLiteral("folderPath")).toString();
+    profile.protocol = object.value(QStringLiteral("protocol")).toString(QStringLiteral("SSH"));
+    profile.authMode = object.value(QStringLiteral("authMode")).toString(QStringLiteral("Password"));
+    profile.privateKeyPath = object.value(QStringLiteral("privateKeyPath")).toString();
+    profile.knownHostsPolicy =
+        object.value(QStringLiteral("knownHostsPolicy")).toString(QStringLiteral("Ask"));
+    profile.rdpSecurityMode =
+        object.value(QStringLiteral("rdpSecurityMode")).toString(QStringLiteral("Negotiate"));
+    profile.rdpPerformanceProfile =
+        object.value(QStringLiteral("rdpPerformanceProfile")).toString(QStringLiteral("Balanced"));
+    profile.tags = object.value(QStringLiteral("tags")).toString();
+    return profile;
+}
 }
 
 ProfilesWindow::ProfilesWindow(QWidget* parent)
-    : QMainWindow(parent),
+    : QWidget(parent),
       m_searchBox(nullptr),
       m_viewModeBox(nullptr),
       m_sortBox(nullptr),
@@ -104,10 +152,6 @@ ProfilesWindow::ProfilesWindow(QWidget* parent)
       m_deleteButton(nullptr),
       m_repository(std::make_unique<ProfileRepository>())
 {
-    setWindowTitle(QStringLiteral("OrbitHub Profiles"));
-    resize(860, 640);
-    setWindowIcon(QApplication::windowIcon());
-
     setupUi();
 
     if (!m_repository->initError().isEmpty()) {
@@ -131,36 +175,35 @@ ProfilesWindow::~ProfilesWindow() = default;
 
 void ProfilesWindow::setupUi()
 {
-    auto* central = new QWidget(this);
-    auto* rootLayout = new QVBoxLayout(central);
+    auto* rootLayout = new QVBoxLayout(this);
 
-    auto* searchLabel = new QLabel(QStringLiteral("Search"), central);
-    m_searchBox = new QLineEdit(central);
+    auto* searchLabel = new QLabel(QStringLiteral("Search"), this);
+    m_searchBox = new QLineEdit(this);
     m_searchBox->setPlaceholderText(QStringLiteral("Filter by name, host, folder, or tags..."));
 
-    auto* viewModeLabel = new QLabel(QStringLiteral("View"), central);
-    m_viewModeBox = new QComboBox(central);
+    auto* viewModeLabel = new QLabel(QStringLiteral("View"), this);
+    m_viewModeBox = new QComboBox(this);
     m_viewModeBox->addItem(QStringLiteral("List"));
     m_viewModeBox->addItem(QStringLiteral("Folders"));
 
-    auto* sortLabel = new QLabel(QStringLiteral("Sort"), central);
-    m_sortBox = new QComboBox(central);
+    auto* sortLabel = new QLabel(QStringLiteral("Sort"), this);
+    m_sortBox = new QComboBox(this);
     m_sortBox->addItem(QStringLiteral("Name"), static_cast<int>(ProfileSortOrder::NameAsc));
     m_sortBox->addItem(QStringLiteral("Protocol"), static_cast<int>(ProfileSortOrder::ProtocolAsc));
     m_sortBox->addItem(QStringLiteral("Host"), static_cast<int>(ProfileSortOrder::HostAsc));
 
-    auto* protocolFilterLabel = new QLabel(QStringLiteral("Protocol"), central);
-    m_protocolFilterBox = new QComboBox(central);
+    auto* protocolFilterLabel = new QLabel(QStringLiteral("Protocol"), this);
+    m_protocolFilterBox = new QComboBox(this);
     m_protocolFilterBox->addItem(QStringLiteral("All"));
     m_protocolFilterBox->addItem(QStringLiteral("SSH"));
     m_protocolFilterBox->addItem(QStringLiteral("RDP"));
     m_protocolFilterBox->addItem(QStringLiteral("VNC"));
 
-    auto* tagFilterLabel = new QLabel(QStringLiteral("Tag"), central);
-    m_tagFilterBox = new QComboBox(central);
+    auto* tagFilterLabel = new QLabel(QStringLiteral("Tag"), this);
+    m_tagFilterBox = new QComboBox(this);
     m_tagFilterBox->addItem(QStringLiteral("All"));
 
-    m_profilesTree = new ProfilesTreeWidget(central);
+    m_profilesTree = new ProfilesTreeWidget(this);
     m_profilesTree->setSelectionMode(QAbstractItemView::SingleSelection);
     m_profilesTree->setColumnCount(4);
     m_profilesTree->setHeaderLabels(
@@ -179,9 +222,9 @@ void ProfilesWindow::setupUi()
     m_profilesTree->header()->setSectionResizeMode(3, QHeaderView::Stretch);
 
     auto* buttonRow = new QHBoxLayout();
-    m_newButton = new QPushButton(QStringLiteral("New"), central);
-    m_editButton = new QPushButton(QStringLiteral("Edit"), central);
-    m_deleteButton = new QPushButton(QStringLiteral("Delete"), central);
+    m_newButton = new QPushButton(QStringLiteral("New"), this);
+    m_editButton = new QPushButton(QStringLiteral("Edit"), this);
+    m_deleteButton = new QPushButton(QStringLiteral("Delete"), this);
 
     buttonRow->addWidget(m_newButton);
     buttonRow->addWidget(m_editButton);
@@ -204,40 +247,6 @@ void ProfilesWindow::setupUi()
     rootLayout->addWidget(m_profilesTree, 1);
     rootLayout->addLayout(buttonRow);
 
-    setCentralWidget(central);
-
-    QMenu* fileMenu = menuBar()->addMenu(QStringLiteral("File"));
-    QAction* newProfileAction = fileMenu->addAction(QStringLiteral("New Profile"));
-    QAction* newFolderAction = fileMenu->addAction(QStringLiteral("New Folder"));
-    fileMenu->addSeparator();
-    QAction* quitAction = fileMenu->addAction(QStringLiteral("Quit"));
-
-    connect(newProfileAction,
-            &QAction::triggered,
-            this,
-            [this]() {
-                const QString folderPath = folderPathForItem(m_profilesTree->currentItem());
-                createProfile(folderPath);
-            });
-    connect(newFolderAction,
-            &QAction::triggered,
-            this,
-            [this]() {
-                const QString folderPath = folderPathForItem(m_profilesTree->currentItem());
-                createFolderInContext(folderPath);
-            });
-    connect(quitAction, &QAction::triggered, this, [this]() { close(); });
-
-    QMenu* helpMenu = menuBar()->addMenu(QStringLiteral("Help"));
-    QAction* aboutAction = helpMenu->addAction(QStringLiteral("About OrbitHub"));
-    connect(aboutAction,
-            &QAction::triggered,
-            this,
-            [this]() {
-                AboutDialog dialog(this);
-                dialog.exec();
-            });
-
     connect(m_searchBox,
             &QLineEdit::textChanged,
             this,
@@ -578,6 +587,8 @@ void ProfilesWindow::showTreeContextMenu(const QPoint& pos)
 
     const QString contextFolder = folderPathForItem(item);
     const bool isProfileItem = item != nullptr && item->data(0, kProfileIdRole).isValid();
+    const bool isFolderItem =
+        item != nullptr && !isProfileItem && item->data(0, kFolderPathRole).isValid();
 
     QMenu menu(this);
     QAction* newConnectionAction = menu.addAction(QStringLiteral("New Connection"));
@@ -585,12 +596,16 @@ void ProfilesWindow::showTreeContextMenu(const QPoint& pos)
     QAction* connectAction = nullptr;
     QAction* editAction = nullptr;
     QAction* deleteAction = nullptr;
+    QAction* deleteFolderAction = nullptr;
 
     if (isProfileItem) {
         menu.addSeparator();
         connectAction = menu.addAction(QStringLiteral("Connect"));
         editAction = menu.addAction(QStringLiteral("Edit"));
         deleteAction = menu.addAction(QStringLiteral("Delete"));
+    } else if (isFolderItem) {
+        menu.addSeparator();
+        deleteFolderAction = menu.addAction(QStringLiteral("Delete Folder"));
     }
 
     QAction* chosen = menu.exec(m_profilesTree->viewport()->mapToGlobal(pos));
@@ -620,6 +635,10 @@ void ProfilesWindow::showTreeContextMenu(const QPoint& pos)
         deleteSelectedProfile();
         return;
     }
+    if (isFolderItem && chosen == deleteFolderAction) {
+        deleteFolderInContext(contextFolder);
+        return;
+    }
 }
 
 void ProfilesWindow::createFolderInContext(const QString& baseFolderPath)
@@ -657,6 +676,72 @@ void ProfilesWindow::createFolderInContext(const QString& baseFolderPath)
     loadProfiles();
 }
 
+void ProfilesWindow::deleteFolderInContext(const QString& folderPath)
+{
+    const QString normalized = normalizeFolderPathForView(folderPath);
+    if (normalized.isEmpty()) {
+        return;
+    }
+
+    // Deleting a folder never deletes profiles -- everything inside it
+    // (profiles and subfolders) shifts up to take its place. Count what's
+    // affected so the confirmation is honest about that, rather than
+    // reading like the usual destructive "Delete" action.
+    const QString prefix = normalized + QStringLiteral("/");
+    int profileCount = 0;
+    for (const Profile& profile : m_repository->listProfiles()) {
+        if (profile.folderPath == normalized || profile.folderPath.startsWith(prefix)) {
+            ++profileCount;
+        }
+    }
+    int subfolderCount = 0;
+    for (const QString& folder : m_repository->listFolders()) {
+        if (folder != normalized && folder.startsWith(prefix)) {
+            ++subfolderCount;
+        }
+    }
+
+    if (profileCount > 0 || subfolderCount > 0) {
+        QStringList parentParts = splitFolderPath(normalized);
+        parentParts.removeLast();
+        const QString destination = parentParts.isEmpty()
+            ? QStringLiteral("the top level")
+            : QStringLiteral("'%1'").arg(parentParts.join(QStringLiteral("/")));
+
+        QStringList details;
+        if (profileCount > 0) {
+            details.push_back(QStringLiteral("%1 profile(s)").arg(profileCount));
+        }
+        if (subfolderCount > 0) {
+            details.push_back(QStringLiteral("%1 subfolder(s)").arg(subfolderCount));
+        }
+
+        const QMessageBox::StandardButton confirm = QMessageBox::question(
+            this,
+            QStringLiteral("Delete Folder"),
+            QStringLiteral("Delete folder '%1'?\n\nNothing will be deleted: %2 currently inside "
+                           "it will move up to %3.")
+                .arg(normalized, details.join(QStringLiteral(" and ")), destination),
+            QMessageBox::Yes | QMessageBox::No,
+            QMessageBox::No);
+        if (confirm != QMessageBox::Yes) {
+            return;
+        }
+    }
+
+    if (!m_repository->deleteFolder(normalized)) {
+        QMessageBox::warning(this,
+                             QStringLiteral("Delete Folder"),
+                             QStringLiteral("Failed to delete folder: %1")
+                                 .arg(m_repository->lastError().isEmpty()
+                                          ? QStringLiteral("unknown error")
+                                          : m_repository->lastError()));
+        return;
+    }
+
+    loadProfiles();
+}
+
 void ProfilesWindow::persistFolderAssignmentsFromTree()
 {
     if (!isFolderViewEnabled() || m_profilesTree == nullptr) {
@@ -959,16 +1044,142 @@ void ProfilesWindow::openSessionForItem(QTreeWidgetItem* item)
         return;
     }
 
-    if (m_sessionWindow.isNull()) {
-        m_sessionWindow = new SessionWindow(profile.value());
-        m_sessionWindow->setAttribute(Qt::WA_DeleteOnClose);
-        connect(m_sessionWindow, &QObject::destroyed, this, [this]() { m_sessionWindow = nullptr; });
-    } else {
-        m_sessionWindow->openProfile(profile.value());
+    emit connectRequested(profile.value());
+}
+
+void ProfilesWindow::createProfileInCurrentContext()
+{
+    const QString folderPath = folderPathForItem(m_profilesTree->currentItem());
+    createProfile(folderPath);
+}
+
+void ProfilesWindow::createFolderInCurrentContext()
+{
+    const QString folderPath = folderPathForItem(m_profilesTree->currentItem());
+    createFolderInContext(folderPath);
+}
+
+void ProfilesWindow::exportProfiles()
+{
+    const QString fileName = QFileDialog::getSaveFileName(
+        this, QStringLiteral("Export Profiles"), QStringLiteral("orbithub-profiles.json"),
+        QStringLiteral("JSON Files (*.json)"));
+    if (fileName.isEmpty()) {
+        return;
     }
 
-    m_sessionWindow->setWindowState(m_sessionWindow->windowState() & ~Qt::WindowMinimized);
-    m_sessionWindow->show();
-    m_sessionWindow->raise();
-    m_sessionWindow->activateWindow();
+    QJsonArray folders;
+    for (const QString& folderPath : m_repository->listFolders()) {
+        folders.append(folderPath);
+    }
+
+    QJsonArray profiles;
+    for (const Profile& profile : m_repository->listProfiles()) {
+        profiles.append(profileToJson(profile));
+    }
+
+    QJsonObject root;
+    root.insert(QStringLiteral("orbithubProfileExport"), kProfileExportFormatVersion);
+    root.insert(QStringLiteral("folders"), folders);
+    root.insert(QStringLiteral("profiles"), profiles);
+
+    QFile file(fileName);
+    if (!file.open(QIODevice::WriteOnly | QIODevice::Truncate)) {
+        QMessageBox::warning(this,
+                             QStringLiteral("Export Profiles"),
+                             QStringLiteral("Failed to write %1: %2")
+                                 .arg(fileName, file.errorString()));
+        return;
+    }
+    file.write(QJsonDocument(root).toJson(QJsonDocument::Indented));
+    file.close();
+
+    QMessageBox::information(this,
+                             QStringLiteral("Export Profiles"),
+                             QStringLiteral("Exported %1 profile(s) to %2.")
+                                 .arg(profiles.size())
+                                 .arg(fileName));
+}
+
+void ProfilesWindow::importProfiles()
+{
+    const QString fileName = QFileDialog::getOpenFileName(
+        this, QStringLiteral("Import Profiles"), QString(), QStringLiteral("JSON Files (*.json)"));
+    if (fileName.isEmpty()) {
+        return;
+    }
+
+    QFile file(fileName);
+    if (!file.open(QIODevice::ReadOnly)) {
+        QMessageBox::warning(this,
+                             QStringLiteral("Import Profiles"),
+                             QStringLiteral("Failed to read %1: %2")
+                                 .arg(fileName, file.errorString()));
+        return;
+    }
+
+    QJsonParseError parseError{};
+    const QJsonDocument doc = QJsonDocument::fromJson(file.readAll(), &parseError);
+    file.close();
+    if (parseError.error != QJsonParseError::NoError || !doc.isObject()) {
+        QMessageBox::warning(this,
+                             QStringLiteral("Import Profiles"),
+                             QStringLiteral("%1 is not a valid OrbitHub profile export: %2")
+                                 .arg(fileName, parseError.errorString()));
+        return;
+    }
+
+    const QJsonObject root = doc.object();
+    if (!root.value(QStringLiteral("profiles")).isArray()) {
+        QMessageBox::warning(this,
+                             QStringLiteral("Import Profiles"),
+                             QStringLiteral("%1 does not contain a profile list.").arg(fileName));
+        return;
+    }
+
+    for (const QJsonValue& folderValue : root.value(QStringLiteral("folders")).toArray()) {
+        const QString folderPath = folderValue.toString();
+        if (!folderPath.isEmpty()) {
+            m_repository->createFolder(folderPath);
+        }
+    }
+
+    const QJsonArray profilesArray = root.value(QStringLiteral("profiles")).toArray();
+    int imported = 0;
+    QStringList failures;
+    for (const QJsonValue& profileValue : profilesArray) {
+        if (!profileValue.isObject()) {
+            continue;
+        }
+        const Profile profile = profileFromJson(profileValue.toObject());
+        if (profile.name.isEmpty() || profile.host.isEmpty()) {
+            failures.push_back(QStringLiteral("(unnamed profile): missing name or host"));
+            continue;
+        }
+        // No need to createFolder(profile.folderPath) here: the tree view
+        // already synthesizes folder nodes from a profile's own folderPath
+        // (see ProfilesWindow::loadProfiles). Explicit profile_folders rows
+        // are only for folders with no profiles in them, and those are
+        // already recreated above from the export's top-level "folders"
+        // list -- doing it again per-profile would just add spurious
+        // entries not present in the original export.
+        if (m_repository->createProfile(profile).has_value()) {
+            ++imported;
+        } else {
+            failures.push_back(QStringLiteral("%1: %2").arg(profile.name, m_repository->lastError()));
+        }
+    }
+
+    loadProfiles();
+
+    QString summary = QStringLiteral("Imported %1 of %2 profile(s) from %3.")
+                          .arg(imported)
+                          .arg(profilesArray.size())
+                          .arg(fileName);
+    if (!failures.isEmpty()) {
+        summary += QStringLiteral("\n\nFailed:\n%1").arg(failures.join(QChar::fromLatin1('\n')));
+        QMessageBox::warning(this, QStringLiteral("Import Profiles"), summary);
+    } else {
+        QMessageBox::information(this, QStringLiteral("Import Profiles"), summary);
+    }
 }

src/profiles_window.h

@@ -3,7 +3,7 @@
 
 #include "profile_repository.h"
 
-#include <QMainWindow>
+#include <QWidget>
 #include <QString>
 #include <QStringList>
 #include <QtGlobal>
@@ -11,7 +11,6 @@
 #include <memory>
 #include <map>
 #include <optional>
-#include <QPointer>
 #include <vector>
 #include <unordered_map>
 
@@ -21,10 +20,9 @@ class QLineEdit;
 class QPushButton;
 class QComboBox;
 class QPoint;
-class SessionWindow;
 class ProfilesTreeWidget;
 
-class ProfilesWindow : public QMainWindow
+class ProfilesWindow : public QWidget
 {
     Q_OBJECT
 
@@ -32,6 +30,14 @@ public:
     explicit ProfilesWindow(QWidget* parent = nullptr);
     ~ProfilesWindow() override;
 
+    void createProfileInCurrentContext();
+    void createFolderInCurrentContext();
+    void exportProfiles();
+    void importProfiles();
+
+signals:
+    void connectRequested(const Profile& profile);
+
 private:
     QLineEdit* m_searchBox;
     QComboBox* m_viewModeBox;
@@ -42,7 +48,6 @@ private:
     QPushButton* m_newButton;
     QPushButton* m_editButton;
     QPushButton* m_deleteButton;
-    QPointer<SessionWindow> m_sessionWindow;
     std::unique_ptr<ProfileRepository> m_repository;
     std::unordered_map<qint64, Profile> m_profileCache;
     QString m_pendingTagFilterPreference;
@@ -60,6 +65,7 @@ private:
     QString folderPathForItem(const QTreeWidgetItem* item) const;
     void showTreeContextMenu(const QPoint& pos);
     void createFolderInContext(const QString& baseFolderPath);
+    void deleteFolderInContext(const QString& folderPath);
     void persistFolderAssignmentsFromTree();
     void collectProfileAssignments(const QTreeWidgetItem* item,
                                    const QString& parentFolderPath,

src/rdp_display_widget.cpp

@@ -1,8 +1,11 @@
 #include "rdp_display_widget.h"
 
+#include <QCursor>
+#include <QEvent>
 #include <QKeyEvent>
 #include <QMouseEvent>
 #include <QPainter>
+#include <QPixmap>
 #include <QResizeEvent>
 #include <QTimer>
 #include <QWheelEvent>
@@ -13,20 +16,38 @@ QSize sanitizeSize(const QSize& size)
 {
     return QSize(qMax(1, size.width()), qMax(1, size.height()));
 }
+
+qreal sanitizeDevicePixelRatio(qreal ratio)
+{
+    if (!(ratio > 0.0)) {
+        return 1.0;
+    }
+    return qBound(1.0, ratio, 4.0);
+}
+
+// Windows' virtual-display driver can visibly glitch (stale composited
+// content left on screen) when asked to change resolution repeatedly in
+// quick succession, which naturally happens as the window's layout settles
+// right after creation/connect. Coalescing bursts of resize events into one
+// request avoids triggering that.
+constexpr int kResizeDebounceMs = 150;
 }
 
 RdpDisplayWidget::RdpDisplayWidget(QWidget* parent)
-    : QWidget(parent), m_remoteSize(1280, 720)
+    : QWidget(parent),
+      m_remoteSize(1280, 720),
+      m_cursorMode(CursorMode::Default),
+      m_resizeDebounceTimer(new QTimer(this))
 {
     setFocusPolicy(Qt::StrongFocus);
     setMouseTracking(true);
     setAutoFillBackground(false);
     setMinimumSize(320, 200);
 
-    QTimer::singleShot(0, this, [this]() {
-        const QSize size = sanitizeSize(this->size());
-        emit viewportSizeChanged(size.width(), size.height());
-    });
+    m_resizeDebounceTimer->setSingleShot(true);
+    connect(m_resizeDebounceTimer, &QTimer::timeout, this, &RdpDisplayWidget::emitViewportGeometry);
+
+    scheduleViewportGeometryEmit();
 }
 
 void RdpDisplayWidget::setFrame(const QImage& frame)
@@ -52,6 +73,13 @@ void RdpDisplayWidget::setRemoteDesktopSize(int width, int height)
     }
 
     m_remoteSize = nextSize;
+    // The next actual frame (via setFrame) arrives asynchronously and isn't
+    // guaranteed to be sized to match yet. Drawing the old frame stretched
+    // to a renderRect() computed from the new m_remoteSize would scale it
+    // by the wrong factor for the transition window, producing visibly
+    // distorted/duplicated-looking content. Clear it and show the existing
+    // "waiting for frame" placeholder until a correctly-sized frame lands.
+    m_frame = QImage();
     update();
 }
 
@@ -61,6 +89,62 @@ void RdpDisplayWidget::clearFrame()
     update();
 }
 
+void RdpDisplayWidget::setCursorImage(const QImage& image, const QPoint& hotspot)
+{
+    m_cursorImage = image;
+    m_cursorHotspot = hotspot;
+    m_cursorMode = CursorMode::Custom;
+    applyCursor();
+}
+
+void RdpDisplayWidget::setCursorHidden()
+{
+    m_cursorMode = CursorMode::Hidden;
+    applyCursor();
+}
+
+void RdpDisplayWidget::setCursorDefault()
+{
+    m_cursorMode = CursorMode::Default;
+    applyCursor();
+}
+
+void RdpDisplayWidget::applyCursor()
+{
+    if (m_cursorMode == CursorMode::Hidden) {
+        setCursor(Qt::BlankCursor);
+        return;
+    }
+
+    if (m_cursorMode == CursorMode::Default || m_cursorImage.isNull()) {
+        unsetCursor();
+        return;
+    }
+
+    const QSize remote = effectiveRemoteSize();
+    const QRectF target = renderRect();
+    if (remote.isEmpty() || target.isEmpty()) {
+        setCursor(QCursor(QPixmap::fromImage(m_cursorImage),
+                          m_cursorHotspot.x(),
+                          m_cursorHotspot.y()));
+        return;
+    }
+
+    const qreal scale = target.width() / remote.width();
+    QImage scaledImage = m_cursorImage;
+    if (!qFuzzyCompare(scale, 1.0)) {
+        scaledImage = m_cursorImage.scaled(
+            qMax(1, qRound(m_cursorImage.width() * scale)),
+            qMax(1, qRound(m_cursorImage.height() * scale)),
+            Qt::IgnoreAspectRatio,
+            Qt::SmoothTransformation);
+    }
+
+    const int hotX = qBound(0, qRound(m_cursorHotspot.x() * scale), scaledImage.width());
+    const int hotY = qBound(0, qRound(m_cursorHotspot.y() * scale), scaledImage.height());
+    setCursor(QCursor(QPixmap::fromImage(scaledImage), hotX, hotY));
+}
+
 void RdpDisplayWidget::paintEvent(QPaintEvent* event)
 {
     Q_UNUSED(event);
@@ -82,16 +166,51 @@ void RdpDisplayWidget::paintEvent(QPaintEvent* event)
 void RdpDisplayWidget::resizeEvent(QResizeEvent* event)
 {
     QWidget::resizeEvent(event);
-    const QSize size = sanitizeSize(event->size());
-    emit viewportSizeChanged(size.width(), size.height());
+    scheduleViewportGeometryEmit();
+    applyCursor();
+}
+
+bool RdpDisplayWidget::event(QEvent* event)
+{
+    // Fires when this widget's effective screen changes (e.g. dragged to a
+    // different monitor), which is what changes devicePixelRatio(). Newer
+    // Qt versions add a more specific QEvent::DevicePixelRatioChange, but
+    // this project's Qt 6.2 floor doesn't have it.
+    if (event->type() == QEvent::ScreenChangeInternal) {
+        scheduleViewportGeometryEmit();
+    }
+    return QWidget::event(event);
+}
+
+void RdpDisplayWidget::scheduleViewportGeometryEmit()
+{
+    // Restarting an already-running single-shot timer resets its countdown,
+    // so a burst of resize events collapses into one emission after things
+    // settle, rather than one request per event.
+    m_resizeDebounceTimer->start(kResizeDebounceMs);
+}
+
+void RdpDisplayWidget::emitViewportGeometry()
+{
+    const QSize logicalSize = sanitizeSize(this->size());
+    const qreal ratio = sanitizeDevicePixelRatio(this->devicePixelRatioF());
+    const QSize physicalSize(qRound(logicalSize.width() * ratio), qRound(logicalSize.height() * ratio));
+    emit viewportSizeChanged(physicalSize.width(), physicalSize.height());
+    emit displayScaleChanged(ratio);
 }
 
 void RdpDisplayWidget::keyPressEvent(QKeyEvent* event)
 {
-    if (event == nullptr || event->isAutoRepeat()) {
+    if (event == nullptr) {
         return;
     }
 
+    // Auto-repeat presses must reach the remote server so it can perform
+    // its own typematic repeat, exactly as a physical keyboard held down
+    // would. Only release events filter out isAutoRepeat() (below), since
+    // Qt uses a synthetic release/press pair purely to normalize platform
+    // auto-repeat quirks -- forwarding that synthetic release would send a
+    // spurious key-up for a key that is still physically held.
     emit keyInput(event->key(),
                   event->nativeScanCode(),
                   event->text(),
@@ -114,6 +233,14 @@ void RdpDisplayWidget::keyReleaseEvent(QKeyEvent* event)
     event->accept();
 }
 
+bool RdpDisplayWidget::focusNextPrevChild(bool next)
+{
+    Q_UNUSED(next);
+    // Tab/Shift+Tab must reach keyPressEvent() and be forwarded to the
+    // remote session instead of moving focus to the next local widget.
+    return false;
+}
+
 void RdpDisplayWidget::mousePressEvent(QMouseEvent* event)
 {
     if (event == nullptr) {

src/rdp_display_widget.h

@@ -8,6 +8,7 @@ class QKeyEvent;
 class QMouseEvent;
 class QPaintEvent;
 class QResizeEvent;
+class QTimer;
 class QWheelEvent;
 
 class RdpDisplayWidget : public QWidget
@@ -20,6 +21,9 @@ public:
     void setFrame(const QImage& frame);
     void setRemoteDesktopSize(int width, int height);
     void clearFrame();
+    void setCursorImage(const QImage& image, const QPoint& hotspot);
+    void setCursorHidden();
+    void setCursorDefault();
 
 signals:
     void keyInput(int key, quint32 nativeScanCode, const QString& text, bool pressed, int modifiers);
@@ -27,24 +31,40 @@ signals:
     void mouseButtonInput(int x, int y, int button, bool pressed);
     void mouseWheelInput(int x, int y, int deltaX, int deltaY);
     void viewportSizeChanged(int width, int height);
+    void displayScaleChanged(qreal devicePixelRatio);
 
 protected:
     void paintEvent(QPaintEvent* event) override;
     void resizeEvent(QResizeEvent* event) override;
+    bool event(QEvent* event) override;
     void keyPressEvent(QKeyEvent* event) override;
     void keyReleaseEvent(QKeyEvent* event) override;
     void mousePressEvent(QMouseEvent* event) override;
     void mouseReleaseEvent(QMouseEvent* event) override;
     void mouseMoveEvent(QMouseEvent* event) override;
     void wheelEvent(QWheelEvent* event) override;
+    bool focusNextPrevChild(bool next) override;
 
 private:
+    enum class CursorMode {
+        Default,
+        Custom,
+        Hidden,
+    };
+
     QImage m_frame;
     QSize m_remoteSize;
+    QImage m_cursorImage;
+    QPoint m_cursorHotspot;
+    CursorMode m_cursorMode;
+    QTimer* m_resizeDebounceTimer;
 
     QRectF renderRect() const;
     QPoint mapToRemote(const QPointF& pos) const;
     QSize effectiveRemoteSize() const;
+    void applyCursor();
+    void emitViewportGeometry();
+    void scheduleViewportGeometryEmit();
 };
 
 #endif

src/rdp_session_backend.h

@@ -19,6 +19,24 @@ public:
     explicit RdpSessionBackend(const Profile& profile, QObject* parent = nullptr);
     ~RdpSessionBackend() override;
 
+    // Pure, state-free helpers exposed as public statics purely so tests
+    // can exercise them without a live FreeRDP connection. UINT32 values
+    // are surfaced as quint32 here to keep FreeRDP/WinPR types out of this
+    // header (uint32_t is what UINT32 always is on every platform this
+    // project targets).
+    static QString normalizedRdpSecurityMode(const QString& value);
+    static QString normalizedRdpPerformanceProfile(const QString& value);
+    static quint32 nearestFreeRdpScaleValue(qreal ratio);
+    static quint32 scancodeFromNativeScanCode(quint32 nativeScanCode);
+    static quint32 scancodeForQtKey(int key, Qt::KeyboardModifiers modifiers, quint32 nativeScanCode);
+    static QString mapRdpError(quint32 code);
+    static bool isExpectedDisconnectCode(quint32 code);
+    static bool isExpectedConnectAbortCode(quint32 code);
+    static QString disconnectMessageForCode(quint32 code);
+    static QString rdpErrorRaw(quint32 code);
+    static int sanitizeDesktopWidth(int width);
+    static int sanitizeDesktopHeight(int height);
+
 public slots:
     void connectSession(const SessionConnectOptions& options) override;
     void disconnectSession() override;
@@ -26,6 +44,7 @@ public slots:
     void sendInput(const QString& input) override;
     void confirmHostKey(bool trustHost) override;
     void updateTerminalSize(int columns, int rows) override;
+    void updateDisplayScale(qreal devicePixelRatio) override;
     void sendKeyEvent(int key,
                       quint32 nativeScanCode,
                       const QString& text,
@@ -34,6 +53,7 @@ public slots:
     void sendMouseMoveEvent(int x, int y) override;
     void sendMouseButtonEvent(int x, int y, int button, bool pressed) override;
     void sendMouseWheelEvent(int x, int y, int deltaX, int deltaY) override;
+    void setClipboardText(const QString& text) override;
 
 private:
     enum class InputEventType {
@@ -42,6 +62,7 @@ private:
         MouseButton,
         MouseWheel,
         Resize,
+        SetClipboardText,
     };
 
     struct InputEvent {
@@ -66,6 +87,7 @@ private:
 
     std::atomic_int m_requestedDesktopWidth;
     std::atomic_int m_requestedDesktopHeight;
+    std::atomic<qreal> m_devicePixelRatio;
 
     std::thread m_worker;
     std::atomic_bool m_workerRunning;
@@ -83,6 +105,19 @@ private:
     bool m_resizeFailureLogged;
     int m_lastResizeWidth;
     int m_lastResizeHeight;
+    int m_lastResizeScale;
+
+    std::mutex m_cliprdrMutex;
+    void* m_cliprdrContext;
+    QString m_pendingLocalClipboardText;
+
+    // Set synchronously by orbitVerifyChangedCertificateEx (called from this
+    // object's own worker thread during freerdp_connect) when a server's TLS
+    // certificate has changed since a prior trusted connection. Read back by
+    // workerMain() right after freerdp_connect() fails, to show the specific
+    // reason instead of a generic "TLS negotiation failed" message. Cleared
+    // at the start of every connect attempt.
+    QString m_certificateRejectionReason;
 
     void setState(SessionState state, const QString& message);
     bool validateProfile(QString& message) const;
@@ -92,17 +127,21 @@ private:
     void enqueueInputEvent(const InputEvent& event);
     void processInputEvents(rdp_freerdp* instance);
     bool sendDisplayResize(rdp_freerdp* instance, int width, int height);
+    void sendClipboardTextToRemote(rdp_freerdp* instance, const QString& text);
 public:
     void onChannelConnectedEvent(const char* name, void* channelInterface);
     void onChannelDisconnectedEvent(const char* name, void* channelInterface);
     void onDisplayControlCaps(uint32_t maxNumMonitors,
                               uint32_t maxMonitorAreaFactorA,
                               uint32_t maxMonitorAreaFactorB);
+    void onCliprdrMonitorReady();
+    void onCliprdrServerFormatList(bool hasUnicodeText);
+    void onCliprdrServerFormatDataRequest(uint32_t requestedFormatId);
+    void onCliprdrServerFormatDataResponse(bool success, const uint8_t* data, uint32_t size);
+    void recordCertificateRejection(const QString& reason);
 private:
     void emitStateAsync(SessionState state, const QString& message);
     void emitConnectionFailureAsync(const QString& displayMessage, const QString& rawMessage);
-    int sanitizeDesktopWidth(int width) const;
-    int sanitizeDesktopHeight(int height) const;
 };
 
 #endif

src/session_backend.h

@@ -5,6 +5,7 @@
 
 #include <QImage>
 #include <QObject>
+#include <QPoint>
 #include <QString>
 #include <QtGlobal>
 
@@ -46,6 +47,14 @@ public slots:
     virtual void sendInput(const QString& input) = 0;
     virtual void confirmHostKey(bool trustHost) = 0;
     virtual void updateTerminalSize(int columns, int rows) = 0;
+    virtual void updateDisplayScale(qreal devicePixelRatio)
+    {
+        Q_UNUSED(devicePixelRatio);
+    }
+    virtual void setClipboardText(const QString& text)
+    {
+        Q_UNUSED(text);
+    }
     virtual void sendKeyEvent(int key,
                               quint32 nativeScanCode,
                               const QString& text,
@@ -86,6 +95,10 @@ signals:
     void hostKeyConfirmationRequested(const QString& prompt);
     void frameUpdated(const QImage& frame);
     void remoteDesktopSizeChanged(int width, int height);
+    void remoteClipboardTextChanged(const QString& text);
+    void cursorImageChanged(const QImage& image, const QPoint& hotspot);
+    void cursorHidden();
+    void cursorReset();
 
 private:
     Profile m_profile;

src/session_tab.cpp

@@ -13,15 +13,16 @@
 #include <QFont>
 #include <QFontDatabase>
 #include <QHBoxLayout>
-#include <QInputDialog>
 #include <QLabel>
 #include <QLineEdit>
 #include <QMessageBox>
 #include <QPlainTextEdit>
 #include <QApplication>
 #include <QClipboard>
+#include <QMimeData>
 #include <QComboBox>
 #include <QProcessEnvironment>
+#include <QPushButton>
 #include <QThread>
 #include <QTimer>
 #include <QToolButton>
@@ -71,6 +72,11 @@ SessionTab::SessionTab(const Profile& profile,
       m_terminalThemeName(preferences.terminalThemeName.trimmed().isEmpty()
                               ? QStringLiteral("Dark")
                               : preferences.terminalThemeName.trimmed()),
+      m_terminalFontPointSize(preferences.terminalFontPointSize > 0
+                                  ? preferences.terminalFontPointSize
+                                  : 0),
+      m_clipboardSyncSupported(profile.protocol.compare(QStringLiteral("RDP"), Qt::CaseInsensitive)
+                                == 0),
       m_sshTerminal(nullptr),
       m_rdpDisplay(nullptr),
       m_terminalOutput(nullptr),
@@ -81,6 +87,11 @@ SessionTab::SessionTab(const Profile& profile,
       m_clearEventsButton(nullptr),
       m_exportEventsButton(nullptr),
       m_eventsPanel(nullptr),
+      m_passwordPromptBar(nullptr),
+      m_passwordPromptLabel(nullptr),
+      m_passwordPromptInput(nullptr),
+      m_passwordPromptConnectButton(nullptr),
+      m_passwordPromptCancelButton(nullptr),
       m_eventSeverityFilter(EventSeverity::Info),
       m_eventsPanelExpanded(preferences.eventsPanelExpanded)
 {
@@ -165,6 +176,11 @@ SessionTab::SessionTab(const Profile& profile,
                 m_backend,
                 &SessionBackend::updateTerminalSize,
                 Qt::QueuedConnection);
+        connect(this,
+                &SessionTab::requestDisplayScale,
+                m_backend,
+                &SessionBackend::updateDisplayScale,
+                Qt::QueuedConnection);
         connect(this,
                 &SessionTab::requestKeyEvent,
                 m_backend,
@@ -185,6 +201,11 @@ SessionTab::SessionTab(const Profile& profile,
                 m_backend,
                 &SessionBackend::sendMouseWheelEvent,
                 Qt::QueuedConnection);
+        connect(this,
+                &SessionTab::requestSetClipboardText,
+                m_backend,
+                &SessionBackend::setClipboardText,
+                Qt::QueuedConnection);
 
         connect(m_backend,
                 &SessionBackend::stateChanged,
@@ -229,10 +250,49 @@ SessionTab::SessionTab(const Profile& profile,
                     }
                 },
                 Qt::QueuedConnection);
+        connect(m_backend,
+                &SessionBackend::remoteClipboardTextChanged,
+                this,
+                &SessionTab::onBackendRemoteClipboardTextChanged,
+                Qt::QueuedConnection);
+        connect(m_backend,
+                &SessionBackend::cursorImageChanged,
+                this,
+                [this](const QImage& image, const QPoint& hotspot) {
+                    if (m_rdpDisplay != nullptr) {
+                        m_rdpDisplay->setCursorImage(image, hotspot);
+                    }
+                },
+                Qt::QueuedConnection);
+        connect(m_backend,
+                &SessionBackend::cursorHidden,
+                this,
+                [this]() {
+                    if (m_rdpDisplay != nullptr) {
+                        m_rdpDisplay->setCursorHidden();
+                    }
+                },
+                Qt::QueuedConnection);
+        connect(m_backend,
+                &SessionBackend::cursorReset,
+                this,
+                [this]() {
+                    if (m_rdpDisplay != nullptr) {
+                        m_rdpDisplay->setCursorDefault();
+                    }
+                },
+                Qt::QueuedConnection);
 
         m_backendThread->start();
     }
 
+    if (m_clipboardSyncSupported) {
+        connect(QApplication::clipboard(),
+                &QClipboard::dataChanged,
+                this,
+                &SessionTab::onSystemClipboardChanged);
+    }
+
     setState(SessionState::Disconnected, QStringLiteral("Ready to connect."));
     QTimer::singleShot(0, this, &SessionTab::connectSession);
 }
@@ -265,21 +325,20 @@ void SessionTab::connectSession()
         return;
     }
 
-    const std::optional<SessionConnectOptions> options = buildConnectOptions();
-    if (!options.has_value()) {
-        return;
-    }
-
-    m_lastConnectOptions = options.value();
-
-    if (m_useKodoTermForSsh) {
-        if (!startSshTerminal(options.value())) {
+    requestConnectOptions([this](std::optional<SessionConnectOptions> options) {
+        if (!options.has_value()) {
             return;
         }
-        return;
-    }
 
-    emit requestConnect(options.value());
+        m_lastConnectOptions = options.value();
+
+        if (m_useKodoTermForSsh) {
+            startSshTerminal(options.value());
+            return;
+        }
+
+        emit requestConnect(options.value());
+    });
 }
 
 void SessionTab::disconnectSession()
@@ -305,24 +364,25 @@ void SessionTab::reconnectSession()
         return;
     }
 
-    const std::optional<SessionConnectOptions> options = buildConnectOptions();
-    if (!options.has_value()) {
-        return;
-    }
-
-    m_lastConnectOptions = options.value();
-
-    if (m_useKodoTermForSsh) {
-        if (m_sshTerminal != nullptr) {
-            m_sshTerminal->kill();
+    requestConnectOptions([this](std::optional<SessionConnectOptions> options) {
+        if (!options.has_value()) {
+            return;
         }
-        QTimer::singleShot(50,
-                           this,
-                           [this, options]() { startSshTerminal(options.value()); });
-        return;
-    }
 
-    emit requestReconnect(options.value());
+        m_lastConnectOptions = options.value();
+
+        if (m_useKodoTermForSsh) {
+            if (m_sshTerminal != nullptr) {
+                m_sshTerminal->kill();
+            }
+            QTimer::singleShot(50,
+                               this,
+                               [this, options]() { startSshTerminal(options.value()); });
+            return;
+        }
+
+        emit requestReconnect(options.value());
+    });
 }
 
 void SessionTab::clearTerminal()
@@ -380,6 +440,84 @@ bool SessionTab::supportsClearAction() const
     return m_useKodoTermForSsh || m_terminalOutput != nullptr;
 }
 
+bool SessionTab::supportsZoom() const
+{
+    return m_useKodoTermForSsh || m_terminalOutput != nullptr;
+}
+
+void SessionTab::zoomIn()
+{
+    if (m_useKodoTermForSsh && m_sshTerminal != nullptr) {
+        m_sshTerminal->zoomIn();
+        m_terminalFontPointSize = m_sshTerminal->getConfig().font.pointSize();
+    } else if (m_terminalOutput != nullptr) {
+        m_terminalFontPointSize = m_terminalOutput->font().pointSize() + 1;
+        m_terminalOutput->setFontPointSize(m_terminalFontPointSize);
+    } else {
+        return;
+    }
+
+    emit terminalFontSizeChanged(m_terminalFontPointSize);
+}
+
+void SessionTab::zoomOut()
+{
+    if (m_useKodoTermForSsh && m_sshTerminal != nullptr) {
+        m_sshTerminal->zoomOut();
+        m_terminalFontPointSize = m_sshTerminal->getConfig().font.pointSize();
+    } else if (m_terminalOutput != nullptr) {
+        const int newSize = m_terminalOutput->font().pointSize() - 1;
+        if (newSize < 6) {
+            return;
+        }
+        m_terminalFontPointSize = newSize;
+        m_terminalOutput->setFontPointSize(m_terminalFontPointSize);
+    } else {
+        return;
+    }
+
+    emit terminalFontSizeChanged(m_terminalFontPointSize);
+}
+
+void SessionTab::resetZoom()
+{
+    if (m_useKodoTermForSsh && m_sshTerminal != nullptr) {
+        m_sshTerminal->resetZoom();
+        m_terminalFontPointSize = m_sshTerminal->getConfig().font.pointSize();
+    } else if (m_terminalOutput != nullptr) {
+        m_terminalFontPointSize = defaultTerminalFont().pointSize();
+        m_terminalOutput->setFontPointSize(m_terminalFontPointSize);
+    } else {
+        return;
+    }
+
+    emit terminalFontSizeChanged(m_terminalFontPointSize);
+}
+
+void SessionTab::setTerminalFontPointSize(int pointSize)
+{
+    const int clamped = qBound(6, pointSize, 72);
+
+    if (m_useKodoTermForSsh && m_sshTerminal != nullptr) {
+        KodoTermConfig config = m_sshTerminal->getConfig();
+        config.font.setPointSize(clamped);
+        m_sshTerminal->setConfig(config);
+        m_terminalFontPointSize = clamped;
+    } else if (m_terminalOutput != nullptr) {
+        m_terminalFontPointSize = clamped;
+        m_terminalOutput->setFontPointSize(clamped);
+    } else {
+        return;
+    }
+
+    emit terminalFontSizeChanged(m_terminalFontPointSize);
+}
+
+int SessionTab::terminalFontPointSize() const
+{
+    return m_terminalFontPointSize;
+}
+
 bool SessionTab::isEventsPanelExpanded() const
 {
     return m_eventsPanelExpanded;
@@ -529,13 +667,46 @@ void SessionTab::onBackendHostKeyConfirmationRequested(const QString& prompt)
     emit requestHostKeyConfirmation(reply == QMessageBox::Yes);
 }
 
+void SessionTab::onBackendRemoteClipboardTextChanged(const QString& text)
+{
+    if (text == m_lastSyncedClipboardText) {
+        return;
+    }
+
+    m_lastSyncedClipboardText = text;
+    QApplication::clipboard()->setText(text);
+}
+
+void SessionTab::onSystemClipboardChanged()
+{
+    if (!m_clipboardSyncSupported || m_state != SessionState::Connected) {
+        return;
+    }
+
+    const QClipboard* clipboard = QApplication::clipboard();
+    if (!clipboard->mimeData()->hasText()) {
+        return;
+    }
+
+    const QString text = clipboard->text();
+    if (text == m_lastSyncedClipboardText) {
+        return;
+    }
+
+    m_lastSyncedClipboardText = text;
+    emit requestSetClipboardText(text);
+}
+
 void SessionTab::setupUi()
 {
     auto* rootLayout = new QVBoxLayout(this);
 
     if (m_useKodoTermForSsh) {
         m_sshTerminal = new KodoTerm(this);
-        const QFont terminalFont = defaultTerminalFont();
+        QFont terminalFont = defaultTerminalFont();
+        if (m_terminalFontPointSize > 0) {
+            terminalFont.setPointSize(m_terminalFontPointSize);
+        }
 
         KodoTermConfig config = m_sshTerminal->getConfig();
         config.font = terminalFont;
@@ -548,7 +719,11 @@ void SessionTab::setupUi()
         rootLayout->addWidget(m_rdpDisplay, 1);
     } else {
         m_terminalOutput = new TerminalView(this);
-        m_terminalOutput->setFont(defaultTerminalFont());
+        QFont fallbackFont = defaultTerminalFont();
+        if (m_terminalFontPointSize > 0) {
+            fallbackFont.setPointSize(m_terminalFontPointSize);
+        }
+        m_terminalOutput->setFont(fallbackFont);
         m_terminalOutput->setMinimumHeight(260);
         m_terminalOutput->setReadOnly(true);
         if (m_profile.protocol.compare(QStringLiteral("VNC"), Qt::CaseInsensitive) == 0) {
@@ -563,6 +738,45 @@ void SessionTab::setupUi()
 
     applyTerminalTheme(m_terminalThemeName);
 
+    auto* passwordPromptLayout = new QHBoxLayout();
+    m_passwordPromptLabel = new QLabel(this);
+    m_passwordPromptInput = new QLineEdit(this);
+    m_passwordPromptInput->setEchoMode(QLineEdit::Password);
+    m_passwordPromptConnectButton = new QPushButton(QStringLiteral("Connect"), this);
+    m_passwordPromptCancelButton = new QPushButton(QStringLiteral("Cancel"), this);
+    passwordPromptLayout->addWidget(m_passwordPromptLabel);
+    passwordPromptLayout->addWidget(m_passwordPromptInput, 1);
+    passwordPromptLayout->addWidget(m_passwordPromptConnectButton);
+    passwordPromptLayout->addWidget(m_passwordPromptCancelButton);
+
+    m_passwordPromptBar = new QWidget(this);
+    m_passwordPromptBar->setLayout(passwordPromptLayout);
+    m_passwordPromptBar->setAutoFillBackground(true);
+    m_passwordPromptBar->setVisible(false);
+    rootLayout->addWidget(m_passwordPromptBar);
+
+    connect(m_passwordPromptConnectButton, &QPushButton::clicked, this, [this]() {
+        if (!m_passwordPromptCallback) {
+            return;
+        }
+        const QString password = m_passwordPromptInput->text();
+        const auto callback = m_passwordPromptCallback;
+        hidePasswordPrompt();
+        callback(password);
+    });
+    connect(m_passwordPromptCancelButton, &QPushButton::clicked, this, [this]() {
+        if (!m_passwordPromptCallback) {
+            return;
+        }
+        const auto callback = m_passwordPromptCallback;
+        hidePasswordPrompt();
+        callback(std::nullopt);
+    });
+    connect(m_passwordPromptInput,
+            &QLineEdit::returnPressed,
+            m_passwordPromptConnectButton,
+            &QPushButton::click);
+
     auto* eventsHeader = new QHBoxLayout();
     m_toggleEventsButton = new QToolButton(this);
     m_toggleEventsButton->setCheckable(true);
@@ -651,6 +865,10 @@ void SessionTab::setupUi()
                 &RdpDisplayWidget::viewportSizeChanged,
                 this,
                 [this](int width, int height) { emit requestTerminalSize(width, height); });
+        connect(m_rdpDisplay,
+                &RdpDisplayWidget::displayScaleChanged,
+                this,
+                [this](qreal ratio) { emit requestDisplayScale(ratio); });
         connect(m_rdpDisplay,
                 &RdpDisplayWidget::keyInput,
                 this,
@@ -676,77 +894,85 @@ void SessionTab::setupUi()
     }
 }
 
-std::optional<SessionConnectOptions> SessionTab::buildConnectOptions()
+void SessionTab::requestConnectOptions(
+    std::function<void(std::optional<SessionConnectOptions>)> callback)
 {
-    SessionConnectOptions options;
-    options.knownHostsPolicy = m_profile.knownHostsPolicy;
+    SessionConnectOptions baseOptions;
+    baseOptions.knownHostsPolicy = m_profile.knownHostsPolicy;
 
     const bool isSsh = m_profile.protocol.compare(QStringLiteral("SSH"), Qt::CaseInsensitive) == 0;
     const bool isRdp = m_profile.protocol.compare(QStringLiteral("RDP"), Qt::CaseInsensitive) == 0;
 
     if (!isSsh && !isRdp) {
-        return options;
+        callback(baseOptions);
+        return;
     }
 
     if (isRdp) {
         if (m_profile.authMode.compare(QStringLiteral("Password"), Qt::CaseInsensitive) != 0) {
-            return options;
+            callback(baseOptions);
+            return;
         }
 
-        bool accepted = false;
-        const QString password = QInputDialog::getText(
-            this,
-            QStringLiteral("RDP Password"),
-            QStringLiteral("Password for %1:")
-                .arg(m_profile.username.trimmed().isEmpty()
-                         ? m_profile.host
-                         : QStringLiteral("%1@%2").arg(m_profile.username, m_profile.host)),
-            QLineEdit::Password,
-            QString(),
-            &accepted);
-        if (!accepted) {
-            return std::nullopt;
-        }
+        const QString label = QStringLiteral("RDP password for %1:")
+            .arg(m_profile.username.trimmed().isEmpty()
+                     ? m_profile.host
+                     : QStringLiteral("%1@%2").arg(m_profile.username, m_profile.host));
 
-        if (password.isEmpty()) {
-            QMessageBox::warning(this,
-                                 QStringLiteral("Connect"),
-                                 QStringLiteral("Password is required for password authentication."));
-            return std::nullopt;
-        }
+        showPasswordPrompt(
+            label,
+            [this, baseOptions, callback](std::optional<QString> password) {
+                if (!password.has_value()) {
+                    callback(std::nullopt);
+                    return;
+                }
 
-        options.password = password;
-        return options;
+                if (password->isEmpty()) {
+                    QMessageBox::warning(
+                        this,
+                        QStringLiteral("Connect"),
+                        QStringLiteral("Password is required for password authentication."));
+                    callback(std::nullopt);
+                    return;
+                }
+
+                SessionConnectOptions options = baseOptions;
+                options.password = password.value();
+                callback(options);
+            });
+        return;
     }
 
     if (m_useKodoTermForSsh
         && m_profile.authMode.compare(QStringLiteral("Password"), Qt::CaseInsensitive) == 0) {
         // Password is entered directly in terminal prompt.
-        return options;
+        callback(baseOptions);
+        return;
     }
 
     if (m_profile.authMode.compare(QStringLiteral("Password"), Qt::CaseInsensitive) == 0) {
-        bool accepted = false;
-        const QString password = QInputDialog::getText(this,
-                                                       QStringLiteral("SSH Password"),
-                                                       QStringLiteral("Password for %1@%2:")
-                                                           .arg(m_profile.username, m_profile.host),
-                                                       QLineEdit::Password,
-                                                       QString(),
-                                                       &accepted);
-        if (!accepted) {
-            return std::nullopt;
-        }
+        showPasswordPrompt(
+            QStringLiteral("SSH password for %1@%2:").arg(m_profile.username, m_profile.host),
+            [this, baseOptions, callback](std::optional<QString> password) {
+                if (!password.has_value()) {
+                    callback(std::nullopt);
+                    return;
+                }
 
-        if (password.isEmpty()) {
-            QMessageBox::warning(this,
-                                 QStringLiteral("Connect"),
-                                 QStringLiteral("Password is required for password authentication."));
-            return std::nullopt;
-        }
+                if (password->isEmpty()) {
+                    QMessageBox::warning(
+                        this,
+                        QStringLiteral("Connect"),
+                        QStringLiteral("Password is required for password authentication."));
+                    callback(std::nullopt);
+                    return;
+                }
 
-        options.password = password;
-        return options;
+                SessionConnectOptions options = baseOptions;
+                options.password = password.value();
+                callback(options);
+            });
+        return;
     }
 
     QString keyPath = m_profile.privateKeyPath.trimmed();
@@ -756,7 +982,8 @@ std::optional<SessionConnectOptions> SessionTab::buildConnectOptions()
                                                QString(),
                                                QStringLiteral("All Files (*)"));
         if (keyPath.isEmpty()) {
-            return std::nullopt;
+            callback(std::nullopt);
+            return;
         }
     }
 
@@ -764,11 +991,35 @@ std::optional<SessionConnectOptions> SessionTab::buildConnectOptions()
         QMessageBox::warning(this,
                              QStringLiteral("Connect"),
                              QStringLiteral("Private key file not found: %1").arg(keyPath));
-        return std::nullopt;
+        callback(std::nullopt);
+        return;
     }
 
+    SessionConnectOptions options = baseOptions;
     options.privateKeyPath = keyPath;
-    return options;
+    callback(options);
+}
+
+void SessionTab::showPasswordPrompt(const QString& labelText,
+                                    std::function<void(std::optional<QString>)> callback)
+{
+    if (m_passwordPromptCallback) {
+        const auto previousCallback = m_passwordPromptCallback;
+        m_passwordPromptCallback = nullptr;
+        previousCallback(std::nullopt);
+    }
+
+    m_passwordPromptCallback = std::move(callback);
+    m_passwordPromptLabel->setText(labelText);
+    m_passwordPromptInput->clear();
+    m_passwordPromptBar->setVisible(true);
+    m_passwordPromptInput->setFocus();
+}
+
+void SessionTab::hidePasswordPrompt()
+{
+    m_passwordPromptBar->setVisible(false);
+    m_passwordPromptCallback = nullptr;
 }
 
 bool SessionTab::validateProfileForConnect()

src/session_tab.h

@@ -8,6 +8,7 @@
 #include <QStringList>
 #include <QtGlobal>
 
+#include <functional>
 #include <optional>
 #include <vector>
 
@@ -19,12 +20,15 @@ class RdpDisplayWidget;
 class QToolButton;
 class QLineEdit;
 class QComboBox;
+class QLabel;
+class QPushButton;
 class KodoTerm;
 
 struct SessionUiPreferences
 {
     QString terminalThemeName = QStringLiteral("Dark");
     bool eventsPanelExpanded = false;
+    int terminalFontPointSize = 0;
 };
 
 class SessionTab : public QWidget
@@ -46,6 +50,12 @@ public:
     QString terminalThemeName() const;
     bool supportsThemeSelection() const;
     bool supportsClearAction() const;
+    bool supportsZoom() const;
+    void zoomIn();
+    void zoomOut();
+    void resetZoom();
+    void setTerminalFontPointSize(int pointSize);
+    int terminalFontPointSize() const;
     bool isEventsPanelExpanded() const;
     void setEventsPanelExpanded(bool expanded);
     void clearEvents();
@@ -56,6 +66,7 @@ signals:
     void tabTitleChanged(const QString& title);
     void tabStateChanged(SessionState state);
     void terminalThemeChanged(const QString& themeName);
+    void terminalFontSizeChanged(int pointSize);
     void eventsPanelVisibilityChanged(bool expanded);
     void requestConnect(const SessionConnectOptions& options);
     void requestDisconnect();
@@ -63,6 +74,7 @@ signals:
     void requestInput(const QString& input);
     void requestHostKeyConfirmation(bool trustHost);
     void requestTerminalSize(int columns, int rows);
+    void requestDisplayScale(qreal devicePixelRatio);
     void requestKeyEvent(int key,
                          quint32 nativeScanCode,
                          const QString& text,
@@ -71,6 +83,7 @@ signals:
     void requestMouseMoveEvent(int x, int y);
     void requestMouseButtonEvent(int x, int y, int button, bool pressed);
     void requestMouseWheelEvent(int x, int y, int deltaX, int deltaY);
+    void requestSetClipboardText(const QString& text);
 
 private slots:
     void onBackendStateChanged(SessionState state, const QString& message);
@@ -78,6 +91,8 @@ private slots:
     void onBackendConnectionError(const QString& displayMessage, const QString& rawMessage);
     void onBackendOutputReceived(const QString& text);
     void onBackendHostKeyConfirmationRequested(const QString& prompt);
+    void onBackendRemoteClipboardTextChanged(const QString& text);
+    void onSystemClipboardChanged();
 
 private:
     Profile m_profile;
@@ -88,6 +103,9 @@ private:
     QString m_lastError;
     SessionConnectOptions m_lastConnectOptions;
     QString m_terminalThemeName;
+    int m_terminalFontPointSize;
+    QString m_lastSyncedClipboardText;
+    bool m_clipboardSyncSupported;
 
     KodoTerm* m_sshTerminal;
     RdpDisplayWidget* m_rdpDisplay;
@@ -99,6 +117,12 @@ private:
     QToolButton* m_clearEventsButton;
     QToolButton* m_exportEventsButton;
     QWidget* m_eventsPanel;
+    QWidget* m_passwordPromptBar;
+    QLabel* m_passwordPromptLabel;
+    QLineEdit* m_passwordPromptInput;
+    QPushButton* m_passwordPromptConnectButton;
+    QPushButton* m_passwordPromptCancelButton;
+    std::function<void(std::optional<QString>)> m_passwordPromptCallback;
     enum class EventSeverity {
         Info,
         Warning,
@@ -114,7 +138,10 @@ private:
     bool m_eventsPanelExpanded;
 
     void setupUi();
-    std::optional<SessionConnectOptions> buildConnectOptions();
+    void requestConnectOptions(std::function<void(std::optional<SessionConnectOptions>)> callback);
+    void showPasswordPrompt(const QString& labelText,
+                            std::function<void(std::optional<QString>)> callback);
+    void hidePasswordPrompt();
     bool validateProfileForConnect();
     void appendEvent(const QString& message);
     void setState(SessionState state, const QString& message);

src/session_window.cpp

@@ -1,11 +1,14 @@
 #include "session_window.h"
 
 #include "about_dialog.h"
+#include "profiles_window.h"
+#include "user_guide_dialog.h"
 #include <QApplication>
 #include "session_tab.h"
 
 #include <QAction>
 #include <QColor>
+#include <QInputDialog>
 #include <QMenu>
 #include <QMenuBar>
 #include <QPalette>
@@ -37,12 +40,12 @@ QStringList terminalThemeNames()
 }
 }
 
-SessionWindow::SessionWindow(const Profile& profile, QWidget* parent)
-    : QMainWindow(parent), m_tabs(new QTabWidget(this))
+SessionWindow::SessionWindow(QWidget* parent)
+    : QMainWindow(parent), m_tabs(new QTabWidget(this)), m_profilesWidget(nullptr)
 {
     loadUiPreferences();
 
-    setWindowTitle(QStringLiteral("OrbitHub Session - %1").arg(profile.name));
+    setWindowTitle(QStringLiteral("OrbitHub"));
     resize(1080, 760);
     setWindowIcon(QApplication::windowIcon());
 
@@ -57,8 +60,8 @@ SessionWindow::SessionWindow(const Profile& profile, QWidget* parent)
                 }
                 m_tabs->removeTab(index);
                 delete tab;
-                if (m_tabs->count() == 0) {
-                    close();
+                if (sessionTabCount() == 0) {
+                    setWindowTitle(QStringLiteral("OrbitHub"));
                 }
             });
     m_tabs->tabBar()->setContextMenuPolicy(Qt::CustomContextMenu);
@@ -105,6 +108,18 @@ SessionWindow::SessionWindow(const Profile& profile, QWidget* parent)
                     clearAction = menu.addAction(QStringLiteral("Clear"));
                 }
 
+                QAction* zoomInAction = nullptr;
+                QAction* zoomOutAction = nullptr;
+                QAction* resetZoomAction = nullptr;
+                QAction* setFontSizeAction = nullptr;
+                if (tab->supportsZoom()) {
+                    menu.addSeparator();
+                    zoomInAction = menu.addAction(QStringLiteral("Increase Font Size"));
+                    zoomOutAction = menu.addAction(QStringLiteral("Decrease Font Size"));
+                    resetZoomAction = menu.addAction(QStringLiteral("Reset Font Size"));
+                    setFontSizeAction = menu.addAction(QStringLiteral("Set Font Size..."));
+                }
+
                 QAction* chosen = menu.exec(m_tabs->tabBar()->mapToGlobal(pos));
                 if (chosen == disconnectAction) {
                     tab->disconnectSession();
@@ -120,6 +135,27 @@ SessionWindow::SessionWindow(const Profile& profile, QWidget* parent)
                     tab->clearEvents();
                 } else if (clearAction != nullptr && chosen == clearAction) {
                     tab->clearTerminal();
+                } else if (zoomInAction != nullptr && chosen == zoomInAction) {
+                    tab->zoomIn();
+                } else if (zoomOutAction != nullptr && chosen == zoomOutAction) {
+                    tab->zoomOut();
+                } else if (resetZoomAction != nullptr && chosen == resetZoomAction) {
+                    tab->resetZoom();
+                } else if (setFontSizeAction != nullptr && chosen == setFontSizeAction) {
+                    bool accepted = false;
+                    const int currentSize =
+                        tab->terminalFontPointSize() > 0 ? tab->terminalFontPointSize() : 10;
+                    const int newSize = QInputDialog::getInt(this,
+                                                             QStringLiteral("Set Font Size"),
+                                                             QStringLiteral("Font size (points):"),
+                                                             currentSize,
+                                                             6,
+                                                             72,
+                                                             1,
+                                                             &accepted);
+                    if (accepted) {
+                        tab->setTerminalFontPointSize(newSize);
+                    }
                 } else {
                     for (QAction* themeAction : themeActions) {
                         if (chosen == themeAction) {
@@ -130,7 +166,42 @@ SessionWindow::SessionWindow(const Profile& profile, QWidget* parent)
                 }
             });
 
+    QMenu* fileMenu = menuBar()->addMenu(QStringLiteral("File"));
+    QAction* newProfileAction = fileMenu->addAction(QStringLiteral("New Profile"));
+    QAction* newFolderAction = fileMenu->addAction(QStringLiteral("New Folder"));
+    fileMenu->addSeparator();
+    QAction* importProfilesAction = fileMenu->addAction(QStringLiteral("Import Profiles..."));
+    QAction* exportProfilesAction = fileMenu->addAction(QStringLiteral("Export Profiles..."));
+    fileMenu->addSeparator();
+    QAction* quitAction = fileMenu->addAction(QStringLiteral("Quit"));
+
+    connect(newProfileAction,
+            &QAction::triggered,
+            this,
+            [this]() { m_profilesWidget->createProfileInCurrentContext(); });
+    connect(newFolderAction,
+            &QAction::triggered,
+            this,
+            [this]() { m_profilesWidget->createFolderInCurrentContext(); });
+    connect(importProfilesAction,
+            &QAction::triggered,
+            this,
+            [this]() { m_profilesWidget->importProfiles(); });
+    connect(exportProfilesAction,
+            &QAction::triggered,
+            this,
+            [this]() { m_profilesWidget->exportProfiles(); });
+    connect(quitAction, &QAction::triggered, this, []() { qApp->quit(); });
+
     QMenu* helpMenu = menuBar()->addMenu(QStringLiteral("Help"));
+    QAction* userGuideAction = helpMenu->addAction(QStringLiteral("User Guide"));
+    connect(userGuideAction,
+            &QAction::triggered,
+            this,
+            [this]() {
+                UserGuideDialog dialog(this);
+                dialog.exec();
+            });
     QAction* aboutAction = helpMenu->addAction(QStringLiteral("About OrbitHub"));
     connect(aboutAction,
             &QAction::triggered,
@@ -141,7 +212,15 @@ SessionWindow::SessionWindow(const Profile& profile, QWidget* parent)
             });
 
     setCentralWidget(m_tabs);
-    addSessionTab(profile);
+
+    m_profilesWidget = new ProfilesWindow(this);
+    const int profilesIndex = m_tabs->addTab(m_profilesWidget, QStringLiteral("Profiles"));
+    m_tabs->tabBar()->setTabButton(profilesIndex, QTabBar::LeftSide, nullptr);
+    m_tabs->tabBar()->setTabButton(profilesIndex, QTabBar::RightSide, nullptr);
+    connect(m_profilesWidget,
+            &ProfilesWindow::connectRequested,
+            this,
+            &SessionWindow::addSessionTab);
 }
 
 void SessionWindow::openProfile(const Profile& profile)
@@ -154,8 +233,10 @@ void SessionWindow::addSessionTab(const Profile& profile)
     auto* tab = new SessionTab(profile, m_preferences, this);
     const int index = m_tabs->addTab(tab, tab->tabTitle());
     m_tabs->setCurrentIndex(index);
-    if (m_tabs->count() > 1) {
+    if (sessionTabCount() > 1) {
         setWindowTitle(QStringLiteral("OrbitHub Sessions"));
+    } else {
+        setWindowTitle(QStringLiteral("OrbitHub Session - %1").arg(profile.name));
     }
     m_tabs->tabBar()->setTabTextColor(
         index, tabColorForState(SessionState::Disconnected, m_tabs->palette()));
@@ -185,6 +266,16 @@ void SessionWindow::addSessionTab(const Profile& profile)
                     : themeName.trimmed();
                 saveUiPreferences();
             });
+    connect(tab,
+            &SessionTab::terminalFontSizeChanged,
+            this,
+            [this](int pointSize) {
+                if (pointSize <= 0) {
+                    return;
+                }
+                m_preferences.terminalFontPointSize = pointSize;
+                saveUiPreferences();
+            });
     connect(tab,
             &SessionTab::eventsPanelVisibilityChanged,
             this,
@@ -204,6 +295,11 @@ void SessionWindow::updateTabTitle(SessionTab* tab, const QString& title)
     }
 }
 
+int SessionWindow::sessionTabCount() const
+{
+    return m_tabs->count() - 1;
+}
+
 void SessionWindow::loadUiPreferences()
 {
     QSettings settings;
@@ -216,6 +312,8 @@ void SessionWindow::loadUiPreferences()
     }
     m_preferences.eventsPanelExpanded =
         settings.value(QStringLiteral("session/eventsPanelExpanded"), false).toBool();
+    m_preferences.terminalFontPointSize =
+        settings.value(QStringLiteral("session/terminalFontPointSize"), 0).toInt();
 }
 
 void SessionWindow::saveUiPreferences() const
@@ -225,4 +323,6 @@ void SessionWindow::saveUiPreferences() const
                       m_preferences.terminalThemeName);
     settings.setValue(QStringLiteral("session/eventsPanelExpanded"),
                       m_preferences.eventsPanelExpanded);
+    settings.setValue(QStringLiteral("session/terminalFontPointSize"),
+                      m_preferences.terminalFontPointSize);
 }

src/session_window.h

@@ -7,23 +7,26 @@
 #include <QMainWindow>
 
 class QTabWidget;
+class ProfilesWindow;
 
 class SessionWindow : public QMainWindow
 {
     Q_OBJECT
 
 public:
-    explicit SessionWindow(const Profile& profile, QWidget* parent = nullptr);
+    explicit SessionWindow(QWidget* parent = nullptr);
     void openProfile(const Profile& profile);
 
 private:
     QTabWidget* m_tabs;
+    ProfilesWindow* m_profilesWidget;
     SessionUiPreferences m_preferences;
 
     void addSessionTab(const Profile& profile);
     void updateTabTitle(SessionTab* tab, const QString& title);
     void loadUiPreferences();
     void saveUiPreferences() const;
+    int sessionTabCount() const;
 };
 
 #endif

src/ssh_session_backend.cpp

@@ -7,16 +7,14 @@
 #include <QTextStream>
 #include <QUuid>
 
-namespace {
-QString escapeForShellSingleQuotes(const QString& value)
+SshSessionBackend::SshSessionBackend(const Profile& profile, QObject* parent)
+    : SshSessionBackend(profile, QStringLiteral("ssh"), parent)
 {
-    QString escaped = value;
-    escaped.replace(QStringLiteral("'"), QStringLiteral("'\"'\"'"));
-    return escaped;
-}
 }
 
-SshSessionBackend::SshSessionBackend(const Profile& profile, QObject* parent)
+SshSessionBackend::SshSessionBackend(const Profile& profile,
+                                     const QString& sshProgramOverride,
+                                     QObject* parent)
     : SessionBackend(profile, parent),
       m_process(new QProcess(this)),
       m_connectedProbeTimer(new QTimer(this)),
@@ -27,7 +25,8 @@ SshSessionBackend::SshSessionBackend(const Profile& profile, QObject* parent)
       m_waitingForHostKeyConfirmation(false),
       m_passwordSubmitted(false),
       m_terminalColumns(0),
-      m_terminalRows(0)
+      m_terminalRows(0),
+      m_sshProgram(sshProgramOverride)
 {
     m_connectedProbeTimer->setSingleShot(true);
 
@@ -395,7 +394,7 @@ bool SshSessionBackend::startSshProcess(const SessionConnectOptions& options)
     args << target;
 
     m_process->setProcessEnvironment(environment);
-    m_process->setProgram(QStringLiteral("ssh"));
+    m_process->setProgram(m_sshProgram);
     m_process->setArguments(args);
     m_process->setProcessChannelMode(QProcess::SeparateChannels);
 
@@ -471,7 +470,7 @@ void SshSessionBackend::cleanupAskPassScript()
     }
 }
 
-QString SshSessionBackend::mapSshError(const QString& rawError) const
+QString SshSessionBackend::mapSshError(const QString& rawError)
 {
     const QString raw = rawError.trimmed();
     if (raw.contains(QStringLiteral("Permission denied"), Qt::CaseInsensitive)) {
@@ -510,6 +509,13 @@ QString SshSessionBackend::mapSshError(const QString& rawError) const
     return QStringLiteral("SSH connection failed.");
 }
 
+QString SshSessionBackend::escapeForShellSingleQuotes(const QString& value)
+{
+    QString escaped = value;
+    escaped.replace(QStringLiteral("'"), QStringLiteral("'\"'\"'"));
+    return escaped;
+}
+
 QString SshSessionBackend::knownHostsFileForNullDevice() const
 {
 #ifdef Q_OS_WIN

src/ssh_session_backend.h

@@ -13,8 +13,16 @@ class SshSessionBackend : public SessionBackend
 
 public:
     explicit SshSessionBackend(const Profile& profile, QObject* parent = nullptr);
+    // Test-only: overrides the executable launched instead of "ssh", so
+    // tests can point it at a controllable fixture script.
+    SshSessionBackend(const Profile& profile, const QString& sshProgramOverride, QObject* parent);
     ~SshSessionBackend() override;
 
+    // Pure, state-free helpers exposed as public statics purely so tests
+    // can exercise them directly without spinning up a real ssh process.
+    static QString mapSshError(const QString& rawError);
+    static QString escapeForShellSingleQuotes(const QString& value);
+
 public slots:
     void connectSession(const SessionConnectOptions& options) override;
     void disconnectSession() override;
@@ -46,6 +54,7 @@ private:
     bool m_passwordSubmitted;
     int m_terminalColumns;
     int m_terminalRows;
+    QString m_sshProgram;
 
     void setState(SessionState state, const QString& message);
     bool startSshProcess(const SessionConnectOptions& options);
@@ -53,7 +62,6 @@ private:
                           QProcessEnvironment& environment,
                           QString& error);
     void cleanupAskPassScript();
-    QString mapSshError(const QString& rawError) const;
     QString knownHostsFileForNullDevice() const;
     void applyTerminalSizeIfAvailable();
 };

src/terminal_view.cpp

@@ -52,6 +52,14 @@ void TerminalView::setThemeName(const QString& themeName)
     applyThemePalette(paletteByName(themeName));
 }
 
+void TerminalView::setFontPointSize(int pointSize)
+{
+    QFont updatedFont = font();
+    updatedFont.setPointSize(pointSize);
+    setFont(updatedFont);
+    emitTerminalSize();
+}
+
 void TerminalView::appendTerminalData(const QString& data)
 {
     if (data.isEmpty()) {
@@ -211,6 +219,14 @@ void TerminalView::focusInEvent(QFocusEvent* event)
     moveCursor(QTextCursor::End);
 }
 
+bool TerminalView::focusNextPrevChild(bool next)
+{
+    Q_UNUSED(next);
+    // Tab/Shift+Tab must reach keyPressEvent() and be forwarded to the
+    // remote session instead of moving focus to the next local widget.
+    return false;
+}
+
 void TerminalView::resizeEvent(QResizeEvent* event)
 {
     QTextEdit::resizeEvent(event);

src/terminal_view.h

@@ -19,6 +19,7 @@ public:
     static QStringList themeNames();
     void setThemeName(const QString& themeName);
     void appendTerminalData(const QString& data);
+    void setFontPointSize(int pointSize);
 
 signals:
     void inputGenerated(const QString& input);
@@ -28,6 +29,7 @@ protected:
     void keyPressEvent(QKeyEvent* event) override;
     void focusInEvent(QFocusEvent* event) override;
     void resizeEvent(QResizeEvent* event) override;
+    bool focusNextPrevChild(bool next) override;
 
 private:
     struct ThemePalette {

src/user_guide_dialog.cpp

@@ -0,0 +1,149 @@
+#include "user_guide_dialog.h"
+
+#include <QApplication>
+#include <QDesktopServices>
+#include <QDialogButtonBox>
+#include <QFile>
+#include <QListWidget>
+#include <QSplitter>
+#include <QTextBrowser>
+#include <QTextStream>
+#include <QUrl>
+#include <QVBoxLayout>
+
+namespace {
+
+QString slugify(const QString& title)
+{
+    QString slug;
+    slug.reserve(title.size());
+    bool lastWasHyphen = false;
+    for (const QChar& ch : title) {
+        if (ch.isLetterOrNumber()) {
+            slug += ch.toLower();
+            lastWasHyphen = false;
+        } else if (!lastWasHyphen && !slug.isEmpty()) {
+            slug += QLatin1Char('-');
+            lastWasHyphen = true;
+        }
+    }
+    while (slug.endsWith(QLatin1Char('-'))) {
+        slug.chop(1);
+    }
+    return slug;
+}
+
+}
+
+UserGuideDialog::UserGuideDialog(QWidget* parent)
+    : QDialog(parent), m_sectionList(nullptr), m_browser(nullptr)
+{
+    setWindowTitle(QStringLiteral("OrbitHub User Guide"));
+    setWindowIcon(QApplication::windowIcon());
+    resize(900, 640);
+
+    auto* layout = new QVBoxLayout(this);
+    layout->setContentsMargins(16, 16, 16, 16);
+    layout->setSpacing(12);
+
+    auto* splitter = new QSplitter(Qt::Horizontal, this);
+
+    m_sectionList = new QListWidget(splitter);
+    m_sectionList->setMaximumWidth(220);
+
+    m_browser = new QTextBrowser(splitter);
+    m_browser->setOpenExternalLinks(false);
+    m_browser->setOpenLinks(false);
+
+    splitter->addWidget(m_sectionList);
+    splitter->addWidget(m_browser);
+    splitter->setStretchFactor(0, 0);
+    splitter->setStretchFactor(1, 1);
+
+    auto* buttons = new QDialogButtonBox(QDialogButtonBox::Close, this);
+    connect(buttons, &QDialogButtonBox::rejected, this, &QDialog::reject);
+    connect(buttons, &QDialogButtonBox::accepted, this, &QDialog::accept);
+
+    layout->addWidget(splitter, 1);
+    layout->addWidget(buttons);
+
+    loadSections();
+
+    connect(m_sectionList,
+            &QListWidget::currentRowChanged,
+            this,
+            [this](int row) { showSection(row); });
+    connect(m_browser, &QTextBrowser::anchorClicked, this, &UserGuideDialog::onAnchorClicked);
+
+    if (!m_sections.isEmpty()) {
+        m_sectionList->setCurrentRow(0);
+    }
+}
+
+void UserGuideDialog::loadSections()
+{
+    QFile file(QStringLiteral(":/docs/USER_GUIDE.md"));
+    if (!file.open(QIODevice::ReadOnly | QIODevice::Text)) {
+        return;
+    }
+
+    QTextStream stream(&file);
+    const QString content = stream.readAll();
+    const QStringList lines = content.split(QLatin1Char('\n'));
+
+    QString currentTitle;
+    QStringList currentLines;
+
+    auto flushSection = [this, &currentTitle, &currentLines]() {
+        if (currentTitle.isEmpty()) {
+            return;
+        }
+        Section section;
+        section.title = currentTitle;
+        section.anchor = slugify(currentTitle);
+        section.markdown = currentLines.join(QLatin1Char('\n'));
+        m_sections.append(section);
+    };
+
+    for (const QString& line : lines) {
+        if (line.startsWith(QStringLiteral("## "))) {
+            flushSection();
+            currentTitle = line.mid(3).trimmed();
+            currentLines.clear();
+        }
+        currentLines.append(line);
+    }
+    flushSection();
+
+    for (const Section& section : m_sections) {
+        m_sectionList->addItem(section.title);
+    }
+}
+
+void UserGuideDialog::showSection(int index)
+{
+    if (index < 0 || index >= m_sections.size()) {
+        return;
+    }
+    m_browser->setMarkdown(m_sections[index].markdown);
+}
+
+void UserGuideDialog::onAnchorClicked(const QUrl& url)
+{
+    if (!url.scheme().isEmpty()) {
+        QDesktopServices::openUrl(url);
+        return;
+    }
+
+    const QString fragment = url.fragment();
+    if (fragment.isEmpty()) {
+        return;
+    }
+
+    for (int i = 0; i < m_sections.size(); ++i) {
+        if (m_sections[i].anchor == fragment) {
+            m_sectionList->setCurrentRow(i);
+            return;
+        }
+    }
+}

src/user_guide_dialog.h

@@ -0,0 +1,35 @@
+#ifndef ORBITHUB_USER_GUIDE_DIALOG_H
+#define ORBITHUB_USER_GUIDE_DIALOG_H
+
+#include <QDialog>
+#include <QString>
+#include <QVector>
+
+class QListWidget;
+class QTextBrowser;
+class QUrl;
+
+class UserGuideDialog : public QDialog
+{
+    Q_OBJECT
+
+public:
+    explicit UserGuideDialog(QWidget* parent = nullptr);
+
+private:
+    struct Section {
+        QString title;
+        QString anchor;
+        QString markdown;
+    };
+
+    void loadSections();
+    void showSection(int index);
+    void onAnchorClicked(const QUrl& url);
+
+    QListWidget* m_sectionList;
+    QTextBrowser* m_browser;
+    QVector<Section> m_sections;
+};
+
+#endif

tests/CMakeLists.txt

@@ -0,0 +1,42 @@
+add_executable(test_profile_repository
+    test_profile_repository.cpp
+    ${CMAKE_SOURCE_DIR}/src/profile_repository.cpp
+)
+target_include_directories(test_profile_repository PRIVATE ${CMAKE_SOURCE_DIR}/src)
+target_link_libraries(test_profile_repository PRIVATE Qt6::Core Qt6::Sql Qt6::Test)
+add_test(NAME test_profile_repository COMMAND test_profile_repository)
+
+add_executable(test_ssh_session_backend
+    test_ssh_session_backend.cpp
+    ${CMAKE_SOURCE_DIR}/src/ssh_session_backend.cpp
+    ${CMAKE_SOURCE_DIR}/src/session_backend.h
+)
+target_include_directories(test_ssh_session_backend PRIVATE ${CMAKE_SOURCE_DIR}/src)
+target_link_libraries(test_ssh_session_backend PRIVATE Qt6::Core Qt6::Gui Qt6::Test)
+target_compile_definitions(test_ssh_session_backend PRIVATE
+    ORBITHUB_TEST_FIXTURES_DIR="${CMAKE_CURRENT_SOURCE_DIR}/fixtures"
+)
+add_test(NAME test_ssh_session_backend COMMAND test_ssh_session_backend)
+
+if(TARGET freerdp AND TARGET winpr)
+    add_executable(test_rdp_session_backend
+        test_rdp_session_backend.cpp
+        ${CMAKE_SOURCE_DIR}/src/rdp_session_backend.cpp
+        ${CMAKE_SOURCE_DIR}/src/session_backend.h
+    )
+    target_include_directories(test_rdp_session_backend PRIVATE
+        ${CMAKE_SOURCE_DIR}/src
+        ${CMAKE_SOURCE_DIR}/third_party/FreeRDP/include
+        ${CMAKE_SOURCE_DIR}/third_party/FreeRDP/winpr/include
+        ${CMAKE_BINARY_DIR}/third_party/FreeRDP/include
+        ${CMAKE_BINARY_DIR}/third_party/FreeRDP/winpr/include
+    )
+    target_compile_definitions(test_rdp_session_backend PRIVATE ORBITHUB_HAS_FREERDP)
+    target_link_libraries(test_rdp_session_backend PRIVATE Qt6::Core Qt6::Gui Qt6::Test freerdp winpr)
+    if(TARGET freerdp-client)
+        target_link_libraries(test_rdp_session_backend PRIVATE freerdp-client)
+    endif()
+    add_test(NAME test_rdp_session_backend COMMAND test_rdp_session_backend)
+else()
+    message(STATUS "FreeRDP targets not available -- skipping test_rdp_session_backend")
+endif()

tests/fixtures/fake_ssh.sh

@@ -0,0 +1,29 @@
+#!/bin/sh
+# Minimal, deterministic stand-in for the real `ssh` binary, used by
+# SshSessionBackend's state-machine tests so they never touch a real
+# network or SSH server. Behavior is selected by which fixture hostname
+# appears among argv (SshSessionBackend always passes the profile's
+# host, optionally as user@host, as the final argument).
+for arg in "$@"; do
+    case "$arg" in
+        *@succeed|succeed)
+            echo "Welcome to the fake host."
+            # Stay alive echoing stdin back (simulates an interactive
+            # session) until the backend terminates us.
+            while IFS= read -r line; do
+                echo "$line"
+            done
+            exit 0
+            ;;
+        *@fail-auth|fail-auth)
+            echo "Permission denied (publickey,password)." >&2
+            exit 255
+            ;;
+        *@refuse|refuse)
+            echo "ssh: connect to host refuse port 22: Connection refused" >&2
+            exit 255
+            ;;
+    esac
+done
+echo "fake_ssh.sh: no recognized fixture host in arguments: $*" >&2
+exit 1

tests/test_profile_repository.cpp

@@ -0,0 +1,375 @@
+#include "profile_repository.h"
+
+#include <QTemporaryDir>
+#include <QTest>
+
+#include <memory>
+
+namespace {
+Profile makeSshProfile(const QString& name = QStringLiteral("Prod SSH Box"))
+{
+    Profile profile;
+    profile.name = name;
+    profile.host = QStringLiteral("prod.example.com");
+    profile.port = 22;
+    profile.username = QStringLiteral("deploy");
+    profile.protocol = QStringLiteral("SSH");
+    profile.authMode = QStringLiteral("Password");
+    profile.tags = QStringLiteral("prod,linux");
+    return profile;
+}
+
+Profile makeRdpProfile(const QString& name = QStringLiteral("Windows RDP Box"))
+{
+    Profile profile;
+    profile.name = name;
+    profile.host = QStringLiteral("win.example.com");
+    profile.port = 3389;
+    profile.username = QStringLiteral("admin");
+    profile.domain = QStringLiteral("CORP");
+    profile.protocol = QStringLiteral("RDP");
+    profile.rdpSecurityMode = QStringLiteral("NLA");
+    profile.rdpPerformanceProfile = QStringLiteral("Best Performance");
+    return profile;
+}
+}
+
+class TestProfileRepository : public QObject
+{
+    Q_OBJECT
+
+private slots:
+    void init();
+    void cleanup();
+
+    void initializesCleanly();
+    void createAndGetSshProfile();
+    void createAndGetRdpProfile();
+    void createProfileRejectsMissingName();
+    void createProfileRejectsMissingHost();
+    void createProfileRejectsInvalidPort();
+    void createProfileRejectsMissingUsernameForSsh();
+    void createProfileRejectsMissingPrivateKeyForKeyAuth();
+    void createProfileRejectsDuplicateName();
+    void updateProfilePersistsChanges();
+    void deleteProfileRemovesIt();
+    void getProfileReturnsNulloptForUnknownId();
+    void listProfilesFiltersBySearchQuery();
+    void listProfilesSortsByRequestedOrder();
+    void tagsAreTrimmedDedupedAndJoined();
+    void emptyTagsRoundTripAsEmpty();
+    void folderCreateAndListRoundTrips();
+    void folderCreateIgnoresDuplicates();
+    void folderPathIsNormalized();
+    void deleteEmptyFolderRemovesIt();
+    void deleteFolderMovesDirectProfilesToParent();
+    void deleteRootLevelFolderMovesProfilesToRoot();
+    void deleteFolderShiftsSubfoldersAndTheirProfilesUp();
+    void deleteFolderRejectsEmptyPath();
+    void deleteNonexistentFolderSucceedsAsNoOp();
+
+private:
+    std::unique_ptr<QTemporaryDir> m_tempDir;
+    std::unique_ptr<ProfileRepository> m_repo;
+};
+
+void TestProfileRepository::init()
+{
+    m_tempDir = std::make_unique<QTemporaryDir>();
+    QVERIFY(m_tempDir->isValid());
+    m_repo = std::make_unique<ProfileRepository>(m_tempDir->filePath(QStringLiteral("test.sqlite")));
+}
+
+void TestProfileRepository::cleanup()
+{
+    m_repo.reset();
+    m_tempDir.reset();
+}
+
+void TestProfileRepository::initializesCleanly()
+{
+    QCOMPARE(m_repo->initError(), QString());
+    QCOMPARE(m_repo->listProfiles().size(), size_t(0));
+    QCOMPARE(m_repo->listFolders().size(), size_t(0));
+}
+
+void TestProfileRepository::createAndGetSshProfile()
+{
+    const Profile input = makeSshProfile();
+    const std::optional<Profile> created = m_repo->createProfile(input);
+    QVERIFY(created.has_value());
+    QVERIFY(created->id > 0);
+
+    const std::optional<Profile> fetched = m_repo->getProfile(created->id);
+    QVERIFY(fetched.has_value());
+    QCOMPARE(fetched->name, input.name);
+    QCOMPARE(fetched->host, input.host);
+    QCOMPARE(fetched->port, input.port);
+    QCOMPARE(fetched->username, input.username);
+    QCOMPARE(fetched->protocol, QStringLiteral("SSH"));
+    QCOMPARE(fetched->authMode, QStringLiteral("Password"));
+    QCOMPARE(fetched->tags, QStringLiteral("prod, linux"));
+}
+
+void TestProfileRepository::createAndGetRdpProfile()
+{
+    const Profile input = makeRdpProfile();
+    const std::optional<Profile> created = m_repo->createProfile(input);
+    QVERIFY(created.has_value());
+
+    const std::optional<Profile> fetched = m_repo->getProfile(created->id);
+    QVERIFY(fetched.has_value());
+    QCOMPARE(fetched->protocol, QStringLiteral("RDP"));
+    QCOMPARE(fetched->domain, QStringLiteral("CORP"));
+    QCOMPARE(fetched->rdpSecurityMode, QStringLiteral("NLA"));
+    QCOMPARE(fetched->rdpPerformanceProfile, QStringLiteral("Best Performance"));
+    QCOMPARE(fetched->port, 3389);
+    // Auth-mode/private-key fields are SSH-only and must not leak through
+    // for a non-SSH protocol.
+    QCOMPARE(fetched->authMode, QStringLiteral("Password"));
+    QCOMPARE(fetched->privateKeyPath, QString());
+}
+
+void TestProfileRepository::createProfileRejectsMissingName()
+{
+    Profile profile = makeSshProfile();
+    profile.name.clear();
+    QVERIFY(!m_repo->createProfile(profile).has_value());
+    QVERIFY(!m_repo->lastError().isEmpty());
+}
+
+void TestProfileRepository::createProfileRejectsMissingHost()
+{
+    Profile profile = makeSshProfile();
+    profile.host.clear();
+    QVERIFY(!m_repo->createProfile(profile).has_value());
+    QVERIFY(!m_repo->lastError().isEmpty());
+}
+
+void TestProfileRepository::createProfileRejectsInvalidPort()
+{
+    Profile profile = makeSshProfile();
+    profile.port = 0;
+    QVERIFY(!m_repo->createProfile(profile).has_value());
+
+    profile.port = 70000;
+    QVERIFY(!m_repo->createProfile(profile).has_value());
+}
+
+void TestProfileRepository::createProfileRejectsMissingUsernameForSsh()
+{
+    Profile profile = makeSshProfile();
+    profile.username.clear();
+    QVERIFY(!m_repo->createProfile(profile).has_value());
+}
+
+void TestProfileRepository::createProfileRejectsMissingPrivateKeyForKeyAuth()
+{
+    Profile profile = makeSshProfile();
+    profile.authMode = QStringLiteral("Private Key");
+    profile.privateKeyPath.clear();
+    QVERIFY(!m_repo->createProfile(profile).has_value());
+}
+
+void TestProfileRepository::createProfileRejectsDuplicateName()
+{
+    QVERIFY(m_repo->createProfile(makeSshProfile(QStringLiteral("Same Name"))).has_value());
+    QVERIFY(!m_repo->createProfile(makeSshProfile(QStringLiteral("Same Name"))).has_value());
+}
+
+void TestProfileRepository::updateProfilePersistsChanges()
+{
+    const std::optional<Profile> created = m_repo->createProfile(makeSshProfile());
+    QVERIFY(created.has_value());
+
+    Profile updated = created.value();
+    updated.host = QStringLiteral("new-host.example.com");
+    updated.port = 2222;
+    updated.tags = QStringLiteral("updated");
+    QVERIFY(m_repo->updateProfile(updated));
+
+    const std::optional<Profile> fetched = m_repo->getProfile(created->id);
+    QVERIFY(fetched.has_value());
+    QCOMPARE(fetched->host, QStringLiteral("new-host.example.com"));
+    QCOMPARE(fetched->port, 2222);
+    QCOMPARE(fetched->tags, QStringLiteral("updated"));
+}
+
+void TestProfileRepository::deleteProfileRemovesIt()
+{
+    const std::optional<Profile> created = m_repo->createProfile(makeSshProfile());
+    QVERIFY(created.has_value());
+    QVERIFY(m_repo->deleteProfile(created->id));
+    QVERIFY(!m_repo->getProfile(created->id).has_value());
+}
+
+void TestProfileRepository::getProfileReturnsNulloptForUnknownId()
+{
+    QVERIFY(!m_repo->getProfile(999999).has_value());
+}
+
+void TestProfileRepository::listProfilesFiltersBySearchQuery()
+{
+    QVERIFY(m_repo->createProfile(makeSshProfile(QStringLiteral("Alpha"))).has_value());
+    QVERIFY(m_repo->createProfile(makeRdpProfile(QStringLiteral("Beta"))).has_value());
+
+    const auto byName = m_repo->listProfiles(QStringLiteral("Alpha"));
+    QCOMPARE(byName.size(), size_t(1));
+    QCOMPARE(byName[0].name, QStringLiteral("Alpha"));
+
+    const auto byHost = m_repo->listProfiles(QStringLiteral("win.example"));
+    QCOMPARE(byHost.size(), size_t(1));
+    QCOMPARE(byHost[0].name, QStringLiteral("Beta"));
+
+    const auto byTag = m_repo->listProfiles(QStringLiteral("linux"));
+    QCOMPARE(byTag.size(), size_t(1));
+    QCOMPARE(byTag[0].name, QStringLiteral("Alpha"));
+
+    QCOMPARE(m_repo->listProfiles(QStringLiteral("nonexistent")).size(), size_t(0));
+}
+
+void TestProfileRepository::listProfilesSortsByRequestedOrder()
+{
+    QVERIFY(m_repo->createProfile(makeSshProfile(QStringLiteral("Zeta"))).has_value());
+    QVERIFY(m_repo->createProfile(makeRdpProfile(QStringLiteral("Alpha"))).has_value());
+
+    const auto byName = m_repo->listProfiles(QString(), ProfileSortOrder::NameAsc);
+    QCOMPARE(byName.size(), size_t(2));
+    QCOMPARE(byName[0].name, QStringLiteral("Alpha"));
+    QCOMPARE(byName[1].name, QStringLiteral("Zeta"));
+
+    const auto byProtocol = m_repo->listProfiles(QString(), ProfileSortOrder::ProtocolAsc);
+    QCOMPARE(byProtocol[0].protocol, QStringLiteral("RDP"));
+    QCOMPARE(byProtocol[1].protocol, QStringLiteral("SSH"));
+}
+
+void TestProfileRepository::tagsAreTrimmedDedupedAndJoined()
+{
+    Profile profile = makeSshProfile();
+    profile.tags = QStringLiteral(" prod ,, Prod , linux ,linux");
+    const std::optional<Profile> created = m_repo->createProfile(profile);
+    QVERIFY(created.has_value());
+
+    // createProfile()'s return value echoes the input as-is; normalization
+    // only happens on the DB round trip, so re-fetch to observe it.
+    const std::optional<Profile> fetched = m_repo->getProfile(created->id);
+    QVERIFY(fetched.has_value());
+    // Case-insensitive de-dup keeps the first-seen casing of each tag.
+    QCOMPARE(fetched->tags, QStringLiteral("prod, linux"));
+}
+
+void TestProfileRepository::emptyTagsRoundTripAsEmpty()
+{
+    const std::optional<Profile> created = m_repo->createProfile(makeRdpProfile());
+    QVERIFY(created.has_value());
+    const std::optional<Profile> fetched = m_repo->getProfile(created->id);
+    QVERIFY(fetched.has_value());
+    QCOMPARE(fetched->tags, QString());
+}
+
+void TestProfileRepository::folderCreateAndListRoundTrips()
+{
+    QVERIFY(m_repo->createFolder(QStringLiteral("Work/Servers")));
+    const auto folders = m_repo->listFolders();
+    QCOMPARE(folders.size(), size_t(1));
+    QCOMPARE(folders[0], QStringLiteral("Work/Servers"));
+}
+
+void TestProfileRepository::folderCreateIgnoresDuplicates()
+{
+    QVERIFY(m_repo->createFolder(QStringLiteral("Work")));
+    QVERIFY(m_repo->createFolder(QStringLiteral("Work")));
+    QCOMPARE(m_repo->listFolders().size(), size_t(1));
+}
+
+void TestProfileRepository::folderPathIsNormalized()
+{
+    QVERIFY(m_repo->createFolder(QStringLiteral("\\Work\\\\Servers\\")));
+    const auto folders = m_repo->listFolders();
+    QCOMPARE(folders.size(), size_t(1));
+    QCOMPARE(folders[0], QStringLiteral("Work/Servers"));
+}
+
+void TestProfileRepository::deleteEmptyFolderRemovesIt()
+{
+    QVERIFY(m_repo->createFolder(QStringLiteral("Empty")));
+    QVERIFY(m_repo->deleteFolder(QStringLiteral("Empty")));
+    QCOMPARE(m_repo->listFolders().size(), size_t(0));
+}
+
+void TestProfileRepository::deleteFolderMovesDirectProfilesToParent()
+{
+    QVERIFY(m_repo->createFolder(QStringLiteral("Work")));
+    Profile profile = makeSshProfile();
+    profile.folderPath = QStringLiteral("Work");
+    const std::optional<Profile> created = m_repo->createProfile(profile);
+    QVERIFY(created.has_value());
+
+    QVERIFY(m_repo->deleteFolder(QStringLiteral("Work")));
+    QCOMPARE(m_repo->listFolders().size(), size_t(0));
+
+    const std::optional<Profile> fetched = m_repo->getProfile(created->id);
+    QVERIFY(fetched.has_value());
+    // Deleting a folder is never destructive to profiles -- they shift up
+    // to take its place, here landing at the root since "Work" had no
+    // parent of its own.
+    QCOMPARE(fetched->folderPath, QString());
+}
+
+void TestProfileRepository::deleteRootLevelFolderMovesProfilesToRoot()
+{
+    Profile profile = makeRdpProfile();
+    profile.folderPath = QStringLiteral("Solo");
+    const std::optional<Profile> created = m_repo->createProfile(profile);
+    QVERIFY(created.has_value());
+
+    QVERIFY(m_repo->deleteFolder(QStringLiteral("Solo")));
+    const std::optional<Profile> fetched = m_repo->getProfile(created->id);
+    QVERIFY(fetched.has_value());
+    QCOMPARE(fetched->folderPath, QString());
+}
+
+void TestProfileRepository::deleteFolderShiftsSubfoldersAndTheirProfilesUp()
+{
+    QVERIFY(m_repo->createFolder(QStringLiteral("Work/Servers")));
+
+    Profile inTarget = makeSshProfile(QStringLiteral("InWork"));
+    inTarget.folderPath = QStringLiteral("Work");
+    const std::optional<Profile> createdInTarget = m_repo->createProfile(inTarget);
+    QVERIFY(createdInTarget.has_value());
+
+    Profile inSubfolder = makeRdpProfile(QStringLiteral("InServers"));
+    inSubfolder.folderPath = QStringLiteral("Work/Servers");
+    const std::optional<Profile> createdInSubfolder = m_repo->createProfile(inSubfolder);
+    QVERIFY(createdInSubfolder.has_value());
+
+    QVERIFY(m_repo->deleteFolder(QStringLiteral("Work")));
+
+    // "Work/Servers" shifts up to become root-level "Servers"; the profile
+    // that was directly in "Work" moves to root; nothing is deleted.
+    const auto folders = m_repo->listFolders();
+    QCOMPARE(folders.size(), size_t(1));
+    QCOMPARE(folders[0], QStringLiteral("Servers"));
+
+    const std::optional<Profile> fetchedInTarget = m_repo->getProfile(createdInTarget->id);
+    QVERIFY(fetchedInTarget.has_value());
+    QCOMPARE(fetchedInTarget->folderPath, QString());
+
+    const std::optional<Profile> fetchedInSubfolder = m_repo->getProfile(createdInSubfolder->id);
+    QVERIFY(fetchedInSubfolder.has_value());
+    QCOMPARE(fetchedInSubfolder->folderPath, QStringLiteral("Servers"));
+}
+
+void TestProfileRepository::deleteFolderRejectsEmptyPath()
+{
+    QVERIFY(!m_repo->deleteFolder(QString()));
+    QVERIFY(!m_repo->lastError().isEmpty());
+}
+
+void TestProfileRepository::deleteNonexistentFolderSucceedsAsNoOp()
+{
+    QVERIFY(m_repo->deleteFolder(QStringLiteral("Never/Created")));
+}
+
+QTEST_GUILESS_MAIN(TestProfileRepository)
+#include "test_profile_repository.moc"

tests/test_rdp_session_backend.cpp

@@ -0,0 +1,281 @@
+#include "rdp_session_backend.h"
+
+#include <QTest>
+
+#include <freerdp/error.h>
+#include <freerdp/locale/keyboard.h>
+#include <freerdp/scancode.h>
+
+class TestRdpSessionBackend : public QObject
+{
+    Q_OBJECT
+
+private slots:
+    void normalizedRdpSecurityModeRecognizesKnownValues();
+    void normalizedRdpSecurityModeFallsBackToNegotiate();
+    void normalizedRdpPerformanceProfileRecognizesKnownValues();
+    void normalizedRdpPerformanceProfileFallsBackToBalanced();
+    void nearestFreeRdpScaleValueMapsToLegalValues();
+
+    void sanitizeDesktopWidthClampsToLegalRange();
+    void sanitizeDesktopHeightClampsToLegalRange();
+
+    void scancodeFromNativeScanCodeHandlesZero();
+#if defined(Q_OS_LINUX)
+    void scancodeFromNativeScanCodeDelegatesToX11TableOnLinux();
+    void scancodeFromNativeScanCodeDoesNotTreatX11KeycodeAsPcAtScancode();
+#endif
+
+    void scancodeForQtKeyMapsDirectKeys();
+    void scancodeForQtKeyRespectsKeypadModifier();
+    void scancodeForQtKeyDisambiguatesLeftRightModifiers();
+    void scancodeForQtKeyReturnsUnknownForUnhandledKey();
+
+    void mapRdpErrorRecognizesAuthFailureCodes();
+    void mapRdpErrorRecognizesAccountStateCodes();
+    void mapRdpErrorRecognizesNetworkCodes();
+    void mapRdpErrorFallsBackForUnknownCode();
+
+    void isExpectedDisconnectCodeRecognizesBenignCodes();
+    void isExpectedDisconnectCodeRejectsAuthFailure();
+
+    void isExpectedConnectAbortCodeRecognizesCancellation();
+    void isExpectedConnectAbortCodeRejectsAuthFailure();
+
+    void disconnectMessageForCodeRecognizesKnownCodes();
+    void disconnectMessageForCodeFallsBackForUnknownCode();
+
+    void rdpErrorRawIncludesHexCode();
+};
+
+void TestRdpSessionBackend::normalizedRdpSecurityModeRecognizesKnownValues()
+{
+    QCOMPARE(RdpSessionBackend::normalizedRdpSecurityMode(QStringLiteral("nla")),
+             QStringLiteral("NLA"));
+    QCOMPARE(RdpSessionBackend::normalizedRdpSecurityMode(QStringLiteral(" TLS ")),
+             QStringLiteral("TLS"));
+    QCOMPARE(RdpSessionBackend::normalizedRdpSecurityMode(QStringLiteral("Rdp")),
+             QStringLiteral("RDP"));
+}
+
+void TestRdpSessionBackend::normalizedRdpSecurityModeFallsBackToNegotiate()
+{
+    QCOMPARE(RdpSessionBackend::normalizedRdpSecurityMode(QStringLiteral("bogus")),
+             QStringLiteral("Negotiate"));
+    QCOMPARE(RdpSessionBackend::normalizedRdpSecurityMode(QString()),
+             QStringLiteral("Negotiate"));
+}
+
+void TestRdpSessionBackend::normalizedRdpPerformanceProfileRecognizesKnownValues()
+{
+    QCOMPARE(RdpSessionBackend::normalizedRdpPerformanceProfile(QStringLiteral("best quality")),
+             QStringLiteral("Best Quality"));
+    QCOMPARE(RdpSessionBackend::normalizedRdpPerformanceProfile(QStringLiteral(" Best Performance ")),
+             QStringLiteral("Best Performance"));
+    QCOMPARE(RdpSessionBackend::normalizedRdpPerformanceProfile(QStringLiteral("auto detect")),
+             QStringLiteral("Auto Detect"));
+}
+
+void TestRdpSessionBackend::normalizedRdpPerformanceProfileFallsBackToBalanced()
+{
+    QCOMPARE(RdpSessionBackend::normalizedRdpPerformanceProfile(QStringLiteral("bogus")),
+             QStringLiteral("Balanced"));
+}
+
+void TestRdpSessionBackend::nearestFreeRdpScaleValueMapsToLegalValues()
+{
+    // MS-RDPEDISP legally permits only {100, 140, 180} -- anything else is
+    // silently ignored by the server.
+    QCOMPARE(RdpSessionBackend::nearestFreeRdpScaleValue(1.0), quint32(100));
+    QCOMPARE(RdpSessionBackend::nearestFreeRdpScaleValue(1.2), quint32(100));
+    QCOMPARE(RdpSessionBackend::nearestFreeRdpScaleValue(1.25), quint32(140));
+    QCOMPARE(RdpSessionBackend::nearestFreeRdpScaleValue(1.6), quint32(140));
+    QCOMPARE(RdpSessionBackend::nearestFreeRdpScaleValue(2.0), quint32(180));
+    QCOMPARE(RdpSessionBackend::nearestFreeRdpScaleValue(3.0), quint32(180));
+}
+
+void TestRdpSessionBackend::sanitizeDesktopWidthClampsToLegalRange()
+{
+    QCOMPARE(RdpSessionBackend::sanitizeDesktopWidth(0), 1280);
+    QCOMPARE(RdpSessionBackend::sanitizeDesktopWidth(-100), 1280);
+    QCOMPARE(RdpSessionBackend::sanitizeDesktopWidth(100), 640);
+    QCOMPARE(RdpSessionBackend::sanitizeDesktopWidth(1920), 1920);
+    QCOMPARE(RdpSessionBackend::sanitizeDesktopWidth(99999), 8192);
+}
+
+void TestRdpSessionBackend::sanitizeDesktopHeightClampsToLegalRange()
+{
+    QCOMPARE(RdpSessionBackend::sanitizeDesktopHeight(0), 720);
+    QCOMPARE(RdpSessionBackend::sanitizeDesktopHeight(-100), 720);
+    QCOMPARE(RdpSessionBackend::sanitizeDesktopHeight(100), 360);
+    QCOMPARE(RdpSessionBackend::sanitizeDesktopHeight(1080), 1080);
+    QCOMPARE(RdpSessionBackend::sanitizeDesktopHeight(99999), 4320);
+}
+
+void TestRdpSessionBackend::scancodeFromNativeScanCodeHandlesZero()
+{
+    QCOMPARE(RdpSessionBackend::scancodeFromNativeScanCode(0), quint32(RDP_SCANCODE_UNKNOWN));
+}
+
+#if defined(Q_OS_LINUX)
+void TestRdpSessionBackend::scancodeFromNativeScanCodeDelegatesToX11TableOnLinux()
+{
+    // Our wrapper must be a faithful passthrough to FreeRDP's own
+    // authoritative X11-keycode table, not a reimplementation of it.
+    const quint32 apostropheKeycode = 0x30;
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+#endif
+    const quint32 expected =
+        static_cast<quint32>(freerdp_keyboard_get_rdp_scancode_from_x11_keycode(apostropheKeycode));
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic pop
+#endif
+    QCOMPARE(RdpSessionBackend::scancodeFromNativeScanCode(apostropheKeycode), expected);
+}
+
+void TestRdpSessionBackend::scancodeFromNativeScanCodeDoesNotTreatX11KeycodeAsPcAtScancode()
+{
+    // Regression guard for the historical bug this table replaced: X11
+    // keycode 0x30 (apostrophe/quote) must NOT resolve to whatever a naive
+    // "treat the X11 keycode as a PC/AT set-1 scancode" interpretation
+    // would give (PC/AT 0x30 is the B key).
+    const quint32 apostropheKeycode = 0x30;
+    const quint32 naivePcAtInterpretation = MAKE_RDP_SCANCODE(apostropheKeycode, FALSE);
+    QVERIFY(RdpSessionBackend::scancodeFromNativeScanCode(apostropheKeycode)
+            != naivePcAtInterpretation);
+}
+#endif
+
+void TestRdpSessionBackend::scancodeForQtKeyMapsDirectKeys()
+{
+    QCOMPARE(RdpSessionBackend::scancodeForQtKey(Qt::Key_Escape, Qt::NoModifier, 0),
+             quint32(RDP_SCANCODE_ESCAPE));
+    QCOMPARE(RdpSessionBackend::scancodeForQtKey(Qt::Key_A, Qt::NoModifier, 0),
+             quint32(RDP_SCANCODE_KEY_A));
+    QCOMPARE(RdpSessionBackend::scancodeForQtKey(Qt::Key_F1, Qt::NoModifier, 0),
+             quint32(RDP_SCANCODE_F1));
+    QCOMPARE(RdpSessionBackend::scancodeForQtKey(Qt::Key_Space, Qt::NoModifier, 0),
+             quint32(RDP_SCANCODE_SPACE));
+}
+
+void TestRdpSessionBackend::scancodeForQtKeyRespectsKeypadModifier()
+{
+    QCOMPARE(RdpSessionBackend::scancodeForQtKey(Qt::Key_Insert, Qt::NoModifier, 0),
+             quint32(RDP_SCANCODE_INSERT));
+    QCOMPARE(RdpSessionBackend::scancodeForQtKey(Qt::Key_Insert, Qt::KeypadModifier, 0),
+             quint32(RDP_SCANCODE_NUMPAD0));
+
+    QCOMPARE(RdpSessionBackend::scancodeForQtKey(Qt::Key_Delete, Qt::NoModifier, 0),
+             quint32(RDP_SCANCODE_DELETE));
+    QCOMPARE(RdpSessionBackend::scancodeForQtKey(Qt::Key_Delete, Qt::KeypadModifier, 0),
+             quint32(RDP_SCANCODE_DECIMAL));
+}
+
+void TestRdpSessionBackend::scancodeForQtKeyDisambiguatesLeftRightModifiers()
+{
+    // With no reliable native scancode (0 -> RDP_SCANCODE_UNKNOWN, which
+    // matches neither side), both Shift and Control must default to their
+    // left variant rather than picking arbitrarily.
+    QCOMPARE(RdpSessionBackend::scancodeForQtKey(Qt::Key_Shift, Qt::NoModifier, 0),
+             quint32(RDP_SCANCODE_LSHIFT));
+    QCOMPARE(RdpSessionBackend::scancodeForQtKey(Qt::Key_Control, Qt::NoModifier, 0),
+             quint32(RDP_SCANCODE_LCONTROL));
+}
+
+void TestRdpSessionBackend::scancodeForQtKeyReturnsUnknownForUnhandledKey()
+{
+    QCOMPARE(RdpSessionBackend::scancodeForQtKey(Qt::Key_MediaPlay, Qt::NoModifier, 0),
+             quint32(RDP_SCANCODE_UNKNOWN));
+}
+
+void TestRdpSessionBackend::mapRdpErrorRecognizesAuthFailureCodes()
+{
+    const QString expected = QStringLiteral("Authentication failed. Check username and password.");
+    QCOMPARE(RdpSessionBackend::mapRdpError(FREERDP_ERROR_CONNECT_LOGON_FAILURE), expected);
+    QCOMPARE(RdpSessionBackend::mapRdpError(FREERDP_ERROR_CONNECT_WRONG_PASSWORD), expected);
+    QCOMPARE(RdpSessionBackend::mapRdpError(FREERDP_ERROR_CONNECT_ACCESS_DENIED), expected);
+}
+
+void TestRdpSessionBackend::mapRdpErrorRecognizesAccountStateCodes()
+{
+    QCOMPARE(RdpSessionBackend::mapRdpError(FREERDP_ERROR_CONNECT_ACCOUNT_DISABLED),
+             QStringLiteral("Account is disabled."));
+    QCOMPARE(RdpSessionBackend::mapRdpError(FREERDP_ERROR_CONNECT_ACCOUNT_LOCKED_OUT),
+             QStringLiteral("Account is locked out."));
+    QCOMPARE(RdpSessionBackend::mapRdpError(FREERDP_ERROR_CONNECT_ACCOUNT_EXPIRED),
+             QStringLiteral("Account has expired."));
+    QCOMPARE(RdpSessionBackend::mapRdpError(FREERDP_ERROR_CONNECT_PASSWORD_EXPIRED),
+             QStringLiteral("Password has expired."));
+}
+
+void TestRdpSessionBackend::mapRdpErrorRecognizesNetworkCodes()
+{
+    QCOMPARE(RdpSessionBackend::mapRdpError(FREERDP_ERROR_DNS_NAME_NOT_FOUND),
+             QStringLiteral("Host could not be resolved."));
+    QCOMPARE(RdpSessionBackend::mapRdpError(FREERDP_ERROR_CONNECT_TRANSPORT_FAILED),
+             QStringLiteral("Network transport failed while connecting."));
+    QCOMPARE(RdpSessionBackend::mapRdpError(FREERDP_ERROR_SECURITY_NEGO_CONNECT_FAILED),
+             QStringLiteral("RDP security negotiation failed. Try a different RDP security mode."));
+}
+
+void TestRdpSessionBackend::mapRdpErrorFallsBackForUnknownCode()
+{
+    // Not a code mapRdpError special-cases; must still return something
+    // non-empty rather than crashing or returning an empty string.
+    const QString result = RdpSessionBackend::mapRdpError(0x7FFFFFFF);
+    QVERIFY(!result.isEmpty());
+}
+
+void TestRdpSessionBackend::isExpectedDisconnectCodeRecognizesBenignCodes()
+{
+    QVERIFY(RdpSessionBackend::isExpectedDisconnectCode(FREERDP_ERROR_SUCCESS));
+    QVERIFY(RdpSessionBackend::isExpectedDisconnectCode(FREERDP_ERROR_NONE));
+    QVERIFY(RdpSessionBackend::isExpectedDisconnectCode(FREERDP_ERROR_LOGOFF_BY_USER));
+    QVERIFY(RdpSessionBackend::isExpectedDisconnectCode(FREERDP_ERROR_IDLE_TIMEOUT));
+}
+
+void TestRdpSessionBackend::isExpectedDisconnectCodeRejectsAuthFailure()
+{
+    // An authentication failure must be treated as a real error, never as
+    // an expected/benign disconnect -- otherwise the user would see no
+    // error message at all for a failed login.
+    QVERIFY(!RdpSessionBackend::isExpectedDisconnectCode(FREERDP_ERROR_CONNECT_LOGON_FAILURE));
+}
+
+void TestRdpSessionBackend::isExpectedConnectAbortCodeRecognizesCancellation()
+{
+    QVERIFY(RdpSessionBackend::isExpectedConnectAbortCode(FREERDP_ERROR_CONNECT_CANCELLED));
+    QVERIFY(RdpSessionBackend::isExpectedConnectAbortCode(FREERDP_ERROR_SUCCESS));
+}
+
+void TestRdpSessionBackend::isExpectedConnectAbortCodeRejectsAuthFailure()
+{
+    QVERIFY(!RdpSessionBackend::isExpectedConnectAbortCode(FREERDP_ERROR_CONNECT_LOGON_FAILURE));
+}
+
+void TestRdpSessionBackend::disconnectMessageForCodeRecognizesKnownCodes()
+{
+    QCOMPARE(RdpSessionBackend::disconnectMessageForCode(FREERDP_ERROR_IDLE_TIMEOUT),
+             QStringLiteral("RDP session disconnected due to idle timeout."));
+    QCOMPARE(RdpSessionBackend::disconnectMessageForCode(FREERDP_ERROR_LOGOFF_BY_USER),
+             QStringLiteral("RDP session signed out."));
+    QCOMPARE(RdpSessionBackend::disconnectMessageForCode(FREERDP_ERROR_CONNECT_CANCELLED),
+             QStringLiteral("Connection cancelled."));
+}
+
+void TestRdpSessionBackend::disconnectMessageForCodeFallsBackForUnknownCode()
+{
+    QCOMPARE(RdpSessionBackend::disconnectMessageForCode(0x7FFFFFFF),
+             QStringLiteral("RDP session ended."));
+}
+
+void TestRdpSessionBackend::rdpErrorRawIncludesHexCode()
+{
+    const QString result = RdpSessionBackend::rdpErrorRaw(FREERDP_ERROR_SUCCESS);
+    QVERIFY(result.contains(QStringLiteral("(0x00000000)")));
+}
+
+QTEST_GUILESS_MAIN(TestRdpSessionBackend)
+#include "test_rdp_session_backend.moc"

tests/test_ssh_session_backend.cpp

@@ -0,0 +1,236 @@
+#include "ssh_session_backend.h"
+
+#include <QTest>
+
+#include <memory>
+
+#ifndef ORBITHUB_TEST_FIXTURES_DIR
+#error "ORBITHUB_TEST_FIXTURES_DIR must be defined by the build"
+#endif
+
+namespace {
+Profile makeProfile(const QString& fixtureHost)
+{
+    Profile profile;
+    profile.name = QStringLiteral("Test Profile");
+    profile.host = fixtureHost;
+    profile.port = 22;
+    profile.username = QStringLiteral("tester");
+    profile.protocol = QStringLiteral("SSH");
+    profile.authMode = QStringLiteral("Password");
+    return profile;
+}
+
+SessionConnectOptions makeOptions()
+{
+    SessionConnectOptions options;
+    options.password = QStringLiteral("dummy-password");
+    return options;
+}
+}
+
+class TestSshSessionBackend : public QObject
+{
+    Q_OBJECT
+
+private slots:
+    // Pure-function coverage -- no process involved.
+    void mapSshErrorRecognizesKnownPatterns();
+    void mapSshErrorFallsBackForUnknownText();
+    void mapSshErrorHandlesEmptyInput();
+    void escapeForShellSingleQuotesNeutralizesQuotes();
+    void escapeForShellSingleQuotesLeavesPlainTextAlone();
+
+    // State-machine coverage, driven against tests/fixtures/fake_ssh.sh
+    // instead of a real ssh binary or network.
+    void init();
+    void cleanup();
+    void successfulConnectReachesConnectedThenDisconnects();
+    void authFailureReachesFailedStateWithMappedMessage();
+    void connectionRefusedReachesFailedState();
+    void sendInputEchoesThroughOutputReceived();
+    void reconnectRestartsAndReachesConnectedAgain();
+
+private:
+    QString fixturePath() const;
+    void createBackend(const QString& fixtureHost);
+
+    std::unique_ptr<SshSessionBackend> m_backend;
+    SessionState m_lastState = SessionState::Disconnected;
+    QString m_lastErrorDisplay;
+    QString m_lastErrorRaw;
+    QString m_receivedOutput;
+};
+
+QString TestSshSessionBackend::fixturePath() const
+{
+    return QStringLiteral(ORBITHUB_TEST_FIXTURES_DIR "/fake_ssh.sh");
+}
+
+void TestSshSessionBackend::createBackend(const QString& fixtureHost)
+{
+    m_backend =
+        std::make_unique<SshSessionBackend>(makeProfile(fixtureHost), fixturePath(), nullptr);
+    connect(m_backend.get(),
+            &SessionBackend::stateChanged,
+            this,
+            [this](SessionState state, const QString&) { m_lastState = state; });
+    connect(m_backend.get(),
+            &SessionBackend::connectionError,
+            this,
+            [this](const QString& display, const QString& raw) {
+                m_lastErrorDisplay = display;
+                m_lastErrorRaw = raw;
+            });
+    connect(m_backend.get(),
+            &SessionBackend::outputReceived,
+            this,
+            [this](const QString& chunk) { m_receivedOutput += chunk; });
+}
+
+void TestSshSessionBackend::mapSshErrorRecognizesKnownPatterns()
+{
+    QCOMPARE(SshSessionBackend::mapSshError(QStringLiteral("Permission denied (publickey,password).")),
+             QStringLiteral("Authentication failed. Check username and credentials."));
+    QCOMPARE(SshSessionBackend::mapSshError(QStringLiteral("Host key verification failed.")),
+             QStringLiteral("Host key verification failed."));
+    QCOMPARE(SshSessionBackend::mapSshError(QStringLiteral("ssh: Could not resolve hostname bogus")),
+             QStringLiteral("Host could not be resolved."));
+    QCOMPARE(SshSessionBackend::mapSshError(QStringLiteral("ssh: connect to host x port 22: Connection timed out")),
+             QStringLiteral("Connection timed out."));
+    QCOMPARE(SshSessionBackend::mapSshError(QStringLiteral("ssh: connect to host x port 22: Connection refused")),
+             QStringLiteral("Connection refused by remote host."));
+    QCOMPARE(SshSessionBackend::mapSshError(QStringLiteral("ssh: connect to host x port 22: No route to host")),
+             QStringLiteral("No route to host."));
+    QCOMPARE(SshSessionBackend::mapSshError(QStringLiteral("Identity file /nope not accessible: No such file.")),
+             QStringLiteral("Private key file is not accessible."));
+    QCOMPARE(SshSessionBackend::mapSshError(QStringLiteral("posix_spawn: /usr/bin/ssh-askpass: No such file or directory")),
+             QStringLiteral("SSH password helper is missing or failed to launch."));
+    QCOMPARE(SshSessionBackend::mapSshError(QStringLiteral("open /some/other/path: No such file or directory")),
+             QStringLiteral("Required file was not found."));
+}
+
+void TestSshSessionBackend::mapSshErrorFallsBackForUnknownText()
+{
+    QCOMPARE(SshSessionBackend::mapSshError(QStringLiteral("some completely novel ssh error text")),
+             QStringLiteral("SSH connection failed."));
+}
+
+void TestSshSessionBackend::mapSshErrorHandlesEmptyInput()
+{
+    QCOMPARE(SshSessionBackend::mapSshError(QString()),
+             QStringLiteral("SSH connection failed for an unknown reason."));
+    QCOMPARE(SshSessionBackend::mapSshError(QStringLiteral("   ")),
+             QStringLiteral("SSH connection failed for an unknown reason."));
+}
+
+void TestSshSessionBackend::escapeForShellSingleQuotesNeutralizesQuotes()
+{
+    // A password containing a single quote must not be able to break out
+    // of the single-quoted printf argument in the askpass script -- this
+    // is the actual security boundary, not just cosmetic escaping.
+    const QString malicious = QStringLiteral("pw' ; rm -rf ~ ; echo '");
+    const QString escaped = SshSessionBackend::escapeForShellSingleQuotes(malicious);
+    const QString reconstructedScriptArg = QStringLiteral("'") + escaped + QStringLiteral("'");
+    // Every single quote in the reconstructed argument must be either the
+    // outer boundary quote (open at index 0, close at the very end) or the
+    // start of a full '"'"' re-opening sequence -- never a bare, unescaped
+    // quote that could close the argument early.
+    int index = 0;
+    while (index < reconstructedScriptArg.length()) {
+        if (reconstructedScriptArg.at(index) != QChar::fromLatin1('\'')) {
+            ++index;
+            continue;
+        }
+        if (index == 0 || index == reconstructedScriptArg.length() - 1) {
+            ++index;
+            continue;
+        }
+        QCOMPARE(reconstructedScriptArg.mid(index, 5), QStringLiteral("'\"'\"'"));
+        index += 5;
+    }
+}
+
+void TestSshSessionBackend::escapeForShellSingleQuotesLeavesPlainTextAlone()
+{
+    QCOMPARE(SshSessionBackend::escapeForShellSingleQuotes(QStringLiteral("plain-password-123")),
+             QStringLiteral("plain-password-123"));
+}
+
+void TestSshSessionBackend::init()
+{
+#ifdef Q_OS_WIN
+    // fixtures/fake_ssh.sh is a POSIX shell script; there's no Windows
+    // fixture yet, so skip only the tests that actually launch it. The
+    // pure-function tests above (mapSshError*, escapeForShellSingleQuotes*)
+    // don't touch the fixture and still run everywhere.
+    const QByteArray currentTest = QTest::currentTestFunction();
+    if (!currentTest.startsWith("mapSshError") && !currentTest.startsWith("escapeForShellSingleQuotes")) {
+        QSKIP("No Windows equivalent of tests/fixtures/fake_ssh.sh yet");
+    }
+#endif
+
+    m_lastState = SessionState::Disconnected;
+    m_lastErrorDisplay.clear();
+    m_lastErrorRaw.clear();
+    m_receivedOutput.clear();
+    // Individual tests call createBackend() with the fixture host they
+    // need; most want "succeed", so provide it as the default here.
+    createBackend(QStringLiteral("succeed"));
+}
+
+void TestSshSessionBackend::cleanup()
+{
+    if (m_backend) {
+        m_backend->disconnectSession();
+    }
+    m_backend.reset();
+}
+
+void TestSshSessionBackend::successfulConnectReachesConnectedThenDisconnects()
+{
+    m_backend->connectSession(makeOptions());
+    QTRY_COMPARE(m_lastState, SessionState::Connected);
+
+    m_backend->disconnectSession();
+    QTRY_COMPARE(m_lastState, SessionState::Disconnected);
+}
+
+void TestSshSessionBackend::authFailureReachesFailedStateWithMappedMessage()
+{
+    createBackend(QStringLiteral("fail-auth"));
+    m_backend->connectSession(makeOptions());
+    QTRY_COMPARE(m_lastState, SessionState::Failed);
+    QCOMPARE(m_lastErrorDisplay, QStringLiteral("Authentication failed. Check username and credentials."));
+    QVERIFY(m_lastErrorRaw.contains(QStringLiteral("Permission denied")));
+}
+
+void TestSshSessionBackend::connectionRefusedReachesFailedState()
+{
+    createBackend(QStringLiteral("refuse"));
+    m_backend->connectSession(makeOptions());
+    QTRY_COMPARE(m_lastState, SessionState::Failed);
+    QCOMPARE(m_lastErrorDisplay, QStringLiteral("Connection refused by remote host."));
+}
+
+void TestSshSessionBackend::sendInputEchoesThroughOutputReceived()
+{
+    m_backend->connectSession(makeOptions());
+    QTRY_COMPARE(m_lastState, SessionState::Connected);
+
+    m_backend->sendInput(QStringLiteral("hello-from-test\n"));
+    QTRY_VERIFY(m_receivedOutput.contains(QStringLiteral("hello-from-test")));
+}
+
+void TestSshSessionBackend::reconnectRestartsAndReachesConnectedAgain()
+{
+    m_backend->connectSession(makeOptions());
+    QTRY_COMPARE(m_lastState, SessionState::Connected);
+
+    m_lastState = SessionState::Connecting;
+    m_backend->reconnectSession(makeOptions());
+    QTRY_COMPARE(m_lastState, SessionState::Connected);
+}
+
+QTEST_GUILESS_MAIN(TestSshSessionBackend)
+#include "test_ssh_session_backend.moc"

third_party/FreeRDP/.source_tag

@@ -0,0 +1 @@
+3.23.1-dev0

tools/user-guide-pdf/CMakeLists.txt

@@ -0,0 +1,11 @@
+cmake_minimum_required(VERSION 3.21)
+
+project(OrbitHubUserGuidePdf LANGUAGES CXX)
+
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+find_package(Qt6 6.2 REQUIRED COMPONENTS Widgets PrintSupport)
+
+add_executable(user-guide-pdf main.cpp)
+target_link_libraries(user-guide-pdf PRIVATE Qt6::Widgets Qt6::PrintSupport)

tools/user-guide-pdf/main.cpp

@@ -0,0 +1,44 @@
+#include <QApplication>
+#include <QFile>
+#include <QPageSize>
+#include <QPrinter>
+#include <QTextDocument>
+#include <QTextStream>
+
+#include <cstdio>
+
+int main(int argc, char* argv[])
+{
+    QApplication app(argc, argv);
+
+    if (argc != 3) {
+        std::fprintf(stderr, "Usage: %s <input.md> <output.pdf>\n", argv[0]);
+        return 1;
+    }
+
+    const QString inputPath = QString::fromLocal8Bit(argv[1]);
+    const QString outputPath = QString::fromLocal8Bit(argv[2]);
+
+    QFile input(inputPath);
+    if (!input.open(QIODevice::ReadOnly | QIODevice::Text)) {
+        std::fprintf(stderr, "Could not open %s\n", qPrintable(inputPath));
+        return 1;
+    }
+
+    QTextStream stream(&input);
+    const QString markdown = stream.readAll();
+
+    QTextDocument document;
+    document.setMarkdown(markdown);
+
+    QPrinter printer(QPrinter::HighResolution);
+    printer.setOutputFormat(QPrinter::PdfFormat);
+    printer.setPageSize(QPageSize(QPageSize::Letter));
+    printer.setPageMargins(QMarginsF(50, 50, 50, 50), QPageLayout::Point);
+    printer.setOutputFileName(outputPath);
+
+    document.print(&printer);
+
+    std::printf("Wrote %s\n", qPrintable(outputPath));
+    return 0;
+}