remove fromIntegral

.github/actions/swap/action.yml

@@ -1,44 +0,0 @@
-name: 'Set Swap Space'
-description: 'Add moar swap'
-branding:
-  icon: 'crop'
-  color: 'orange'
-inputs:
-  swap-size-gb:
-    description: 'Swap space to create, in Gigabytes.'
-    required: false
-    default: '10'
-runs:
-  using: "composite"
-  steps:
-    - name: Swap space report before modification
-      shell: bash
-      run: |
-        echo "Memory and swap:"
-        free -h
-        echo
-        swapon --show
-        echo
-    - name: Set Swap
-      shell: bash
-      run: |
-          export SWAP_FILE=$(swapon --show=NAME | tail -n 1)
-          echo "Swap file: $SWAP_FILE"
-          if [ -z "$SWAP_FILE" ]; then
-            SWAP_FILE=/opt/swapfile
-          else
-            sudo swapoff $SWAP_FILE
-            sudo rm $SWAP_FILE
-          fi
-          sudo fallocate -l ${{ inputs.swap-size-gb }}G $SWAP_FILE
-          sudo chmod 600 $SWAP_FILE
-          sudo mkswap $SWAP_FILE
-          sudo swapon $SWAP_FILE
-    - name: Swap space report after modification
-      shell: bash
-      run: |
-        echo "Memory and swap:"
-        free -h
-        echo
-        swapon --show
-        echo

.github/workflows/build.yml

@@ -10,25 +10,62 @@ on:
   pull_request:
 
 jobs:
-
-# =============================
-#       Create release
-# =============================
-
-# Create release, but only if it's triggered by tag push.
-# On pull requests/commits push, this job will always complete.
-
-  maybe-release:
-    runs-on: ubuntu-latest
+  build:
+    name: build-${{ matrix.os }}-${{ matrix.ghc }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: ubuntu-20.04
+            platform_name: 20_04-x86-64
+            ghc: "8.10.7"
+          - os: ubuntu-20.04
+            platform_name: 20_04-x86-64
+            ghc: "9.6.3"
+          - os: ubuntu-22.04
+            platform_name: 22_04-x86-64
+            ghc: "9.6.3"
     steps:
       - name: Clone project
-        if: startsWith(github.ref, 'refs/tags/v')
         uses: actions/checkout@v3
 
-      - name: Build changelog
-        id: build_changelog
+      - name: Setup Haskell
+        uses: haskell-actions/setup@v2
+        with:
+          ghc-version: ${{ matrix.ghc }}
+          cabal-version: "3.10.1.0"
+
+      - name: Cache dependencies
+        uses: actions/cache@v2
+        with:
+          path: |
+            ~/.cabal/store
+            dist-newstyle
+          key: ${{ matrix.os }}-${{ hashFiles('cabal.project', 'simplexmq.cabal') }}
+
+      - name: Build
+        shell: bash
+        run: cabal build --enable-tests
+
+      - name: Test
+        timeout-minutes: 30
+        shell: bash
+        run: cabal test --test-show-details=direct
+
+      - name: Prepare binaries
         if: startsWith(github.ref, 'refs/tags/v')
-        uses: simplex-chat/release-changelog-builder-action@v5
+        shell: bash
+        run: |
+          mv $(cabal list-bin smp-server) smp-server-ubuntu-${{ matrix.platform_name}}
+          mv $(cabal list-bin ntf-server) ntf-server-ubuntu-${{ matrix.platform_name}}
+          mv $(cabal list-bin xftp-server) xftp-server-ubuntu-${{ matrix.platform_name}}
+          mv $(cabal list-bin xftp) xftp-ubuntu-${{ matrix.platform_name}}
+
+      - name: Build changelog
+        if: startsWith(github.ref, 'refs/tags/v') && matrix.os == 'ubuntu-20.04'
+        id: build_changelog
+        uses: mikepenz/release-changelog-builder-action@v1
         with:
           configuration: .github/changelog_conf.json
           failOnError: true
@@ -38,8 +75,8 @@ jobs:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 
       - name: Create release
-        if: startsWith(github.ref, 'refs/tags/v')
-        uses: simplex-chat/action-gh-release@v2
+        if: startsWith(github.ref, 'refs/tags/v') && matrix.os == 'ubuntu-20.04' && matrix.ghc == '9.6.3'
+        uses: softprops/action-gh-release@v1
         with:
           body: |
             See full changelog [here](https://github.com/simplex-chat/simplexmq/blob/master/CHANGELOG.md).
@@ -49,241 +86,10 @@ jobs:
           prerelease: true
           files: |
             LICENSE
+            smp-server-ubuntu-${{ matrix.platform_name}}
+            ntf-server-ubuntu-${{ matrix.platform_name}}
+            xftp-server-ubuntu-${{ matrix.platform_name}}
+            xftp-ubuntu-${{ matrix.platform_name}}
           fail_on_unmatched_files: true
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-
-# =============================
-#        Main build job
-# =============================
-
-  build:
-    name: "ubuntu-${{ matrix.os }}-${{ matrix.arch }}, GHC: ${{ matrix.ghc }}"
-    needs: maybe-release
-    env:
-      apps: "smp-server xftp-server ntf-server xftp"
-    runs-on: ${{ matrix.runner }}
-    services:
-      postgres:
-        image: postgres:15
-        env:
-          POSTGRES_HOST_AUTH_METHOD: trust # Allows passwordless access
-        options: >-
-          --health-cmd pg_isready
-          --health-interval 10s
-          --health-timeout 5s
-          --health-retries 5
-        ports:
-          # Maps tcp port 5432 on service container to the host
-          - 5432:5432
-    strategy:
-      fail-fast: false
-      matrix:
-        include:
-          - os: 22.04
-            os_underscore: 22_04
-            arch: x86-64
-            runner: "ubuntu-22.04"
-            ghc: "8.10.7"
-            should_run: ${{ !(github.ref == 'refs/heads/stable' || startsWith(github.ref, 'refs/tags/v')) }}
-          - os: 22.04
-            os_underscore: 22_04
-            arch: x86-64
-            runner: "ubuntu-22.04"
-            ghc: "9.6.3"
-            should_run: true
-          - os: 24.04
-            os_underscore: 24_04
-            arch: x86-64
-            runner: "ubuntu-24.04"
-            ghc: "9.6.3"
-            should_run: true
-          - os: 22.04
-            os_underscore: 22_04
-            arch: aarch64
-            runner: "ubuntu-22.04-arm"
-            ghc: "9.6.3"
-            should_run: true
-          - os: 24.04
-            os_underscore: 24_04
-            arch: aarch64
-            runner: "ubuntu-24.04-arm"
-            ghc: "9.6.3"
-            should_run: true
-    steps:
-      - name: Clone project
-        if: matrix.should_run == true
-        uses: actions/checkout@v3
-
-      - name: Set up Docker Buildx
-        if: matrix.should_run == true
-        uses: simplex-chat/docker-setup-buildx-action@v3
-
-      - name: Setup swap
-        if: matrix.ghc == '8.10.7' && matrix.should_run == true
-        uses: ./.github/actions/swap
-        with:
-          swap-size-gb: 20
-
-      - name: Install PostgreSQL 15 client tools
-        if: matrix.os == '22.04' && matrix.should_run == true
-        shell: bash
-        run: |
-          # Import the repository signing key
-          sudo install -d /usr/share/postgresql-common/pgdg
-          sudo curl -o /usr/share/postgresql-common/pgdg/apt.postgresql.org.asc --fail https://www.postgresql.org/media/keys/ACCC4CF8.asc
-          # Add the PostgreSQL APT repository
-          sudo sh -c 'echo "deb [signed-by=/usr/share/postgresql-common/pgdg/apt.postgresql.org.asc] https://apt.postgresql.org/pub/repos/apt $(lsb_release -cs)-pgdg main" > /etc/apt/sources.list.d/pgdg.list'
-          # Update repository and install postgresql tools
-          sudo apt update
-          sudo apt -y install postgresql-client-15
-
-      - name: Build and cache Docker image
-        if: matrix.should_run == true
-        uses: simplex-chat/docker-build-push-action@v6
-        with:
-          context: .
-          load: true
-          file: Dockerfile.build
-          tags: build/${{ matrix.os }}:latest
-          build-args: |
-            TAG=${{ matrix.os }}
-            GHC=${{ matrix.ghc }}
-
-      - name: Cache dependencies
-        if: matrix.should_run == true
-        uses: actions/cache@v4
-        with:
-          path: |
-            ~/.cabal/store
-            dist-newstyle
-          key: ubuntu-${{ matrix.os }}-${{ matrix.arch }}-ghc${{ matrix.ghc }}-${{ hashFiles('cabal.project', 'simplexmq.cabal') }}
-
-      - name: Start container
-        if: matrix.should_run == true
-        shell: bash
-        run: |
-          docker run -t -d \
-            --device /dev/fuse \
-            --cap-add SYS_ADMIN \
-            --security-opt apparmor:unconfined \
-            --name builder \
-            -v ~/.cabal:/root/.cabal \
-            -v /home/runner/work/_temp:/home/runner/work/_temp \
-            -v ${{ github.workspace }}:/project \
-            build/${{ matrix.os }}:latest
-
-      - name: Build smp-server (postgresql) and tests
-        if: matrix.should_run == true
-        shell: docker exec -t builder sh -eu {0}
-        run: |
-          chmod -fR 777 ~/.cabal ./dist-newstyle || :; git config --global --add safe.directory '*'
-          cabal clean
-          cabal update
-          cabal build --jobs=$(nproc) --enable-tests -fserver_postgres
-          mkdir -p /out
-          for i in smp-server simplexmq-test; do
-            bin=$(find /project/dist-newstyle -name "$i" -type f -executable)
-            chmod +x "$bin"
-            mv "$bin" /out/
-          done
-          strip /out/smp-server
-
-      - name: Copy simplexmq-test from container
-        if: matrix.should_run == true
-        shell: bash
-        run: |
-          docker cp builder:/out/simplexmq-test .
-
-      - name: Copy smp-server (postgresql) from container and prepare it
-        if: startsWith(github.ref, 'refs/tags/v') && matrix.should_run == true
-        id: prepare-postgres
-        shell: bash
-        run: |
-          name="smp-server-postgres-ubuntu-${{ matrix.os_underscore }}-${{ matrix.arch }}"
-          docker cp builder:/out/smp-server $name
-
-          path="${{ github.workspace }}/$name"
-          echo "bin=$path" >> $GITHUB_OUTPUT
-
-          hash="SHA2-256($name)= $(openssl sha256 $path | cut -d' ' -f 2)"
-          printf 'hash=%s' "$hash" >> $GITHUB_OUTPUT
-
-      - name: Build everything else (standard)
-        if: matrix.should_run == true
-        shell: docker exec -t builder sh -eu {0}
-        run: |
-          cabal build --jobs=$(nproc)
-          mkdir -p /out
-          for i in ${{ env.apps }}; do
-            bin=$(find /project/dist-newstyle -name "$i" -type f -executable)
-            strip "$bin"
-            chmod +x "$bin"
-            mv "$bin" /out/
-          done
-
-      - name: Copy binaries from container and prepare them
-        id: prepare-regular
-        if: startsWith(github.ref, 'refs/tags/v') && matrix.should_run == true
-        shell: bash
-        run: |
-          docker cp builder:/out .
-
-          printf 'bins<<EOF\n' > bins.output
-          printf 'hashes<<EOF\n' > hashes.output
-          for i in ${{ env.apps }}; do
-            name="$i-ubuntu-${{ matrix.os_underscore }}-${{ matrix.arch }}"
-
-            mv ./out/$i ./$name
-
-            path="${{ github.workspace }}/$name"
-            hash="SHA2-256($name)= $(openssl sha256 $path | cut -d' ' -f 2)"
-
-            printf '%s\n' "$path" >> bins.output
-            printf '%s\n\n' "$hash" >> hashes.output
-          done
-          printf 'EOF\n' >> bins.output
-          printf 'EOF\n' >> hashes.output
-
-          cat bins.output >> "$GITHUB_OUTPUT"
-          cat hashes.output >> "$GITHUB_OUTPUT"
-
-      - name: Upload binaries
-        if: startsWith(github.ref, 'refs/tags/v') && matrix.should_run == true
-        uses: simplex-chat/action-gh-release@v2
-        with:
-          append_body: true
-          prerelease: true
-          fail_on_unmatched_files: true
-          body: |
-            ${{ steps.prepare-regular.outputs.hashes }}
-            ${{ steps.prepare-postgres.outputs.hash }}
-          files: |
-            ${{ steps.prepare-regular.outputs.bins }}
-            ${{ steps.prepare-postgres.outputs.bin }}
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-
-      - name: Test
-        if: matrix.should_run == true && matrix.arch == 'x86-64'
-        timeout-minutes: 120
-        shell: bash
-        env:
-          PGHOST: localhost
-        run: |
-          i=1
-          attempts=1
-          ${{ (github.ref == 'refs/heads/stable' || startsWith(github.ref, 'refs/tags/v')) }} && attempts=3
-          while [ "$i" -le "$attempts" ]; do
-            if ./simplexmq-test; then
-              break
-            else
-              echo "Attempt $i failed, retrying..."
-              i=$((i + 1))
-              sleep 1
-            fi
-          done
-          if [ "$i" -gt "$attempts" ]; then
-            echo "All "$attempts" attempts failed."
-            exit 1
-          fi

.github/workflows/docker-image.yml

@@ -14,22 +14,22 @@ jobs:
       matrix:
         include:
           - app: smp-server
-            app_port: "443 5223"
+            app_port: 5223
           - app: xftp-server
-            app_port: 443
+            app_port: 443 
     steps:
       - name: Clone project
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
 
       - name: Log in to Docker Hub
-        uses: simplex-chat/docker-login-action@v3
+        uses: docker/login-action@v2
         with:
           username: ${{ secrets.DOCKERHUB_USERNAME }}
           password: ${{ secrets.DOCKERHUB_PASSWORD }}
 
       - name: Extract metadata for Docker image
         id: meta
-        uses: simplex-chat/docker-metadata-action@v5
+        uses: docker/metadata-action@v4
         with:
           images: ${{ secrets.DOCKERHUB_USERNAME }}/${{ matrix.app }}
           flavor: |
@@ -39,17 +39,9 @@ jobs:
             type=semver,pattern=v{{major}}.{{minor}}
             type=semver,pattern=v{{major}}
 
-      - name: Set up QEMU
-        uses: docker/setup-qemu-action@v3
-
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v3
-
       - name: Build and push Docker image
-        uses: simplex-chat/docker-build-push-action@v6
+        uses: docker/build-push-action@v4
         with:
-          context: .
-          platforms: linux/amd64,linux/arm64
           push: true
           build-args: |
             APP=${{ matrix.app }}

.github/workflows/reproduce-schedule.yml

@@ -1,45 +0,0 @@
-name: Reproduce latest release
-
-on:
-  workflow_dispatch:
-  schedule:
-    - cron: '0 2 * * *' # every day at 02:00 night
-
-jobs:
-  reproduce:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v3
-
-      - name: Get latest release
-        shell: bash
-        run: |
-          curl --proto '=https' \
-               --tlsv1.2 \
-               -sSf -L \
-               'https://api.github.com/repos/simplex-chat/simplexmq/releases/latest' \
-               2>/dev/null | \
-          grep -i "tag_name" | \
-          awk -F \" '{print "TAG="$4}' >> $GITHUB_ENV
-
-      - name: Execute reproduce script
-        run: |
-          ${GITHUB_WORKSPACE}/scripts/simplexmq-reproduce-builds.sh "$TAG" || :
-
-      - name: Check if build has been reproduced
-        env:
-          url: ${{ secrets.STATUS_SIMPLEX_WEBHOOK_URL }}
-          user: ${{ secrets.STATUS_SIMPLEX_WEBHOOK_USER }}
-          pass: ${{ secrets.STATUS_SIMPLEX_WEBHOOK_PASS }}
-        run: |
-          if [ -f "${GITHUB_WORKSPACE}/${TAG}-simplexmq/_sha256sums" ]; then
-            exit 0
-          else
-            curl --proto '=https' --tlsv1.2 -sSf \
-              -u "${user}:${pass}" \
-              -H 'Content-Type: application/json' \
-              -d '{"title": "👾 GitHub: Runner", "description": "⛔️ '"$TAG"' did not reproduce."}' \
-              "$url"
-            exit 1
-          fi

.gitignore

@@ -11,4 +11,3 @@ cabal.project.local~
 .hpc/
 *.tix
 .coverage
-

2026-02-04-xftp-web-persistent-connections.md

@@ -1,53 +0,0 @@
-# XFTPClientAgent Pattern
-
-## TOC
-1. Executive Summary
-2. Changes: client.ts
-3. Changes: agent.ts
-4. Changes: test/browser.test.ts
-5. Verification
-
-## Executive Summary
-
-Add `XFTPClientAgent` — a per-server connection pool matching the Haskell pattern. The agent caches `XFTPClient` instances by server URL. All orchestration functions (`uploadFile`, `downloadFile`, `deleteFile`) take `agent` as first parameter and use `getXFTPServerClient(agent, server)` instead of calling `connectXFTP` directly. Connections stay open on success; the caller creates and closes the agent.
-
-`connectXFTP` and `closeXFTP` stay exported (used by `XFTPWebTests.hs` Haskell tests). The `browserClients` hack, per-function `connections: Map`, and `getOrConnect` are deleted.
-
-## Changes: client.ts
-
-**Add** after types section: `XFTPClientAgent` interface, `newXFTPAgent`, `getXFTPServerClient`, `closeXFTPServerClient`, `closeXFTPAgent`.
-
-**Delete**: `browserClients` Map and all `isNode` browser-cache checks in `connectXFTP` and `closeXFTP`.
-
-**Revert `closeXFTP`** to unconditional `c.transport.close()` (browser transport.close() is already a no-op).
-
-`connectXFTP` stays exported (backward compat) but becomes a raw low-level function — no caching.
-
-## Changes: agent.ts
-
-**Imports**: replace `connectXFTP`/`closeXFTP` with `getXFTPServerClient`/`closeXFTPAgent` etc.
-
-**Re-export** from agent.ts: `newXFTPAgent`, `closeXFTPAgent`, `XFTPClientAgent`.
-
-**`uploadFile`**: add `agent: XFTPClientAgent` as first param. Replace `connectXFTP` → `getXFTPServerClient`. Remove `finally { closeXFTP }`. Pass `agent` to `uploadRedirectDescription`.
-
-**`uploadRedirectDescription`**: change from `(client, server, innerFd)` to `(agent, server, innerFd)`. Get client via `getXFTPServerClient`.
-
-**`downloadFile`**: add `agent` param. Delete local `connections: Map`. Replace `getOrConnect` → `getXFTPServerClient`. Remove finally cleanup. Pass `agent` to `downloadWithRedirect`.
-
-**`downloadWithRedirect`**: add `agent` param. Same replacements. Remove try/catch cleanup. Recursive call passes `agent`.
-
-**`deleteFile`**: add `agent` param. Same pattern.
-
-**Delete**: `getOrConnect` function entirely.
-
-## Changes: test/browser.test.ts
-
-Create agent before operations, pass to upload/download, close in finally.
-
-## Verification
-
-1. `npx vitest --run` — browser round-trip test passes
-2. No remaining `browserClients`, `getOrConnect`, or per-function `connections: Map` locals
-3. `connectXFTP` and `closeXFTP` still exported (XFTPWebTests.hs compat)
-4. All orchestration functions take `agent` as first param

CHANGELOG.md

@@ -1,468 +1,3 @@
-# 6.4.4
-
-Servers:
-- fix server pages when source code is not specified.
-- include commit SHA in printed version and in web page (#1608).
-
-SMP server:
-- support short SimpleX addresses in server information page (#1600).
-- wrap all queries in transactions (#1603).
-
-SMP agent:
-- chat relay address type for short links (#1602).
-- extend xrcp certificate validity 1 hour in the past, to allow out of sync clocks (#1601).
-
-# 6.4.3
-
-SMP agent:
-- fix some connection errors by updating contact request server hosts to match server in short link (#1597).
-
-SMP server:
-- support short link URI as queue identifier in control port commands (#1596).
-
-# 6.4.2
-
-SMP server:
-- fix memory leak when connection interrupts straight after client connects.
-- do not include repeated queue blocking into stats/quota.
-
-XFTP server:
-- prometheus metrics
-
-# 6.4.1
-
-SMP protocol:
-- create notification credentials via NEW command that creates the queue (#1586)
-
-SMP server:
-- control port session improvements (#1591)
-- additional stat counter for ntf credentials created together with the queue (#1589)
-
-# 6.4.0
-
-SMP protocol (server/client):
-- support associated queue data and short connection links (see [RFC](./rfcs/2025-03-16-smp-queues.md)).
-- service certificates to optimize subscriptions.
-
-SMP agent:
-- support retries for interactive connection handshakes.
-- use web port 443 by default for preset servers.
-- use static RNG function to avoid creating dynamic C stubs when generating sntrup keys (it was detected as Dynamic Code Loading in GrapheneOS).
-- different timeouts for interactive and background operations.
-
-Ntf server:
-- PostgreSQL storage.
-- Prometheus metrics.
-- use service certificates.
-- fix repeat token registration.
-
-# 6.3.2
-
-Servers:
-- enable store log by default (#1501).
-
-SMP server:
-- reduce memory usage (#1498)
-
-SMP agent:
-- handle client/agent version downgrades after connection was established (#1508).
-
-# 6.3.1
-
-Servers:
-- handle ECONNABORTED error on client connections.
-- reproducible builds.
-- blocking records for content moderation.
-- update script (simplex-servers-update) downloads scripts from the specified or the latest stable tag.
-
-SMP server:
-- support for PostgreSQL database for queue records for higher traffic servers.
-- fix old clients sending messages to new servers (#1443)
-- remove empty journals when opening message queues and expiring idle queues (#1456, #1458).
-- additional start options (#1465):
-  - `maintenance` to run all start/stop operations without starting server.
-  - `skip-warnings` to ignore the last corrupted line in store log (can happen on abnormal termination).
-
-Ntf server:
-- record date of last token activity, to allow expiring inactive tokens.
-- additional token invalidation reasons in logs.
-
-SMP agent:
-- store message sent to multiple connections only once, to reduce storage when sending to groups (#1453).
-- encrypt messages on delivery, to reduce database writes (#1446).
-- don't block method calls on congested sockets for better concurrency (#1454).
-- check notification token status on client connection.
-- option to skip SQLite vacuum on migrations.
-
-# 6.3.0
-
-SMP agent: fix joining connection after failure by using the same ratchet.
-
-# 6.2.2
-
-SMP server:
-- add optional Prometheus metrics (#1411).
-
-Build:
-- remove three modules from client library.
-
-# 6.2.0
-
-Version 6.2.0.7
-
-Build:
-- client_library flag to build only used modules in the clients, remove package yaml
-
-SMP server:
-- journal storage for messages (BETA).
-- prevent race condition when deleting queue and to avoid "orphan" messages (#1395).
-
-SMP agent:
-- support SMP and XFTP server roles (storage/proxy) and operators (#1343).
-- treat blocked STM and other critical errors that offer restart as temporary for message delivery (#1405).
-- fix inconsistent state after app restart while accepting contact request (#1412).
-
-# 6.1.3
-
-SMP server: fix restoring notification credentials.
-
-# 6.1.2
-
-Servers: more reliable restoring of state.
-
-SMP server: reduced memory usage and faster start.
-
-Notifications: compensate for iOS notifications being dropped by Apple while device is offline (#1378):
-- Ntf server: send multiple SMP notifications in one iOS notification.
-- Agent: get multiple messages for one iOS notification.
-
-# 6.1.1
-
-SMP:
-- stop server faster (#1371)
-- add STORE error (#1372)
-
-# 6.1.0
-
-Version 6.1.0.7
-
-SMP server and client:
-- transport block encryption (#1317).
-
-Agent:
-- batch and optimize iOS notifications processing (#1308, #1311, #1313, #1316, #1330, #1331, #1333, #1337, #1346).
-- allow receiving multiple messages from single iOS notification (#1355, #1362).
-- prepare connection to accept to avoid race condition with events (#1365).
-- transport isolation mode "Session" (default) to use new SOCKS credentials when client restarts or SOCKS proxy configuration changes (#1321).
-
-Ntf server:
-- control port (#1354).
-- enable pings on ntf subscriptions, to resubscribe on reconnection (#1353).
-
-SMP server:
-- support multiple server ports (#1319).
-- support serving HTTPS and SMP transport on the same port (#1326, #1327).
-- persist iOS notifications to avoid losing them when Ntf server is offline (#1336, #1339, #1350).
-- fix lost notification subscriptions (#1347).
-- reject SKEY with different key earlier, at verification step (#1366).
-- pass server information via CLI during server initialization (#1356).
-- show version on server page (#1341).
-- explicit graceful shutdown on SIGINT (#1360).
-
-XRCP (remote access protocol):
-- use SHA3-256 in hybrid key agreement (#1302).
-- session encryption with forward secrecy (#1328).
-
-# 6.0.5
-
-SMP agent:
-- support generic SOCKS proxy (without isolate-by-auth).
-- reduce max message sizes
-
-# 6.0.4
-
-SMP server:
-- better performance/memory: fewer map updates on re-subscriptions (#1297), split and reduce STM transactions (#1294)
-- send DELD when subscribed queue is deleted (#1312)
-- add created/updated/used date to queues to manage expiration (#1306)
-
-XFTP server: truncate file creation time to 1 hour (#1310)
-
-Servers:
-- bind control port only to 127.0.0.1 for better security in case of firewall misconfiguration (#1280)
-- reduce memory used for period stats (#1298)
-
-Agent: process last notification from list (#1307)
-- report receive file error with redirected file ID, when redirect is present (#1304)
-- special error when deleted user record is not in database (#1303)
-- fix race when sending a message to the deleted connection (#1296)
-- support for multiple messages in a single notification
-
-Ntf server:
-- only use SOCKS proxy for servers without public address (#1314)
-
-# 6.0.3
-
-Agent:
-- fix possible stuck queue rotation (#1290).
-
-SMP server:
-- batch END responses when subscribed client switches to reduce server and client traffic.
-- reduce STM transactions for better performance.
-- add stats for END events and for SUB/DEL event batches.
-- remove "expensive" stats to save memory.
-
-# 6.0.2
-
-SMP agent:
-- fix stuck connection commands when a server is not responding.
-- store query errors, reduce slow query threshold to 1ms.
-
-Notification server:
-- reduce PING interval to 1 minute.
-- fix subscriptions disabled on race condition (only mark subscriptions with END status when received via the active connection).
-
-# 6.0.1
-
-SMP agent:
-- support changing user of the new connection.
-- do not start delivery workers when there are no messages to deliver.
-- enable notifications for all connections.
-- combine database transactions when subscribing.
-
-SMP server:
-- safe compacting of store log.
-- fix possible race when creating client that might lead to memory leak.
-
-Dependencies: upgrade tls to 1.9
-
-# 6.0.0
-
-Version 6.0.0.8
-
-Agent:
-- enabled fast handshake support.
-- batch-send multiple messages in each connection.
-- resume subscriptions as soon as agent moves to foreground or as network connection resumes.
-- "known" servers to determine whether to use SMP proxy.
-- retry on SMP proxy NO_SESSION error.
-- fixes to notification subscriptions.
-- persistent server statistics.
-- better concurrency.
-
-SMP server:
-- reduce threads usage.
-- additional statistics.
-- improve disabling inactive clients.
-- additional control port commands for monitoring.
-
-Notification server:
-- support onion-only SMP servers.
-
-# 5.8.2
-
-Agent:
-- fast handshake support (disabled).
-- new statistics api.
-
-SMP server:
-- fast handshake support (SKEY command).
-- minor changes to reduce memory usage.
-
-# 5.8.1
-
-Agent:
-- API to reconnect one server.
-- Better error handling of file errors and remote control connection errors.
-- Only start uploading file once all chunks were registered on the servers.
-
-SMP server:
-- additional stats for sent message notifications.
-- fix server page layout.
-
-# 5.8.0
-
-Version 5.8.0.10
-
-SMP server and client:
-- protocol extension to forward messages to the destination servers, to protect sending client IP address and transport session.
-
-Agent:
-- process timed out subscription responses to reduce the number of resubscriptions.
-- avoid sending messages and commands when waiting for response timed out (except batched SUB and DEL commands).
-- fix issue with stuck message reception on slow connection (when response to ACK timed out, and the new message was not processed until resubscribed).
-- fix issue when temporary file sending or receiving error was treated as permanent.
-
-SMP server:
-- include OK responses to all batched SUB requests to reduce subscription timeouts.
-
-XFTP server:
-- report file upload timeout as TIMEOUT, to avoid delivery failure.
-
-# 5.7.6
-
-XFTP agent:
-- treat XFTP handshake timeouts and network errors as temporary, to retry file operations.
-
-# 5.7.5
-
-SMP agent:
-- fail if non-unique connection IDs are passed to sendMessages (to prevent client errors and deadlocks).
-
-# 5.7.4
-
-SMP agent:
-- remove re-subscription timeouts (as they are tracked per operation, and could cause failed subscriptions).
-- reconnect XFTP clients when network settings changes.
-- fix lock contention resulting in stuck subscriptions on network change.
-
-# 5.7.3
-
-SMP/NTF protocol:
-- add ALPN for handshake version negotiation, similar to XFTP (to preserve backwards compatibility with the old clients).
-- upgrade clients to versions v7/v2 of the protocols.
-
-SMP server:
-- faster responses to subscription requests.
-
-XFTP client:
-- fix network exception during file download treated as permanent file error.
-
-SMP agent:
-- do not report subscription timeouts while client is offline.
-
-# 5.7.2
-
-SMP agent:
-- fix connections failing when connecting via link due to race condition on slow network.
-- remove concurrency limit when waiting for connection subscription.
-- remove TLS timeout.
-
-# 5.7.1
-
-SMP agent:
-- increase timeout for TLS connection via SOCKS
-
-# 5.7.0
-
-Version 5.7.0.4
-
-_Please note_: the earliest SimpleX Chat clients supported by this version of the servers is 5.5.3 (released on February 11, 2024).
-
-SMP server:
-- increase max SMP protocol version to 7 (support for deniable authenticators).
-
-NTF server:
-- increase max NTF protocol version to 2 (support for deniable authenticators).
-
-XFTP server:
-- version handshake using ALPN.
-
-SMP agent:
-- increase timeouts for XFTP files.
-- don't send commands after timeout.
-- PQ encryption support.
-
-# 5.6.2
-
-Version 5.6.2.2.
-
-SMP agent:
-- Lower memory consumption (~20-25%).
-- More stable XFTP file uploads and downloads.
-- API to receive network connectivity changes from the apps.
-- to reduce battery consumption: connection attempts interval growing to every 2 hours when app reports as offline.
-- to reduce retries and traffic: 50% increased timeouts when on mobile network.
-
-XFTP server:
-- expire files on start.
-- version negotiation based on TLS ALPN and handshake.
-
-NTF server:
-- reduced downtime by ~100x faster start time.
-- exclude test tokens from statistics.
-
-# 5.6.1
-
-Version 5.6.1.0.
-
-- Much faster iOS notification server start time (fewer skipped notifications).
-- Fix SMP server stored message stats.
-- Prevent overwriting uploaded XFTP files with subsequent upload attempts.
-- Faster base64 encoding/parsing.
-- Control port audit log and authentication.
-
-# 5.6.0
-
-Version 5.6.0.4.
-
-SMP protocol/client/server:
-- support deniable sender command authorization (to be enabled in the next version).
-- remove support for SMP protocol versions (prior to v4, 07/2022).
-
-Agent:
-- optional post-quantum key agreement using sntrup761 in double ratchet protocol.
-- improve performance of deleting multiple connections and files by batching database operations.
-- delay connection deletion to deliver pending messages.
-- API to test for notifications server.
-- remove support for client protocols versions (prior to 10/2022).
-
-XFTP server:
-- restore storage quota in case of failed uploads.
-
-Performance and stability improvements.
-
-# 5.5.3
-
-Agent:
-- notification token API also returns active notifications server.
-- support file descriptions with redirection and file URIs.
-
-Servers:
-- CLI commands for online key and certificate rotation.
-- Configure config and log paths via environment variables.
-
-# 5.5.2
-
-Extensible handshake for clients and SMP/NTF servers (ignore extra data).
-
-# 5.5.1
-
-SMP servers:
-- do not keep stats file open
-- additional stats about currently stored messages
-
-Agent:
-- support multiple notification servers (only one can be used at a time).
-- expire messages after "quota exceeded" error after 7 days (instead of 21 days previously).
-- stabilize message delivery, remove unnecessary subscription retries and traffic.
-- improve database performance for message delivery.
-- fix sockets/memory leak - a very old bug "activated" by improvements in v5.5.0.
-
-# 5.5.0
-
-Code:
-- compatible with GHC 8.10.7 to support compilation for armv7a.
-- migrate to `crypton` from deprecated `cryptonite` (the seed for DRG is now sha512-hashed).
-- use ChaChaDRG for all random IDs, keys and nonces, only using hashed entropy as seed.
-- more efficient transaction batching in SMP protocol client and server.
-
-Agent:
-- stabilize message reception and delivery, migrate message delivery to database queue.
-- additional event MSGNTF confirming that message received via notification is processed.
-- efficient processing of messages sent to multiple recipients with batched database transactions.
-- new worker abstraction for all queued tasks resilient to race conditions and some database errors.
-- many fixed race conditions.
-- background mode for iOS NSE.
-- additional error reporting to client on critical errors (to be show as alert in the clients).
-- functional api to get worker statistics.
-
-SMP/XFTP servers:
-- fix socket and memory leak on servers with high load (inactive clients without subscriptions are disconnected after set time of inactivity).
-- control port improvements.
-- fix statistics for stored queues, messages and files.
-- make writing to store log atomic (fixes a rare bug in XFTP server).
-
 # 5.4.0
 
 Migrate to GHC 9.6.3

Dockerfile

@@ -1,20 +1,15 @@
-# syntax=docker/dockerfile:1.7.0-labs
-ARG TAG=24.04
+ARG TAG=22.04
 
 FROM ubuntu:${TAG} AS build
 
 ### Build stage
 
 # Install curl and git and simplexmq dependencies
-RUN apt-get update && apt-get install -y curl git build-essential libgmp3-dev zlib1g-dev llvm-18 llvm-18-dev libnuma-dev libssl-dev
+RUN apt-get update && apt-get install -y curl git build-essential libgmp3-dev zlib1g-dev llvm-12 llvm-12-dev libnuma-dev libssl-dev
 
 # Specify bootstrap Haskell versions
 ENV BOOTSTRAP_HASKELL_GHC_VERSION=9.6.3
-ENV BOOTSTRAP_HASKELL_CABAL_VERSION=3.12.1.0
-
-# Do not install Stack
-ENV BOOTSTRAP_HASKELL_INSTALL_NO_STACK=true
-ENV BOOTSTRAP_HASKELL_INSTALL_NO_STACK_HOOK=true
+ENV BOOTSTRAP_HASKELL_CABAL_VERSION=3.10.1.0
 
 # Install ghcup
 RUN curl --proto '=https' --tlsv1.2 -sSf https://get-ghcup.haskell.org | BOOTSTRAP_HASKELL_NONINTERACTIVE=1 sh
@@ -26,42 +21,26 @@ ENV PATH="/root/.cabal/bin:/root/.ghcup/bin:$PATH"
 RUN ghcup set ghc "${BOOTSTRAP_HASKELL_GHC_VERSION}" && \
     ghcup set cabal "${BOOTSTRAP_HASKELL_CABAL_VERSION}"
 
-# Copy only the source code
-COPY apps /project/apps/
-COPY cbits /project/cbits/
-COPY src /project/src/
-
-COPY cabal.project Setup.hs simplexmq.cabal LICENSE /project
-
+COPY . /project
 WORKDIR /project
 
-# Debug
-#ARG CACHEBUST=1
-
-#ADD --chmod=755 https://github.com/MShekow/directory-checksum/releases/download/v1.4.6/directory-checksum_1.4.6_linux_amd64 /usr/local/bin/directory-checksum
-#RUN directory-checksum --max-depth 2 .
-
-# Set build arguments and check if they exist
 ARG APP
-RUN if [ -z "$APP" ]; then printf "Please spcify \$APP build-arg.\n"; exit 1; fi
+ARG APP_PORT
+RUN if [ -z "$APP" ] || [ -z "$APP_PORT" ]; then printf "Please spcify \$APP and \$APP_PORT build-arg.\n"; exit 1; fi
 
 # Compile app
 RUN cabal update
 RUN cabal build exe:$APP
 
-# Copy scripts
-COPY scripts /project/scripts/
-
 # Create new path containing all files needed
 RUN mkdir /final
 WORKDIR /final
 
 # Strip the binary from debug symbols to reduce size
-RUN bin="$(find /project/dist-newstyle -name "$APP" -type f -executable)" && \
+RUN bin=$(find /project/dist-newstyle -name "$APP" -type f -executable) && \
     mv "$bin" ./ && \
     strip ./"$APP" &&\
-    mv /project/scripts/docker/entrypoint-"$APP" ./entrypoint &&\
-    mv /project/scripts/main/simplex-servers-stopscript ./simplex-servers-stopscript
+    mv /project/scripts/docker/entrypoint-"$APP" ./entrypoint
 
 ### Final stage
 FROM ubuntu:${TAG}
@@ -74,8 +53,6 @@ COPY --from=build /final /usr/local/bin/
 
 # Open app listening port
 ARG APP_PORT
-RUN if [ -z "$APP_PORT" ]; then printf "Please spcify \$APP_PORT build-arg.\n"; exit 1; fi
-
 EXPOSE $APP_PORT
 
 # simplexmq requires using SIGINT to correctly preserve undelivered messages and restore them on restart

Dockerfile.build

@@ -1,31 +0,0 @@
-# syntax=docker/dockerfile:1.7.0-labs
-ARG TAG=24.04
-FROM ubuntu:${TAG} AS build
-
-### Build stage
-
-ARG GHC=9.6.3
-ARG CABAL=3.14.1.1
-
-# Install curl, git and and simplexmq dependencies
-RUN apt-get update && apt-get install -y curl libpq-dev git sqlite3 libsqlite3-dev build-essential libgmp3-dev zlib1g-dev llvm llvm-dev libnuma-dev libssl-dev
-
-# Specify bootstrap Haskell versions
-ENV BOOTSTRAP_HASKELL_GHC_VERSION=${GHC}
-ENV BOOTSTRAP_HASKELL_CABAL_VERSION=${CABAL}
-
-# Do not install Stack
-ENV BOOTSTRAP_HASKELL_INSTALL_NO_STACK=true
-ENV BOOTSTRAP_HASKELL_INSTALL_NO_STACK_HOOK=true
-
-# Install ghcup
-RUN curl --proto '=https' --tlsv1.2 -sSf https://get-ghcup.haskell.org | BOOTSTRAP_HASKELL_NONINTERACTIVE=1 sh
-
-# Adjust PATH
-ENV PATH="/root/.cabal/bin:/root/.ghcup/bin:$PATH"
-
-# Set both as default
-RUN ghcup set ghc "${GHC}" && \
-    ghcup set cabal "${CABAL}"
-
-WORKDIR /project

README.md

@@ -1,6 +1,6 @@
 # SimpleXMQ
 
-[![GitHub build](https://github.com/simplex-chat/simplexmq/actions/workflows/build.yml/badge.svg)](https://github.com/simplex-chat/simplexmq/actions/workflows/build.yml)
+[![GitHub build](https://github.com/simplex-chat/simplexmq/workflows/build/badge.svg)](https://github.com/simplex-chat/simplexmq/actions?query=workflow%3Abuild)
 [![GitHub release](https://img.shields.io/github/v/release/simplex-chat/simplexmq)](https://github.com/simplex-chat/simplexmq/releases)
 
 📢 SimpleXMQ v1 is released - with many security, privacy and efficiency improvements, new functionality - see [release notes](https://github.com/simplex-chat/simplexmq/releases/tag/v1.0.0).
@@ -116,7 +116,7 @@ On Linux, you can deploy smp and xftp server using Docker. This will download im
 2. Run your Docker container.
 
    - `smp-server`
-
+   
      You must change **your_ip_or_domain**. `-e "pass=password"` is optional variable to password-protect your `smp` server:
      ```sh
      docker run -d \
@@ -129,7 +129,7 @@ On Linux, you can deploy smp and xftp server using Docker. This will download im
      ```
 
    - `xftp-server`
-
+   
      You must change **your_ip_or_domain** and **maximum_storage**.
      ```sh
      docker run -d \
@@ -149,15 +149,8 @@ On Linux, you can deploy smp and xftp server using Docker. This will download im
 You can install and setup servers automatically using our script:
 
 ```sh
-curl --proto '=https' --tlsv1.2 -sSf https://raw.githubusercontent.com/simplex-chat/simplexmq/stable/install.sh -o simplex-server-install.sh &&\
-if echo '53fcdb4ceab324316e2c4cda7e84dbbb344f32550a65975a7895425e5a1be757 simplex-server-install.sh' | sha256sum -c; then
-  chmod +x ./simplex-server-install.sh
-  ./simplex-server-install.sh
-  rm ./simplex-server-install.sh
-else
-  echo "SHA-256 checksum is incorrect!"
-  rm ./simplex-server-install.sh
-fi
+curl --proto '=https' --tlsv1.2 -sSf https://raw.githubusercontent.com/simplex-chat/simplexmq/stable/install.sh -o simplex-server-install.sh \
+&& if echo 'b8cf2be103f21f9461d9a500bcd3db06ab7d01d68871b07f4bd245195cbead1d simplex-server-install.sh' | sha256sum -c; then chmod +x ./simplex-server-install.sh && ./simplex-server-install.sh; rm ./simplex-server-install.sh; else echo "SHA-256 checksum is incorrect!" && rm ./simplex-server-install.sh; fi
 ```
 
 ### Build from source
@@ -187,7 +180,7 @@ On Linux, you can build smp server using Docker.
 3. Run your Docker container.
 
    - `smp-server`
-
+   
      You must change **your_ip_or_domain**. `-e "pass=password"` is optional variable to password-protect your `smp` server:
      ```sh
      docker run -d \
@@ -200,7 +193,7 @@ On Linux, you can build smp server using Docker.
      ```
 
    - `xftp-server`
-
+   
      You must change **your_ip_or_domain** and **maximum_storage**.
      ```sh
      docker run -d \
@@ -215,17 +208,14 @@ On Linux, you can build smp server using Docker.
 
 #### Using your distribution
 
-1. Install dependencies and build tools (`GHC`, `cabal` and dev libs):
+1. Install [Haskell GHCup](https://www.haskell.org/ghcup/), GHC 8.10.7 and cabal:
 
    ```sh
-   # On Ubuntu. Depending on your distribution, use your package manager to determine package names.
-   sudo apt-get update && apt-get install -y build-essential curl libffi-dev libffi7 libgmp3-dev libgmp10 libncurses-dev libncurses5 libtinfo5 pkg-config zlib1g-dev libnuma-dev libssl-dev
-   export BOOTSTRAP_HASKELL_GHC_VERSION=9.6.3
-   export BOOTSTRAP_HASKELL_CABAL_VERSION=3.10.3.0
-   curl --proto '=https' --tlsv1.2 -sSf https://get-ghcup.haskell.org | BOOTSTRAP_HASKELL_NONINTERACTIVE=1 sh
-   ghcup set ghc "${BOOTSTRAP_HASKELL_GHC_VERSION}"
-   ghcup set cabal "${BOOTSTRAP_HASKELL_CABAL_VERSION}"
-   source ~/.ghcup/env
+   curl --proto '=https' --tlsv1.2 -sSf https://get-ghcup.haskell.org | sh
+   ghcup install ghc 8.10.7
+   ghcup install cabal
+   ghcup set ghc 8.10.7
+   ghcup set cabal
    ```
 
 2. Build the project:
@@ -234,20 +224,10 @@ On Linux, you can build smp server using Docker.
    git clone https://github.com/simplex-chat/simplexmq
    cd simplexmq
    git checkout stable
+   # On Ubuntu. Depending on your distribution, use your package manager to determine package names.
+   apt-get update && apt-get install -y build-essential libgmp3-dev zlib1g-dev
    cabal update
-   cabal build exe:smp-server exe:xftp-server
-   ```
-
-3. List compiled binaries:
-
-   `smp-server`
-   ```sh
-   cabal list-bin exe:smp-server
-   ```
-
-   `xftp-server`
-   ```sh
-   cabal list-bin exe:xftp-server
+   cabal install
    ```
 
 - Initialize SMP server with `smp-server init [-l] -n <fqdn>` or `smp-server init [-l] --ip <ip>` - depending on how you initialize it, either FQDN or IP will be used for server's address.

apps/common/Web/Embedded.hs

@@ -1,15 +0,0 @@
-{-# LANGUAGE TemplateHaskell #-}
-
-module Web.Embedded where
-
-import Data.FileEmbed (embedDir, embedFile)
-import Simplex.Messaging.Server.Web (EmbeddedContent (..))
-
-embeddedContent :: EmbeddedContent
-embeddedContent =
-  EmbeddedContent
-    { indexHtml = $(embedFile "apps/common/Web/static/index.html"),
-      linkHtml = $(embedFile "apps/common/Web/static/link.html"),
-      mediaContent = $(embedDir "apps/common/Web/static/media/"),
-      wellKnown = $(embedDir "apps/common/Web/static/.well-known/")
-    }

apps/common/Web/static/.well-known/apple-app-site-association

@@ -1,49 +0,0 @@
-{
-  "applinks": {
-    "details": [
-      {
-        "appIDs": [
-          "5NN7GUYB6T.chat.simplex.app"
-        ],
-        "components": [
-          {
-            "/": "/contact/*"
-          },
-          {
-            "/": "/contact"
-          },
-          {
-            "/": "/invitation/*"
-          },
-          {
-            "/": "/invitation"
-          },
-          {
-            "/": "/a/*"
-          },
-          {
-            "/": "/a"
-          },
-          {
-            "/": "/c/*"
-          },
-          {
-            "/": "/c"
-          },
-          {
-            "/": "/g/*"
-          },
-          {
-            "/": "/g"
-          },
-          {
-            "/": "/i/*"
-          },
-          {
-            "/": "/i"
-          }
-        ]
-      }
-    ]
-  }
-}

apps/common/Web/static/.well-known/assetlinks.json

@@ -1,16 +0,0 @@
-[
-    {
-        "relation": [
-            "delegate_permission/common.handle_all_urls"
-        ],
-        "target": {
-            "namespace": "android_app",
-            "package_name": "chat.simplex.app",
-            "sha256_cert_fingerprints": [
-                "5E:3E:DC:C2:00:FB:A8:D5:F4:88:F3:CA:4C:32:5B:05:78:C5:6A:9C:03:A1:CC:B5:92:9C:D7:5C:7E:57:E2:4D",
-                "3C:52:C4:FD:3C:AD:1C:07:C9:B0:0A:70:80:E3:58:FA:B9:FE:FC:B8:AF:5A:EC:14:77:65:F1:6D:0F:21:AD:85",
-                "AE:C1:95:DC:FD:46:14:BD:3A:91:EC:26:D1:D5:14:C8:75:71:C5:CC:8D:CF:48:08:3F:92:83:14:3C:A2:B9:A6"
-            ]
-        }
-    }
-]

apps/common/Web/static/media/apple_store.svg

@@ -1,26 +0,0 @@
-<svg width="119" height="40" viewBox="0 0 119 40" fill="none" xmlns="http://www.w3.org/2000/svg">
-<path d="M8.44484 39.125C8.14016 39.125 7.84284 39.1211 7.54055 39.1143C6.91433 39.1061 6.28957 39.0516 5.67141 38.9512C5.095 38.8519 4.53661 38.6673 4.01467 38.4033C3.49751 38.1415 3.02582 37.7983 2.61767 37.3867C2.20361 36.98 1.85888 36.5082 1.59716 35.9902C1.33255 35.4688 1.14942 34.9099 1.05416 34.333C0.951281 33.7131 0.895621 33.0863 0.887656 32.458C0.881316 32.2471 0.873016 31.5449 0.873016 31.5449V8.44434C0.873016 8.44434 0.881856 7.75293 0.887706 7.5498C0.895332 6.92248 0.950669 6.29665 1.05324 5.67773C1.14868 5.09925 1.33194 4.53875 1.5967 4.01563C1.85746 3.49794 2.20027 3.02586 2.61184 2.61768C3.02294 2.20562 3.49614 1.8606 4.01418 1.59521C4.53492 1.33209 5.09225 1.14873 5.6675 1.05127C6.28769 0.949836 6.91462 0.894996 7.54301 0.88721L8.44533 0.875H111.214L112.127 0.8877C112.75 0.895099 113.371 0.94945 113.985 1.05029C114.566 1.14898 115.13 1.33362 115.656 1.59814C116.694 2.13299 117.539 2.97916 118.071 4.01807C118.332 4.53758 118.512 5.09351 118.606 5.66699C118.71 6.29099 118.768 6.92174 118.78 7.5542C118.783 7.8374 118.783 8.1416 118.783 8.44434C118.791 8.81934 118.791 9.17627 118.791 9.53613V30.4648C118.791 30.8281 118.791 31.1826 118.783 31.54C118.783 31.8652 118.783 32.1631 118.779 32.4697C118.768 33.0909 118.71 33.7104 118.608 34.3232C118.515 34.9043 118.333 35.4675 118.068 35.9932C117.805 36.5056 117.462 36.9733 117.053 37.3789C116.644 37.7927 116.172 38.1379 115.653 38.4014C115.128 38.6674 114.566 38.8527 113.985 38.9512C113.367 39.0522 112.742 39.1067 112.116 39.1143C111.823 39.1211 111.517 39.125 111.219 39.125L110.135 39.127L8.44484 39.125Z" fill="black"/>
-<path d="M24.7689 20.3007C24.7796 19.466 25.0013 18.6477 25.4134 17.9217C25.8254 17.1957 26.4144 16.5858 27.1254 16.1486C26.6737 15.5035 26.0778 14.9725 25.3849 14.598C24.6921 14.2234 23.9215 14.0156 23.1343 13.991C21.455 13.8147 19.8271 14.9958 18.9714 14.9958C18.0991 14.9958 16.7816 14.0085 15.3629 14.0376C14.4452 14.0673 13.5509 14.3341 12.767 14.8122C11.9831 15.2903 11.3364 15.9632 10.89 16.7655C8.95597 20.1139 10.3986 25.035 12.2512 27.7416C13.1781 29.0669 14.2613 30.5474 15.6788 30.4949C17.0659 30.4374 17.5839 29.6104 19.2582 29.6104C20.917 29.6104 21.403 30.4949 22.8492 30.4615C24.3376 30.4374 25.2753 29.1303 26.1697 27.7924C26.8357 26.848 27.3481 25.8043 27.6881 24.6999C26.8234 24.3341 26.0855 23.722 25.5664 22.9397C25.0473 22.1574 24.7699 21.2396 24.7689 20.3007V20.3007Z" fill="white"/>
-<path d="M22.0373 12.2109C22.8488 11.2367 23.2486 9.98451 23.1518 8.72028C21.9119 8.8505 20.7667 9.44306 19.9442 10.3799C19.5421 10.8376 19.2341 11.37 19.0378 11.9468C18.8416 12.5235 18.7609 13.1333 18.8005 13.7413C19.4206 13.7477 20.0341 13.6132 20.5948 13.3482C21.1555 13.0831 21.6487 12.6942 22.0373 12.2109Z" fill="white"/>
-<path d="M42.3023 27.1396H37.5689L36.4322 30.4961H34.4273L38.9107 18.0781H40.9937L45.4771 30.4961H43.438L42.3023 27.1396ZM38.0591 25.5908H41.8111L39.9615 20.1435H39.9097L38.0591 25.5908Z" fill="white"/>
-<path d="M55.1597 25.9697C55.1597 28.7832 53.6538 30.5908 51.3814 30.5908C50.8057 30.6209 50.2332 30.4883 49.7294 30.2082C49.2256 29.928 48.8109 29.5117 48.5327 29.0068H48.4897V33.4912H46.6313V21.4424H48.4302V22.9482H48.4644C48.7553 22.4458 49.1771 22.0316 49.6847 21.7497C50.1923 21.4679 50.7669 21.3289 51.3472 21.3476C53.645 21.3477 55.1597 23.1641 55.1597 25.9697ZM53.2495 25.9697C53.2495 24.1367 52.3023 22.9316 50.857 22.9316C49.437 22.9316 48.482 24.1621 48.482 25.9697C48.482 27.7939 49.437 29.0156 50.857 29.0156C52.3023 29.0156 53.2495 27.8193 53.2495 25.9697Z" fill="white"/>
-<path d="M65.1245 25.9697C65.1245 28.7832 63.6187 30.5908 61.3462 30.5908C60.7706 30.6209 60.1981 30.4883 59.6943 30.2082C59.1905 29.928 58.7758 29.5117 58.4976 29.0068H58.4546V33.4912H56.5962V21.4424H58.395V22.9482H58.4292C58.7201 22.4458 59.1419 22.0316 59.6495 21.7497C60.1571 21.4679 60.7317 21.3289 61.312 21.3476C63.6099 21.3476 65.1245 23.164 65.1245 25.9697ZM63.2144 25.9697C63.2144 24.1367 62.2671 22.9316 60.8218 22.9316C59.4019 22.9316 58.4468 24.1621 58.4468 25.9697C58.4468 27.7939 59.4019 29.0156 60.8218 29.0156C62.2671 29.0156 63.2144 27.8193 63.2144 25.9697H63.2144Z" fill="white"/>
-<path d="M71.7105 27.0361C71.8482 28.2676 73.0445 29.0761 74.6792 29.0761C76.2456 29.0761 77.3726 28.2675 77.3726 27.1572C77.3726 26.1933 76.6929 25.6162 75.0835 25.2207L73.4742 24.833C71.1939 24.2822 70.1353 23.2158 70.1353 21.4853C70.1353 19.3427 72.0025 17.871 74.6538 17.871C77.2778 17.871 79.0767 19.3427 79.1372 21.4853H77.2612C77.1489 20.246 76.1245 19.498 74.6274 19.498C73.1304 19.498 72.106 20.2548 72.106 21.3564C72.106 22.2343 72.7603 22.7509 74.3608 23.1464L75.729 23.4823C78.2769 24.0849 79.3355 25.1083 79.3355 26.9247C79.3355 29.248 77.4849 30.703 74.5415 30.703C71.7876 30.703 69.9282 29.2821 69.8081 27.036L71.7105 27.0361Z" fill="white"/>
-<path d="M83.3462 19.2998V21.4424H85.0679V22.9141H83.3462V27.9053C83.3462 28.6807 83.6909 29.042 84.4478 29.042C84.6522 29.0384 84.8562 29.0241 85.0591 28.999V30.4619C84.7188 30.5255 84.373 30.5543 84.0269 30.5478C82.1939 30.5478 81.479 29.8593 81.479 28.1035V22.9141H80.1626V21.4424H81.479V19.2998H83.3462Z" fill="white"/>
-<path d="M86.065 25.9697C86.065 23.1211 87.7427 21.3311 90.3589 21.3311C92.9839 21.3311 94.6539 23.1211 94.6539 25.9697C94.6539 28.8262 92.9927 30.6084 90.3589 30.6084C87.7261 30.6084 86.065 28.8262 86.065 25.9697ZM92.7603 25.9697C92.7603 24.0156 91.8648 22.8623 90.3589 22.8623C88.8531 22.8623 87.9585 24.0244 87.9585 25.9697C87.9585 27.9316 88.8531 29.0762 90.3589 29.0762C91.8648 29.0762 92.7603 27.9316 92.7603 25.9697H92.7603Z" fill="white"/>
-<path d="M96.1861 21.4424H97.9585V22.9834H98.0015C98.1215 22.5021 98.4034 22.0768 98.8 21.7789C99.1966 21.481 99.6836 21.3287 100.179 21.3476C100.393 21.3469 100.607 21.3702 100.816 21.417V23.1553C100.546 23.0726 100.264 23.0347 99.981 23.043C99.711 23.032 99.4419 23.0796 99.192 23.1825C98.9422 23.2854 98.7176 23.4411 98.5336 23.639C98.3496 23.8369 98.2106 24.0723 98.1262 24.3289C98.0418 24.5856 98.0139 24.8575 98.0445 25.126V30.4961H96.1861L96.1861 21.4424Z" fill="white"/>
-<path d="M109.384 27.8369C109.134 29.4805 107.534 30.6084 105.486 30.6084C102.852 30.6084 101.217 28.8437 101.217 26.0127C101.217 23.1729 102.861 21.3311 105.408 21.3311C107.913 21.3311 109.488 23.0518 109.488 25.7969V26.4336H103.093V26.5459C103.064 26.8791 103.105 27.2148 103.216 27.5306C103.326 27.8464 103.502 28.1352 103.732 28.3778C103.963 28.6203 104.242 28.8111 104.552 28.9374C104.861 29.0637 105.195 29.1226 105.529 29.1103C105.968 29.1515 106.409 29.0498 106.785 28.8203C107.162 28.5909 107.455 28.246 107.62 27.8369L109.384 27.8369ZM103.102 25.1348H107.628C107.645 24.8352 107.6 24.5354 107.495 24.2541C107.39 23.9729 107.229 23.7164 107.02 23.5006C106.812 23.2849 106.561 23.1145 106.283 23.0003C106.006 22.8861 105.708 22.8305 105.408 22.8369C105.105 22.8351 104.805 22.8933 104.525 23.008C104.245 23.1227 103.99 23.2918 103.776 23.5054C103.562 23.7191 103.392 23.973 103.276 24.2527C103.16 24.5323 103.101 24.8321 103.102 25.1348V25.1348Z" fill="white"/>
-<path d="M37.8262 8.73101C38.2158 8.70305 38.6068 8.76191 38.9709 8.90335C39.335 9.04478 39.6632 9.26526 39.9318 9.54889C40.2004 9.83251 40.4026 10.1722 40.524 10.5435C40.6455 10.9148 40.6829 11.3083 40.6338 11.6959C40.6338 13.6021 39.6035 14.6979 37.8262 14.6979H35.6709V8.73101H37.8262ZM36.5977 13.854H37.7227C38.0011 13.8707 38.2797 13.825 38.5382 13.7204C38.7968 13.6158 39.0287 13.4548 39.2172 13.2493C39.4057 13.0437 39.546 12.7987 39.6279 12.5321C39.7097 12.2655 39.7311 11.9839 39.6904 11.708C39.7282 11.4332 39.7046 11.1534 39.6215 10.8887C39.5384 10.6241 39.3977 10.3811 39.2097 10.1771C39.0216 9.97322 38.7908 9.81341 38.5337 9.70917C38.2766 9.60494 37.9997 9.55885 37.7227 9.57422H36.5977V13.854Z" fill="white"/>
-<path d="M41.6807 12.4443C41.6524 12.1484 41.6862 11.8499 41.7801 11.5678C41.8739 11.2857 42.0257 11.0264 42.2256 10.8064C42.4255 10.5864 42.6693 10.4107 42.9411 10.2904C43.213 10.1701 43.507 10.108 43.8042 10.108C44.1015 10.108 44.3955 10.1701 44.6673 10.2904C44.9392 10.4107 45.1829 10.5864 45.3828 10.8064C45.5828 11.0264 45.7345 11.2857 45.8284 11.5678C45.9222 11.8499 45.9561 12.1484 45.9278 12.4443C45.9566 12.7406 45.9232 13.0396 45.8296 13.3221C45.736 13.6046 45.5843 13.8644 45.3843 14.0848C45.1843 14.3052 44.9404 14.4814 44.6683 14.6019C44.3962 14.7225 44.1018 14.7847 43.8042 14.7847C43.5066 14.7847 43.2123 14.7225 42.9401 14.6019C42.668 14.4814 42.4241 14.3052 42.2241 14.0848C42.0241 13.8644 41.8725 13.6046 41.7789 13.3221C41.6853 13.0396 41.6518 12.7406 41.6807 12.4443V12.4443ZM45.0137 12.4443C45.0137 11.4683 44.5752 10.8975 43.8057 10.8975C43.0332 10.8975 42.5987 11.4683 42.5987 12.4444C42.5987 13.4282 43.0333 13.9946 43.8057 13.9946C44.5752 13.9946 45.0137 13.4243 45.0137 12.4443H45.0137Z" fill="white"/>
-<path d="M51.5733 14.6978H50.6514L49.7207 11.3813H49.6504L48.7237 14.6978H47.8106L46.5694 10.1948H47.4707L48.2774 13.6308H48.3438L49.2696 10.1948H50.1221L51.0479 13.6308H51.1182L51.9209 10.1948H52.8096L51.5733 14.6978Z" fill="white"/>
-<path d="M53.8536 10.1948H54.709V10.9102H54.7754C54.8881 10.6532 55.0781 10.4379 55.319 10.2941C55.5598 10.1503 55.8396 10.0852 56.1192 10.1079C56.3383 10.0914 56.5583 10.1245 56.7629 10.2046C56.9675 10.2847 57.1514 10.4098 57.3011 10.5706C57.4508 10.7315 57.5624 10.9239 57.6276 11.1337C57.6928 11.3436 57.7099 11.5654 57.6778 11.7827V14.6977H56.7891V12.0059C56.7891 11.2822 56.4746 10.9224 55.8174 10.9224C55.6687 10.9154 55.5202 10.9408 55.3821 10.9966C55.244 11.0524 55.1197 11.1375 55.0176 11.2458C54.9154 11.3542 54.838 11.4834 54.7904 11.6245C54.7429 11.7657 54.7265 11.9154 54.7422 12.0635V14.6978H53.8535L53.8536 10.1948Z" fill="white"/>
-<path d="M59.0938 8.43701H59.9825V14.6978H59.0938V8.43701Z" fill="white"/>
-<path d="M61.2178 12.4443C61.1895 12.1484 61.2234 11.8498 61.3172 11.5677C61.4111 11.2857 61.5629 11.0263 61.7629 10.8063C61.9628 10.5863 62.2065 10.4106 62.4784 10.2903C62.7503 10.17 63.0443 10.1079 63.3416 10.1079C63.6389 10.1079 63.9329 10.17 64.2047 10.2903C64.4766 10.4106 64.7203 10.5863 64.9203 10.8063C65.1203 11.0263 65.272 11.2857 65.3659 11.5677C65.4598 11.8498 65.4936 12.1484 65.4654 12.4443C65.4942 12.7406 65.4607 13.0396 65.3671 13.3221C65.2734 13.6046 65.1218 13.8644 64.9217 14.0848C64.7217 14.3052 64.4778 14.4814 64.2057 14.6019C63.9335 14.7224 63.6392 14.7847 63.3416 14.7847C63.044 14.7847 62.7496 14.7224 62.4775 14.6019C62.2053 14.4814 61.9614 14.3052 61.7614 14.0848C61.5614 13.8644 61.4097 13.6046 61.3161 13.3221C61.2225 13.0396 61.189 12.7406 61.2178 12.4443V12.4443ZM64.5508 12.4443C64.5508 11.4683 64.1123 10.8975 63.3428 10.8975C62.5703 10.8975 62.1358 11.4683 62.1358 12.4444C62.1358 13.4282 62.5704 13.9946 63.3428 13.9946C64.1123 13.9946 64.5508 13.4243 64.5508 12.4443H64.5508Z" fill="white"/>
-<path d="M66.4009 13.4243C66.4009 12.6138 67.0044 12.1465 68.0757 12.0801L69.2954 12.0098V11.6211C69.2954 11.1455 68.981 10.877 68.3736 10.877C67.8775 10.877 67.5337 11.0591 67.4351 11.3775H66.5747C66.6656 10.604 67.3931 10.1079 68.4146 10.1079C69.5435 10.1079 70.1802 10.6699 70.1802 11.6211V14.6978H69.3247V14.065H69.2544C69.1117 14.292 68.9113 14.477 68.6737 14.6012C68.4361 14.7254 68.1697 14.7844 67.9019 14.772C67.7129 14.7916 67.5218 14.7715 67.341 14.7128C67.1603 14.6541 66.9938 14.5581 66.8524 14.4312C66.711 14.3042 66.5977 14.149 66.52 13.9756C66.4422 13.8022 66.4017 13.6144 66.4009 13.4243V13.4243ZM69.2954 13.0396V12.6631L68.1958 12.7334C67.5757 12.7749 67.2945 12.9859 67.2945 13.3828C67.2945 13.7881 67.646 14.0239 68.1295 14.0239C68.2711 14.0383 68.4142 14.024 68.5502 13.9819C68.6862 13.9398 68.8123 13.8708 68.9211 13.7789C69.0299 13.6871 69.1191 13.5743 69.1834 13.4473C69.2477 13.3203 69.2858 13.1816 69.2954 13.0396V13.0396Z" fill="white"/>
-<path d="M71.3482 12.4444C71.3482 11.0215 72.0796 10.1201 73.2173 10.1201C73.4987 10.1072 73.778 10.1746 74.0226 10.3145C74.2671 10.4544 74.4667 10.661 74.5982 10.9101H74.6646V8.43701H75.5533V14.6978H74.7017V13.9863H74.6314C74.4898 14.2338 74.2832 14.4378 74.0339 14.5763C73.7847 14.7148 73.5023 14.7825 73.2173 14.772C72.0718 14.772 71.3482 13.8706 71.3482 12.4444ZM72.2662 12.4444C72.2662 13.3994 72.7164 13.9741 73.4693 13.9741C74.2183 13.9741 74.6812 13.3911 74.6812 12.4483C74.6812 11.5098 74.2134 10.9185 73.4693 10.9185C72.7212 10.9185 72.2661 11.4971 72.2661 12.4444H72.2662Z" fill="white"/>
-<path d="M79.23 12.4443C79.2017 12.1484 79.2356 11.8499 79.3294 11.5678C79.4232 11.2857 79.575 11.0264 79.7749 10.8064C79.9749 10.5864 80.2186 10.4107 80.4904 10.2904C80.7623 10.1701 81.0563 10.108 81.3536 10.108C81.6508 10.108 81.9448 10.1701 82.2167 10.2904C82.4885 10.4107 82.7322 10.5864 82.9322 10.8064C83.1321 11.0264 83.2839 11.2857 83.3777 11.5678C83.4715 11.8499 83.5054 12.1484 83.4771 12.4443C83.5059 12.7406 83.4725 13.0396 83.3789 13.3221C83.2853 13.6046 83.1336 13.8644 82.9336 14.0848C82.7336 14.3052 82.4897 14.4814 82.2176 14.6019C81.9455 14.7225 81.6512 14.7847 81.3536 14.7847C81.0559 14.7847 80.7616 14.7225 80.4895 14.6019C80.2173 14.4814 79.9735 14.3052 79.7735 14.0848C79.5735 13.8644 79.4218 13.6046 79.3282 13.3221C79.2346 13.0396 79.2012 12.7406 79.23 12.4443V12.4443ZM82.563 12.4443C82.563 11.4683 82.1245 10.8975 81.355 10.8975C80.5826 10.8975 80.148 11.4683 80.148 12.4444C80.148 13.4282 80.5826 13.9946 81.355 13.9946C82.1245 13.9946 82.563 13.4243 82.563 12.4443Z" fill="white"/>
-<path d="M84.6695 10.1948H85.5249V10.9102H85.5913C85.704 10.6532 85.894 10.4379 86.1349 10.2941C86.3757 10.1503 86.6555 10.0852 86.9351 10.1079C87.1542 10.0914 87.3742 10.1245 87.5788 10.2046C87.7834 10.2847 87.9673 10.4098 88.117 10.5706C88.2667 10.7315 88.3783 10.9239 88.4435 11.1337C88.5087 11.3436 88.5258 11.5654 88.4937 11.7827V14.6977H87.605V12.0059C87.605 11.2822 87.2906 10.9224 86.6333 10.9224C86.4846 10.9154 86.3361 10.9408 86.198 10.9966C86.06 11.0524 85.9356 11.1375 85.8335 11.2458C85.7314 11.3542 85.6539 11.4834 85.6064 11.6245C85.5588 11.7657 85.5424 11.9154 85.5581 12.0635V14.6978H84.6695V10.1948Z" fill="white"/>
-<path d="M93.5152 9.07373V10.2153H94.4908V10.9639H93.5152V13.2793C93.5152 13.751 93.7095 13.9575 94.1519 13.9575C94.2651 13.9572 94.3783 13.9503 94.4908 13.937V14.6772C94.3312 14.7058 94.1695 14.721 94.0074 14.7226C93.0191 14.7226 92.6255 14.375 92.6255 13.5068V10.9638H91.9107V10.2153H92.6255V9.07373H93.5152Z" fill="white"/>
-<path d="M95.7046 8.43701H96.5855V10.9185H96.6558C96.7739 10.6591 96.9691 10.4425 97.2148 10.2982C97.4605 10.1539 97.7448 10.0888 98.0288 10.1118C98.2467 10.1 98.4646 10.1364 98.6669 10.2184C98.8692 10.3004 99.0509 10.4261 99.199 10.5864C99.3471 10.7468 99.458 10.9378 99.5238 11.146C99.5896 11.3541 99.6086 11.5742 99.5796 11.7905V14.6978H98.69V12.0098C98.69 11.2905 98.355 10.9263 97.7271 10.9263C97.5744 10.9137 97.4207 10.9347 97.277 10.9878C97.1332 11.0408 97.0027 11.1247 96.8948 11.2334C96.7868 11.3421 96.7038 11.4732 96.6518 11.6173C96.5997 11.7614 96.5798 11.9152 96.5933 12.0679V14.6977H95.7047L95.7046 8.43701Z" fill="white"/>
-<path d="M104.761 13.4819C104.641 13.8935 104.379 14.2495 104.022 14.4876C103.666 14.7258 103.236 14.8309 102.81 14.7847C102.513 14.7925 102.219 14.7357 101.946 14.6182C101.674 14.5006 101.43 14.3252 101.232 14.1041C101.034 13.8829 100.887 13.6214 100.8 13.3376C100.713 13.0537 100.689 12.7544 100.73 12.4605C100.691 12.1656 100.715 11.8656 100.801 11.581C100.888 11.2963 101.034 11.0335 101.231 10.8105C101.428 10.5874 101.671 10.4092 101.942 10.288C102.214 10.1668 102.509 10.1054 102.806 10.1079C104.059 10.1079 104.815 10.9639 104.815 12.3779V12.688H101.635V12.7378C101.621 12.9031 101.642 13.0694 101.696 13.2261C101.75 13.3829 101.837 13.5266 101.95 13.6481C102.062 13.7695 102.2 13.866 102.352 13.9314C102.504 13.9968 102.669 14.0297 102.835 14.0278C103.047 14.0533 103.262 14.0151 103.453 13.9178C103.644 13.8206 103.802 13.6689 103.906 13.4819L104.761 13.4819ZM101.635 12.0308H103.91C103.921 11.8796 103.9 11.7278 103.849 11.5851C103.798 11.4424 103.718 11.3119 103.614 11.2021C103.509 11.0922 103.383 11.0054 103.243 10.9472C103.103 10.8891 102.953 10.8608 102.801 10.8643C102.648 10.8623 102.495 10.8912 102.353 10.9491C102.21 11.0071 102.081 11.0929 101.972 11.2017C101.864 11.3104 101.778 11.4397 101.72 11.5821C101.662 11.7245 101.633 11.8771 101.635 12.0308H101.635Z" fill="white"/>
-</svg>

apps/common/Web/static/media/contact.js

@@ -1,77 +0,0 @@
-(function () {
-
-  let complete = false
-  run()
-  window.onload = run
-
-  async function run() {
-    const connURIel = document.getElementById("conn_req_uri_text");
-    const mobileConnURIanchor = document.getElementById("mobile_conn_req_uri");
-    const connQRCodes = document.getElementsByClassName("conn_req_uri_qrcode");
-    console.log(connQRCodes);
-    if (complete || !connURIel || !mobileConnURIanchor || connQRCodes < 2) return
-    complete = true
-    let connURI = document.location.toString()
-    const parsedURI = new URL(connURI)
-    const path = parsedURI.pathname.split("/")
-    const len = path.length
-    const action = path[len - (path[len - 1] == "" ? 2 : 1)]
-    parsedURI.protocol = "https"
-    parsedURI.pathname = "/" + action
-    connURI = parsedURI.toString()
-    console.log("connection URI: ", connURI)
-    const hash = parsedURI.hash
-    const hostname = parsedURI.hostname
-    let appURI = "simplex:" + parsedURI.pathname
-    appURI += action.length > 1 // not short link
-              ? hash
-              : !hash.includes("?") // otherwise add server hostname
-              ? hash + "?h=" + hostname // no parameters
-              : !hash.includes("?h=") && !hash.includes("&h=")
-              ? hash + "&h=" + hostname // no "h" parameter
-              : hash.replace(/([?&])h=([^&]+)/, `$1h=${hostname},$2`) // add as the first hostname to "h" parameter
-    mobileConnURIanchor.href = appURI
-    console.log("app URI: ", appURI)
-    connURIel.innerText = "/c " + connURI
-    for (const connQRCode of connQRCodes) {
-      try {
-        await QRCode.toCanvas(connQRCode, connURI, {
-          errorCorrectionLevel: "M",
-          color: {dark: "#062D56"}
-        });
-        connQRCode.style.width = "320px";
-        connQRCode.style.height = "320px";
-      } catch (err) {
-        console.error(err);
-      }
-    }
-
-    function contentCopyWithTooltip(parent) {
-      const content = parent.querySelector(".content");
-      const tooltip = parent.querySelector(".tooltiptext");
-      console.log(parent.querySelector(".content_copy"), 111)
-      console.log(parent)
-      const copyButton = parent.querySelector(".content_copy");
-      copyButton.addEventListener("click", copyAddress)
-      copyButton.addEventListener("mouseout", resetTooltip)
-
-      function copyAddress() {
-        navigator.clipboard.writeText(content.innerText || content.value);
-        tooltip.innerHTML = "Copied!";
-      }
-
-      function resetTooltip() {
-        tooltip.innerHTML = "Copy to clipboard";
-      }
-    }
-
-    function copyAddress() {
-      navigator.clipboard.writeText(connURI);
-      tooltipEl.innerHTML = "Copied!";
-    }
-
-    function resetTooltip() {
-      tooltipEl.innerHTML = "Copy to clipboard";
-    }
-  }
-})();

apps/common/Web/static/media/f_droid.svg

@@ -1,372 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="no"?>
-<svg
-   width="560"
-   height="164"
-   version="1.1"
-   id="svg1048"
-   sodipodi:docname="f_droid.svg"
-   inkscape:version="1.1.2 (0a00cf5339, 2022-02-04, custom)"
-   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
-   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
-   xmlns:xlink="http://www.w3.org/1999/xlink"
-   xmlns="http://www.w3.org/2000/svg"
-   xmlns:svg="http://www.w3.org/2000/svg">
-  <sodipodi:namedview
-     id="namedview1050"
-     pagecolor="#505050"
-     bordercolor="#ffffff"
-     borderopacity="1"
-     inkscape:pageshadow="0"
-     inkscape:pageopacity="0"
-     inkscape:pagecheckerboard="1"
-     showgrid="false"
-     inkscape:snap-bbox="true"
-     inkscape:bbox-paths="true"
-     inkscape:bbox-nodes="true"
-     inkscape:snap-bbox-edge-midpoints="true"
-     inkscape:snap-bbox-midpoints="true"
-     inkscape:snap-intersection-paths="true"
-     inkscape:object-paths="true"
-     inkscape:snap-smooth-nodes="true"
-     inkscape:snap-midpoints="true"
-     inkscape:snap-object-midpoints="true"
-     inkscape:snap-center="true"
-     inkscape:snap-text-baseline="true"
-     inkscape:snap-page="true"
-     fit-margin-top="0"
-     fit-margin-left="0"
-     fit-margin-right="0"
-     fit-margin-bottom="0"
-     inkscape:zoom="1.1996734"
-     inkscape:cx="186.71748"
-     inkscape:cy="100.02722"
-     inkscape:window-width="1920"
-     inkscape:window-height="1007"
-     inkscape:window-x="0"
-     inkscape:window-y="0"
-     inkscape:window-maximized="1"
-     inkscape:current-layer="svg1048" />
-  <defs
-     id="defs974">
-    <linearGradient
-       id="a">
-      <stop
-         offset="0"
-         stop-color="#fff"
-         stop-opacity=".098"
-         id="stop968" />
-      <stop
-         offset="1"
-         stop-color="#fff"
-         stop-opacity="0"
-         id="stop970" />
-    </linearGradient>
-    <radialGradient
-       xlink:href="#a"
-       id="b"
-       cx="113"
-       cy="-12.89"
-       fx="113"
-       fy="-12.89"
-       r="59.661999"
-       gradientTransform="matrix(0,1.96105,-1.97781,0,254.507,78.763)"
-       gradientUnits="userSpaceOnUse" />
-  </defs>
-  <g
-     transform="translate(-332,-355.362)"
-     id="g1046">
-    <rect
-       style="stroke:none;marker:none"
-       width="560"
-       height="164"
-       x="332"
-       y="355.362"
-       rx="20"
-       ry="20"
-       color="#000000"
-       overflow="visible"
-       stroke="#a6a6a6"
-       stroke-width="4"
-       id="rect976" />
-    <text
-       y="402.367"
-       x="508.95099"
-       style="line-height:100%;-inkscape-font-specification:'DejaVu Sans';marker:none"
-       color="#000000"
-       font-weight="400"
-       font-size="12.395px"
-       font-family="'DejaVu Sans'"
-       letter-spacing="0"
-       word-spacing="0"
-       overflow="visible"
-       fill="#ffffff"
-       id="text980"><tspan
-         y="402.367"
-         x="508.95099"
-         style="-inkscape-font-specification:'DejaVu Sans'"
-         font-size="34.125px"
-         id="tspan978">GET IT ON</tspan></text>
-    <text
-       style="line-height:100%;-inkscape-font-specification:'Rokkitt Bold';text-align:start;marker:none"
-       x="508.21301"
-       y="489.36099"
-       color="#000000"
-       font-weight="700"
-       font-size="29.709px"
-       font-family="Rokkitt"
-       letter-spacing="0"
-       word-spacing="0"
-       overflow="visible"
-       fill="#ffffff"
-       id="text984"><tspan
-         x="508.21301"
-         y="489.36099"
-         style="line-height:100%;-inkscape-font-specification:'Roboto Slab Bold';text-align:start"
-         font-size="95px"
-         font-family="'Roboto Slab'"
-         id="tspan982">F-Droid</tspan></text>
-    <g
-       fill-rule="evenodd"
-       id="g994">
-      <path
-         d="m 2.589,1006.862 4.25,5.5"
-         fill="#8ab000"
-         stroke="#769616"
-         stroke-width="2.5"
-         stroke-linecap="round"
-         transform="matrix(-2.63159,0,0,2.63157,483.158,-2270.475)"
-         id="path986" />
-      <path
-         style="line-height:normal;text-indent:0;text-align:start;text-decoration-line:none;text-decoration-style:solid;text-decoration-color:#000000;text-transform:none;isolation:auto;mix-blend-mode:normal"
-         d="m 476.286,375.862 c 1.193,0.031 2.004,0.497 2.58,1.18 -5.333,6.34 -6.232,7.347 -13.514,16.372 -2.683,3.472 -5.478,1.678 -2.795,-1.793 l 11.185,-14.474 c 0.602,-0.804 1.54,-1.258 2.544,-1.285 z"
-         color="#000000"
-         font-weight="400"
-         font-family="sans-serif"
-         white-space="normal"
-         overflow="visible"
-         fill="#ffffff"
-         fill-opacity="0.298"
-         id="path988" />
-      <path
-         style="line-height:normal;text-indent:0;text-align:start;text-decoration-line:none;text-decoration-style:solid;text-decoration-color:#000000;text-transform:none;isolation:auto;mix-blend-mode:normal"
-         d="m 478.89,377.075 c 0.325,0.39 1.476,2.118 0.058,4.096 l -11.184,14.473 c -2.683,3.471 -3.026,-1.611 -3.026,-1.611 0,0 9.828,-11.869 14.151,-16.958 z"
-         color="#000000"
-         font-weight="400"
-         font-family="sans-serif"
-         white-space="normal"
-         overflow="visible"
-         fill="#263238"
-         fill-opacity="0.2"
-         id="path990" />
-      <path
-         style="line-height:normal;text-indent:0;text-align:start;text-decoration-line:none;text-decoration-style:solid;text-decoration-color:#000000;text-transform:none;isolation:auto;mix-blend-mode:normal"
-         d="m 477.006,376.48 c 1.153,0 2.525,0.373 2.169,2.102 -0.273,1.32 -12.266,15.985 -12.266,15.985 -2.683,3.47 -6.562,1.78 -3.879,-1.691 l 11.143,-14.402 c 0.685,-0.763 1.602,-1.957 2.833,-1.994 z"
-         color="#000000"
-         font-weight="400"
-         font-family="sans-serif"
-         white-space="normal"
-         overflow="visible"
-         fill="#8ab000"
-         id="path992" />
-    </g>
-    <g
-       fill-rule="evenodd"
-       id="g1004">
-      <path
-         d="m 2.589,1006.862 4.25,5.5"
-         fill="#8ab000"
-         stroke="#769616"
-         stroke-width="2.5"
-         stroke-linecap="round"
-         transform="matrix(2.63159,0,0,2.63157,356.842,-2270.475)"
-         id="path996" />
-      <path
-         d="m 363.714,375.862 c -1.193,0.031 -2.004,0.497 -2.58,1.18 5.333,6.34 6.232,7.347 13.514,16.372 2.683,3.472 5.478,1.678 2.795,-1.793 l -11.185,-14.474 c -0.602,-0.804 -1.54,-1.258 -2.544,-1.285 z"
-         style="line-height:normal;text-indent:0;text-align:start;text-decoration-line:none;text-decoration-style:solid;text-decoration-color:#000000;text-transform:none;isolation:auto;mix-blend-mode:normal"
-         color="#000000"
-         font-weight="400"
-         font-family="sans-serif"
-         white-space="normal"
-         overflow="visible"
-         fill="#ffffff"
-         fill-opacity="0.298"
-         id="path998" />
-      <path
-         d="m 361.11,377.075 c -0.325,0.39 -1.476,2.118 -0.058,4.096 l 11.184,14.473 c 2.683,3.471 3.026,-1.611 3.026,-1.611 0,0 -9.828,-11.869 -14.151,-16.958 z"
-         style="line-height:normal;text-indent:0;text-align:start;text-decoration-line:none;text-decoration-style:solid;text-decoration-color:#000000;text-transform:none;isolation:auto;mix-blend-mode:normal"
-         color="#000000"
-         font-weight="400"
-         font-family="sans-serif"
-         white-space="normal"
-         overflow="visible"
-         fill="#263238"
-         fill-opacity="0.2"
-         id="path1000" />
-      <path
-         d="m 362.995,376.48 c -1.153,0 -2.526,0.373 -2.17,2.102 0.273,1.32 12.266,15.985 12.266,15.985 2.683,3.47 6.562,1.78 3.879,-1.691 l -11.143,-14.402 c -0.685,-0.763 -1.602,-1.957 -2.832,-1.994 z"
-         style="line-height:normal;text-indent:0;text-align:start;text-decoration-line:none;text-decoration-style:solid;text-decoration-color:#000000;text-transform:none;isolation:auto;mix-blend-mode:normal"
-         color="#000000"
-         font-weight="400"
-         font-family="sans-serif"
-         white-space="normal"
-         overflow="visible"
-         fill="#8ab000"
-         id="path1002" />
-    </g>
-    <g
-       transform="matrix(2.63159,0,0,2.63157,467.369,-2270.475)"
-       id="g1014">
-      <rect
-         ry="3"
-         rx="3"
-         y="1010.36"
-         x="-37"
-         height="12.92"
-         width="38"
-         fill="#aeea00"
-         id="rect1006" />
-      <rect
-         width="38"
-         height="10"
-         x="-37"
-         y="1013.279"
-         rx="3"
-         ry="3"
-         fill="#263238"
-         fill-opacity="0.2"
-         id="rect1008" />
-      <rect
-         width="38"
-         height="10"
-         x="-37"
-         y="1010.362"
-         rx="3"
-         ry="3"
-         fill="#ffffff"
-         fill-opacity="0.298"
-         id="rect1010" />
-      <rect
-         width="38"
-         height="10.641"
-         x="-37"
-         y="1011.5"
-         rx="3"
-         ry="2.4560001"
-         fill="#aeea00"
-         id="rect1012" />
-    </g>
-    <g
-       transform="matrix(2.63159,0,0,2.63157,356.842,-2270.745)"
-       id="g1024">
-      <rect
-         ry="3"
-         rx="3"
-         y="1024.522"
-         x="5"
-         height="25.84"
-         width="38"
-         fill="#1976d2"
-         id="rect1016" />
-      <rect
-         width="38"
-         height="13"
-         x="5"
-         y="1037.3621"
-         rx="3"
-         ry="3"
-         fill="#263238"
-         fill-opacity="0.2"
-         id="rect1018" />
-      <rect
-         width="38"
-         height="13"
-         x="5"
-         y="1024.442"
-         rx="3"
-         ry="3"
-         fill="#ffffff"
-         fill-opacity="0.2"
-         id="rect1020" />
-      <rect
-         width="38"
-         height="23.559999"
-         x="5"
-         y="1025.662"
-         rx="3"
-         ry="2.7179999"
-         fill="#1976d2"
-         id="rect1022" />
-    </g>
-    <g
-       transform="matrix(2.63159,0,0,2.63157,356.842,396.264)"
-       id="g1030">
-      <path
-         d="m 24,17.75 c -2.88,0 -5.32,1.985 -6.033,4.65 H 21.18 A 3.215,3.215 0 0 1 24,20.75 3.228,3.228 0 0 1 27.25,24 3.228,3.228 0 0 1 24,27.25 3.219,3.219 0 0 1 21.07,25.4 h -3.154 c 0.642,2.766 3.132,4.85 6.084,4.85 3.434,0 6.25,-2.816 6.25,-6.25 0,-3.434 -2.816,-6.25 -6.25,-6.25 z"
-         style="line-height:normal;text-indent:0;text-align:start;text-decoration-line:none;text-decoration-style:solid;text-decoration-color:#000000;text-transform:none;isolation:auto;mix-blend-mode:normal"
-         color="#000000"
-         font-weight="400"
-         font-family="sans-serif"
-         white-space="normal"
-         overflow="visible"
-         fill="#0d47a1"
-         id="path1026" />
-      <circle
-         r="9.5500002"
-         cy="24"
-         cx="24"
-         fill="none"
-         stroke="#0d47a1"
-         stroke-width="1.9"
-         stroke-linecap="round"
-         id="circle1028" />
-    </g>
-    <g
-       transform="matrix(2.63159,0,0,2.63157,356.842,-2269.159)"
-       id="g1036">
-      <ellipse
-         ry="3.875"
-         rx="3.375"
-         cx="14.375"
-         cy="1016.487"
-         fill="#263238"
-         fill-opacity="0.2"
-         id="ellipse1032" />
-      <circle
-         r="3.375"
-         cy="1016.987"
-         cx="14.375"
-         fill="#ffffff"
-         id="circle1034" />
-    </g>
-    <g
-       transform="matrix(2.63159,0,0,2.63157,408.158,-2269.159)"
-       id="g1042">
-      <ellipse
-         cy="1016.487"
-         cx="14.375"
-         rx="3.375"
-         ry="3.875"
-         fill="#263238"
-         fill-opacity="0.2"
-         id="ellipse1038" />
-      <circle
-         cx="14.375"
-         cy="1016.987"
-         r="3.375"
-         fill="#ffffff"
-         id="circle1040" />
-    </g>
-    <path
-       d="m 282.715,299.835 a 3.29,3.29 0 0 0 -2.662,5.336 l 9.474,12.261 A 7.894,7.894 0 0 0 289,320.257 v 18.21 a 7.877,7.877 0 0 0 7.895,7.895 h 84.21 A 7.877,7.877 0 0 0 389,338.468 v -18.211 c 0,-0.999 -0.19,-1.949 -0.525,-2.826 l 9.472,-12.26 a 3.29,3.29 0 0 0 -2.433,-5.334 3.29,3.29 0 0 0 -2.772,1.31 l -9.013,11.666 a 7.91,7.91 0 0 0 -2.624,-0.45 h -84.21 c -0.922,0 -1.8,0.163 -2.622,0.45 l -9.015,-11.666 a 3.29,3.29 0 0 0 -2.543,-1.312 z m 14.18,49.527 A 7.877,7.877 0 0 0 289,357.257 v 52.21 a 7.877,7.877 0 0 0 7.895,7.895 h 84.21 A 7.877,7.877 0 0 0 389,409.468 v -52.211 a 7.877,7.877 0 0 0 -7.895,-7.895 z"
-       style="line-height:normal;text-indent:0;text-align:start;text-decoration-line:none;text-decoration-style:solid;text-decoration-color:#000000;text-transform:none;isolation:auto;mix-blend-mode:normal;fill:url(#b)"
-       color="#000000"
-       font-weight="400"
-       font-family="sans-serif"
-       white-space="normal"
-       overflow="visible"
-       fill="url(#b)"
-       fill-rule="evenodd"
-       transform="translate(81,76)"
-       id="path1044" />
-  </g>
-</svg>

apps/common/Web/static/media/google_play.svg

@@ -1,39 +0,0 @@
-<svg width="135" height="41" viewBox="0 0 135 41" fill="none" xmlns="http://www.w3.org/2000/svg">
-<path d="M130 40.5H5C2.2 40.5 0 38.3 0 35.5V5.5C0 2.7 2.2 0.5 5 0.5H130C132.8 0.5 135 2.7 135 5.5V35.5C135 38.3 132.8 40.5 130 40.5Z" fill="black"/>
-<path d="M47.4 10.7C47.4 11.5 47.2 12.2 46.7 12.7C46.1 13.3 45.4 13.6 44.5 13.6C43.6 13.6 42.9 13.3 42.3 12.7C41.7 12.1 41.4 11.4 41.4 10.5C41.4 9.60002 41.7 8.90002 42.3 8.30002C42.9 7.70002 43.6 7.40002 44.5 7.40002C44.9 7.40002 45.3 7.50002 45.7 7.70002C46.1 7.90002 46.4 8.10002 46.6 8.40002L46.1 8.90002C45.7 8.40002 45.2 8.20002 44.5 8.20002C43.9 8.20002 43.3 8.40002 42.9 8.90002C42.4 9.30002 42.2 9.90002 42.2 10.6C42.2 11.3 42.4 11.9 42.9 12.3C43.4 12.7 43.9 13 44.5 13C45.2 13 45.7 12.8 46.2 12.3C46.5 12 46.7 11.6 46.7 11.1H44.5V10.3H47.4V10.7V10.7ZM52 8.20002H49.3V10.1H51.8V10.8H49.3V12.7H52V13.5H48.5V7.50002H52V8.20002ZM55.3 13.5H54.5V8.20002H52.8V7.50002H57V8.20002H55.3V13.5ZM59.9 13.5V7.50002H60.7V13.5H59.9ZM64.1 13.5H63.3V8.20002H61.6V7.50002H65.7V8.20002H64V13.5H64.1ZM73.6 12.7C73 13.3 72.3 13.6 71.4 13.6C70.5 13.6 69.8 13.3 69.2 12.7C68.6 12.1 68.3 11.4 68.3 10.5C68.3 9.60002 68.6 8.90002 69.2 8.30002C69.8 7.70002 70.5 7.40002 71.4 7.40002C72.3 7.40002 73 7.70002 73.6 8.30002C74.2 8.90002 74.5 9.60002 74.5 10.5C74.5 11.4 74.2 12.1 73.6 12.7ZM69.8 12.2C70.2 12.6 70.8 12.9 71.4 12.9C72 12.9 72.6 12.7 73 12.2C73.4 11.8 73.7 11.2 73.7 10.5C73.7 9.80002 73.5 9.20002 73 8.80002C72.6 8.40002 72 8.10002 71.4 8.10002C70.8 8.10002 70.2 8.30002 69.8 8.80002C69.4 9.20002 69.1 9.80002 69.1 10.5C69.1 11.2 69.3 11.8 69.8 12.2ZM75.6 13.5V7.50002H76.5L79.4 12.2V7.50002H80.2V13.5H79.4L76.3 8.60002V13.5H75.6V13.5Z" fill="white" stroke="white" stroke-width="0.2" stroke-miterlimit="10"/>
-<path d="M68.1 22.3C65.7 22.3 63.8 24.1 63.8 26.6C63.8 29 65.7 30.9 68.1 30.9C70.5 30.9 72.4 29.1 72.4 26.6C72.4 24 70.5 22.3 68.1 22.3ZM68.1 29.1C66.8 29.1 65.7 28 65.7 26.5C65.7 25 66.8 23.9 68.1 23.9C69.4 23.9 70.5 24.9 70.5 26.5C70.5 28 69.4 29.1 68.1 29.1ZM58.8 22.3C56.4 22.3 54.5 24.1 54.5 26.6C54.5 29 56.4 30.9 58.8 30.9C61.2 30.9 63.1 29.1 63.1 26.6C63.1 24 61.2 22.3 58.8 22.3ZM58.8 29.1C57.5 29.1 56.4 28 56.4 26.5C56.4 25 57.5 23.9 58.8 23.9C60.1 23.9 61.2 24.9 61.2 26.5C61.2 28 60.1 29.1 58.8 29.1ZM47.7 23.6V25.4H52C51.9 26.4 51.5 27.2 51 27.7C50.4 28.3 49.4 29 47.7 29C45 29 43 26.9 43 24.2C43 21.5 45.1 19.4 47.7 19.4C49.1 19.4 50.2 20 51 20.7L52.3 19.4C51.2 18.4 49.8 17.6 47.8 17.6C44.2 17.6 41.1 20.6 41.1 24.2C41.1 27.8 44.2 30.8 47.8 30.8C49.8 30.8 51.2 30.2 52.4 28.9C53.6 27.7 54 26 54 24.7C54 24.3 54 23.9 53.9 23.6H47.7V23.6ZM93.1 25C92.7 24 91.7 22.3 89.5 22.3C87.3 22.3 85.5 24 85.5 26.6C85.5 29 87.3 30.9 89.7 30.9C91.6 30.9 92.8 29.7 93.2 29L91.8 28C91.3 28.7 90.7 29.2 89.7 29.2C88.7 29.2 88.1 28.8 87.6 27.9L93.3 25.5L93.1 25V25ZM87.3 26.4C87.3 24.8 88.6 23.9 89.5 23.9C90.2 23.9 90.9 24.3 91.1 24.8L87.3 26.4ZM82.6 30.5H84.5V18H82.6V30.5ZM79.6 23.2C79.1 22.7 78.3 22.2 77.3 22.2C75.2 22.2 73.2 24.1 73.2 26.5C73.2 28.9 75.1 30.7 77.3 30.7C78.3 30.7 79.1 30.2 79.5 29.7H79.6V30.3C79.6 31.9 78.7 32.8 77.3 32.8C76.2 32.8 75.4 32 75.2 31.3L73.6 32C74.1 33.1 75.3 34.5 77.4 34.5C79.6 34.5 81.4 33.2 81.4 30.1V22.5H79.6V23.2V23.2ZM77.4 29.1C76.1 29.1 75 28 75 26.5C75 25 76.1 23.9 77.4 23.9C78.7 23.9 79.7 25 79.7 26.5C79.7 28 78.7 29.1 77.4 29.1ZM101.8 18H97.3V30.5H99.2V25.8H101.8C103.9 25.8 105.9 24.3 105.9 21.9C105.9 19.5 103.9 18 101.8 18V18ZM101.9 24H99.2V19.7H101.9C103.3 19.7 104.1 20.9 104.1 21.8C104 22.9 103.2 24 101.9 24ZM113.4 22.2C112 22.2 110.6 22.8 110.1 24.1L111.8 24.8C112.2 24.1 112.8 23.9 113.5 23.9C114.5 23.9 115.4 24.5 115.5 25.5V25.6C115.2 25.4 114.4 25.1 113.6 25.1C111.8 25.1 110 26.1 110 27.9C110 29.6 111.5 30.7 113.1 30.7C114.4 30.7 115 30.1 115.5 29.5H115.6V30.5H117.4V25.7C117.2 23.5 115.5 22.2 113.4 22.2V22.2ZM113.2 29.1C112.6 29.1 111.7 28.8 111.7 28C111.7 27 112.8 26.7 113.7 26.7C114.5 26.7 114.9 26.9 115.4 27.1C115.2 28.3 114.2 29.1 113.2 29.1V29.1ZM123.7 22.5L121.6 27.9H121.5L119.3 22.5H117.3L120.6 30.1L118.7 34.3H120.6L125.7 22.5H123.7V22.5ZM106.9 30.5H108.8V18H106.9V30.5Z" fill="white"/>
-<path d="M10.4 8C10.1 8.3 10 8.8 10 9.4V31.5C10 32.1 10.2 32.6 10.5 32.9L10.6 33L23 20.6V20.4L10.4 8Z" fill="url(#paint0_linear_7_408)"/>
-<path d="M27 24.8L22.9 20.7V20.4L27 16.3L27.1 16.4L32 19.2C33.4 20 33.4 21.3 32 22.1L27 24.8V24.8Z" fill="url(#paint1_linear_7_408)"/>
-<path d="M27.1 24.7L22.9 20.5L10.4 33C10.9 33.5 11.6 33.5 12.5 33.1L27.1 24.7" fill="url(#paint2_linear_7_408)"/>
-<path d="M27.1 16.3001L12.5 8.00005C11.6 7.50005 10.9 7.60005 10.4 8.10005L22.9 20.5001L27.1 16.3001V16.3001Z" fill="url(#paint3_linear_7_408)"/>
-<path opacity="0.2" d="M27 24.6L12.5 32.8C11.7 33.3 11 33.2 10.5 32.8L10.4 32.9L10.5 33C11 33.4 11.7 33.5 12.5 33L27 24.6Z" fill="black"/>
-<path opacity="0.12" d="M10.4 32.8C10.1 32.5 10 32 10 31.4V31.5C10 32.1 10.2 32.6 10.5 32.9V32.8H10.4ZM32 21.8L27 24.6L27.1 24.7L32 21.9C32.7 21.5 33 21 33 20.5C33 21 32.6 21.4 32 21.8V21.8Z" fill="black"/>
-<path opacity="0.25" d="M12.5 8.10003L32 19.2C32.6 19.6 33 20 33 20.5C33 20 32.7 19.5 32 19.1L12.5 8.00003C11.1 7.20003 10 7.80003 10 9.40003V9.50003C10 8.00003 11.1 7.30003 12.5 8.10003Z" fill="white"/>
-<defs>
-<linearGradient id="paint0_linear_7_408" x1="21.8" y1="9.21" x2="5.017" y2="25.992" gradientUnits="userSpaceOnUse">
-<stop stop-color="#00A0FF"/>
-<stop offset="0.007" stop-color="#00A1FF"/>
-<stop offset="0.26" stop-color="#00BEFF"/>
-<stop offset="0.512" stop-color="#00D2FF"/>
-<stop offset="0.76" stop-color="#00DFFF"/>
-<stop offset="1" stop-color="#00E3FF"/>
-</linearGradient>
-<linearGradient id="paint1_linear_7_408" x1="33.834" y1="20.501" x2="9.63699" y2="20.501" gradientUnits="userSpaceOnUse">
-<stop stop-color="#FFE000"/>
-<stop offset="0.409" stop-color="#FFBD00"/>
-<stop offset="0.775" stop-color="#FFA500"/>
-<stop offset="1" stop-color="#FF9C00"/>
-</linearGradient>
-<linearGradient id="paint2_linear_7_408" x1="24.827" y1="22.796" x2="2.069" y2="45.554" gradientUnits="userSpaceOnUse">
-<stop stop-color="#FF3A44"/>
-<stop offset="1" stop-color="#C31162"/>
-</linearGradient>
-<linearGradient id="paint3_linear_7_408" x1="7.29699" y1="0.676051" x2="17.46" y2="10.8391" gradientUnits="userSpaceOnUse">
-<stop stop-color="#32A071"/>
-<stop offset="0.069" stop-color="#2DA771"/>
-<stop offset="0.476" stop-color="#15CF74"/>
-<stop offset="0.801" stop-color="#06E775"/>
-<stop offset="1" stop-color="#00F076"/>
-</linearGradient>
-</defs>
-</svg>

apps/common/Web/static/media/logo-symbol-dark.svg

@@ -1,10 +0,0 @@
-<svg width="34" height="35" viewBox="0 0 34 35" fill="none" xmlns="http://www.w3.org/2000/svg">
-<path fill-rule="evenodd" clip-rule="evenodd" d="M3.02958 8.60922L8.622 14.2013L14.3705 8.45375L17.1669 11.2498L11.4183 16.9972L17.0114 22.5895L14.1373 25.4633L8.54422 19.871L2.79636 25.6187L0 22.8227L5.74794 17.075L0.155484 11.483L3.02958 8.60922Z" fill="white"/>
-<path fill-rule="evenodd" clip-rule="evenodd" d="M14.0923 25.5156L16.944 22.6642L16.9429 22.6634L22.6467 16.9612L17.0513 11.3675L17.0523 11.367L14.2548 8.56979L8.65972 2.97535L11.5114 0.123963L17.1061 5.71849L22.8099 0.015625L25.6074 2.81285L19.9035 8.51562L25.4984 14.1099L31.2025 8.40729L34 11.2045L28.2958 16.907L33.8917 22.5017L31.0399 25.3531L25.4442 19.7584L19.7409 25.4611L25.3365 31.0559L22.4848 33.9073L16.8892 28.3124L11.1864 34.0156L8.38885 31.2184L14.0923 25.5156Z" fill="url(#paint0_linear_656_10815)"/>
-<defs>
-<linearGradient id="paint0_linear_656_10815" x1="12.8381" y1="-0.678252" x2="9.54355" y2="31.4493" gradientUnits="userSpaceOnUse">
-<stop stop-color="#01F1FF"/>
-<stop offset="1" stop-color="#0197FF"/>
-</linearGradient>
-</defs>
-</svg>

apps/common/Web/static/media/logo-symbol-light.svg

@@ -1,15 +0,0 @@
-<svg width="34" height="34" viewBox="0 0 34 34" fill="none" xmlns="http://www.w3.org/2000/svg">
-<g clip-path="url(#clip0_14_10)">
-<path fill-rule="evenodd" clip-rule="evenodd" d="M3.02972 8.59396L8.62219 14.186L14.3703 8.43848L17.1668 11.2346L11.4182 16.982L17.0112 22.5742L14.1371 25.448L8.5441 19.8557L2.79651 25.6035L0 22.8074L5.74813 17.0597L0.155656 11.4678L3.02972 8.59396Z" fill="#023789"/>
-<path fill-rule="evenodd" clip-rule="evenodd" d="M14.0922 25.5L16.9434 22.6486L16.9423 22.6478L22.6464 16.9456L17.0512 11.3519L17.0518 11.3514L14.2542 8.55418L8.65961 2.95973L11.5114 0.108337L17.106 5.70288L22.8095 0L25.607 2.79722L19.903 8.5L25.4981 14.0943L31.2022 8.39169L33.9997 11.1889L28.2957 16.8914L33.8914 22.4861L31.0396 25.3375L25.4439 19.7428L19.7404 25.4454L25.3361 31.0403L22.4843 33.8917L16.8887 28.2968L11.1862 34L8.38867 31.2028L14.0922 25.5Z" fill="url(#paint0_linear_14_10)"/>
-</g>
-<defs>
-<linearGradient id="paint0_linear_14_10" x1="12.8379" y1="-0.693875" x2="9.54344" y2="31.4337" gradientUnits="userSpaceOnUse">
-<stop stop-color="#01F1FF"/>
-<stop offset="1" stop-color="#0197FF"/>
-</linearGradient>
-<clipPath id="clip0_14_10">
-<rect width="34" height="34" fill="white"/>
-</clipPath>
-</defs>
-</svg>

apps/common/Web/static/media/moon.svg

@@ -1,3 +0,0 @@
-<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
-<path d="M2.92814 12.6789C6.17655 15.9347 11.7044 15.6463 14.5425 12.0117C14.6636 11.8566 14.6825 11.6448 14.5907 11.4708C14.4989 11.2967 14.3136 11.1926 14.1172 11.2049C11.5269 11.3673 8.97627 10.4315 7.0743 8.52765C5.17264 6.62414 4.23958 4.06868 4.40169 1.47281C4.41397 1.2762 4.30965 1.09069 4.13526 0.999048C3.96088 0.907402 3.74893 0.926696 3.59396 1.04833C3.36099 1.23117 3.13828 1.42685 2.92823 1.63726C-0.111372 4.68223 -0.111585 9.63533 2.92814 12.6789Z" stroke="black" stroke-miterlimit="10" stroke-linejoin="round"/>
-</svg>

apps/common/Web/static/media/script.js

@@ -1,39 +0,0 @@
-const isMobile = {
-    Android: () => navigator.userAgent.match(/Android/i),
-    iOS: () => navigator.userAgent.match(/iPhone|iPad|iPod/i)
-};
-
-window.addEventListener('click', clickHandler)
-
-if (isMobile.iOS) {
-    for (const btn of document.getElementsByClassName("close-overlay-btn")) {
-        btn.addEventListener("touchend", (e) => setTimeout(() => closeOverlay(e), 100))
-    }
-}
-
-function clickHandler(e) {
-    if (e.target.closest('.contact-tab-btn')) {
-        e.target.closest('.contact-tab').classList.toggle('active')
-    }
-}
-
-window.addEventListener('load', () => {
-    const googlePlayBtn = document.querySelector('.google-play-btn');
-    const appleStoreBtn = document.querySelector('.apple-store-btn');
-    const fDroidBtn = document.querySelector('.f-droid-btn');
-    if (!googlePlayBtn || !appleStoreBtn || !fDroidBtn) return;
-
-
-    if (isMobile.Android()) {
-        googlePlayBtn.classList.remove('hidden');
-        fDroidBtn.classList.remove('hidden');
-    }
-    else if (isMobile.iOS()) {
-        appleStoreBtn.classList.remove('hidden');
-    }
-    else {
-        appleStoreBtn.classList.remove('hidden');
-        googlePlayBtn.classList.remove('hidden');
-        fDroidBtn.classList.remove('hidden');
-    }
-})

apps/common/Web/static/media/style.css

@@ -1,414 +0,0 @@
-@font-face {
-  font-family: Gilroy;
-  src: url("GilroyRegular.woff2") format("woff2");
-  font-weight: 400;
-  font-style: normal;
-}
-
-@font-face {
-  font-family: Gilroy;
-  src: url("GilroyLight.woff2") format("woff2");
-  font-weight: 300;
-  font-style: normal;
-}
-
-@font-face {
-  font-family: Gilroy;
-  src: url("GilroyMedium.woff2") format("woff2");
-  font-weight: 500;
-  font-style: normal;
-}
-
-@font-face {
-  font-family: Gilroy;
-  src: url("GilroyBold.woff2") format("woff2");
-  font-weight: 700;
-  font-style: normal;
-}
-
-@font-face {
-  font-family: Gilroy;
-  src: url("GilroyRegularItalic.woff2") format("woff2");
-  font-weight: 400;
-  font-style: italic;
-}
-
-html {
-  scroll-behavior: smooth;
-  font-family: Gilroy, Helvetica, sans-serif;
-  ;
-  letter-spacing: 0.003em;
-}
-
-img {
-  user-select: none;
-  -webkit-user-select: none;
-  /* For Safari and older Chrome versions */
-  -moz-user-select: none;
-  /* For Firefox */
-  -ms-user-select: none;
-  /* For Internet Explorer and Edge */
-}
-
-a{
-  word-wrap: break-word;
-}
-
-/* NEW SITE */
-.container,
-.container-fluid,
-.container-xxl,
-.container-xl,
-.container-lg,
-.container-md,
-.container-sm {
-  width: 100%;
-  /* padding: 0 20px; */
-  margin-right: auto;
-  margin-left: auto;
-}
-
-@media (min-width: 576px) {
-
-  .container-sm,
-  .container {
-    max-width: 540px;
-  }
-}
-
-@media (min-width: 768px) {
-
-  .container-md,
-  .container-sm,
-  .container {
-    max-width: 720px;
-  }
-}
-
-@media (min-width: 992px) {
-
-  .container-lg,
-  .container-md,
-  .container-sm,
-  .container {
-    max-width: 960px;
-  }
-}
-
-@media (min-width: 1200px) {
-
-  .container-xl,
-  .container-lg,
-  .container-md,
-  .container-sm,
-  .container {
-    max-width: 1140px;
-  }
-}
-
-@media (min-width: 1400px) {
-
-  .container-xxl,
-  .container-xl,
-  .container-lg,
-  .container-md,
-  .container-sm,
-  .container {
-    max-width: 1320px;
-  }
-}
-
-.gradient-text {
-  background: -webkit-linear-gradient(to bottom, #53C1FF -50%, #0053D0 160%);
-  background: linear-gradient(to bottom, #53C1FF -50%, #0053D0 160%);
-  -webkit-background-clip: text;
-  -webkit-text-fill-color: transparent;
-  background-clip: text;
-  text-fill-color: transparent;
-}
-
-.dark .border-gradient {
-  background:
-    linear-gradient(#11182F, #11182F) padding-box,
-    linear-gradient(to bottom, transparent, #01F1FF 58%) border-box;
-  border: 1px solid transparent;
-}
-
-.dark .only-light {
-  display: none;
-}
-
-.only-dark {
-  display: none;
-}
-
-.dark .only-dark {
-  display: inherit;
-}
-
-.menu-link {
-  font-size: 16px;
-  line-height: 33.42px;
-  color: #0D0E12;
-}
-
-.dark .menu-link {
-  color: #fff;
-}
-
-.nav-link ul li a.active {
-  color: #0053D0;
-
-}
-
-.dark .nav-link ul li a.active {
-  color: #66D9E2;
-}
-
-@media (min-width:1024px) {
-
-  .nav-link-text,
-  .menu-link {
-    display: inline-block;
-    position: relative;
-    color: #0D0E12;
-  }
-
-  .nav-link-text::before,
-  .active .nav-link-text::before,
-  .menu-link::before {
-    content: "";
-    position: absolute;
-    width: 0;
-    height: 1px;
-    bottom: 0;
-    right: 0;
-    /* background-color: initial; */
-    transition: width 0.25s ease-out;
-  }
-
-  .menu-link::before {
-    background-color: #0D0E12;
-  }
-
-  .dark .menu-link::before {
-    background-color: #fff;
-  }
-
-  .active .nav-link-text::before {
-    width: 100%;
-  }
-
-  .nav-link:hover .nav-link-text::before,
-  .menu-link:hover::before {
-    width: 100%;
-    left: 0;
-    right: auto;
-  }
-}
-
-
-.sub-menu {
-  visibility: hidden;
-  opacity: 0;
-  color: #505158;
-}
-
-.sub-menu .no-hover {
-  color: #505158 !important;
-}
-
-.dark .sub-menu,
-.dark .sub-menu .no-hover {
-  color: #fff !important;
-}
-
-.dark .sub-menu li:hover {
-  color: #66D9E2;
-}
-
-.sub-menu li:hover {
-  color: #0053D0;
-}
-
-.sub-menu {
-  transition: all .3s ease !important;
-}
-
-.nav-link span svg,
-header nav {
-  transition: all 0.5s ease;
-}
-
-.nav-link:hover span svg {
-  transform: rotate(180deg);
-}
-
-@media (min-width:1024px) {
-
-  .nav-link:hover .sub-menu,
-  .nav-link:focus-within .sub-menu {
-    visibility: visible;
-    opacity: 1;
-    margin-top: 0;
-  }
-}
-
-@media (max-width: 1024px) {
-  .sub-menu {
-    max-height: 0;
-    transform: translateY(-10px);
-    transition: all .7s ease !important;
-  }
-
-  .active .sub-menu {
-    max-height: 600px;
-    transform: translateY(0px);
-    opacity: 1;
-    visibility: visible;
-    margin-top: 0;
-  }
-
-  header nav {
-    visibility: hidden;
-    opacity: 0;
-    transform: translateX(100%);
-  }
-
-  header nav.open {
-    visibility: visible;
-    opacity: 1;
-    transform: translateX(0);
-  }
-}
-
-.lock-scroll {
-  overflow: hidden;
-}
-
-/* hero */
-header {
-  transition: all .7s ease;
-}
-
-.primary-header {
-  background: linear-gradient(270deg, #0053D0 35.85%, #0197FF 94.78%);
-  -webkit-background-clip: text;
-  -webkit-text-fill-color: transparent;
-  background-clip: text;
-  text-shadow: 0px 4px 74px #e9e7e2;
-}
-
-.dark .primary-header {
-  background: linear-gradient(270deg, #70F0F9 100%, #70F0F9 100%);
-  -webkit-background-clip: text;
-  -webkit-text-fill-color: transparent;
-  background-clip: text;
-  text-shadow: none;
-}
-
-.secondary-header {
-  color: #606c71;
-  text-shadow: 0px 4px 74px #e9e7e2;
-}
-
-.dark .secondary-header {
-  color: #fff;
-  text-shadow: none;
-}
-
-.description {
-  width: 31rem;
-}
-
-p a {
-  color: #0053D0;
-  text-decoration: underline;
-  text-underline-offset: 2px;
-}
-
-.dark p a {
-  color: #70F0F9;
-}
-
-/* For Contact & Invitation Page */
-.primary-header-contact {
-  background: linear-gradient(251.16deg, #53c1ff 1.1%, #0053d0 100.82%);
-  -webkit-background-clip: text;
-  -webkit-text-fill-color: transparent;
-  background-clip: text;
-  text-shadow: 0px 4px 74px #e9e7e2;
-}
-
-.dark .primary-header-contact {
-  background: linear-gradient(270deg, #70F0F9 100%, #70F0F9 100%);
-  -webkit-background-clip: text;
-  -webkit-text-fill-color: transparent;
-  background-clip: text;
-  text-shadow: none;
-}
-
-.secondary-header-contact {
-  text-shadow: 0px 4px 74px #e9e7e2;
-}
-
-.dark .secondary-header-contact {
-  text-shadow: none;
-}
-
-.content_copy_with_tooltip {
-  background-color: #f8f8f6;
-  border-radius: 50px;
-  padding-bottom: 4px;
-  padding-top: 8px;
-  margin-top: 16px;
-  margin-bottom: 16px;
-}
-
-.content_copy_with_tooltip .tooltip {
-  vertical-align: -6px;
-}
-
-.content_copy_with_tooltip .content {
-  font-size: 15px;
-}
-
-.contact-tab>.contact-tab-content,
-.job-tab>.job-tab-content {
-  opacity: 0;
-  max-height: 0;
-  transition: all 0.5s ease;
-  visibility: hidden;
-  transform: translateY(10px);
-  overflow: hidden;
-}
-
-.contact-tab svg,
-.job-tab svg {
-  transform: rotate(-180deg);
-  transition: all .5s ease;
-}
-
-.contact-tab.active>.contact-tab-content,
-.job-tab.active>.job-tab-content {
-  opacity: 1;
-  max-height: 300px;
-  visibility: visible;
-  transform: translateY(0px);
-}
-
-.for-tablet .contact-tab.active>.contact-tab-content,
-.for-tablet .job-tab.active>.job-tab-content {
-  min-height: 450px;
-}
-
-.contact-tab.active svg,
-.contact-tab:hover svg,
-.job-tab.active svg,
-.job-tab:hover svg {
-  transform: rotate(0deg);
-}
-
-.d-none-if-js-disabled {
-  display: none !important;
-}

apps/common/Web/static/media/sun.svg

@@ -1,11 +0,0 @@
-<svg width="24" height="24" viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg">
-<path d="M23.9958 12.2815C23.9363 12.3954 23.8849 12.5146 23.8158 12.6224C23.5945 12.9674 23.2766 13.1624 22.8654 13.1685C22.2182 13.1782 21.5707 13.1764 20.9234 13.17C20.2781 13.1636 19.7772 12.6464 19.7773 11.9999C19.7774 11.3535 20.2754 10.8389 20.9237 10.8303C21.532 10.8221 22.1405 10.8258 22.7488 10.8278C23.3522 10.8298 23.7281 11.0908 23.9462 11.6508C23.956 11.6761 23.9789 11.6964 23.9958 11.719C23.9958 11.9064 23.9958 12.094 23.9958 12.2815Z" fill="white"/>
-<path d="M11.7154 24.0003C11.6217 23.9526 11.5256 23.9088 11.4345 23.8564C11.0545 23.6377 10.836 23.3104 10.8286 22.87C10.8175 22.2149 10.8179 21.5593 10.828 20.9042C10.8378 20.2738 11.3597 19.7812 11.9967 19.7812C12.6336 19.7812 13.155 20.2739 13.1654 20.9042C13.1757 21.5359 13.1717 22.168 13.1682 22.7998C13.1652 23.3392 12.8885 23.7369 12.3906 23.937C12.3509 23.9529 12.3153 23.979 12.2779 24.0003C12.0904 24.0003 11.9029 24.0003 11.7154 24.0003Z" fill="white"/>
-<path d="M17.2592 11.9958C17.2733 14.8825 14.9232 17.2468 12.0032 17.2612C9.11732 17.2754 6.75397 14.9264 6.73836 12.0041C6.72295 9.12027 9.07502 6.75326 11.9946 6.73835C14.8788 6.72363 17.2449 9.07587 17.2592 11.9958Z" stroke="white" stroke-width="1.5"/>
-<path d="M13.1693 2.11324C13.1692 2.43329 13.1744 2.75345 13.1682 3.07341C13.1555 3.7216 12.6425 4.21934 11.995 4.21864C11.3493 4.21789 10.8358 3.71808 10.828 3.06768C10.8204 2.42766 10.8201 1.78736 10.8283 1.14738C10.8365 0.500704 11.3562 -0.000843934 12.0007 1.06615e-06C12.6437 0.000846066 13.1564 0.504314 13.1684 1.15307C13.1743 1.47303 13.1694 1.79318 13.1693 2.11324Z" fill="white"/>
-<path d="M2.10878 13.1714C1.78877 13.1714 1.46872 13.1754 1.14885 13.1705C0.504832 13.1605 -0.000422735 12.6426 2.65407e-07 11.9987C0.000423265 11.3553 0.503376 10.838 1.15138 10.8301C1.79126 10.8223 2.43138 10.8222 3.07126 10.8303C3.72034 10.8385 4.21822 11.3541 4.21794 12.0012C4.21766 12.6477 3.71555 13.1609 3.06872 13.1706C2.7488 13.1753 2.42875 13.1714 2.10878 13.1714Z" fill="white"/>
-<path d="M6.85268 5.524C6.82732 6.152 6.60944 6.52005 6.16969 6.72981C5.73844 6.93552 5.29738 6.90378 4.94534 6.58208C4.41604 6.09838 3.90431 5.59148 3.42451 5.05894C3.02923 4.62023 3.09727 3.9209 3.51626 3.50792C3.9361 3.09409 4.63284 3.03567 5.06893 3.43194C5.59381 3.90888 6.09569 4.41446 6.57188 4.93996C6.73726 5.12252 6.79642 5.4014 6.85268 5.524Z" fill="white"/>
-<path d="M17.1426 18.4446C17.1749 17.8424 17.389 17.4819 17.8198 17.2738C18.2418 17.07 18.6812 17.0888 19.0265 17.3998C19.5706 17.8899 20.0919 18.4099 20.5814 18.9544C20.9675 19.384 20.895 20.0764 20.485 20.4873C20.0824 20.8907 19.3961 20.9756 18.9718 20.5988C18.4129 20.1026 17.89 19.5625 17.3864 19.0096C17.2323 18.8405 17.1926 18.5671 17.1426 18.4446Z" fill="white"/>
-<path d="M18.2026 6.84235C17.8449 6.82333 17.4821 6.61377 17.2723 6.18256C17.0626 5.7515 17.0878 5.30837 17.4061 4.95629C17.8919 4.41887 18.4055 3.90234 18.945 3.41897C19.3826 3.02693 20.0905 3.1037 20.4947 3.52429C20.9057 3.95198 20.9561 4.64003 20.5568 5.07805C20.0843 5.59645 19.576 6.08306 19.071 6.5708C18.8688 6.76619 18.6057 6.84832 18.2026 6.84235Z" fill="white"/>
-<path d="M5.54205 17.1445C6.14812 17.1747 6.51058 17.385 6.72137 17.8153C6.9323 18.2459 6.90765 18.6892 6.58942 19.0415C6.1037 19.5791 5.58933 20.0948 5.05088 20.5795C4.62165 20.9659 3.93035 20.8989 3.51681 20.4933C3.09875 20.0833 3.02864 19.3789 3.4227 18.942C3.908 18.404 4.42706 17.8934 4.96382 17.4066C5.13982 17.247 5.41663 17.1985 5.54205 17.1445Z" fill="white"/>
-</svg>

apps/ntf-server/Main.hs

@@ -1,20 +1,18 @@
 module Main where
 
 import Control.Logger.Simple
-import Simplex.Messaging.Server.CLI (getEnvPath)
 import Simplex.Messaging.Notifications.Server.Main
 
-defaultCfgPath :: FilePath
-defaultCfgPath = "/etc/opt/simplex-notifications"
+cfgPath :: FilePath
+cfgPath = "/etc/opt/simplex-notifications"
 
-defaultLogPath :: FilePath
-defaultLogPath = "/var/opt/simplex-notifications"
+logPath :: FilePath
+logPath = "/var/opt/simplex-notifications"
 
 logCfg :: LogConfig
 logCfg = LogConfig {lc_file = Nothing, lc_stderr = True}
 
 main :: IO ()
 main = do
-  cfgPath <- getEnvPath "NTF_SERVER_CFG_PATH" defaultCfgPath
-  logPath <- getEnvPath "NTF_SERVER_LOG_PATH" defaultLogPath
+  setLogLevel LogDebug -- change to LogError in production
   withGlobalLogging logCfg $ ntfServerCLI cfgPath logPath

apps/smp-agent/Main.hs

@@ -1,5 +1,4 @@
 {-# LANGUAGE DuplicateRecordFields #-}
-{-# LANGUAGE NamedFieldPuns #-}
 {-# LANGUAGE OverloadedStrings #-}
 {-# LANGUAGE TypeApplications #-}
 
@@ -39,8 +38,7 @@ logCfg = LogConfig {lc_file = Nothing, lc_stderr = True}
 -- Warning: this SMP agent server is experimental - it does not work correctly with multiple connected TCP clients in some cases.
 main :: IO ()
 main = do
-  let AgentConfig {tcpPort} = cfg
-  putStrLn $ maybe (error "no agent port") (\port -> "SMP agent listening on port " ++ port) tcpPort
+  putStrLn $ "SMP agent listening on port " ++ tcpPort (cfg :: AgentConfig)
   setLogLevel LogInfo -- LogError
   Right st <- createAgentStore agentDbFile agentDbKey False MCConsole
   withGlobalLogging logCfg $ runSMPAgent (transport @TLS) cfg servers st

apps/smp-server/Main.hs

@@ -1,10 +1,10 @@
+{-# LANGUAGE LambdaCase #-}
+
 module Main where
 
 import Control.Logger.Simple
-import Simplex.Messaging.Server.CLI (getEnvPath)
-import Simplex.Messaging.Server.Main (smpServerCLI_)
-import Simplex.Messaging.Server.Web (serveStaticFiles, attachStaticFiles)
-import SMPWeb (smpGenerateSite)
+import Simplex.Messaging.Server.Main
+import System.Environment
 
 defaultCfgPath :: FilePath
 defaultCfgPath = "/etc/opt/simplex"
@@ -17,6 +17,10 @@ logCfg = LogConfig {lc_file = Nothing, lc_stderr = True}
 
 main :: IO ()
 main = do
+  setLogLevel LogDebug
   cfgPath <- getEnvPath "SMP_SERVER_CFG_PATH" defaultCfgPath
   logPath <- getEnvPath "SMP_SERVER_LOG_PATH" defaultLogPath
-  withGlobalLogging logCfg $ smpServerCLI_ smpGenerateSite serveStaticFiles attachStaticFiles cfgPath logPath
+  withGlobalLogging logCfg $ smpServerCLI cfgPath logPath
+    
+getEnvPath :: String -> FilePath -> IO FilePath
+getEnvPath name def = maybe def (\case "" -> def; f -> f) <$> lookupEnv name

apps/smp-server/SMPWeb.hs

@@ -1,43 +0,0 @@
-{-# LANGUAGE NamedFieldPuns #-}
-{-# LANGUAGE OverloadedStrings #-}
-
-module SMPWeb
-  ( smpGenerateSite,
-    serverInformation,
-  ) where
-
-import Data.ByteString (ByteString)
-import Data.String (fromString)
-import Web.Embedded (embeddedContent)
-import Simplex.Messaging.Encoding.String (strEncode)
-import Simplex.Messaging.Server.Information
-import Simplex.Messaging.Server.Main (simplexmqSource)
-import qualified Simplex.Messaging.Server.Web as Web
-import Simplex.Messaging.Server.Web (render, serverInfoSubsts, timedTTLText)
-import Simplex.Messaging.Transport.Client (TransportHost (..))
-
-smpGenerateSite :: ServerInformation -> Maybe TransportHost -> FilePath -> IO ()
-smpGenerateSite si onionHost path =
-  Web.generateSite embeddedContent (serverInformation si onionHost) smpLinkPages path
-
-smpLinkPages :: [String]
-smpLinkPages = ["contact", "invitation", "a", "c", "g", "r", "i"]
-
-serverInformation :: ServerInformation -> Maybe TransportHost -> ByteString
-serverInformation ServerInformation {config, information} onionHost = render (Web.indexHtml embeddedContent) substs
-  where
-    substs = [("smpConfig", Just "y"), ("xftpConfig", Nothing)] <> substConfig <> serverInfoSubsts simplexmqSource information <> [("onionHost", strEncode <$> onionHost), ("iniFileName", Just "smp-server.ini")]
-    substConfig =
-      [ ( "persistence",
-          Just $ case persistence config of
-            SPMMemoryOnly -> "In-memory only"
-            SPMQueues -> "Queues"
-            SPMMessages -> "Queues and messages"
-        ),
-        ("messageExpiration", Just $ maybe "Never" (fromString . timedTTLText) $ messageExpiration config),
-        ("statsEnabled", Just . yesNo $ statsEnabled config),
-        ("newQueuesAllowed", Just . yesNo $ newQueuesAllowed config),
-        ("basicAuthEnabled", Just . yesNo $ basicAuthEnabled config)
-      ]
-    yesNo True = "Yes"
-    yesNo False = "No"

apps/xftp-server/Main.hs

@@ -1,16 +1,13 @@
 module Main where
 
 import Control.Logger.Simple
-import Simplex.FileTransfer.Server.Main (xftpServerCLI_)
-import Simplex.Messaging.Server.CLI (getEnvPath)
-import Simplex.Messaging.Server.Web (serveStaticFiles)
-import XFTPWeb (xftpGenerateSite)
+import Simplex.FileTransfer.Server.Main
 
-defaultCfgPath :: FilePath
-defaultCfgPath = "/etc/opt/simplex-xftp"
+cfgPath :: FilePath
+cfgPath = "/etc/opt/simplex-xftp"
 
-defaultLogPath :: FilePath
-defaultLogPath = "/var/opt/simplex-xftp"
+logPath :: FilePath
+logPath = "/var/opt/simplex-xftp"
 
 logCfg :: LogConfig
 logCfg = LogConfig {lc_file = Nothing, lc_stderr = True}
@@ -18,6 +15,4 @@ logCfg = LogConfig {lc_file = Nothing, lc_stderr = True}
 main :: IO ()
 main = do
   setLogLevel LogDebug -- change to LogError in production
-  cfgPath <- getEnvPath "XFTP_SERVER_CFG_PATH" defaultCfgPath
-  logPath <- getEnvPath "XFTP_SERVER_LOG_PATH" defaultLogPath
-  withGlobalLogging logCfg $ xftpServerCLI_ xftpGenerateSite serveStaticFiles cfgPath logPath
+  withGlobalLogging logCfg $ xftpServerCLI cfgPath logPath

apps/xftp-server/XFTPWeb.hs

@@ -1,67 +0,0 @@
-{-# LANGUAGE NamedFieldPuns #-}
-{-# LANGUAGE OverloadedStrings #-}
-{-# LANGUAGE TemplateHaskell #-}
-
-module XFTPWeb
-  ( xftpGenerateSite,
-    xftpServerInformation,
-  ) where
-
-import Control.Monad (forM_)
-import qualified Data.ByteString.Char8 as B
-import Data.ByteString (ByteString)
-import Data.FileEmbed (embedDir, embedFile)
-import Data.Maybe (isJust)
-import Data.String (fromString)
-import Web.Embedded (embeddedContent)
-import Simplex.FileTransfer.Server.Env (XFTPServerConfig (..))
-import Simplex.Messaging.Encoding.String (strEncode)
-import Simplex.Messaging.Server.Expiration (ExpirationConfig (..))
-import Simplex.Messaging.Server.Information (ServerPublicInfo)
-import Simplex.Messaging.Server.Main (simplexmqSource)
-import qualified Simplex.Messaging.Server.Web as Web
-import Simplex.Messaging.Server.Web (render, serverInfoSubsts, timedTTLText)
-import Simplex.Messaging.Transport.Client (TransportHost (..))
-import System.Directory (createDirectoryIfMissing)
-import System.FilePath ((</>))
-
-xftpWebContent :: [(FilePath, ByteString)]
-xftpWebContent = $(embedDir "apps/xftp-server/static/xftp-web-bundle/")
-
-xftpMediaContent :: [(FilePath, ByteString)]
-xftpMediaContent = $(embedDir "apps/xftp-server/static/media/")
-
-xftpFilePageHtml :: ByteString
-xftpFilePageHtml = $(embedFile "apps/xftp-server/static/file.html")
-
-xftpGenerateSite :: XFTPServerConfig -> Maybe ServerPublicInfo -> Maybe TransportHost -> FilePath -> IO ()
-xftpGenerateSite cfg info onionHost path = do
-  let substs = xftpSubsts cfg info onionHost
-  Web.generateSite embeddedContent (render (Web.indexHtml embeddedContent) substs) [] path
-  let xftpDir = path </> "xftp-web-bundle"
-      mediaDir = path </> "media"
-      fileDir = path </> "file"
-  filePage xftpDir xftpWebContent
-  filePage mediaDir xftpMediaContent
-  createDirectoryIfMissing True fileDir
-  B.writeFile (fileDir </> "index.html") $ render xftpFilePageHtml substs
-  where
-    filePage dir content_ = do
-      createDirectoryIfMissing True dir
-      forM_ content_ $ \(fp, content) -> B.writeFile (dir </> fp) content
-
-xftpServerInformation :: XFTPServerConfig -> Maybe ServerPublicInfo -> Maybe TransportHost -> ByteString
-xftpServerInformation cfg info onionHost = render (Web.indexHtml embeddedContent) (xftpSubsts cfg info onionHost)
-
-xftpSubsts :: XFTPServerConfig -> Maybe ServerPublicInfo -> Maybe TransportHost -> [(ByteString, Maybe ByteString)]
-xftpSubsts XFTPServerConfig {fileExpiration, logStatsInterval, allowNewFiles, newFileBasicAuth} information onionHost =
-  [("smpConfig", Nothing), ("xftpConfig", Just "y")] <> substConfig <> serverInfoSubsts simplexmqSource information <> [("onionHost", strEncode <$> onionHost), ("iniFileName", Just "file-server.ini")]
-  where
-    substConfig =
-      [ ("fileExpiration", Just $ maybe "Never" (fromString . timedTTLText . ttl) fileExpiration),
-        ("statsEnabled", Just . yesNo $ isJust logStatsInterval),
-        ("newUploadsAllowed", Just . yesNo $ allowNewFiles),
-        ("basicAuthEnabled", Just . yesNo $ isJust newFileBasicAuth)
-      ]
-    yesNo True = "Yes"
-    yesNo False = "No"

apps/xftp-server/static/media/xftp-protocol-dark.svg

@@ -1,115 +0,0 @@
-<svg width="440" height="520" viewBox="-20 0 440 520" fill="none" xmlns="http://www.w3.org/2000/svg">
-  <!-- Sender browser -->
-  <rect x="120" y="16" width="160" height="56" rx="10" stroke="#70F0F9" stroke-width="1.5"/>
-  <text x="200" y="40" text-anchor="middle" font-family="system-ui, sans-serif" font-size="13" font-weight="600" fill="#70F0F9">Sender's browser</text>
-  <text x="200" y="56" text-anchor="middle" font-family="system-ui, sans-serif" font-size="11" fill="rgba(112,240,249,0.7)">encrypts file</text>
-
-  <!-- Arrow down from sender to chunks -->
-  <line x1="200" y1="72" x2="200" y2="120" stroke="#70F0F9" stroke-width="1.5" marker-end="url(#arrowC)"/>
-
-  <!-- Chunks row -->
-  <rect x="112" y="120" width="176" height="40" rx="8" fill="none" stroke="#70F0F9" stroke-width="1" stroke-dasharray="4 3"/>
-  <text x="200" y="145" text-anchor="middle" font-family="system-ui, sans-serif" font-size="12" fill="#70F0F9">encrypted chunks</text>
-
-  <!-- Arrows from chunks to routers -->
-  <line x1="152" y1="160" x2="80" y2="220" stroke="#70F0F9" stroke-width="1.5" marker-end="url(#arrowC)"/>
-  <line x1="200" y1="160" x2="200" y2="220" stroke="#70F0F9" stroke-width="1.5" marker-end="url(#arrowC)"/>
-  <line x1="248" y1="160" x2="320" y2="220" stroke="#70F0F9" stroke-width="1.5" marker-end="url(#arrowC)"/>
-
-  <!-- Router 1 (SimpleX) -->
-  <rect x="20" y="220" width="120" height="56" rx="6" fill="none" stroke="#70F0F9" stroke-width="1.5"/>
-  <g transform="translate(28, 227)">
-    <rect width="14" height="4" rx="1" fill="rgba(112,240,249,0.5)"/>
-    <rect y="6" width="14" height="4" rx="1" fill="rgba(112,240,249,0.5)"/>
-    <rect y="12" width="14" height="4" rx="1" fill="rgba(112,240,249,0.5)"/>
-    <circle cx="11" cy="2" r="1" fill="#70F0F9"/>
-    <circle cx="11" cy="8" r="1" fill="#70F0F9"/>
-    <circle cx="11" cy="14" r="1" fill="#70F0F9"/>
-  </g>
-  <text x="80" y="244" text-anchor="middle" font-family="system-ui, sans-serif" font-size="11" font-weight="600" fill="#70F0F9">SimpleX</text>
-  <text x="80" y="258" text-anchor="middle" font-family="system-ui, sans-serif" font-size="9" fill="rgba(112,240,249,0.7)">XFTP router</text>
-
-  <!-- Router 2 (Flux) -->
-  <rect x="155" y="220" width="90" height="56" rx="6" fill="none" stroke="#70F0F9" stroke-width="1.5"/>
-  <g transform="translate(163, 227)">
-    <rect width="14" height="4" rx="1" fill="rgba(112,240,249,0.5)"/>
-    <rect y="6" width="14" height="4" rx="1" fill="rgba(112,240,249,0.5)"/>
-    <rect y="12" width="14" height="4" rx="1" fill="rgba(112,240,249,0.5)"/>
-    <circle cx="11" cy="2" r="1" fill="#70F0F9"/>
-    <circle cx="11" cy="8" r="1" fill="#70F0F9"/>
-    <circle cx="11" cy="14" r="1" fill="#70F0F9"/>
-  </g>
-  <text x="200" y="244" text-anchor="middle" font-family="system-ui, sans-serif" font-size="11" font-weight="600" fill="#70F0F9">Flux</text>
-  <text x="200" y="258" text-anchor="middle" font-family="system-ui, sans-serif" font-size="9" fill="rgba(112,240,249,0.7)">XFTP router</text>
-
-  <!-- Router 3 (SimpleX) -->
-  <rect x="260" y="220" width="120" height="56" rx="6" fill="none" stroke="#70F0F9" stroke-width="1.5"/>
-  <g transform="translate(268, 227)">
-    <rect width="14" height="4" rx="1" fill="rgba(112,240,249,0.5)"/>
-    <rect y="6" width="14" height="4" rx="1" fill="rgba(112,240,249,0.5)"/>
-    <rect y="12" width="14" height="4" rx="1" fill="rgba(112,240,249,0.5)"/>
-    <circle cx="11" cy="2" r="1" fill="#70F0F9"/>
-    <circle cx="11" cy="8" r="1" fill="#70F0F9"/>
-    <circle cx="11" cy="14" r="1" fill="#70F0F9"/>
-  </g>
-  <text x="320" y="244" text-anchor="middle" font-family="system-ui, sans-serif" font-size="11" font-weight="600" fill="#70F0F9">SimpleX</text>
-  <text x="320" y="258" text-anchor="middle" font-family="system-ui, sans-serif" font-size="9" fill="rgba(112,240,249,0.7)">XFTP router</text>
-
-  <!-- Arrows from routers down -->
-  <line x1="80" y1="276" x2="152" y2="336" stroke="#70F0F9" stroke-width="1.5" marker-end="url(#arrowC)"/>
-  <line x1="200" y1="276" x2="200" y2="336" stroke="#70F0F9" stroke-width="1.5" marker-end="url(#arrowC)"/>
-  <line x1="320" y1="276" x2="248" y2="336" stroke="#70F0F9" stroke-width="1.5" marker-end="url(#arrowC)"/>
-
-  <!-- Re-encrypt label -->
-  <text x="330" y="310" text-anchor="start" font-family="system-ui, sans-serif" font-size="10" fill="rgba(112,240,249,0.7)">re-encrypted</text>
-  <text x="330" y="322" text-anchor="start" font-family="system-ui, sans-serif" font-size="10" fill="rgba(112,240,249,0.7)">per recipient</text>
-
-  <!-- Chunks row (download) -->
-  <rect x="112" y="336" width="176" height="40" rx="8" fill="none" stroke="#70F0F9" stroke-width="1" stroke-dasharray="4 3"/>
-  <text x="200" y="361" text-anchor="middle" font-family="system-ui, sans-serif" font-size="12" fill="#70F0F9">encrypted chunks</text>
-
-  <!-- Arrow down to recipient -->
-  <line x1="200" y1="376" x2="200" y2="424" stroke="#70F0F9" stroke-width="1.5" marker-end="url(#arrowC)"/>
-
-  <!-- Recipient browser -->
-  <rect x="120" y="424" width="160" height="56" rx="10" stroke="#70F0F9" stroke-width="1.5"/>
-  <text x="200" y="448" text-anchor="middle" font-family="system-ui, sans-serif" font-size="13" font-weight="600" fill="#70F0F9">Recipient's browser</text>
-  <text x="200" y="464" text-anchor="middle" font-family="system-ui, sans-serif" font-size="11" fill="rgba(112,240,249,0.7)">decrypts file</text>
-
-  <!-- Key path (dashed, side) -->
-  <path d="M120 44 L8 44 L8 452 L120 452" stroke="#70F0F9" stroke-width="1.5" stroke-dasharray="6 4" fill="none" marker-end="url(#arrowC)"/>
-  <text x="-6" y="240" text-anchor="middle" font-family="system-ui, sans-serif" font-size="10" fill="#70F0F9" transform="rotate(-90 -6 240)">key in URL fragment - never sent to page server or data router</text>
-
-
-  <!-- Closed padlock: encryption (between sender and chunks) -->
-  <g transform="translate(192, 88)">
-    <path d="M4,7 V4 C4,1.2 12,1.2 12,4 V7" stroke="#60a5fa" stroke-width="1.5" fill="none" stroke-linecap="round"/>
-    <rect x="2" y="7" width="12" height="9" rx="2" fill="#60a5fa"/>
-    <circle cx="8" cy="12" r="1.2" fill="#0B2A59"/>
-  </g>
-
-  <!-- Open padlock: decryption (between chunks and recipient) -->
-  <g transform="translate(192, 392)">
-    <path d="M4,7 V4 C4,1.2 12,1.2 12,4 V2" stroke="#60a5fa" stroke-width="1.5" fill="none" stroke-linecap="round"/>
-    <rect x="2" y="7" width="12" height="9" rx="2" fill="#60a5fa"/>
-    <circle cx="8" cy="12" r="1.2" fill="#0B2A59"/>
-  </g>
-
-  <!-- Key icon on dashed line -->
-  <g transform="translate(8, 410)">
-    <circle cx="0" cy="0" r="6" stroke="#FBBF24" stroke-width="2" fill="#FBBF24"/>
-    <circle cx="0" cy="0" r="2" fill="#0B2A59"/>
-    <line x1="6" y1="0" x2="16" y2="0" stroke="#FBBF24" stroke-width="2"/>
-    <line x1="14" y1="0" x2="14" y2="4" stroke="#FBBF24" stroke-width="2"/>
-    <line x1="11" y1="0" x2="11" y2="3.5" stroke="#FBBF24" stroke-width="2"/>
-  </g>
-
-  <!-- Annotation: no shared IDs -->
-  <text x="200" y="510" text-anchor="middle" font-family="system-ui, sans-serif" font-size="10" fill="rgba(112,240,249,0.7)">Each file fragment uses unique anonymous credentials - no shared identifiers</text>
-
-  <defs>
-    <marker id="arrowC" viewBox="0 0 10 10" refX="9" refY="5" markerWidth="6" markerHeight="6" orient="auto-start-reverse">
-      <path d="M 0 0 L 10 5 L 0 10 z" fill="#70F0F9"/>
-    </marker>
-  </defs>
-</svg>

apps/xftp-server/static/media/xftp-protocol.svg

@@ -1,130 +0,0 @@
-<svg width="440" height="520" viewBox="-20 0 440 520" fill="none" xmlns="http://www.w3.org/2000/svg">
-  <!-- Sender browser -->
-  <rect x="120" y="16" width="160" height="56" rx="10" fill="url(#gBox)" stroke="#606C71" stroke-width="1.5"/>
-  <text x="200" y="40" text-anchor="middle" font-family="system-ui, sans-serif" font-size="13" font-weight="600" fill="#fff">Sender's browser</text>
-  <text x="200" y="56" text-anchor="middle" font-family="system-ui, sans-serif" font-size="11" fill="rgba(255,255,255,0.8)">encrypts file</text>
-
-  <!-- Arrow down from sender to chunks -->
-  <line x1="200" y1="72" x2="200" y2="120" stroke="#606C71" stroke-width="1.5" marker-end="url(#arrowG)"/>
-
-  <!-- Chunks row -->
-  <rect x="112" y="120" width="176" height="40" rx="8" fill="#f0f7ff" stroke="#0053D0" stroke-width="1" stroke-dasharray="4 3"/>
-  <text x="200" y="145" text-anchor="middle" font-family="system-ui, sans-serif" font-size="12" fill="#0053D0">encrypted chunks</text>
-
-  <!-- Arrows from chunks to routers -->
-  <line x1="152" y1="160" x2="80" y2="220" stroke="#606C71" stroke-width="1.5" marker-end="url(#arrowG)"/>
-  <line x1="200" y1="160" x2="200" y2="220" stroke="#606C71" stroke-width="1.5" marker-end="url(#arrowG)"/>
-  <line x1="248" y1="160" x2="320" y2="220" stroke="#606C71" stroke-width="1.5" marker-end="url(#arrowG)"/>
-
-  <!-- Router 1 (SimpleX) -->
-  <rect x="20" y="220" width="120" height="56" rx="6" fill="#f0f4f8" stroke="#606C71" stroke-width="1.5"/>
-  <g transform="translate(28, 227)">
-    <rect width="14" height="4" rx="1" fill="#606C71"/>
-    <rect y="6" width="14" height="4" rx="1" fill="#606C71"/>
-    <rect y="12" width="14" height="4" rx="1" fill="#606C71"/>
-    <circle cx="11" cy="2" r="1" fill="#53C1FF"/>
-    <circle cx="11" cy="8" r="1" fill="#53C1FF"/>
-    <circle cx="11" cy="14" r="1" fill="#53C1FF"/>
-  </g>
-  <text x="80" y="244" text-anchor="middle" font-family="system-ui, sans-serif" font-size="11" font-weight="600" fill="#3F484B">SimpleX</text>
-  <text x="80" y="258" text-anchor="middle" font-family="system-ui, sans-serif" font-size="9" fill="#606C71">XFTP router</text>
-
-  <!-- Router 2 (Flux) -->
-  <rect x="155" y="220" width="90" height="56" rx="6" fill="#f0f4f8" stroke="#606C71" stroke-width="1.5"/>
-  <g transform="translate(163, 227)">
-    <rect width="14" height="4" rx="1" fill="#606C71"/>
-    <rect y="6" width="14" height="4" rx="1" fill="#606C71"/>
-    <rect y="12" width="14" height="4" rx="1" fill="#606C71"/>
-    <circle cx="11" cy="2" r="1" fill="#53C1FF"/>
-    <circle cx="11" cy="8" r="1" fill="#53C1FF"/>
-    <circle cx="11" cy="14" r="1" fill="#53C1FF"/>
-  </g>
-  <text x="200" y="244" text-anchor="middle" font-family="system-ui, sans-serif" font-size="11" font-weight="600" fill="#3F484B">Flux</text>
-  <text x="200" y="258" text-anchor="middle" font-family="system-ui, sans-serif" font-size="9" fill="#606C71">XFTP router</text>
-
-  <!-- Router 3 (SimpleX) -->
-  <rect x="260" y="220" width="120" height="56" rx="6" fill="#f0f4f8" stroke="#606C71" stroke-width="1.5"/>
-  <g transform="translate(268, 227)">
-    <rect width="14" height="4" rx="1" fill="#606C71"/>
-    <rect y="6" width="14" height="4" rx="1" fill="#606C71"/>
-    <rect y="12" width="14" height="4" rx="1" fill="#606C71"/>
-    <circle cx="11" cy="2" r="1" fill="#53C1FF"/>
-    <circle cx="11" cy="8" r="1" fill="#53C1FF"/>
-    <circle cx="11" cy="14" r="1" fill="#53C1FF"/>
-  </g>
-  <text x="320" y="244" text-anchor="middle" font-family="system-ui, sans-serif" font-size="11" font-weight="600" fill="#3F484B">SimpleX</text>
-  <text x="320" y="258" text-anchor="middle" font-family="system-ui, sans-serif" font-size="9" fill="#606C71">XFTP router</text>
-
-  <!-- Arrows from routers down -->
-  <line x1="80" y1="276" x2="152" y2="336" stroke="#606C71" stroke-width="1.5" marker-end="url(#arrowG)"/>
-  <line x1="200" y1="276" x2="200" y2="336" stroke="#606C71" stroke-width="1.5" marker-end="url(#arrowG)"/>
-  <line x1="320" y1="276" x2="248" y2="336" stroke="#606C71" stroke-width="1.5" marker-end="url(#arrowG)"/>
-
-  <!-- Re-encrypt label -->
-  <text x="330" y="310" text-anchor="start" font-family="system-ui, sans-serif" font-size="10" fill="#606C71">re-encrypted</text>
-  <text x="330" y="322" text-anchor="start" font-family="system-ui, sans-serif" font-size="10" fill="#606C71">per recipient</text>
-
-  <!-- Chunks row (download) -->
-  <rect x="112" y="336" width="176" height="40" rx="8" fill="#f0f7ff" stroke="#0053D0" stroke-width="1" stroke-dasharray="4 3"/>
-  <text x="200" y="361" text-anchor="middle" font-family="system-ui, sans-serif" font-size="12" fill="#0053D0">encrypted chunks</text>
-
-  <!-- Arrow down to recipient -->
-  <line x1="200" y1="376" x2="200" y2="424" stroke="#606C71" stroke-width="1.5" marker-end="url(#arrowG)"/>
-
-  <!-- Recipient browser -->
-  <rect x="120" y="424" width="160" height="56" rx="10" fill="url(#gBox)" stroke="#606C71" stroke-width="1.5"/>
-  <text x="200" y="448" text-anchor="middle" font-family="system-ui, sans-serif" font-size="13" font-weight="600" fill="#fff">Recipient's browser</text>
-  <text x="200" y="464" text-anchor="middle" font-family="system-ui, sans-serif" font-size="11" fill="rgba(255,255,255,0.8)">decrypts file</text>
-
-  <!-- Key path (dashed, side) -->
-  <path d="M120 44 L8 44 L8 452 L120 452" stroke="#0053D0" stroke-width="1.5" stroke-dasharray="6 4" fill="none" marker-end="url(#arrowB)"/>
-  <text x="-6" y="240" text-anchor="middle" font-family="system-ui, sans-serif" font-size="10" fill="#0053D0" transform="rotate(-90 -6 240)">key in URL fragment - never sent to page server or data router</text>
-
-
-  <!-- Closed padlock: encryption (between sender and chunks) -->
-  <g transform="translate(192, 88)">
-    <path d="M4,7 V4 C4,1.2 12,1.2 12,4 V7" stroke="#0053D0" stroke-width="1.5" fill="none" stroke-linecap="round"/>
-    <rect x="2" y="7" width="12" height="9" rx="2" fill="#0053D0"/>
-    <circle cx="8" cy="12" r="1.2" fill="#fff"/>
-  </g>
-
-  <!-- Open padlock: decryption (between chunks and recipient) -->
-  <g transform="translate(192, 392)">
-    <path d="M4,7 V4 C4,1.2 12,1.2 12,4 V2" stroke="#0053D0" stroke-width="1.5" fill="none" stroke-linecap="round"/>
-    <rect x="2" y="7" width="12" height="9" rx="2" fill="#0053D0"/>
-    <circle cx="8" cy="12" r="1.2" fill="#fff"/>
-  </g>
-
-  <!-- Key icon on dashed line -->
-  <g transform="translate(8, 410)">
-    <circle cx="0" cy="0" r="6" stroke="#D97706" stroke-width="2" fill="#D97706"/>
-    <circle cx="0" cy="0" r="2" fill="#fff"/>
-    <line x1="6" y1="0" x2="16" y2="0" stroke="#D97706" stroke-width="2"/>
-    <line x1="14" y1="0" x2="14" y2="4" stroke="#D97706" stroke-width="2"/>
-    <line x1="11" y1="0" x2="11" y2="3.5" stroke="#D97706" stroke-width="2"/>
-  </g>
-
-  <!-- Annotation: no shared IDs -->
-  <text x="200" y="510" text-anchor="middle" font-family="system-ui, sans-serif" font-size="10" fill="#606C71">Each file fragment uses unique anonymous credentials - no shared identifiers</text>
-
-  <defs>
-    <linearGradient id="gBox" x1="120" y1="16" x2="280" y2="72" gradientUnits="userSpaceOnUse">
-      <stop stop-color="#0053D0"/>
-      <stop offset="1" stop-color="#53C1FF"/>
-    </linearGradient>
-    <linearGradient id="gSrv1" x1="20" y1="220" x2="140" y2="276" gradientUnits="userSpaceOnUse">
-      <stop stop-color="#0053D0"/>
-      <stop offset="1" stop-color="#53C1FF"/>
-    </linearGradient>
-    <linearGradient id="gSrv2" x1="155" y1="220" x2="245" y2="276" gradientUnits="userSpaceOnUse">
-      <stop stop-color="#0053D0"/>
-      <stop offset="1" stop-color="#53C1FF"/>
-    </linearGradient>
-    <marker id="arrowG" viewBox="0 0 10 10" refX="9" refY="5" markerWidth="6" markerHeight="6" orient="auto-start-reverse">
-      <path d="M 0 0 L 10 5 L 0 10 z" fill="#606C71"/>
-    </marker>
-    <marker id="arrowB" viewBox="0 0 10 10" refX="9" refY="5" markerWidth="6" markerHeight="6" orient="auto-start-reverse">
-      <path d="M 0 0 L 10 5 L 0 10 z" fill="#0053D0"/>
-    </marker>
-  </defs>
-</svg>

apps/xftp-server/static/xftp-web-bundle/index.css

@@ -1,145 +0,0 @@
-#app, [data-xftp-app] {
-  font-family: system-ui, -apple-system, sans-serif;
-  color: #333;
-  width: 100%;
-  max-width: 480px;
-  padding: 16px;
-  box-sizing: border-box;
-  --xftp-ring-fg: #3b82f6;
-}
-
-:is(#app, [data-xftp-app]) .card {
-  background: #fff;
-  border-radius: 12px;
-  padding: 32px 24px;
-  box-shadow: 0 1px 3px rgba(0,0,0,.1);
-  text-align: center;
-}
-
-:is(#app, [data-xftp-app]) h1 {
-  font-size: 1.25rem;
-  font-weight: 600;
-  margin-bottom: 24px;
-}
-
-:is(#app, [data-xftp-app]) .stage { margin-top: 16px; }
-
-/* Drop zone */
-:is(#app, [data-xftp-app]) .drop-zone {
-  border: 2px dashed #ccc;
-  border-radius: 8px;
-  padding: 32px 16px;
-  transition: border-color .15s, background .15s;
-}
-:is(#app, [data-xftp-app]) .drop-zone.drag-over {
-  border-color: #3b82f6;
-  background: #eff6ff;
-}
-
-/* Buttons */
-:is(#app, [data-xftp-app]) .btn {
-  display: inline-block;
-  padding: 10px 24px;
-  border: none;
-  border-radius: 6px;
-  background: #3b82f6;
-  color: #fff;
-  font-size: .9rem;
-  font-weight: 500;
-  cursor: pointer;
-  transition: background .15s;
-}
-:is(#app, [data-xftp-app]) .btn:hover { background: #2563eb; }
-:is(#app, [data-xftp-app]) .btn-secondary { background: #6b7280; }
-:is(#app, [data-xftp-app]) .btn-secondary:hover { background: #4b5563; }
-
-/* Hints */
-:is(#app, [data-xftp-app]) .hint { color: #999; font-size: .85rem; margin-top: 8px; }
-:is(#app, [data-xftp-app]) .expiry { margin-top: 12px; }
-
-/* Progress */
-:is(#app, [data-xftp-app]) .progress-ring { display: block; margin: 0 auto 12px; }
-:is(#app, [data-xftp-app]) #upload-status,
-:is(#app, [data-xftp-app]) #dl-status { font-size: .9rem; color: #666; margin-bottom: 12px; }
-
-/* Share link row */
-:is(#app, [data-xftp-app]) .link-row {
-  display: flex;
-  gap: 8px;
-  margin-top: 12px;
-}
-:is(#app, [data-xftp-app]) .link-row input {
-  flex: 1;
-  padding: 8px 10px;
-  border: 1px solid #ccc;
-  border-radius: 6px;
-  font-size: .85rem;
-  background: #f9fafb;
-}
-
-/* Upload link */
-:is(#app, [data-xftp-app]) .upload-link {
-  margin-top: 12px;
-  color: #3b82f6;
-  font-size: .9rem;
-  text-decoration: none;
-  cursor: pointer;
-}
-:is(#app, [data-xftp-app]) .upload-link:not([hidden]) {
-  display: inline-block;
-}
-:is(#app, [data-xftp-app]) .upload-link:hover { text-decoration: underline; }
-
-/* Messages */
-:is(#app, [data-xftp-app]) .success { color: #16a34a; font-weight: 600; }
-:is(#app, [data-xftp-app]) .error { color: #dc2626; font-weight: 500; margin-bottom: 12px; }
-
-/* Security note */
-:is(#app, [data-xftp-app]) .security-note {
-  margin-top: 20px;
-  padding: 12px;
-  background: #f0fdf4;
-  border-radius: 6px;
-  font-size: .8rem;
-  color: #555;
-  text-align: left;
-}
-:is(#app, [data-xftp-app]) .security-note p + p { margin-top: 6px; }
-:is(#app, [data-xftp-app]) .security-note a { color: #3b82f6; text-decoration: none; }
-:is(#app, [data-xftp-app]) .security-note a:hover { text-decoration: underline; }
-
-/* ── Dark mode ─────────────────────────────────── */
-.dark :is(#app, [data-xftp-app]) {
-  color: #e5e7eb;
-  --xftp-ring-bg: #374151;
-  --xftp-ring-fg: #60a5fa;
-  --xftp-ring-text: #e5e7eb;
-  --xftp-ring-done: #4ade80;
-}
-.dark :is(#app, [data-xftp-app]) .card {
-  background: #1f2937;
-  box-shadow: 0 1px 3px rgba(0,0,0,.4);
-}
-.dark :is(#app, [data-xftp-app]) .drop-zone { border-color: #4b5563; }
-.dark :is(#app, [data-xftp-app]) .drop-zone.drag-over {
-  border-color: #60a5fa;
-  background: rgba(59,130,246,.15);
-}
-.dark :is(#app, [data-xftp-app]) .btn-secondary { background: #4b5563; }
-.dark :is(#app, [data-xftp-app]) .btn-secondary:hover { background: #374151; }
-.dark :is(#app, [data-xftp-app]) .hint { color: #9ca3af; }
-.dark :is(#app, [data-xftp-app]) #upload-status,
-.dark :is(#app, [data-xftp-app]) #dl-status { color: #9ca3af; }
-.dark :is(#app, [data-xftp-app]) .link-row input {
-  background: #374151;
-  border-color: #4b5563;
-  color: #e5e7eb;
-}
-.dark :is(#app, [data-xftp-app]) .success { color: #4ade80; }
-.dark :is(#app, [data-xftp-app]) .error { color: #f87171; }
-.dark :is(#app, [data-xftp-app]) .security-note {
-  background: rgba(34,197,94,.1);
-  color: #d1d5db;
-}
-.dark :is(#app, [data-xftp-app]) .upload-link { color: #60a5fa; }
-.dark :is(#app, [data-xftp-app]) .security-note a { color: #60a5fa; }

bench/ClientSim.hs

@@ -1,133 +0,0 @@
-{-# LANGUAGE DataKinds #-}
-{-# LANGUAGE DuplicateRecordFields #-}
-{-# LANGUAGE GADTs #-}
-{-# LANGUAGE LambdaCase #-}
-{-# LANGUAGE NamedFieldPuns #-}
-{-# LANGUAGE OverloadedStrings #-}
-{-# LANGUAGE PatternSynonyms #-}
-{-# LANGUAGE ScopedTypeVariables #-}
-{-# LANGUAGE TupleSections #-}
-{-# LANGUAGE TypeApplications #-}
-{-# OPTIONS_GHC -fno-warn-ambiguous-fields #-}
-
-module ClientSim
-  ( SimClient (..),
-    connectClient,
-    createQueue,
-    subscribeQueue,
-    sendMessage,
-    receiveAndAck,
-    connectN,
-    benchKeyHash,
-  )
-where
-
-import Control.Concurrent.Async (mapConcurrently)
-import Control.Concurrent.STM
-import Control.Monad (forM_)
-import Control.Monad.Except (runExceptT)
-import Data.ByteString.Char8 (ByteString)
-import Data.List (unfoldr)
-import qualified Data.List.NonEmpty as L
-import Network.Socket (ServiceName)
-import qualified Simplex.Messaging.Crypto as C
-import Simplex.Messaging.Encoding
-import Simplex.Messaging.Protocol
-import Simplex.Messaging.Transport
-import Simplex.Messaging.Transport.Client
-import Simplex.Messaging.Version
-
-data SimClient = SimClient
-  { scHandle :: THandleSMP TLS 'TClient,
-    scRcvKey :: C.APrivateAuthKey,
-    scRcvId :: RecipientId,
-    scSndId :: SenderId,
-    scDhSecret :: C.DhSecret 'C.X25519
-  }
-
-benchKeyHash :: C.KeyHash
-benchKeyHash = "LcJUMfVhwD8yxjAiSaDzzGF3-kLG4Uh0Fl_ZIjrRwjI="
-
-connectClient :: TransportHost -> ServiceName -> IO (THandleSMP TLS 'TClient)
-connectClient host port = do
-  let tcConfig = defaultTransportClientConfig {clientALPN = Just alpnSupportedSMPHandshakes}
-  runTransportClient tcConfig Nothing host port (Just benchKeyHash) $ \h ->
-    runExceptT (smpClientHandshake h Nothing benchKeyHash supportedClientSMPRelayVRange False Nothing) >>= \case
-      Right th -> pure th
-      Left e -> error $ "SMP handshake failed: " <> show e
-
-connectN :: Int -> TransportHost -> ServiceName -> IO [THandleSMP TLS 'TClient]
-connectN n host port = do
-  let batches = chunksOf 100 [1 .. n]
-  concat <$> mapM (\batch -> mapConcurrently (\_ -> connectClient host port) batch) batches
-
-createQueue :: THandleSMP TLS 'TClient -> IO SimClient
-createQueue h = do
-  g <- C.newRandom
-  (rPub, rKey) <- atomically $ C.generateAuthKeyPair C.SEd448 g
-  (sPub, sKey) <- atomically $ C.generateAuthKeyPair C.SEd25519 g
-  (dhPub, dhPriv :: C.PrivateKeyX25519) <- atomically $ C.generateKeyPair g
-  -- NEW command
-  Resp "1" NoEntity (Ids rId sId srvDh) <- signSendRecv h rKey ("1", NoEntity, New rPub dhPub)
-  let dhShared = C.dh' srvDh dhPriv
-  -- KEY command (secure queue)
-  Resp "2" _ OK <- signSendRecv h rKey ("2", rId, KEY sPub)
-  pure SimClient {scHandle = h, scRcvKey = rKey, scRcvId = rId, scSndId = sId, scDhSecret = dhShared}
-
-subscribeQueue :: SimClient -> IO ()
-subscribeQueue SimClient {scHandle = h, scRcvKey = rKey, scRcvId = rId} = do
-  Resp "3" _ (SOK _) <- signSendRecv h rKey ("3", rId, SUB)
-  pure ()
-
-sendMessage :: THandleSMP TLS 'TClient -> C.APrivateAuthKey -> SenderId -> ByteString -> IO ()
-sendMessage h sKey sId body = do
-  Resp "4" _ OK <- signSendRecv h sKey ("4", sId, SEND noMsgFlags body)
-  pure ()
-
-receiveAndAck :: SimClient -> IO ()
-receiveAndAck SimClient {scHandle = h, scRcvKey = rKey, scRcvId = rId} = do
-  (_, _, Right (MSG RcvMessage {msgId = mId})) <- tGet1 h
-  Resp "5" _ OK <- signSendRecv h rKey ("5", rId, ACK mId)
-  pure ()
-
--- Helpers (same patterns as ServerTests.hs)
-
-pattern Resp :: CorrId -> EntityId -> BrokerMsg -> Transmission (Either ErrorType BrokerMsg)
-pattern Resp corrId queueId command <- (corrId, queueId, Right command)
-
-pattern Ids :: RecipientId -> SenderId -> RcvPublicDhKey -> BrokerMsg
-pattern Ids rId sId srvDh <- IDS (QIK rId sId srvDh _ _ Nothing Nothing)
-
-pattern New :: RcvPublicAuthKey -> RcvPublicDhKey -> Command 'Creator
-pattern New rPub dhPub = NEW (NewQueueReq rPub dhPub Nothing SMSubscribe (Just (QRMessaging Nothing)) Nothing)
-
-signSendRecv :: (Transport c, PartyI p) => THandleSMP c 'TClient -> C.APrivateAuthKey -> (ByteString, EntityId, Command p) -> IO (Transmission (Either ErrorType BrokerMsg))
-signSendRecv h pk t = do
-  signSend h pk t
-  (r L.:| _) <- tGetClient h
-  pure r
-
-signSend :: (Transport c, PartyI p) => THandleSMP c 'TClient -> C.APrivateAuthKey -> (ByteString, EntityId, Command p) -> IO ()
-signSend h@THandle {params} (C.APrivateAuthKey a pk) (corrId, qId, cmd) = do
-  let TransmissionForAuth {tForAuth, tToSend} = encodeTransmissionForAuth params (CorrId corrId, qId, cmd)
-      authorize t = (,Nothing) <$> case a of
-        C.SEd25519 -> Just . TASignature . C.ASignature C.SEd25519 $ C.sign' pk t
-        C.SEd448 -> Just . TASignature . C.ASignature C.SEd448 $ C.sign' pk t
-        C.SX25519 -> (\THAuthClient {peerServerPubKey = k} -> TAAuthenticator $ C.cbAuthenticate k pk (C.cbNonce corrId) t) <$> thAuth params
-  Right () <- tPut1 h (authorize tForAuth, tToSend)
-  pure ()
-
-tPut1 :: Transport c => THandle v c 'TClient -> SentRawTransmission -> IO (Either TransportError ())
-tPut1 h t = do
-  rs <- tPut h (Right t L.:| [])
-  case rs of
-    (r : _) -> pure r
-    [] -> error "tPut1: empty result"
-
-tGet1 :: (ProtocolEncoding v err cmd, Transport c) => THandle v c 'TClient -> IO (Transmission (Either err cmd))
-tGet1 h = do
-  (r L.:| _) <- tGetClient h
-  pure r
-
-chunksOf :: Int -> [a] -> [[a]]
-chunksOf n = unfoldr $ \xs -> if null xs then Nothing else Just (splitAt n xs)

bench/Dockerfile

@@ -1,25 +0,0 @@
-FROM haskell:9.6.3 AS build
-
-WORKDIR /src
-
-# Copy cabal file first for dependency caching
-COPY simplexmq.cabal cabal.project* ./
-RUN cabal update && cabal build --only-dependencies -f server_postgres smp-server-bench || true
-
-# Copy full source
-COPY . .
-RUN cabal build -f server_postgres smp-server-bench \
-  && cp $(cabal list-bin -f server_postgres smp-server-bench) /usr/local/bin/smp-server-bench
-
-FROM debian:bookworm-slim
-
-RUN apt-get update && apt-get install -y --no-install-recommends \
-      libgmp10 libpq5 libffi8 zlib1g ca-certificates \
-  && rm -rf /var/lib/apt/lists/*
-
-COPY --from=build /usr/local/bin/smp-server-bench /usr/local/bin/smp-server-bench
-COPY tests/fixtures /app/tests/fixtures
-
-WORKDIR /app
-
-ENTRYPOINT ["smp-server-bench"]

bench/Main.hs

@@ -1,243 +0,0 @@
-{-# LANGUAGE CPP #-}
-{-# LANGUAGE DataKinds #-}
-{-# LANGUAGE DuplicateRecordFields #-}
-{-# LANGUAGE GADTs #-}
-{-# LANGUAGE LambdaCase #-}
-{-# LANGUAGE NamedFieldPuns #-}
-{-# LANGUAGE NumericUnderscores #-}
-{-# LANGUAGE OverloadedStrings #-}
-{-# LANGUAGE ScopedTypeVariables #-}
-{-# LANGUAGE TypeApplications #-}
-{-# OPTIONS_GHC -fno-warn-ambiguous-fields #-}
-
-module Main where
-
-import Control.Concurrent (threadDelay)
-import Control.Concurrent.Async (async, cancel, forConcurrently_, mapConcurrently, mapConcurrently_)
-import Control.Concurrent.STM
-import Control.Monad (forever, forM_, void, when)
-import Data.ByteString.Char8 (ByteString)
-import qualified Data.ByteString.Char8 as B
-import Data.IORef
-import Data.List (unfoldr)
-import Data.Time.Clock (getCurrentTime, utctDayTime)
-import Network.Socket (ServiceName)
-import System.Environment (getArgs)
-import System.IO (hFlush, stdout)
-
-import ClientSim
-import Report
-
-import Crypto.Random (ChaChaDRG)
-import qualified Simplex.Messaging.Crypto as C
-import Simplex.Messaging.Server (runSMPServerBlocking)
-import Simplex.Messaging.Server.Env.STM as Env
-import Simplex.Messaging.Server.Expiration (ExpirationConfig (..))
-import Simplex.Messaging.Server.MsgStore.Postgres (PostgresMsgStore)
-import Simplex.Messaging.Server.QueueStore.Postgres.Config (PostgresStoreCfg (..))
-import Simplex.Messaging.Agent.Store.Postgres.Options (DBOpts (..))
-import Simplex.Messaging.Agent.Store.Shared (MigrationConfirmation (..))
-import Simplex.Messaging.Client.Agent (SMPClientAgentConfig (..), defaultSMPClientAgentConfig)
-import Simplex.Messaging.Transport
-import Simplex.Messaging.Transport.Server (ServerCredentials (..), mkTransportServerConfig)
-import Simplex.Messaging.Version
-import UnliftIO.Exception (bracket)
-
-import Control.Logger.Simple (logInfo, withGlobalLogging, LogConfig (..), setLogLevel, LogLevel (..))
-
-data BenchConfig = BenchConfig
-  { numClients :: Int,
-    sustainedMinutes :: Int,
-    pgConnStr :: ByteString,
-    serverPort :: ServiceName,
-    timeSeriesFile :: FilePath
-  }
-
-defaultBenchConfig :: BenchConfig
-defaultBenchConfig =
-  BenchConfig
-    { numClients = 5000,
-      sustainedMinutes = 5,
-      pgConnStr = "postgresql://smp@localhost:15432/smp_bench",
-      serverPort = "15001",
-      timeSeriesFile = "bench-timeseries.csv"
-    }
-
-parseArgs :: IO BenchConfig
-parseArgs = do
-  args <- getArgs
-  pure $ go args defaultBenchConfig
-  where
-    go [] c = c
-    go ("--clients" : n : rest) c = go rest c {numClients = read n}
-    go ("--minutes" : n : rest) c = go rest c {sustainedMinutes = read n}
-    go ("--pg" : s : rest) c = go rest c {pgConnStr = B.pack s}
-    go ("--port" : p : rest) c = go rest c {serverPort = p}
-    go ("--timeseries" : f : rest) c = go rest c {timeSeriesFile = f}
-    go (x : _) _ = error $ "Unknown argument: " <> x
-
-main :: IO ()
-main = withGlobalLogging LogConfig {lc_file = Nothing, lc_stderr = True} $ do
-  setLogLevel LogInfo
-  bc@BenchConfig {numClients, sustainedMinutes, serverPort, timeSeriesFile, pgConnStr} <- parseArgs
-  putStrLn $ "SMP Server Memory Benchmark"
-  putStrLn $ "  clients:  " <> show numClients
-  putStrLn $ "  sustain:  " <> show sustainedMinutes <> " min"
-  putStrLn $ "  pg:       " <> B.unpack pgConnStr
-  putStrLn $ "  port:     " <> serverPort
-  putStrLn ""
-
-  snapshotsRef <- newIORef []
-
-  let snap phase clients = do
-        s <- takeSnapshot phase clients
-        modifyIORef' snapshotsRef (s :)
-        putStrLn $ "  [" <> show phase <> "] live=" <> show (snapLive s `div` (1024 * 1024)) <> "MB large=" <> show (snapLarge s `div` (1024 * 1024)) <> "MB"
-        hFlush stdout
-
-  withBenchServer bc $ do
-    putStrLn "Phase 1: Baseline (no clients)"
-    snap "baseline" 0
-
-    putStrLn $ "Phase 2: Connecting " <> show numClients <> " TLS clients..."
-    handles <- connectN numClients "localhost" serverPort
-    putStrLn $ "  Connected " <> show (length handles) <> " clients"
-    snap "tls_connect" (length handles)
-
-    putStrLn "Phase 3: Creating queues (NEW + KEY)..."
-    simClients <- mapConcurrently createQueue handles
-    putStrLn $ "  Created " <> show (length simClients) <> " queues"
-    snap "queue_create" (length simClients)
-
-    putStrLn "Phase 4: Subscribing (SUB)..."
-    mapConcurrently_ subscribeQueue simClients
-    snap "subscribe" (length simClients)
-
-    -- Pair up clients: first half sends to second half
-    let halfN = length simClients `div` 2
-        senders = take halfN simClients
-        receivers = drop halfN simClients
-        pairs = zip senders receivers
-
-    putStrLn $ "Phase 5: Sending " <> show halfN <> " messages..."
-    g <- C.newRandom
-    forConcurrently_ pairs $ \(sender, receiver) -> do
-      (_, sKey) <- atomically $ C.generateAuthKeyPair C.SEd25519 g
-      sendMessage (scHandle sender) sKey (scSndId receiver) "benchmark test message payload 1234567890"
-    snap "msg_send" (length simClients)
-
-    putStrLn "Phase 6: Receiving and ACKing messages..."
-    forConcurrently_ receivers receiveAndAck
-    snap "msg_recv" (length simClients)
-
-    putStrLn $ "Phase 7: Sustained load (" <> show sustainedMinutes <> " min)..."
-    writeTimeSeriesHeader timeSeriesFile
-    -- Logger thread: snapshot every 10s
-    logger <- async $ forever $ do
-      threadDelay 10_000_000
-      s <- takeSnapshot "sustained" (length simClients)
-      appendTimeSeries timeSeriesFile s
-    -- Worker threads: continuous send/receive
-    let loopDurationUs = sustainedMinutes * 60 * 1_000_000
-    workersDone <- newTVarIO False
-    workers <- async $ do
-      deadline <- (+ loopDurationUs) <$> getMonotonicTimeUs
-      sustainedLoop g pairs deadline
-      atomically $ writeTVar workersDone True
-    -- Wait for workers
-    void $ atomically $ readTVar workersDone >>= \done -> when (not done) retry
-    cancel logger
-    cancel workers
-    snap "sustained_end" (length simClients)
-
-  snapshots <- reverse <$> readIORef snapshotsRef
-  printSummary snapshots
-  putStrLn $ "\nTime-series written to: " <> timeSeriesFile
-
-sustainedLoop :: TVar ChaChaDRG -> [(SimClient, SimClient)] -> Int -> IO ()
-sustainedLoop g pairs deadline = go
-  where
-    go = do
-      now <- getMonotonicTimeUs
-      when (now < deadline) $ do
-        forConcurrently_ pairs $ \(sender, receiver) -> do
-          (_, sKey) <- atomically $ C.generateAuthKeyPair C.SEd25519 g
-          sendMessage (scHandle sender) sKey (scSndId receiver) "sustained load message payload"
-        forConcurrently_ (map snd pairs) receiveAndAck
-        go
-
-getMonotonicTimeUs :: IO Int
-getMonotonicTimeUs = do
-  t <- getCurrentTime
-  pure $ round (utctDayTime t * 1_000_000)
-
-withBenchServer :: BenchConfig -> IO a -> IO a
-withBenchServer BenchConfig {pgConnStr, serverPort} action = do
-  started <- newEmptyTMVarIO
-  let srvCfg = benchServerConfig pgConnStr serverPort
-  bracket
-    (async $ runSMPServerBlocking started srvCfg Nothing)
-    cancel
-    (\_ -> waitForServer started >> action)
-  where
-    waitForServer started = do
-      r <- atomically $ takeTMVar started
-      if r
-        then putStrLn $ "Server started on port " <> serverPort
-        else error "Server failed to start"
-
-benchServerConfig :: ByteString -> ServiceName -> ServerConfig PostgresMsgStore
-benchServerConfig pgConn port =
-  let storeCfg = PostgresStoreCfg
-        { dbOpts = DBOpts {connstr = pgConn, schema = "smp_server", poolSize = 10, createSchema = True},
-          dbStoreLogPath = Nothing,
-          confirmMigrations = MCYesUp,
-          deletedTTL = 86400
-        }
-   in ServerConfig
-        { transports = [(port, transport @TLS, False)],
-          smpHandshakeTimeout = 120_000_000,
-          tbqSize = 128,
-          msgQueueQuota = 128,
-          maxJournalMsgCount = 256,
-          maxJournalStateLines = 16,
-          queueIdBytes = 24,
-          msgIdBytes = 24,
-          serverStoreCfg = SSCDatabase storeCfg,
-          storeNtfsFile = Nothing,
-          allowNewQueues = True,
-          newQueueBasicAuth = Nothing,
-          controlPortUserAuth = Nothing,
-          controlPortAdminAuth = Nothing,
-          dailyBlockQueueQuota = 20,
-          messageExpiration = Just defaultMessageExpiration,
-          expireMessagesOnStart = False,
-          expireMessagesOnSend = False,
-          idleQueueInterval = 14400,
-          notificationExpiration = defaultNtfExpiration,
-          inactiveClientExpiration = Nothing,
-          logStatsInterval = Nothing,
-          logStatsStartTime = 0,
-          serverStatsLogFile = "bench/tmp/stats.log",
-          serverStatsBackupFile = Nothing,
-          prometheusInterval = Nothing,
-          prometheusMetricsFile = "bench/tmp/metrics.txt",
-          pendingENDInterval = 500_000,
-          ntfDeliveryInterval = 200_000,
-          smpCredentials =
-            ServerCredentials
-              { caCertificateFile = Just "tests/fixtures/ca.crt",
-                privateKeyFile = "tests/fixtures/server.key",
-                certificateFile = "tests/fixtures/server.crt"
-              },
-          httpCredentials = Nothing,
-          smpServerVRange = supportedServerSMPRelayVRange,
-          Env.transportConfig = mkTransportServerConfig True (Just alpnSupportedSMPHandshakes) True,
-          controlPort = Nothing,
-          smpAgentCfg = defaultSMPClientAgentConfig {persistErrorInterval = 1},
-          allowSMPProxy = False,
-          serverClientConcurrency = 16,
-          information = Nothing,
-          startOptions = StartOptions {maintenance = False, compactLog = False, logLevel = LogInfo, skipWarnings = True, confirmMigrations = MCYesUp}
-        }
-

bench/Report.hs

@@ -1,113 +0,0 @@
-{-# LANGUAGE NamedFieldPuns #-}
-{-# LANGUAGE NumericUnderscores #-}
-{-# LANGUAGE OverloadedStrings #-}
-
-module Report
-  ( Snapshot (..),
-    takeSnapshot,
-    printSummary,
-    writeTimeSeriesHeader,
-    appendTimeSeries,
-  )
-where
-
-import Control.Concurrent (threadDelay)
-import Data.List (foldl')
-import Data.Text (Text)
-import qualified Data.Text as T
-import qualified Data.Text.IO as T
-import Data.Time.Clock (UTCTime, getCurrentTime)
-import Data.Time.Format.ISO8601 (iso8601Show)
-import Data.Word (Word32, Word64)
-import GHC.Stats (RTSStats (..), GCDetails (..), getRTSStats)
-import System.IO (Handle, IOMode (..), hFlush, hSetBuffering, BufferMode (..), withFile)
-import System.Mem (performMajorGC)
-
-data Snapshot = Snapshot
-  { snapTime :: UTCTime,
-    snapPhase :: Text,
-    snapLive :: Word64,
-    snapHeap :: Word64,
-    snapLarge :: Word64,
-    snapFrag :: Word64,
-    snapGCs :: Word32,
-    snapClients :: Int
-  }
-
-takeSnapshot :: Text -> Int -> IO Snapshot
-takeSnapshot phase clients = do
-  performMajorGC
-  threadDelay 1_000_000
-  rts <- getRTSStats
-  ts <- getCurrentTime
-  let GCDetails {gcdetails_live_bytes, gcdetails_mem_in_use_bytes, gcdetails_large_objects_bytes, gcdetails_block_fragmentation_bytes} = gc rts
-  pure
-    Snapshot
-      { snapTime = ts,
-        snapPhase = phase,
-        snapLive = gcdetails_live_bytes,
-        snapHeap = gcdetails_mem_in_use_bytes,
-        snapLarge = gcdetails_large_objects_bytes,
-        snapFrag = gcdetails_block_fragmentation_bytes,
-        snapGCs = gcs rts,
-        snapClients = clients
-      }
-
-printSummary :: [Snapshot] -> IO ()
-printSummary [] = putStrLn "No snapshots collected."
-printSummary snaps = do
-  putStrLn ""
-  putStrLn hdr
-  putStrLn $ replicate (length hdr) '-'
-  mapM_ printRow (zip (Snapshot {snapLive = 0, snapHeap = 0, snapLarge = 0, snapFrag = 0, snapGCs = 0, snapClients = 0, snapPhase = "", snapTime = snapTime (head snaps)} : snaps) snaps)
-  where
-    hdr = padR 20 "Phase" <> padL 12 "live_MB" <> padL 12 "large_MB" <> padL 12 "frag_MB" <> padL 12 "heap_MB" <> padL 10 "clients" <> padL 14 "d_live_MB" <> padL 14 "d_large_MB" <> padL 14 "KB/client"
-    printRow (prev, cur) =
-      putStrLn $
-        padR 20 (T.unpack $ snapPhase cur)
-          <> padL 12 (showMB $ snapLive cur)
-          <> padL 12 (showMB $ snapLarge cur)
-          <> padL 12 (showMB $ snapFrag cur)
-          <> padL 12 (showMB $ snapHeap cur)
-          <> padL 10 (show $ snapClients cur)
-          <> padL 14 (showDeltaMB (snapLive cur) (snapLive prev))
-          <> padL 14 (showDeltaMB (snapLarge cur) (snapLarge prev))
-          <> padL 14 (perClient cur)
-    showMB w = show (w `div` (1024 * 1024))
-    showDeltaMB a b
-      | a >= b = "+" <> show ((a - b) `div` (1024 * 1024))
-      | otherwise = "-" <> show ((b - a) `div` (1024 * 1024))
-    perClient Snapshot {snapClients, snapLive}
-      | snapClients > 0 = show (snapLive `div` fromIntegral snapClients `div` 1024)
-      | otherwise = "-"
-    padR n s = s <> replicate (max 0 (n - length s)) ' '
-    padL n s = replicate (max 0 (n - length s)) ' ' <> s
-
-csvHeader :: Text
-csvHeader = "timestamp,phase,rts_live,rts_heap,rts_large,rts_frag,rts_gc,clients"
-
-snapshotCsv :: Snapshot -> Text
-snapshotCsv Snapshot {snapTime, snapPhase, snapLive, snapHeap, snapLarge, snapFrag, snapGCs, snapClients} =
-  T.intercalate
-    ","
-    [ T.pack $ iso8601Show snapTime,
-      snapPhase,
-      tshow snapLive,
-      tshow snapHeap,
-      tshow snapLarge,
-      tshow snapFrag,
-      tshow snapGCs,
-      tshow snapClients
-    ]
-
-writeTimeSeriesHeader :: FilePath -> IO ()
-writeTimeSeriesHeader path = T.writeFile path (csvHeader <> "\n")
-
-appendTimeSeries :: FilePath -> Snapshot -> IO ()
-appendTimeSeries path snap =
-  withFile path AppendMode $ \h -> do
-    hSetBuffering h LineBuffering
-    T.hPutStrLn h $ snapshotCsv snap
-
-tshow :: Show a => a -> Text
-tshow = T.pack . show

bench/docker-compose.yml

@@ -1,46 +0,0 @@
-services:
-  postgres:
-    image: postgres:17
-    environment:
-      POSTGRES_USER: smp
-      POSTGRES_DB: smp_bench
-      POSTGRES_HOST_AUTH_METHOD: trust
-    volumes:
-      - ./init.sql:/docker-entrypoint-initdb.d/init.sql
-      - pgdata:/var/lib/postgresql/data
-    healthcheck:
-      test: ["CMD-SHELL", "pg_isready -U smp -d smp_bench"]
-      interval: 2s
-      timeout: 5s
-      retries: 10
-
-  bench:
-    build:
-      context: ..
-      dockerfile: bench/Dockerfile
-    depends_on:
-      postgres:
-        condition: service_healthy
-    environment:
-      BENCH_PG: "postgresql://smp@postgres/smp_bench"
-      BENCH_CLIENTS: "${BENCH_CLIENTS:-5000}"
-      BENCH_MINUTES: "${BENCH_MINUTES:-5}"
-    command:
-      - "--pg"
-      - "postgresql://smp@postgres/smp_bench"
-      - "--clients"
-      - "${BENCH_CLIENTS:-5000}"
-      - "--minutes"
-      - "${BENCH_MINUTES:-5}"
-      - "--timeseries"
-      - "/results/timeseries.csv"
-      - "+RTS"
-      - "-N"
-      - "-A16m"
-      - "-T"
-      - "-RTS"
-    volumes:
-      - ./results:/results
-
-volumes:
-  pgdata:

bench/init.sql

@@ -1,2 +0,0 @@
-CREATE EXTENSION IF NOT EXISTS pgcrypto;
-CREATE SCHEMA IF NOT EXISTS smp_server;

bench/run.sh

@@ -1,60 +0,0 @@
-#!/bin/bash
-set -e
-cd "$(dirname "$0")"
-
-mkdir -p results
-
-reset_db() {
-  docker compose down -v 2>/dev/null || true
-  docker compose up -d --wait postgres
-  echo "PostgreSQL ready."
-}
-
-if [ "$1" = "--compare-rts" ]; then
-  shift
-  docker compose build bench
-  for label_flags in \
-    "default:-N -A16m -T" \
-    "F1.2:-N -A16m -F1.2 -T" \
-    "F1.5:-N -A16m -F1.5 -T" \
-    "A4m:-N -A4m -T" \
-    "A4m-F1.2:-N -A4m -F1.2 -T" \
-    "compact:-N -A16m -c -T" \
-    "nonmoving:-N -A16m -xn -T"; do
-    label="${label_flags%%:*}"
-    flags="${label_flags#*:}"
-    echo ""
-    echo "=========================================="
-    echo "  RTS config: $label ($flags)"
-    echo "=========================================="
-    reset_db
-    docker compose run --rm \
-      -e BENCH_CLIENTS="${BENCH_CLIENTS:-1000}" \
-      -e BENCH_MINUTES="${BENCH_MINUTES:-2}" \
-      bench \
-      --pg "postgresql://smp@postgres/smp_bench" \
-      --clients "${BENCH_CLIENTS:-1000}" \
-      --minutes "${BENCH_MINUTES:-2}" \
-      --timeseries "/results/bench-${label}.csv" \
-      "$@" \
-      +RTS $flags -RTS
-  done
-  echo ""
-  echo "Done. Results in bench/results/"
-elif [ "$1" = "--local" ]; then
-  # Run natively (not in container) — requires local Postgres
-  shift
-  reset_db
-  cabal run smp-server-bench -f server_postgres -- \
-    --pg "postgresql://smp@localhost:15432/smp_bench" \
-    --clients "${BENCH_CLIENTS:-5000}" \
-    --minutes "${BENCH_MINUTES:-5}" \
-    "$@" \
-    +RTS -N -A16m -s -RTS
-else
-  # Run fully in containers
-  reset_db
-  docker compose run --rm bench "$@"
-fi
-
-docker compose down

cabal.project

@@ -4,15 +4,6 @@ packages: .
 -- packages: . ../http2
 -- packages: . ../network-transport
 
--- uncomment two sections below to run tests with coverage
--- package *
-   -- coverage: True
-   -- library-coverage: True
-
--- package attoparsec
-   -- coverage: False
-   -- library-coverage: False
-
 index-state: 2023-12-12T00:00:00Z
 
 package cryptostore
@@ -37,17 +28,3 @@ source-repository-package
     type: git
     location: https://github.com/simplex-chat/sqlcipher-simple.git
     tag: a46bd361a19376c5211f1058908fc0ae6bf42446
-
--- waiting for published warp-tls-3.4.7
-source-repository-package
-    type: git
-    location: https://github.com/yesodweb/wai.git
-    tag: ec5e017d896a78e787a5acea62b37a4e677dec2e
-    subdir: warp-tls
-
--- backported fork due http-5.0
-source-repository-package
-    type: git
-    location: https://github.com/simplex-chat/wai.git
-    tag: 2f6e5aa5f05ba9140ac99e195ee647b4f7d926b0
-    subdir: warp

contributing/CODE.md

@@ -1,104 +0,0 @@
-# Coding and building
-
-This file provides guidance on coding style and approaches and on building the code.
-
-## Code Security
-
-When designing code and planning implementations:
-- Apply adversarial thinking, and consider what may happen if one of the communicating parties is malicious.
-- Formulate an explicit threat model for each change - who can do which undesirable things and under which circumstances.
-
-## Code Quality Standards
-
-Haskell client and server code serves as system specification, not just implementation — we use type-driven design to reflect the business domain in types. Quality, conciseness, and clarity of Haskell code are critical.
-
-## Code Style, Formatting and Approaches
-
-The project uses **fourmolu** for Haskell code formatting. Configuration is in `fourmolu.yaml`.
-
-**Key formatting rules:**
-- 2-space indentation
-- Trailing function arrows, commas, and import/export style
-- Record brace without space: `{field = value}`
-- Single newline between declarations
-- Never use unicode symbols
-- Inline `let` style with right-aligned `in`
-
-**Format code before committing:**
-
-```bash
-# Format a single file
-fourmolu -i src/Simplex/Messaging/Protocol.hs
-```
-
-Some files that use CPP language extension cannot be formatted as a whole, so individual code fragments need to be formatted.
-
-**Follow existing code patterns:**
-- Match the style of surrounding code
-- Use qualified imports with short aliases (e.g., `import qualified Data.ByteString.Char8 as B`)
-- Use record syntax for types with multiple fields
-- Prefer explicit pattern matching over partial functions
-
-**Comments policy:**
-- Avoid redundant comments that restate what the code already says
-- Only comment on non-obvious design decisions or tricky implementation details
-- Function names and type signatures should be self-documenting
-- Do not add comments like "wire format encoding" (Encoding class is always wire format) or "check if X" when the function name already says that
-- Assume a competent Haskell reader
-
-**Diff and refactoring:**
-- Avoid unnecessary changes and code movements
-- Never do refactoring unless it substantially reduces cost of solving the current problem, including the cost of refactoring
-- Aim to minimize the code changes - do what is minimally required to solve users' problems
-
-**Document and code structure:**
-- **Never move existing code or sections around** - add new content at appropriate locations without reorganizing existing structure.
-- When adding new sections to documents, continue the existing numbering scheme.
-- Minimize diff size - prefer small, targeted changes over reorganization.
-
-**Code analysis and review:**
-- Trace data flows end-to-end: from origin, through storage/parameters, to consumption. Flag values that are discarded and reconstructed from partial data (e.g. extracted from a URI missing original fields) — this is usually a bug.
-- Read implementations of called functions, not just signatures — if duplication involves a called function, check whether decomposing it resolves the duplication.
-- Do not save time on analysis. Read every function in the data flow even when the interface seems clear — wrong assumptions about internals are the main source of missed bugs.
-
-### Haskell Extensions
-- `StrictData` enabled by default
-- Use STM for safe concurrency
-- Assume concurrency in PostgreSQL queries
-- Comprehensive warning flags with strict pattern matching
-
-## Build Commands
-
-```bash
-# Standard build
-cabal build
-
-# Fast build
-cabal build --ghc-options -O0
-
-# Build specific executables
-cabal build exe:smp-server exe:xftp-server exe:ntf-server exe:xftp
-
-# Build with PostgreSQL server support
-cabal build -fserver_postgres
-
-# Client-only library build (no server code)
-cabal build -fclient_library
-
-# Find binary location
-cabal list-bin exe:smp-server
-```
-
-### Cabal Flags
-
-- `swift`: Enable Swift JSON format
-- `client_library`: Build without server code
-- `client_postgres`: Use PostgreSQL instead of SQLite for agent persistence
-- `server_postgres`: PostgreSQL support for server queue/notification store
-
-## External Dependencies
-
-Custom forks specified in `cabal.project`:
-- `aeson`, `hs-socks` (SimpleX forks)
-- `direct-sqlcipher`, `sqlcipher-simple` (encrypted SQLite)
-- `warp`, `warp-tls` (HTTP server)

contributing/PROJECT.md

@@ -1,105 +0,0 @@
-# SimpleXMQ repository
-
-This file provides guidance on the project structure to help working with code in this repository.
-
-## Project Overview
-
-SimpleXMQ is a Haskell message broker implementing unidirectional (simplex) queues for privacy-preserving messaging. 
-
-Key components:
-
-- **SimpleX Messaging Protocol**: SMP protocol definition and encodings ([code](../src/Simplex/Messaging/Protocol.hs), [transport code](../src/Simplex/Messaging/Transport.hs), [spec](../protocol/simplex-messaging.md)).
-- **SMP Server**: Message broker with TLS, in-memory queues, optional persistence ([main code](../src/Simplex/Messaging/Server.hs), [all code files](../src/Simplex/Messaging/Server/), [executable](../apps/smp-server/)). For proxying SMP commands the server uses [lightweight SMP client](../src/Simplex/Messaging/Client/Agent.hs).
-- **SMP Client**: Functional API with STM-based message delivery ([code](../src/Simplex/Messaging/Client.hs)).
-- **SMP Agent**: High-level duplex connections via multiple simplex queues with E2E encryption ([code](../src/Simplex/Messaging/Agent.hs)). Implements Agent-to-agent protocol ([code](../src/Simplex/Messaging/Agent/Protocol.hs), [spec](../protocol/agent-protocol.md)) via intermediary agent client ([code](../src/Simplex/Messaging/Agent/Client.hs)).
-- **XFTP**: SimpleX File Transfer Protocol, server and CLI client ([code](../src/Simplex/FileTransfer/), [spec](../protocol/xftp.md)).
-- **XRCP**: SimpleX Remote Control Protocol ([code](`../src/Simplex/RemoteControl/`), [spec](../protocol/xrcp.md)).
-- **Notifications**: Push notifications server requires PostgreSQL ([code](../src/Simplex/Messaging/Notifications), [executable](../apps/ntf-server/)). Client protocol is used for clients to communicate with the server ([code](../src/Simplex/Messaging/Notifications/Protocol.hs), [spec](../protocol/push-notifications.md)). For subscribing to SMP notifications the server uses [lightweight SMP client](../src/Simplex/Messaging/Client/Agent.hs).
-
-## Architecture
-
-For general overview see `../protocol/overview-tjr.md`.
-
-SMP Protocol Layers:
-
-```
-TLS Transport → SMP Protocol → Agent Protocol → Application protocol
-```
-
-XFTP Protocol Layers:
-
-```
-TLS Transport (HTTP2 encoding) → XFTP Protocol → Out-of-band file descriptions
-```
-
-## Key Patterns
-
-1. **Persistence**: All queue state managed via Software Transactional Memory or via PostgreSQL
-   - `Simplex.Messaging.Server.MsgStore.STM` - in-memory messages
-   - `Simplex.Messaging.Server.QueueStore.STM` - in-memory queue state
-   - `Simplex.Messaging.Server.MsgStore.Postgres` - message storage
-   - `Simplex.Messaging.Server.QueueStore.Postgres` - queue storage
-
-2. **Append-Only Store Log**: Optional persistence via journal for in-memory storage
-   - `Simplex.Messaging.Server.StoreLog` - queue creation log
-   - Compacted on restart
-
-3. **Agent Storage**:
-   - SQLite (default) or PostgreSQL
-   - Migrations in `src/Simplex/Messaging/Agent/Store/{SQLite,Postgres}/Migrations/`
-
-4. **Protocol Versioning**: All layers support version negotiation
-   - `Simplex.Messaging.Version` - version range utilities
-
-5. **Double Ratchet E2E**: Per-connection encryption
-   - `Simplex.Messaging.Crypto.Ratchet`
-   - SNTRUP761 post-quantum KEM (`src/Simplex/Messaging/Crypto/SNTRUP761/`)
-
-## Source Layout
-
-```
-src/Simplex/
-├── Messaging/
-│   ├── Agent.hs          # Main agent (~210KB)
-│   ├── Server.hs         # SMP server (~130KB)
-│   ├── Client.hs         # Client API (~65KB)
-│   ├── Protocol.hs       # Protocol types (~77KB)
-│   ├── Crypto.hs         # E2E encryption (~52KB)
-│   ├── Transport.hs      # Transport encoding over TLS
-│   ├── Agent/Store/      # SQLite/Postgres persistence
-│   ├── Server/           # Server internals (QueueStore, MsgStore, Control)
-│   └── Notifications/    # Push notification system
-├── FileTransfer/         # XFTP implementation for file transfers
-└── RemoteControl/        # XRCP implementation for device discovery & control
-```
-
-## Protocol Documentation
-
-- `protocol/overview-tjr.md`: SMP protocols stack overview
-- `protocol/simplex-messaging.md`: SMP protocol spec (v19)
-- `protocol/agent-protocol.md`: Agent protocol spec (v7)
-- `protocol/xftp.md`: File transfer protocol
-- `protocol/xrcp.md`: Remote control protocol
-- `rfcs/`: Design RFCs for features
-
-## Testing
-
-```bash
-# Run all tests
-cabal test --test-show-details=streaming
-
-# Run specific test group (uses HSpec)
-cabal test --test-option=--match="/Core tests/Encryption tests/"
-
-# Run single test
-cabal test --test-option=--match="/SMP client agent/functional API/"
-```
-
-Tests require PostgreSQL running on `localhost:5432` when using `-fserver_postgres` or `-fclient_postgres`.
-
-Test files are in `tests/` with structure:
-- `Test.hs`: Main runner
-- `AgentTests/`: Agent protocol and connection tests
-- `CoreTests/`: Crypto, encoding, storage tests
-- `ServerTests.hs`: SMP server tests
-- `XFTPServerTests.hs`: File transfer tests

contributing/README.md

@@ -1,23 +0,0 @@
-# Contributing to SimpleX repositories
-
-## Focus on user problems
-
-We do not make code changes to improve code - any change must address a specific user problem or request.
-
-## Discuss the plans as early as possible
-
-Please discuss the problem you want to solve and your detailed implementation plan with the project team prior to contributing, to avoid wasted time and additional changes. Acceptance of your contribution depends on your willingness and ability to iterate the proposed contribution to achieve the required quality level, coding style, test coverage, and alignment with user requirements as they are understood by the project team.
-
-## Follow project structure, coding style and approaches
-
-./PROJECT.md has information about the structure of this `simplexmq` repository.
-
-./CODE.md has details about general requirements common for `simplexmq` and `simplex-chat` repositories.
-
-This files can be used with LLM prompts, e.g. if you use Claude Code you can create CLAUDE.md file in project root importing content from these files:
-
-```markdown
-@README.md
-@contributing/PROJECT.md
-@contributing/CODE.md
-```

docs/plans/memory-analysis-results.md

@@ -1,100 +0,0 @@
-## Memory Diagnostics Results
-
-### Data Collection
-
-Server: smp19.simplex.im, PostgreSQL backend, `useCache = False`
-RTS flags: `+RTS -N -A16m -I0.01 -Iw15 -s -RTS` (16 cores)
-
-### Mar 20 Data (1 hour, 07:19-08:19)
-
-```
-Time    rts_live  rts_heap  rts_large  rts_frag   clients  non-large
-07:19    7.5 GB    8.2 GB    5.5 GB    0.03 GB    14,000    2.0 GB
-07:24    6.4 GB   10.8 GB    5.2 GB    3.6 GB     14,806    1.2 GB
-07:29    8.2 GB   10.8 GB    6.5 GB    1.8 GB     15,667    1.7 GB
-07:34   10.0 GB   12.3 GB    7.9 GB    1.4 GB     15,845    2.1 GB
-07:39    6.7 GB   13.0 GB    5.3 GB    5.6 GB     16,589    1.4 GB
-07:44    8.5 GB   13.0 GB    6.7 GB    3.7 GB     16,283    1.8 GB
-07:49    6.5 GB   13.0 GB    5.2 GB    5.8 GB     16,532    1.3 GB
-07:54    6.0 GB   13.0 GB    4.8 GB    6.3 GB     16,636    1.2 GB
-07:59    6.4 GB   13.0 GB    5.1 GB    5.9 GB     16,769    1.3 GB
-08:04    8.3 GB   13.0 GB    6.5 GB    3.9 GB     17,352    1.8 GB
-08:09   10.2 GB   13.0 GB    8.0 GB    1.9 GB     17,053    2.2 GB
-08:14    5.6 GB   13.0 GB    4.5 GB    6.8 GB     17,147    1.1 GB
-08:19    7.6 GB   13.0 GB    6.1 GB    4.6 GB     17,496    1.5 GB
-```
-
-non-large = rts_live - rts_large (normal Haskell heap objects: Maps, TVars, closures)
-
-### Mar 19 Data (5.5 hours, 07:49-13:19)
-
-rts_heap grew from 10.1 GB to 20.7 GB over 5.5 hours.
-Post-GC rts_live floor rose from 5.5 GB to 9.1 GB.
-
-### Findings
-
-**1. Large/pinned objects dominate live data (60-80%)**
-
-`rts_large` = 4.5-8.0 GB out of 5.6-10.2 GB live. These are allocations > ~3KB that go on GHC's large object heap. They oscillate (not growing monotonically), meaning they are being allocated and freed constantly — transient, not leaked.
-
-**2. Fragmentation is the heap growth mechanism**
-
-`rts_heap ≈ rts_live + rts_frag`. The heap grows because pinned/large objects fragment GHC's block allocator. Once GHC expands the heap, it never shrinks. Growth pattern:
-- Large objects allocated → occupy blocks
-- Large objects freed → blocks can't be reused if ANY other object shares the block
-- New allocations need fresh blocks → heap expands
-- Heap never returns memory to OS
-
-**3. Non-large heap data is stable (~1.0-2.2 GB)**
-
-Normal Haskell objects (Maps, TVars, closures, client structures) account for only 1-2 GB. This scales with client count at ~100-130 KB/client and does NOT grow over time.
-
-**4. All tracked data structures are NOT the cause**
-
-- `clientSndQ=0, clientMsgQ=0` — TBQueues empty, no message accumulation
-- `smpQSubs` oscillates ~1.0-1.4M — entries are cleaned up, not leaking
-- `ntfStore` < 2K entries — negligible
-- All proxy agent maps near 0
-- `loadedQ=0` — useCache=False confirmed working
-
-**5. Source of large objects is unclear without heap profiling**
-
-The 4.5-8.0 GB of large objects could come from:
-- PostgreSQL driver (`postgresql-simple`/`libpq`) — pinned ByteStrings for query results
-- TLS library (`tls`) — pinned buffers per connection
-- Network socket I/O — pinned ByteStrings for recv/send
-- SMP protocol message blocks
-
-Cannot distinguish between these without `-hT` heap profiling (which is too expensive for this server).
-
-### Root Cause
-
-**GHC heap fragmentation from constant churn of large/pinned ByteString allocations.**
-
-Not a data structure leak. The live data itself is reasonable (5-10 GB for 15-17K clients). The problem is that GHC's copying GC cannot compact around pinned objects, so the heap grows with fragmentation and never shrinks.
-
-### Mitigation Options
-
-All are RTS flag changes — no rebuild needed, reversible by restart.
-
-**1. `-F1.2`** (reduce GC trigger factor from default 2.0)
-- Triggers major GC when heap reaches 1.2x live data instead of 2x
-- Reclaims fragmented blocks sooner
-- Trade-off: more frequent GC, slightly higher CPU
-- Risk: low — just makes GC run more often
-
-**2. Reduce `-A16m` to `-A4m`** (smaller nursery)
-- More frequent minor GC → short-lived pinned objects freed faster
-- Trade-off: more GC cycles, but each is smaller
-- Risk: low — may actually improve latency by reducing GC pause times
-
-**3. `+RTS -xn`** (nonmoving GC)
-- Designed for pinned-heavy workloads — avoids copying entirely
-- Available since GHC 8.10, improved in 9.x
-- Trade-off: different GC characteristics, less battle-tested
-- Risk: medium — different GC algorithm, should test first
-
-**4. Limit concurrent connections** (application-level)
-- Since large objects scale per-client, fewer clients = less fragmentation
-- Trade-off: reduced capacity
-- Risk: low but impacts users

docs/plans/memory-analysis.md

@@ -1,225 +0,0 @@
-## Root Cause Analysis: SMP Server Memory Growth (23.5GB)
-
-### Environment
-
-- **Server**: smp19.simplex.im, ~21,927 connected clients
-- **Storage**: PostgreSQL backend with `useCache = False`
-- **RTS flags**: `+RTS -N -A16m -I0.01 -Iw15 -s -RTS` (16 cores)
-- **Memory**: 23.5GB RES / 1031GB VIRT (75% of available RAM)
-
-### Log Summary
-
-- **Duration**: ~22 hours (Mar 16 12:12 → Mar 17 10:20)
-- **92,277 proxy connection errors** out of 92,656 total log lines (99.6%)
-- **292 unique failing destination servers**, top offender: `nowhere.moe` (12,875 errors)
-- Only **145 successful proxy connections**
-
----
-
-### Known Factor: GHC Heap Sizing
-
-With 16 cores and `-A16m`:
-- **Nursery**: 16 × 16MB = **256MB baseline**
-- GHC default major GC threshold = **2× live data** — if live data is 10GB, heap grows to ~20GB before major GC
-- The server is rarely idle with 22K clients, so major GC is deferred despite `-I0.01`
-- This is an amplifier — whatever the actual live data size is, GHC roughly doubles it
-
----
-
-### Candidate Structures That Could Grow Unboundedly
-
-Analysis of the full codebase identified these structures that either grow without bound or have uncertain cleanup:
-
-#### 1. `SubscribedClients` maps — `Env/STM.hs:378`
-
-Both `subscribers.queueSubscribers` and `ntfSubscribers.queueSubscribers` (and their `serviceSubscribers`) use `SubscribedClients (TMap EntityId (TVar (Maybe (Client s))))`.
-
-Comment at line 376: *"The subscriptions that were made at any point are not removed"*
-
-`deleteSubcribedClient` IS called on disconnect (Server.hs:1112) and DOES call `TM.delete`. But it only deletes if the current stored client matches — if another client already re-subscribed, the old client's disconnect won't remove the entry. This is by design for mobile client continuity, but the net effect on map size over time is unclear without measurement.
-
-#### 2. ProxyAgent's subscription TMaps — `Client/Agent.hs:145-151`
-
-The `SMPClientAgent` has 4 TMaps that accumulate one top-level entry per unique destination server and **never remove** them:
-
-- `activeServiceSubs :: TMap SMPServer (TVar ...)` (line 145)
-- `activeQueueSubs :: TMap SMPServer (TMap QueueId ...)` (line 146)
-- `pendingServiceSubs :: TMap SMPServer (TVar ...)` (line 149)
-- `pendingQueueSubs :: TMap SMPServer (TMap QueueId ...)` (line 150)
-
-Comment at line 262: *"these vars are never removed, they are only added"*
-
-These are only used for the proxy agent (SParty 'Sender), so they grow with each unique destination SMP server proxied to. With 292 unique servers in this log period, these are likely small — but long-running servers may accumulate thousands.
-
-`closeSMPClientAgent` (line 369) does NOT clear these 4 maps.
-
-#### 3. `NtfStore` — `NtfStore.hs:26`
-
-`NtfStore (TMap NotifierId (TVar [MsgNtf]))` — one entry per NotifierId.
-
-`deleteExpiredNtfs` (line 47) filters expired notifications from lists but does **not remove entries with empty lists** from the TMap. Over time, NotifierIds that no longer receive notifications leave zombie `TVar []` entries.
-
-`deleteNtfs` (line 44) does remove the full entry via `TM.lookupDelete` — but only called when a notifier is explicitly deleted.
-
-#### 4. `serviceLocks` in PostgresQueueStore — `Postgres.hs:112,469`
-
-`serviceLocks :: TMap CertFingerprint Lock` — one Lock per unique certificate fingerprint.
-
-`getCreateService` (line 469) calls `withLockMap (serviceLocks st) fp` which calls `getMapLock` (Agent/Client.hs:1029-1032) — this **unconditionally inserts** a Lock into the TMap. There is **no cleanup code** for serviceLocks anywhere. This is NOT guarded by `useCache`.
-
-#### 5. `sentCommands` per proxy client connection — `Client.hs:580`
-
-Each `PClient` has `sentCommands :: TMap CorrId (Request err msg)`. Entries are added per command sent (line 1369) and only removed when a response arrives (line 698). If a connection drops before all responses arrive, entries remain until the `PClient` is GC'd. Since `PClient` is captured by the connection thread which terminates on error, the `PClient` should become GC-eligible — but GC timing depends on heap pressure.
-
-#### 6. `subQ :: TQueue (ClientSub, ClientId)` — `Env/STM.hs:363`
-
-Unbounded `TQueue` for subscription changes. If the subscriber thread (`serverThread`) can't process changes fast enough, this queue grows without backpressure. With 22K clients subscribing/unsubscribing, sustained bursts could cause this queue to bloat.
-
----
-
-### Ruled Out
-
-1. **PostgreSQL queue cache**: `useCache = False` — `queues`, `senders`, `links`, `notifiers` TMaps are empty.
-2. **`notifierLocks`**: Guarded by `useCache` (Postgres.hs:377,405) — not used with `useCache = False`.
-3. **Client structures**: 22K × ~3KB = ~66MB — negligible.
-4. **TBQueues**: Bounded (`tbqSize = 128`).
-5. **Thread management**: `forkClient` uses weak refs + `finally` blocks. `endThreads` cleared on disconnect.
-6. **Proxy `smpClients`/`smpSessions`**: Properly cleaned on disconnect/expiry.
-7. **`smpSubWorkers`**: Properly cleaned on worker completion; also cleared in `closeSMPClientAgent`.
-8. **`pendingEvents`**: Atomically swapped empty every `pendingENDInterval`.
-9. **Stats IORef counters**: Fixed number, bounded.
-10. **DB connection pool**: Bounded `TBQueue` with bracket-based return.
-
----
-
-### Insufficient Data to Determine Root Cause
-
-Without measuring the actual sizes of these structures at runtime, we cannot determine which (if any) is the primary contributor. The following exact logging changes will identify the root cause.
-
----
-
-### EXACT LOGS TO ADD
-
-Add a new periodic logging thread in `src/Simplex/Messaging/Server.hs`.
-
-Insert at `Server.hs:197` (after `prometheusMetricsThread_`):
-
-```haskell
-        <> memoryDiagThread_ cfg
-```
-
-Then define:
-
-```haskell
-    memoryDiagThread_ :: ServerConfig s -> [M s ()]
-    memoryDiagThread_ ServerConfig {prometheusInterval = Just _} =
-      [memoryDiagThread]
-    memoryDiagThread_ _ = []
-
-    memoryDiagThread :: M s ()
-    memoryDiagThread = do
-      labelMyThread "memoryDiag"
-      Env { ntfStore = NtfStore ntfMap
-          , server = srv@Server {subscribers, ntfSubscribers}
-          , proxyAgent = ProxyAgent {smpAgent = pa}
-          , msgStore_ = ms
-          } <- ask
-      let interval = 300_000_000 -- 5 minutes
-      liftIO $ forever $ do
-        threadDelay interval
-        -- GHC RTS stats
-        rts <- getRTSStats
-        let liveBytes = gcdetails_live_bytes $ gc rts
-            heapSize = gcdetails_mem_in_use_bytes $ gc rts
-            gcCount = gcs rts
-        -- Server structures
-        clientCount <- IM.size <$> getServerClients srv
-        -- SubscribedClients (queue and service subscribers for both SMP and NTF)
-        smpQSubs <- M.size <$> getSubscribedClients (queueSubscribers subscribers)
-        smpSSubs <- M.size <$> getSubscribedClients (serviceSubscribers subscribers)
-        ntfQSubs <- M.size <$> getSubscribedClients (queueSubscribers ntfSubscribers)
-        ntfSSubs <- M.size <$> getSubscribedClients (serviceSubscribers ntfSubscribers)
-        -- Pending events
-        smpPending <- IM.size <$> readTVarIO (pendingEvents subscribers)
-        ntfPending <- IM.size <$> readTVarIO (pendingEvents ntfSubscribers)
-        -- NtfStore
-        ntfStoreSize <- M.size <$> readTVarIO ntfMap
-        -- ProxyAgent maps
-        let SMPClientAgent {smpClients, smpSessions, activeServiceSubs, activeQueueSubs, pendingServiceSubs, pendingQueueSubs, smpSubWorkers} = pa
-        paClients <- M.size <$> readTVarIO smpClients
-        paSessions <- M.size <$> readTVarIO smpSessions
-        paActSvc <- M.size <$> readTVarIO activeServiceSubs
-        paActQ <- M.size <$> readTVarIO activeQueueSubs
-        paPndSvc <- M.size <$> readTVarIO pendingServiceSubs
-        paPndQ <- M.size <$> readTVarIO pendingQueueSubs
-        paWorkers <- M.size <$> readTVarIO smpSubWorkers
-        -- Loaded queue counts
-        lc <- loadedQueueCounts $ fromMsgStore ms
-        -- Log everything
-        logInfo $
-          "MEMORY "
-            <> "rts_live=" <> tshow liveBytes
-            <> " rts_heap=" <> tshow heapSize
-            <> " rts_gc=" <> tshow gcCount
-            <> " clients=" <> tshow clientCount
-            <> " smpQSubs=" <> tshow smpQSubs
-            <> " smpSSubs=" <> tshow smpSSubs
-            <> " ntfQSubs=" <> tshow ntfQSubs
-            <> " ntfSSubs=" <> tshow ntfSSubs
-            <> " smpPending=" <> tshow smpPending
-            <> " ntfPending=" <> tshow ntfPending
-            <> " ntfStore=" <> tshow ntfStoreSize
-            <> " paClients=" <> tshow paClients
-            <> " paSessions=" <> tshow paSessions
-            <> " paActSvc=" <> tshow paActSvc
-            <> " paActQ=" <> tshow paActQ
-            <> " paPndSvc=" <> tshow paPndSvc
-            <> " paPndQ=" <> tshow paPndQ
-            <> " paWorkers=" <> tshow paWorkers
-            <> " loadedQ=" <> tshow (loadedQueueCount lc)
-            <> " loadedNtf=" <> tshow (loadedNotifierCount lc)
-            <> " ntfLocks=" <> tshow (notifierLockCount lc)
-```
-
-Note: `smpSubs.subsCount` (queueSubscribers size) and `smpSubs.subServicesCount` (serviceSubscribers size) are **already logged** in Prometheus (lines 475-496). The log above adds all other candidate structures plus GHC RTS memory stats.
-
-This produces a single log line every 5 minutes:
-
-```
-[INFO] MEMORY rts_live=10737418240 rts_heap=23488102400 rts_gc=4521 clients=21927 smpQSubs=1847233 smpSSubs=42 ntfQSubs=982112 ntfSSubs=31 smpPending=0 ntfPending=0 ntfStore=512844 paClients=12 paSessions=12 paActSvc=0 paActQ=0 paPndSvc=0 paPndQ=0 paWorkers=3 loadedQ=0 loadedNtf=0 ntfLocks=0
-```
-
-### What Each Metric Tells Us
-
-| Metric | What it reveals | If growing = suspect |
-|--------|----------------|---------------------|
-| `rts_live` | Actual live data after last major GC | Baseline — everything else should add up to this |
-| `rts_heap` | Total heap (should be ~2× rts_live) | If >> 2× live, fragmentation issue |
-| `clients` | Connected client count | Known: ~22K |
-| `smpQSubs` | SubscribedClients map size (queue subs) | If >> clients × avg_subs, entries not cleaned |
-| `smpSSubs` | SubscribedClients map size (service subs) | Should be small |
-| `ntfQSubs` | NTF SubscribedClients map (queue subs) | Same concern as smpQSubs |
-| `ntfSSubs` | NTF SubscribedClients map (service subs) | Should be small |
-| `smpPending` / `ntfPending` | Pending END/DELD events per client | If large, subscriber thread lagging |
-| `ntfStore` | NotifierId count in NtfStore | If growing monotonically, zombie entries |
-| `paClients` | Proxy connections to other servers | Should be <= unique dest servers |
-| `paSessions` | Active proxy sessions | Should match paClients |
-| `paActSvc` / `paActQ` | Proxy active subscriptions | If growing, entries never removed |
-| `paPndSvc` / `paPndQ` | Proxy pending subscriptions | If growing, resubscription stuck |
-| `paWorkers` | Active reconnect workers | If growing, workers stuck in retry |
-| `loadedQ` | Cached queues in store (0 with useCache=False) | Should be 0 |
-| `ntfLocks` | Notifier locks in store | Should be 0 with useCache=False |
-
-### Interpretation Guide
-
-**If `smpQSubs` is in the millions**: SubscribedClients is the primary leak. Entries accumulate for every queue ever subscribed to.
-
-**If `ntfStore` grows monotonically**: Zombie notification entries (empty lists after expiration). Fix: `deleteExpiredNtfs` should remove entries with empty lists.
-
-**If `paActSvc` + `paActQ` grow**: Proxy agent subscription maps are the leak. Fix: add cleanup when no active/pending subs exist for a server.
-
-**If `rts_live` is much smaller than `rts_heap`**: GHC heap fragmentation. Fix: tune `-F` flag (GC trigger factor) or use `-c` (compacting GC).
-
-**If `rts_live` ~ 10-12GB**: The live data is genuinely large. Look at which metric is the largest contributor.
-
-**If nothing above is large but `rts_live` is large**: The leak is in a structure not measured here — likely TLS connection buffers, ByteString retention from Postgres queries, or GHC runtime overhead. Next step would be heap profiling with `-hT`.

install.sh

@@ -2,6 +2,10 @@
 set -eu
 
 # Links to scripts/configs
+bin="https://github.com/simplex-chat/simplexmq/releases/latest/download"
+bin_smp="$bin/smp-server-ubuntu-20_04-x86-64"
+bin_xftp="$bin/xftp-server-ubuntu-20_04-x86-64"
+
 scripts="https://raw.githubusercontent.com/simplex-chat/simplexmq/stable/scripts/main"
 scripts_systemd_smp="$scripts/smp-server.service"
 scripts_systemd_xftp="$scripts/xftp-server.service"
@@ -22,8 +26,6 @@ path_conf_var="/var/opt"
 path_conf_smp="$path_conf_etc/simplex $path_conf_var/simplex"
 path_conf_xftp="$path_conf_etc/simplex-xftp $path_conf_var/simplex-xftp /srv/xftp"
 
-path_conf_info="$path_conf_etc/simplex-info"
-
 path_systemd="/etc/systemd/system"
 path_systemd_smp="$path_systemd/smp-server.service"
 path_systemd_xftp="$path_systemd/xftp-server.service"
@@ -54,7 +56,7 @@ ${GRN}1.${NC} Install latest binaries from GitHub releases:
 ${GRN}2.${NC} Create server directories:
     - smp: ${YLW}${path_conf_smp}${NC}
     - xftp: ${YLW}${path_conf_xftp}${NC}
-${GRN}3.${NC} Setup user for server:
+${GRN}3.${NC} Setup user for each server:
     - xmp: ${YLW}${user_smp}${NC}
     - xftp: ${YLW}${user_xftp}${NC}
 ${GRN}4.${NC} Create systemd services:
@@ -63,12 +65,7 @@ ${GRN}4.${NC} Create systemd services:
 ${GRN}5.${NC} Install stopscript (systemd), update and uninstallation script:
     - all: ${YLW}${path_bin_update}${NC}, ${YLW}${path_bin_uninstall}${NC}, ${YLW}${path_bin_stopscript}${NC}
 
-Press:
-  - ${GRN}1${NC} to install smp server
-  - ${GRN}2${NC} to install xftp server
-  - ${RED}Ctrl+C${NC} to cancel installation
-  
-Selection: "
+Press ${GRN}ENTER${NC} to continue or ${RED}Ctrl+C${NC} to cancel installation"
 
 end="Installtion is complete!
 
@@ -79,79 +76,27 @@ Please checkout our server guides:
 To uninstall with full clean-up, simply run: ${YLW}sudo /usr/local/bin/simplex-servers-uninstall${NC}
 "
 
-set_version() {
-  ver="${VER:-latest}"
-
-  case "$ver" in 
-    latest)
-      bin="https://github.com/simplex-chat/simplexmq/releases/latest/download"
-      remote_version="$(curl --proto '=https' --tlsv1.2 -sSf -L https://api.github.com/repos/simplex-chat/simplexmq/releases/latest | grep -i "tag_name" | awk -F \" '{print $4}')"
-      ;;
-    *)
-      bin="https://github.com/simplex-chat/simplexmq/releases/download/${ver}"
-      remote_version="${ver}"
-      ;;
-  esac
-}
-
-os_test() {
- . /etc/os-release
-
- case "$VERSION_ID" in
-  20.04|22.04) : ;;
-  24.04) VERSION_ID='22.04' ;;
-  *) printf "${RED}Unsupported Ubuntu version!${NC}\nPlease file Github issue with request to support Ubuntu %s: https://github.com/simplex-chat/simplexmq/issues/new\n" "$VERSION_ID" && exit 1 ;;
- esac
-
- version="$(printf '%s' "$VERSION_ID" | tr '.' '_')"
- arch="$(uname -p)"
-
- case "$arch" in
-  x86_64) arch="$(printf '%s' "$arch" | tr '_' '-')" ;;
-  *)  printf "${RED}Unsupported architecture!${NC}\nPlease file Github issue with request to support %s architecture: https://github.com/simplex-chat/simplexmq/issues/new" "$arch" && exit 1 ;;
- esac
-
- bin_smp="$bin/smp-server-ubuntu-${version}-${arch}"
- bin_xftp="$bin/xftp-server-ubuntu-${version}-${arch}"
-}
-
 setup_bins() {
- eval "bin=\$bin_${1}"
- eval "path=\$path_bin_${1}"
-
- curl --proto '=https' --tlsv1.2 -sSf -L "$bin" -o "$path" && chmod +x "$path"
-
- unset bin path
+ curl --proto '=https' --tlsv1.2 -sSf -L "$bin_smp" -o "$path_bin_smp" && chmod +x "$path_bin_smp"
+ curl --proto '=https' --tlsv1.2 -sSf -L "$bin_xftp" -o "$path_bin_xftp" && chmod +x "$path_bin_xftp"
 }
 
 setup_users() {
- eval "user=\$user_${1}"
-
- useradd -M "$user" 2> /dev/null || true
-
- unset user
+ useradd -M "$user_smp" 2> /dev/null || true
+ useradd -M "$user_xftp" 2> /dev/null || true
 }
 
 setup_dirs() {
  # Unquoted varibles, so field splitting can occur
- eval "path_conf=\$path_conf_${1}"
- eval "user=\$user_${1}"
-
- mkdir -p $path_conf
- mkdir -p $path_conf_info
- printf "local_version_%s='%s'\n" "$1" "$remote_version" >> "$path_conf_info/release"
- chown -R "$user":"$user" $path_conf
-
- unset path_conf user
+ mkdir -p $path_conf_smp
+ chown "$user_smp":"$user_smp" $path_conf_smp
+ mkdir -p $path_conf_xftp
+ chown "$user_xftp":"$user_xftp" $path_conf_xftp
 }
 
 setup_systemd() {
- eval "scripts_systemd=\$scripts_systemd_${1}"
- eval "path_systemd=\$path_systemd_${1}"
-
- curl --proto '=https' --tlsv1.2 -sSf -L "$scripts_systemd" -o "$path_systemd"
-
- unset scripts_systemd path_systemd
+ curl --proto '=https' --tlsv1.2 -sSf -L "$scripts_systemd_smp" -o "$path_systemd_smp"
+ curl --proto '=https' --tlsv1.2 -sSf -L "$scripts_systemd_xftp" -o "$path_systemd_xftp"
 }
 
 setup_scripts() {
@@ -165,61 +110,32 @@ checks() {
   printf "This script is intended to be run with root privileges. Please re-run script using sudo."
   exit 1
  fi
- 
- set_version
- os_test
-
- mkdir -p $path_conf_info  
 }
 
 main() {
  checks
  
- printf "%b\n%b" "${BLU}$logo${NC}" "$welcome"
+ printf "%b\n%b\n" "${BLU}$logo${NC}" "$welcome"
  read ans
 
- case "$ans" in
-  1) setup='smp' ;;
-  2) setup='xftp' ;;
-  *) printf 'Installation aborted.\n' && exit 0 ;;
- esac
-
  printf "Installing binaries..."
- 
- for i in $setup; do
-  setup_bins "$i"
- done
- 
+ setup_bins
  printf "${GRN} Done!${NC}\n"
 
  printf "Creating users..."
-
- for i in $setup; do
-  setup_users "$i"
- done
-
+ setup_users
  printf "${GRN} Done!${NC}\n"
  
  printf "Creating directories..."
-
- for i in $setup; do
-  setup_dirs "$i"
- done
-
+ setup_dirs
  printf "${GRN} Done!${NC}\n"
 
  printf "Creating systemd services..."
-
- for i in $setup; do
-  setup_systemd "$i"
- done
-
+ setup_systemd
  printf "${GRN} Done!${NC}\n"
 
  printf "Installing stopscript, update and uninstallation script..."
-
  setup_scripts
-
  printf "${GRN} Done!${NC}\n"
 
  printf "%b" "$end"

package.yaml

@@ -0,0 +1,180 @@
+name: simplexmq
+version: 5.5.0.4
+synopsis: SimpleXMQ message broker
+description: |
+  This package includes <./docs/Simplex-Messaging-Server.html server>,
+  <./docs/Simplex-Messaging-Client.html client> and
+  <./docs/Simplex-Messaging-Agent.html agent> for SMP protocols:
+  .
+  * <https://github.com/simplex-chat/simplexmq/blob/master/protocol/simplex-messaging.md SMP protocol>
+  * <https://github.com/simplex-chat/simplexmq/blob/master/protocol/agent-protocol.md SMP agent protocol>
+  .
+  See <https://github.com/simplex-chat/simplex-chat terminal chat prototype> built with SimpleXMQ broker.
+
+homepage: https://github.com/simplex-chat/simplexmq#readme
+license: AGPL-3
+author: simplex.chat
+maintainer: chat@simplex.chat
+copyright: 2020-2022 simplex.chat
+category: Chat, Network, Web, System, Cryptography
+extra-source-files:
+  - README.md
+  - CHANGELOG.md
+  - cbits/sha512.h
+  - cbits/sntrup761.h
+
+dependencies:
+  - aeson == 2.2.*
+  - ansi-terminal >= 0.10 && < 0.12
+  - asn1-encoding == 0.9.*
+  - asn1-types == 0.3.*
+  - async == 2.2.*
+  - attoparsec == 0.14.*
+  - base >= 4.14 && < 5
+  - base64-bytestring >= 1.0 && < 1.3
+  - case-insensitive == 1.2.*
+  - composition == 1.0.*
+  - constraints >= 0.12 && < 0.14
+  - containers == 0.6.*
+  - crypton == 0.34.*
+  - crypton-x509 == 1.7.*
+  - crypton-x509-store == 1.6.*
+  - crypton-x509-validation == 1.6.*
+  - cryptostore == 0.3.*
+  - data-default == 0.7.*
+  - direct-sqlcipher == 2.3.*
+  - directory == 1.3.*
+  - filepath == 1.4.*
+  - hourglass == 0.2.*
+  - http-types == 0.12.*
+  - http2 >= 4.2.2 && < 4.3
+  - ini == 0.4.1
+  - iproute == 1.7.*
+  - iso8601-time == 0.1.*
+  - memory == 0.18.*
+  - mtl >= 2.3.1 && < 3.0
+  - network >= 3.1.2.7 && < 3.2
+  - network-info >= 0.2 && < 0.3
+  - network-transport == 0.5.6
+  - network-udp >= 0.0 && < 0.1
+  - optparse-applicative >= 0.15 && < 0.17
+  - process == 1.6.*
+  - random >= 1.1 && < 1.3
+  - simple-logger == 0.1.*
+  - socks == 0.6.*
+  - sqlcipher-simple == 0.4.*
+  - stm == 2.5.*
+  - temporary == 1.3.*
+  - time == 1.12.*
+  - time-manager == 0.0.*
+  - tls >= 1.7.0 && < 1.8
+  - transformers == 0.6.*
+  - unliftio == 0.2.*
+  - unliftio-core == 0.2.*
+  - websockets == 0.12.*
+  - yaml == 0.11.*
+
+flags:
+  swift:
+    description: Enable swift JSON format
+    manual: True
+    default: False
+  use_crypton:
+    description: Use crypton etc. in cryptostore
+    manual: True
+    default: True
+
+when:
+  - condition: flag(swift)
+    cpp-options:
+      - -DswiftJSON
+  - condition: impl(ghc >= 9.6.2)
+    dependencies:
+      - bytestring == 0.11.*
+      - template-haskell == 2.20.*
+      - text >= 2.0.1 && < 2.2
+  - condition: impl(ghc < 9.6.2)
+    dependencies:
+      - bytestring == 0.10.*
+      - template-haskell == 2.16.*
+      - text >= 1.2.3.0 && < 1.3
+
+library:
+  source-dirs: src
+  c-sources:
+    - cbits/sha512.c
+    - cbits/sntrup761.c
+  include-dirs: cbits
+  extra-libraries: crypto
+
+executables:
+  smp-server:
+    source-dirs: apps/smp-server
+    main: Main.hs
+    dependencies:
+      - simplexmq
+    ghc-options:
+      - -threaded
+      - -rtsopts
+
+  ntf-server:
+    source-dirs: apps/ntf-server
+    main: Main.hs
+    dependencies:
+      - simplexmq
+    ghc-options:
+      - -threaded
+      - -rtsopts
+
+  xftp-server:
+    source-dirs: apps/xftp-server
+    main: Main.hs
+    dependencies:
+      - simplexmq
+    ghc-options:
+      - -threaded
+      - -rtsopts
+
+  smp-agent:
+    source-dirs: apps/smp-agent
+    main: Main.hs
+    dependencies:
+      - simplexmq
+    ghc-options:
+      - -threaded
+      - -rtsopts
+
+  xftp:
+    source-dirs: apps/xftp
+    main: Main.hs
+    dependencies:
+      - simplexmq
+    ghc-options:
+      - -threaded
+      - -rtsopts
+
+tests:
+  simplexmq-test:
+    source-dirs: tests
+    main: Test.hs
+    dependencies:
+      - simplexmq
+      - deepseq == 1.4.*
+      - generic-random == 1.5.*
+      - hspec == 2.11.*
+      - hspec-core == 2.11.*
+      - HUnit == 1.6.*
+      - QuickCheck == 2.14.*
+      - silently == 1.2.*
+      - main-tester == 0.2.*
+      - timeit == 2.0.*
+
+ghc-options:
+  # - -haddock
+  - -Wall
+  - -Wcompat
+  - -Werror=incomplete-patterns
+  - -Wredundant-constraints
+  - -Wincomplete-record-updates
+  - -Wincomplete-uni-patterns
+  - -Wunused-type-patterns

plans/done/2024-09-01-smp-message-storage.md

@@ -1,180 +0,0 @@
-
-# SMP router message storage
-
-## Problem
-
-Currently SMP routers store all queues in router memory. As the traffic grows, so does the number of undelivered messages. What is worse, Haskell is not avoiding heap fragmentation when messages are allocated and then de-allocated - undelivered messages use ByteString and GC cannot move them around, as they use pinned memory.
-
-## Possible solutions
-
-### Solution 1: solve only GC fragmentation problem
-
-Move from ByteString to some other primitive to store messages in memory long term, e.g. ShortByteString, or manage allocation/de-allocation of stored messages manually in some other way.
-
-Pros: the simplest solution that avoids substantial re-engineering of the router.
-
-Cons:
-- not a long term solution, as memory growth still has limits.
-- may be ineffective, as it introduces additional copying of bytes.
-
-### Solution 2: move message storage to hard drive
-
-Use files or RocksDB to store messages.
-
-Pros:
-- much lower memory usage.
-- no message loss in case of abnormal router termination (important until clients have delivery redundancy).
-- this is a long term solution, and at some point it might need to be done anyway.
-
-Cons:
-- substantial re-engineering costs and risks.
-- metadata privacy. Currently we only save undelivered messages when router is restarted, with this approach all messages will be stored for some time. this argument is limited, as hosting providers of VMs can make memory snapshots too, on the other hand they are harder to analyze than files. On another hand, with this approach messages will be stored for a shorter time.
-
-#### RocksDB and other key-value stores
-
-The downside of any key-value stores is that they don't seem to have efficient primitives for sequential delivery. While sequential delivery can be modelled with linked lists, they would require 1 key insert (on send), 3 key updates (1 update to update queue data on send, 1 update of the last message to point to the next, 1 update on delivery or message expiration) and 1 key deletion (on delivery or message expiration) for each delivered message.
-
-This might result in substantial write amplification and compacting costs.
-
-In general, tree structures that are efficient for quick lookups and updates, given approximately fixed value size, are inefficient for modelling queues.
-
-#### Files
-
-The upside of files is that they are well suited for sequential delivery and don't result in the same churn, with careful design, as trees do.
-
-The downside of filesystem is that it does not scale well with the large number of files in a folder, so queues will have to be spread across multiple folders, following tree-like structure.
-
-I could not find an available library that efficiently models sequential delivery in highly concurrent environment.
-
-A possible design could be the following.
-
-##### Queue folder and files
-
-Each message queue is stored in its own folder (see below on folder locations). Folder would contain these files:
-
-- `messages.abcd.log` - the file that is used to read messages from, sequentially
-- `messages.efgh.log` - the optional file that is used to write messages, in case it is different from read file.
-- `queue.log` - append-only file where the last line represents the current queue state
-- `queue.timestamp.log` - previous states of queue.log file
-
-Each line in "queue.log" file has this syntax
-
-```abnf
-queueLogLine =
-    %s"read_file=" base64
-    %s"read_msg=" digits
-    %s"read_byte=" digits
-    %s"write_file=" base64
-    %s"write_msg=" digits
-```
-
-When queue is first requested by the router:
-
-```c
-if queue folder exists:
-    read queue state from last line of queue.log
-    if queue.log contained more than one line: // compaction
-        copy queue.log to queue.timestamp.log
-        write one line queue state to queue.log
-else:
-    create queue folder
-    create messages.abcd.log (abcd is some random string)
-    read_msg = 0
-    read_byte = 0
-    create queue.log with one line: "read_file=abcd read_msg=0 read_byte=0 write_files=abcd write_msg=0"
-open read_file in ReadMode and seek to read_byte position
-nextReadByte = read_byte
-nextReadMsg = read_msg
-open write_file in AppendMode
-```
-
-When message is added to the queue (assumes that queue state is loaded to router memory, if not the previous section will be done first):
-
-```c
-if write_msg > max_queue_messages:
-    return quota error
-else if write_msg = max_queue_messages:
-    add quota_exceeded message to write_file
-    update queue state: write_msg += 1
-    append updated queue state to queue.log
-else
-    // It is required that `max_queue_messages < max_file_messages`,
-    // so that we never need more than one additional write file.
-    if write_msg >= max_file_messages: // queue file rotation
-        create messages.efgh.log // efgh is some random string
-        update queue state: write_file=efgh write_msg=0 // read file remains the same as it was
-        append updated queue state to queue.log
-        copy queue.log to queue.timestamp.log
-        // `old` needs to be defined to limit the number and storage duration,
-        // preserving not more than N files, and not more than M days files, "and then some"
-        // (that is if the queue has high churn, we have file from M days before in any case, for any debugging).
-        delete `old` `queue.timestamp.log` files
-        write one line queue state to queue.log // compaction
-
-    add message to write_file
-    update queue state: write_msg += 1
-    append updated queue state to queue.log
-```
-
-The above algorithm assumes `max_queue_messages < than max_file_messages`, so that we never need more than one write file.
-
-When message is delivered, it is simply read from the read queue, queue state does not change yet:
-
-```c
-if nextReadMsg > read_msg:
-    deliver cached message, no need to read it again
-else
-    read message from read_file handle
-    nextReadMsg = read_msg + 1
-    nextReadByte = current position in file
-```
-
-When message delivery is acknowledged, the read queue needs to be advanced, and possibly switched to read from the current write queue:
-
-```c
-if nextReadByte == read_byte:
-    return error // nothing was delivered
-else if nextReadByte = EOF:
-    // end of file is reached, possibly some other condition,
-    // but it should allow changing max_file_messages on server restart
-    currReadFile = read_file
-    read_file = write_file
-    read_msg = 0
-    read_byte = 0
-    append updated queue state to queue.log
-    delete currReadFile
-else
-    read_msg += 1
-    read_byte = nextReadByte
-    // `seek` should not be necessary, as the handle is already at nextReadByte position here
-    // seek to read_byte
-    append updated queue state to queue.log
-```
-
-The above algorithm delegates the problem of compaction and fragmentation management to file system, that is very optimized for such scenarios.
-
-Also, read and write files will grow to almost a constant size, so the space they used may be re-used.
-
-An important consideration is that writes to queue.log and message.log files and queue state modifications have to be sequential, without concurrency - it can be managed with the usual locks.
-
-##### Queue folders structure
-
-Most Linux systems use EXT4 filesystem where the file lookup time scales linearly to the number of files. While alternatives with logarithmic lookup time exist (XFS), they may be very complex to configure on the existing systems.
-
-So storing all queue folders in one folder won't scale.
-
-To solve this problem we could use recipient queue ID in base64url format not as a folder name, but as a folder path, splitting it to path fragments of some length. The number of fragments can be configurable and migration to a different fragment size can be supported as the number of queues on a given router grows.
-
-Currently, queue ID is 24 bytes random number, thus allowing 2^192 possible queue IDs. If we assume that a router must hold 1b queues, it means that we have ~2^162 possible addresses for each existing queue. 24 bytes in base64 is 32 characters that can be split into say 8 fragments with 4 characters each, so that queue folder path for queue with ID `abcdefghijklmnopqrstuvwxyz012345` would be:
-
-`/var/opt/simplex/messages/abcd/efgh/ijkl/mnop/qrst/uvwx/yz01/2345`
-
-The maximum theoretic number of the folders on the 1st level is 64^4, or 2^24 ~ 16m - this is probably still a large number of subfolders for EXT4. Given that addresses are random, all the possible combinations in the first folder can be used with a large number of queues.
-
-So we could use an unequal split of path, two letters each and the last being long:
-
-`/var/opt/simplex/messages/ab/cd/ef/ghijklmnopqrstuvwxyz012345`
-
-The first three levels in this case can have 4096 subfolders each, and it gives 68b possible subfolders (64^2^3), so the last level will be sparse in case of 1b queues on the router. So we could make it 4 levels with 2 letters to never think about it, accounting for a large variance of the random numbers distribution:
-
-`/var/opt/simplex/messages/ab/cd/ef/gh/ijklmnopqrstuvwxyz012345`

plans/done/2024-09-15-shared-port.md

@@ -1,162 +0,0 @@
-
-# Sharing protocol ports with HTTPS
-
-Some networks block all ports other than web ports, including port 5223 used for SMP protocol by default. Running SMP routers on a common web port 443 would allow them to work on more networks. The routers would need to provide an HTTPS page for browsers (and probes).
-
-## Problem
-
-Browsers and tools rely on system CA bundles instead of certificate pinning.
-The crypto parameters used by HTTPS are different from what the protocols use.
-Public certificate providers like LetsEncrypt can only sign specific types of keys and Ed25519 isn't one of them.
-
-This means a router should distinguish browser and protocol clients and adjust its behavior to match.
-
-## Solution
-
-`tls` package has a server hook that allows producing a different set of `TLS.Credentials` according to a client-provided "Server Name Indication" extension.
-
-Since LE certificates are only handed out to domain names, TLS client will be sending the SNI.
-However client transports are constructed over connected sockets and the SNI wouldn't be present unless explicitly requested.
-When a client sends SNI, then it's a browser and web credentials should be used.
-Otherwise it's a protocol client to be offered the self-signed ca, cert and key.
-
-When a transport colocated with a HTTPS, its ALPN list should be extended with `h2 http/1.1`.
-The browsers will send it, and it should be checked before running transport client.
-If HTTP ALPN is detected, then the client connection is served with HTTP `Application` instead (the same "router information" page).
-
-If some client connects to router IP, doesn't send SNI and doesn't send ALPN, it will look like a pre-handshake client.
-In that case a router will send its handshake first.
-This can be mitigated by delaying its handshake and letting the probe to issue its HTTP request.
-
-## Implementation plan
-
-An unmodified client should be able to use protocols on port 443 right away.
-
-The switchover happens inside `runTransportServerState` before `runClient`:
-
-```haskell
-runServer (tcpPort, ATransport t) = do
-  -- ...
-  runTransportServerState_ ss started tcpPort serverParams tCfg $ \socket h -> do -- expose raw socket for warp-tls internals to attach
-    negotiated <- getSessionALPN
-    if allowHTTP t && isHTTP negotiated -- only attempt the switch for the TLS transport
-      then runHTTP socket (tlsContext h)-- ... collect data and produce values needed to run WAI Application
-      else runClient serverSignKey t h `runReaderT` env -- performs serverHandshake etc as usual
-```
-
-The web app and router live outside, so `runHttp` has to be provided by the `runSMPServer` caller.
-Additonally, Warp is using its `InternalInfo` object that's scoped to `withII` bracket.
-
-```haskell
-  runServer ini = do
-    -- ...
-
-    runWebServer ini ServerInformation {config, information} $ if sharedHttps then Nothing else webHttpsParams -- suppress serving https
-    if sharedHttps
-      then withRunHTTP staticFilesPath \attachStatic -> runSMPServer cfg (Just attachStatic) -- provide wrapped application runner
-      else runSMPServer cfg Nothing
-```
-
-### Upstream
-
-The implementation relies on a few modification to upstream code:
-- `warp-tls`: The library provides `httpOverTls`, but it wants to do handshake itself.
-  Since we have to do the handshake to switch on ALPN, the setup function has to be split.
-  This is a resonable change that may be upstreamed and nothing blocks us from using the recent version.
-- `warp`: Only the re-export of `serveConnection` is needed.
-  Unfortunately the most recent `warp` version can't be used right away due to dependency cascade around `http-5` and `auto-update-2`.
-  So a fork containing the backported re-export has to be used until the dependencies are refreshed.
-### TLS.ServerParams
-
-When a router has port sharing enabled, a new set of TLS params is loaded and combined with transport params:
-
-```haskell
-newEnv config = do
-  -- ...
-  tlsServerParams <- loadTLSServerParams caCertificateFile certificateFile privateKeyFile (alpn transportConfig)
-  sharedServerParams <- forM ((,) <$> sharedHttpsCredentials config <*> alpn transportConfig) $ \((chain, key), alpn) ->
-    let ca = Nothing -- It is possible to provide CA certificate, but it is typical for web server to use combined certificate chains
-    loadHTTPSServerParams tlsServerParams ca chain key alpn
-```
-
-`loadHTTPSServerParams` extends params with:
-1. `onALPNClientSuggest` hook gets `["h2", "http/1.1"]` added to the ALPN list which is now required.
-2. `onServerNameIndication` hook added, which upon detecting client SNI prepends the web credentials.
-3. `sharedCredentials = T.Credentials []` should be done to prevent transport credentials confusing browsers.
-    But that aborts key exchange somewhere in tls internals, so disabled for now.
-    As a workaround, another set of dummy credentials can be provided in the hope that any sane browser would reject them.
-    Like, RC4 ciphers, "impossible" digest combination, etc.
-
-### supportedParameters
-
-TLS certificate chains provided by LetsEncrypt use ECDSA/P256 and that requires extending `supportedParameters` with things disabled in transports:
-
-```haskell
-    browserCiphers =
-      [ TE.cipher_TLS13_AES128CCM8_SHA256
-      , TE.cipher_ECDHE_ECDSA_AES128CCM8_SHA256
-      , TE.cipher_ECDHE_ECDSA_AES256CCM8_SHA256
-      ]
-    browserGroups =
-      [ T.P256
-      ]
-    browserSigs =
-      [ (T.HashSHA256, T.SignatureECDSA),
-        (T.HashSHA384, T.SignatureECDSA)
-      ]
-```
-
-This may not be enough for other certificate providers.
-
-## Configuration
-
-> XXX: This is for the current implementation and should be updated.
-
-Web certificate chain is picked up from the WEB section:
-
-```ini
-[TRANSPORT]
-port: 443
-
-[WEB]
-https: 443
-cert: /etc/opt/simplex/web.cert
-key: /etc/opt/simplex/web.key
-
-# Alternatively, with a proper access configuration, the paths can point to the LE creds directly:
-# cert: /etc/letsencrypt/live/smp.hostname.tld/fullchain.pem
-# key: /etc/letsencrypt/live/smp.hostname.tld/privkey.pem
-```
-
-When `TRANSPORT.port` matches `WEB.https` the transport router becomes shared.
-
-Perhaps a more desirable option would be explicit configuration resulting in additional transported to run:
-
-```ini
-[TRANSPORT]
-port: 5223 ; pure protocol transport
-# control_port: 5224
-shared_port: 443 ; variant 1: register in TRANSPORT
-
-[WEB]
-https: 443
-cert: /etc/opt/simplex/web.cert
-key: /etc/opt/simplex/web.key
-# transport: on ; variant 2:
-```
-
-## Caveats
-
-Serving static files and the protocols together may pose a problem for those who currently use dedicated web servers as they should switch to embedded http handlers.
-
-As before, using embedded HTTP server is increasing attack surface.
-
-Users who want to run everything on a single host will have to add an extra IP address and bind routers to specific IPs instead of 0.0.0.0.
-An amalgamated router binary can be provided that would contain both SMP and XFTP routers, where transport will dispatch connections by handshake ALPN.
-
-## Alternative: Use transports routable with reverse-proxies
-
-An "industrial" reverse proxy may do the ALPN routing, serving HTTP by itself and delegating `smp` and `xftp` to protocol servers.
-Same with the `websockets`.
-
-Since this in effect does TLS termination, the protocol routers will have to rely on credentials from protocol handshakes.

plans/done/2024-11-25-journal-expiration.md

@@ -1,16 +0,0 @@
-
-# Expiring messages in journal storage
-
-## Problem
-
-The journal storage routers recently migrated to do not delete delivered or expired messages, they only update pointers to journal file lines. The messages are actually deleted when the whole journal file is deleted (when fully deleted or fully expired).
-
-The problem is that in case the queue stops receiving the new messages then writing of messages won't switch to the new journal file, and the current journal file containing delivered or expired messages would never be deleted.
-
-## Solution
-
-Remove current journal file and update queue_state.log during message expiration of "idle" queue (that is, without any new messages received or delivered within 3 hours) in case when:
-- the queue is "empty" after the expiration
-- the queue contains only quota marker(s), in which case move them to a new journal file and update the queue_state accordingly. Quota markers can be kept indefinitely to prevent writing the new messages to the dormant queues that reached capacity, so it's important to handle this case.
-
-Also remove current journal file when the queue is opened in case it is empty (as it would not be ever expired in case it remains empty), and also update queue_state.log

plans/done/2026-02-17-fix-subq-deadlock.md

@@ -1,416 +0,0 @@
-
-# Fix subQ deadlock: blocking writeTBQueue inside connLock
-
-## Problem
-
-Users report that message reception silently and permanently stops across all connections, with no error alerts. The app appears functional but no messages arrive. Recovery requires restart.
-
-Root cause: a deadlock between worker threads holding `connLock` and the `agentSubscriber` (sole `subQ` reader).
-
-### The deadlock mechanism
-
-`subQ` (`TBQueue ATransmission`, capacity 4096 on mobile / 1024 on desktop) is the single pipeline between the agent layer and the chat layer. The `agentSubscriber` thread (`Commands.hs:4373`) is its **sole reader**.
-
-Three code sites hold `connLock` and call blocking `writeTBQueue subQ` without a fullness check. When `subQ` is full, these block while holding the lock. If `agentSubscriber` simultaneously needs the same `connLock` (via `sendMessagesB_` → `withConnLocks`), it blocks too — creating a circular wait:
-
-- **Worker**: holds `connLock(X)`, waits for `subQ` space (needs `agentSubscriber` to read)
-- **agentSubscriber**: sole `subQ` reader, waits for `connLock(X)` (needs worker to release)
-- **Result**: permanent silent deadlock — no exception, no alert, all connections blocked
-
-### Confirmed deadlock scenarios
-
-**Scenario 1**: Delivery worker during queue rotation test
-
-```
-Delivery worker:                    agentSubscriber (sole subQ reader):
-  withConnLock(X) [2187]              readTBQueue subQ → processAgentMessageConn
-  ...DB operations...                 → sendPendingGroupMessages (on CON/SENT/QCONT)
-  notify → writeTBQueue subQ [2238]   → batchSendConnMessages → deliverMessagesB
-  [BLOCKED — subQ full]               → withAgent sendMessagesB [synchronous]
-                                      → sendMessagesB_ → withConnLocks({..X..}) [1708]
-                                      [BLOCKED — connLock(X) held]
-```
-
-**Scenario 2**: Async command worker during message ACK with notification
-
-```
-Async cmd worker:                   agentSubscriber (sole subQ reader):
-  tryWithLock "ICAck" [1930→1824]     readTBQueue subQ → processAgentMessageConn
-  → withConnLock(X)                   → sendPendingGroupMessages
-  → ack → ackQueueMessage [1899]      → sendMessagesB_ → withConnLocks({..X..})
-  → sendMsgNtf [2381]                [BLOCKED — connLock(X) held]
-  → writeTBQueue subQ [2386]
-  [BLOCKED — subQ full]
-```
-
-**Scenario 3**: Synchronous `ackMessage'` API (same mechanism as Scenario 2 but from external API caller)
-
-```
-ackMessage' caller:                 agentSubscriber (sole subQ reader):
-  withConnLock(X) [2254]              → sendMessagesB_ → withConnLocks({..X..})
-  → ack → ackQueueMessage [2267]      [BLOCKED — connLock(X) held]
-  → sendMsgNtf [2381]
-  → writeTBQueue subQ [2386]
-  [BLOCKED — subQ full]
-```
-
-### ConnId overlap verified
-
-No guard prevents a connection undergoing queue rotation (AM_QTEST_) or ACK processing from being included in `sendMessagesB_`'s batch. During these operations, the connection has `connStatus == ConnReady`, passing all filters in `memberSendAction`.
-
-### Cascade amplification
-
-Once any single deadlock triggers, `subQ` never drains. ALL other threads that attempt `writeTBQueue subQ` block progressively — their locks are held forever too. The entire threading system freezes within seconds.
-
-### Affected code sites (blocking `writeTBQueue subQ` inside `connLock`)
-
-| Site | File | Lock line | Write line | Events written |
-|------|------|-----------|------------|----------------|
-| `runSmpQueueMsgDelivery::notify` | Agent.hs | 2187 | 2238 | SWITCH SPCompleted, ERR INTERNAL |
-| `runSmpQueueMsgDelivery::internalErr/notifyDel` | Agent.hs | 2187 | 2238 (via notifyDel→notify) | ERR INTERNAL + delMsg |
-| `ackQueueMessage::sendMsgNtf` | Agent.hs | 2254 or 1930 | 2386 | MSGNTF |
-
-### Safe patterns that already exist in the codebase
-
-1. **`isFullTBQueue` + pending TVar** (used at `runCommandProcessing` lines 1782-1784/1937, and `runProcessSMP` lines 3027-3029/3216):
-   ```haskell
-   -- Before processing (e.g. line 1782):
-   pending <- newTVarIO []
-   -- During processing — safe notify (e.g. line 1937):
-   notify cmd =
-     let t = (corrId, connId, AEvt (sAEntity @e) cmd)
-      in atomically $ ifM (isFullTBQueue subQ) (modifyTVar' pendingCmds (t :)) (writeTBQueue subQ t)
-   -- After processing — flush (e.g. line 1784):
-   mapM_ (atomically . writeTBQueue subQ) . reverse =<< readTVarIO pending
-   ```
-
-2. **`nonBlockingWriteTBQueue`** (used at Client.hs:789, NtfSubSupervisor.hs:507):
-   ```haskell
-   nonBlockingWriteTBQueue q x = do
-     sent <- atomically $ tryWriteTBQueue q x
-     unless sent $ void $ forkIO $ atomically $ writeTBQueue q x
-   ```
-   Note: `nonBlockingWriteTBQueue` does NOT preserve ordering — the spawned background thread may complete out of order relative to subsequent direct writes from the same calling thread.
-
-### Exhaustive proof: no other deadlock scenarios exist
-
-All 15 `withConnLock` sites in Agent.hs were analyzed. Only 3 write to `subQ`:
-
-| withConnLock site | Writes subQ? | Safe? |
-|-------------------|-------------|-------|
-| switchConnectionAsync' (899) | No | ✓ |
-| setConnShortLinkAsync' (995) | No | ✓ |
-| setConnShortLink' (1031) | No | ✓ |
-| deleteConnShortLink' (1075) | No | ✓ |
-| allowConnection' (1407) | No | ✓ |
-| acceptContact' (1417) | No | ✓ |
-| sendMessagesB_ (1708, `withConnLocks`) | No | ✓ |
-| tryWithLock/runSmpCommand (1930) | Yes (1937) | ✓ — `isFullTBQueue` check |
-| tryMoveableWithLock/runSmpCommand (1931) | Yes (1937) | ✓ — `isFullTBQueue` check |
-| **runSmpQueueMsgDelivery AM_QTEST_ (2187)** | **Yes (2238)** | **✗ — DEADLOCK** |
-| **ackMessage' (2254)** | **Yes (2386)** | **✗ — DEADLOCK** |
-| switchConnection' (2298) | No | ✓ |
-| abortConnectionSwitch' (2328) | No | ✓ |
-| synchronizeRatchet' (2351) | No | ✓ |
-| suspendConnection' (2390) | No | ✓ |
-| **processSMP (3037)** | Yes (3216) | ✓ — `isFullTBQueue` check |
-
-Note: `processSMP` (line 3037) holds `connLock` and its local `notify` (line 3216) writes to `subQ`, but it uses the safe `isFullTBQueue` pattern. Its `ack` (line 3196) uses `enqueueCmd` (DB-only), NOT `ackQueueMessage`. The actual `ackQueueMessage` runs later from the async command worker via ICAck/ICAckDel.
-
-Other lock pairs checked — no circular dependencies:
-- `connLock × DB MVar`: DB never acquires connLock
-- `entityLock × connLock`: consistent ordering (entity first in chat, conn in agent)
-- `connLock(X) × connLock(Y)`: single agentSubscriber thread, one `withConnLocks` at a time
-
----
-
-## Deadlock call graph: agentSubscriber → connLock
-
-All deadlock paths require `agentSubscriber` to synchronously acquire `connLock`. Exhaustive analysis shows that **every such path converges on a single agent function**: `sendMessagesB_` → `withConnLocks` (Agent.hs:1708). No other agent API function called synchronously from the agentSubscriber acquires connLock.
-
-Verified (FACT): `ackMessageAsync` → `enqueueCommand` only (no connLock). `toggleConnectionNtfs` → no lock. `deleteConnectionAsync` → `deleteLock` not `connLock`. `joinConnectionAsync` → `withInvLock` not `connLock`.
-
-Also verified (FACT): `Lock = TMVar Text` (Lock.hs:24) is **non-reentrant** — double acquisition on the same thread deadlocks.
-
-### All 22 trigger paths
-
-Every path goes through `deliverMessage`/`deliverMessages`/`deliverMessagesB` → `withAgent sendMessagesB` → `sendMessagesB_` → `withConnLocks`:
-
-| # | Trigger | Chat function | ConnIds locked | Risk |
-|---|---------|--------------|----------------|------|
-| 1 | Group CON (Invitee) | `introduceToAll` → broadcast XGrpMemNew | **ALL member connIds** | **HIGHEST** |
-| 2 | Group MSG XGrpLinkAcpt | `introduceToRemaining` → broadcast | **ALL member connIds** | **HIGHEST** |
-| 3 | Group CON (Invitee) | `sendIntroductions` → batch intros to new member | new member connId | Medium |
-| 4 | Group CON (Invitee) | `sendHistory` → batch to new member | new member connId | Medium |
-| 5 | Group CON | `sendPendingGroupMessages` | member connId | Medium |
-| 6 | Group SENT | `sendPendingGroupMessages` | member connId | Medium |
-| 7 | Group QCONT | `sendPendingGroupMessages` | member connId | Medium |
-| 8 | Group CON (PendingReview) | `introduceToModerators` → to moderators | moderator connIds | Medium |
-| 9 | Group CON (PreMember) | `sendXGrpMemCon` → to host | host connId | Low |
-| 10 | Group CON (PreMember) | `probeMatchingMemberContact` → probes + hashes | member + N matching connIds | Medium |
-| 11 | Direct CON | `probeMatchingMembers` → probes + hashes | contact + N matching connIds | Medium |
-| 12 | Direct JOINED | `sendAutoReply` | contact connId | Low |
-| 13 | Group JOINED | `sendGroupAutoReply` | member connId | Low |
-| 14 | Group INV | `sendXGrpMemInv` → to host | host connId | Low |
-| 15 | Group INV (legacy) | `sendGrpInvitation` → to contact | contact connId | Low |
-| 16 | Group MSG XGrpMemInv | `xGrpMemInv` → `sendGroupMemberMessage` | re-member connId | Low |
-| 17 | Group MSG XGrpMemDel | `forwardToMember` | deleted member connId | Low |
-| 18 | Group MSG XGrpLinkMem | `probeMatchingMemberContact` | member + N matching connIds | Medium |
-| 19 | Group MSG (dup relay) | `saveGroupRcvMsg` error → `sendDirectMemberMessage` | forwarder connId | Low |
-| 20 | SFDONE | `sendFileDescriptions` → to recipients | recipient connIds | Medium |
-| 21 | Group MSG XGrpLinkAcpt | `sendHistory` → to accepted member | accepted member connId | Medium |
-| 22 | Direct MSG (autoAccept) | `autoAcceptFile` → inline accept reply | contact connId | Low (test-only config) |
-
-### Key observations
-
-1. **Single bottleneck**: All 22 paths converge on `sendMessagesB_` → `withConnLocks` (Agent.hs:1708). The deadlock is between this lock acquisition and any worker thread holding `connLock` + blocking on `writeTBQueue subQ`.
-
-2. **Highest-risk paths** (#1, #2): Broadcasting to ALL group members in `introduceToAll` / `introduceToRemaining` acquires `withConnLocks` on ALL member connIds in a single batch. For large groups, this holds the agentSubscriber thread for a long time, during which subQ fills, which causes worker threads holding connLock on any of those connIds to deadlock.
-
-3. **Medium-risk paths** (#5-7): `sendPendingGroupMessages` fires on every CON/SENT/QCONT. These are frequent and lock the member's connId, which is the SAME connId that a delivery worker or ACK worker may hold while writing to subQ.
-
----
-
-## Analysis: `withConnLocks` in `sendMessagesB_`
-
-### FACT: the lock protects ratchet encryption state
-
-`sendMessagesB_` (Agent.hs:1708-1713) acquires `withConnLocks` and executes:
-
-1. **`getConn_`** — reads connection metadata, send queues from DB
-2. **`setConnPQSupport`** — updates PQ encryption flag per connection
-3. **`enqueueMessagesB`** → `enqueueMessageB` → `storeSentMsg_` which calls:
-   - **`updateSndIds`** (AgentStore.hs:899) — increments `internalSndId` (sequential send counter)
-   - **`agentRatchetEncryptHeader`** (Agent.hs:3698) — reads current ratchet via `getRatchetForUpdate`, encrypts message header via `rcEncryptHeader`, writes advanced ratchet state via `updateRatchet`
-   - **`createSndMsg`** + **`createSndMsgDelivery`** — inserts message and delivery records
-
-All operations run within `unsafeWithStore` → `withTransaction` (single DB transaction per batch).
-
-### FACT: the lock CANNOT be removed
-
-Without `withConnLocks`, concurrent `sendMessagesB_` calls targeting the same connection would:
-- Read the same ratchet state, both encrypt, one overwrite the other → **ratchet desync** (unrecoverable)
-- Get duplicate `internalSndId` values → **message ID collision**
-- Race on `setConnPQSupport` → **PQ state inconsistency**
-
-The lock serializes ALL operations on the connection's encryption state. Removing it would introduce data corruption.
-
-Note: `sendMessage` (singular, line 530) uses the same `sendMessagesB_` function — there is no lock-free send path.
-
-### Eliminated strategies
-
-- **Strategy C (remove lock)**: The lock protects ratchet encryption. Removing it causes unrecoverable ratchet desync. Eliminated.
-- **Strategy A (async dispatch)**: All 22 chat-layer callers use `deliverMessagesB` return values (delivery IDs, PQ state) synchronously. `forkIO` loses results. Eliminated.
-- **Strategy W (isFullTBQueue + pending TVar)**: The existing pattern (lines 1937, 3216) buffers events in a local TVar and flushes after lock release. Between lock release and flush, another thread can acquire the same connLock and write events to subQ — reordering events within the same connection. This trades a visible deadlock for invisible ordering bugs. Eliminated.
-- **Strategy O (per-connection overflow queues)**: Bounded overflow queues with "drop when full" were analyzed. Drop consequences are unacceptable at 5 of 6 write sites — CONF, INFO, CON cause permanent connection failure after ACK; INV loses connection invitations; SENT/MERR leave messages stuck forever. Unbounded overflow defeats backpressure. Eliminated.
-
----
-
-## Solution: move subQ writes outside connLock
-
-### Root cause
-
-The `writeTBQueue subQ` calls at the 3 deadlock sites are inside `connLock` by accident of code structure, not necessity. `connLock` protects ratchet encryption state and DB consistency. The `notify` calls write informational events to `subQ` — they do not modify any state that `connLock` protects.
-
-Moving the writes outside the lock scope eliminates the deadlock: blocking `writeTBQueue subQ` without holding `connLock` is safe — agentSubscriber is free to acquire the lock, process events, and drain `subQ`.
-
-### Why reordering doesn't matter at these sites
-
-The chat layer handlers for the 3 deadlock site events do NOT advance the ratchet:
-
-| Event | Chat handler | Calls sendMessagesB_? |
-|-------|-------------|----------------------|
-| SWITCH SPCompleted | Creates internal chat item, updates UI | **No** |
-| ERR INTERNAL | Logs error to view | **No** |
-| MSGNTF | `toView CEvtNtfMessage` → empty output | **No** |
-
-Events that DO trigger ratchet advances (CON, SENT, QCONT → `sendPendingGroupMessages` → `sendMessagesB_`) are all already written OUTSIDE `connLock` in the current code.
-
-Ratchet state lives in the DB, not in subQ events. agentSubscriber processes events sequentially regardless of arrival order. The SENT-before-SWITCH race already exists in the current code (new queue worker writes SENT outside connLock while old queue worker writes SWITCH inside connLock).
-
-### Fix: Site 1 — `runSmpQueueMsgDelivery` AM_QTEST_ (line 2187)
-
-Restructure `withConnLock` to return the event, write outside.
-
-**Current code** (Agent.hs:2187-2214):
-```haskell
-AM_QTEST_ -> withConnLock c connId "runSmpQueueMsgDelivery AM_QTEST_" $ do
-  withStore' c $ \db -> setSndQueueStatus db sq Active
-  SomeConn _ conn <- withStore c (`getConn` connId)
-  case conn of
-    DuplexConnection cData' rqs sqs -> do
-      let addr = qAddress sq
-      case findQ addr sqs of
-        Just SndQueue {dbReplaceQueueId = Just replacedId, primary} ->
-          case removeQP (\sq' -> dbQId sq' == replacedId && not (sameQueue addr sq')) sqs of
-            Nothing -> internalErr msgId "sent QTEST: queue not found in connection"
-            Just (sq', sq'' : sqs') -> do
-              checkSQSwchStatus sq' SSSendingQTEST
-              atomically $ TM.delete (qAddress sq') $ smpDeliveryWorkers c
-              withStore' c $ \db -> do
-                when primary $ setSndQueuePrimary db connId sq
-                deletePendingMsgs db connId sq'
-                deleteConnSndQueue db connId sq'
-              let sqs'' = sq'' :| sqs'
-                  conn' = DuplexConnection cData' rqs sqs''
-              cStats <- connectionStats c conn'
-              notify $ SWITCH QDSnd SPCompleted cStats       -- DEADLOCK
-            _ -> internalErr msgId "sent QTEST: ..."         -- DEADLOCK (via notifyDel → notify)
-        _ -> internalErr msgId "sent QTEST: ..."             -- DEADLOCK
-    _ -> internalErr msgId "QTEST sent not in duplex ..."    -- DEADLOCK
-```
-
-**New code:**
-```haskell
-AM_QTEST_ -> do
-  evt_ <- withConnLock c connId "runSmpQueueMsgDelivery AM_QTEST_" $ do
-    withStore' c $ \db -> setSndQueueStatus db sq Active
-    SomeConn _ conn <- withStore c (`getConn` connId)
-    case conn of
-      DuplexConnection cData' rqs sqs -> do
-        let addr = qAddress sq
-        case findQ addr sqs of
-          Just SndQueue {dbReplaceQueueId = Just replacedId, primary} ->
-            case removeQP (\sq' -> dbQId sq' == replacedId && not (sameQueue addr sq')) sqs of
-              Nothing -> pure $ Left "sent QTEST: queue not found in connection"
-              Just (sq', sq'' : sqs') -> do
-                checkSQSwchStatus sq' SSSendingQTEST
-                atomically $ TM.delete (qAddress sq') $ smpDeliveryWorkers c
-                withStore' c $ \db -> do
-                  when primary $ setSndQueuePrimary db connId sq
-                  deletePendingMsgs db connId sq'
-                  deleteConnSndQueue db connId sq'
-                let sqs'' = sq'' :| sqs'
-                    conn' = DuplexConnection cData' rqs sqs''
-                cStats <- connectionStats c conn'
-                pure $ Right $ SWITCH QDSnd SPCompleted cStats
-              _ -> pure $ Left "sent QTEST: there is only one queue in connection"
-          _ -> pure $ Left "sent QTEST: queue not in connection or not replacing another queue"
-      _ -> pure $ Left "QTEST sent not in duplex connection"
-  -- subQ write is now OUTSIDE connLock — blocking writeTBQueue is safe
-  case evt_ of
-    Right evt -> notify evt
-    Left err -> internalErr msgId err
-```
-
-All DB operations remain inside the lock. Only `notify`/`internalErr` (which write to subQ) move outside. `internalErr` calls `notifyDel` = `notify >> delMsg` — both `notify` (subQ write) and `delMsg` (`deleteSndMsgDelivery`, keyed on unique msgId) are safe outside the lock. The existing double-delete pattern (`delMsg` inside `internalErr` + `delMsgKeep` at line 2216) is preserved.
-
-### Fix: Sites 2 & 3 — `ackQueueMessage::sendMsgNtf` (line 2386)
-
-Change `ackQueueMessage` to return the MSGNTF event instead of writing it to subQ. Callers write to subQ after releasing connLock.
-
-**Current code** (Agent.hs:2371-2386):
-```haskell
-ackQueueMessage :: AgentClient -> RcvQueue -> SMP.MsgId -> AM ()
-ackQueueMessage c rq@RcvQueue {userId, connId, server} srvMsgId = do
-  atomically $ incSMPServerStat c userId server ackAttempts
-  tryAllErrors (sendAck c rq srvMsgId) >>= \case
-    Right _ -> sendMsgNtf ackMsgs
-    Left (SMP _ SMP.NO_MSG) -> sendMsgNtf ackNoMsgErrs
-    Left e -> ...
-  where
-    sendMsgNtf stat = do
-      atomically $ incSMPServerStat c userId server stat
-      whenM (liftIO $ hasGetLock c rq) $ do
-        atomically $ releaseGetLock c rq
-        brokerTs_ <- eitherToMaybe <$> tryAllErrors (withStore c $ \db -> getRcvMsgBrokerTs db connId srvMsgId)
-        atomically $ writeTBQueue (subQ c) ("", connId, AEvt SAEConn $ MSGNTF srvMsgId brokerTs_)
-```
-
-**New code** — return `Maybe ATransmission` instead of writing:
-```haskell
-ackQueueMessage :: AgentClient -> RcvQueue -> SMP.MsgId -> AM (Maybe ATransmission)
-ackQueueMessage c rq@RcvQueue {userId, connId, server} srvMsgId = do
-  atomically $ incSMPServerStat c userId server ackAttempts
-  tryAllErrors (sendAck c rq srvMsgId) >>= \case
-    Right _ -> sendMsgNtf ackMsgs
-    Left (SMP _ SMP.NO_MSG) -> sendMsgNtf ackNoMsgErrs
-    Left e -> ... >> pure Nothing
-  where
-    sendMsgNtf stat = do
-      atomically $ incSMPServerStat c userId server stat
-      ifM (liftIO $ hasGetLock c rq)
-        (do atomically $ releaseGetLock c rq
-            brokerTs_ <- eitherToMaybe <$> tryAllErrors (withStore c $ \db -> getRcvMsgBrokerTs db connId srvMsgId)
-            pure $ Just ("", connId, AEvt SAEConn $ MSGNTF srvMsgId brokerTs_))
-        (pure Nothing)
-```
-
-**Caller 1: `ackMessage'`** (Agent.hs:2253-2267) — return event from `withConnLock`, write after:
-```haskell
-ackMessage' c connId msgId rcptInfo_ = do
-  t_ <- withConnLock c connId "ackMessage" $ do
-    SomeConn _ conn <- withStore c (`getConn` connId)
-    case conn of
-      DuplexConnection {} -> do
-        t_ <- ack
-        sendRcpt conn
-        del
-        pure t_
-      RcvConnection {} -> do
-        t_ <- ack
-        del
-        pure t_
-      SndConnection {} -> throwE $ CONN SIMPLEX "ackMessage"
-      ContactConnection {} -> throwE $ CMD PROHIBITED "ackMessage: ContactConnection"
-      NewConnection _ -> throwE $ CMD PROHIBITED "ackMessage: NewConnection"
-  -- subQ write is OUTSIDE connLock
-  case t_ of
-    Just t -> atomically $ writeTBQueue (subQ c) t
-    Nothing -> pure ()
-```
-
-**Caller 2: `ICAck` / `ICAckDel`** (Agent.hs:1823-1824) — inline `tryWithLock` as `tryCommand` + `withConnLock`, write subQ between the two scopes:
-
-`tryWithLock name = tryCommand . withConnLock c connId name` — by inlining, the subQ write can be placed outside `withConnLock` but inside `tryCommand` (retaining retry/error handling).
-
-```haskell
-ICAck rId srvMsgId -> withServer $ \srv ->
-  tryCommand $ do
-    t_ <- withConnLock c connId "ICAck" $ ack srv rId srvMsgId
-    -- subQ write is OUTSIDE connLock — cannot deadlock with agentSubscriber
-    forM_ t_ $ atomically . writeTBQueue subQ
-
-ICAckDel rId srvMsgId msgId -> withServer $ \srv ->
-  tryCommand $ do
-    t_ <- withConnLock c connId "ICAckDel" $ do
-      t_ <- ack srv rId srvMsgId
-      withStore' c (\db -> deleteMsg db connId msgId)
-      pure t_
-    -- subQ write is OUTSIDE connLock — cannot deadlock with agentSubscriber
-    forM_ t_ $ atomically . writeTBQueue subQ
-```
-
-Where `ack` now returns `AM (Maybe ATransmission)`:
-```haskell
-ack srv rId srvMsgId = do
-  rq <- withStore c $ \db -> getRcvQueue db connId srv rId
-  ackQueueMessage c rq srvMsgId
-```
-
-All subQ writes for MSGNTF are now outside connLock. FIFO ordering is preserved — no `nonBlockingWriteTBQueue`, no forked threads. The same thread that held the lock writes to subQ sequentially after releasing it.
-
-### Race analysis
-
-Window between connLock release and subQ write at Site 1:
-
-| Thread | Can acquire connLock(X)? | Writes subQ? | Consequence |
-|--------|-------------------------|-------------|-------------|
-| agentSubscriber via sendMessagesB_ | Yes | **No** (encrypts only) | No race |
-| processSMP for connId X | Yes | Yes (pending flush) | MSG before SWITCH — cosmetic |
-| runCommandProcessing for connId X | Yes | Yes (pending flush) | Command response before SWITCH — cosmetic |
-| New queue delivery worker | No (SENT outside lock) | Yes | SENT before SWITCH — cosmetic, **already exists in current code** |
-
-All races are cosmetic UI ordering. None affect ratchet state, protocol correctness, or message delivery.
-
-### Summary of changes
-
-| File | Change | Lines affected |
-|------|--------|---------------|
-| Agent.hs | Restructure AM_QTEST_ to return event from `withConnLock`, write outside | ~2187-2214 |
-| Agent.hs | Change `ackQueueMessage` return type to `AM (Maybe ATransmission)`, return event instead of writing | ~2371-2386 |
-| Agent.hs | `ackMessage'`: return event from `withConnLock`, write outside | ~2253-2267 |
-| Agent.hs | `ICAck`/`ICAckDel`: inline `tryCommand` + `withConnLock`, write subQ between scopes | ~1823-1824 |
-| Agent.hs | `ack` helper: propagate new return type | ~1899-1901 |
-
-No new data structures. No new modules. No changes to other write sites (1937, 3216 — already safe). ~25 lines changed total.

protocol/diagrams/duplex-messaging/duplex-creating-fast.mmd

@@ -1,65 +0,0 @@
-sequenceDiagram
-  participant A as Alice
-  participant AA as Alice's<br>agent
-  participant AS as Alice's<br>server
-  participant BS as Bob's<br>server
-  participant BA as Bob's<br>agent
-  participant B as Bob
-
-  note over AA, BA: status (receive/send): NONE/NONE
-
-  note over A, AA: 1. request connection<br>from agent
-  A ->> AA: createConnection
- 
-  note over AA, AS: 2. create Alice's SMP queue
-  AA ->> AS: NEW: create SMP queue<br>allow sender to secure
-  AS ->> AA: IDS: SMP queue IDs
-  note over AA: status: NEW/NONE
-
-  AA ->> A: INV: invitation<br>to connect
-
-  note over A, B: 3. out-of-band invitation
-  A ->> B: OOB: invitation to connect
-
-  note over BA, B: 4. accept connection
-  B ->> BA: joinConnection:<br>via invitation info
-  note over BA: status: NONE/NEW
-
-  note over BA, AS: 5. secure Alice's SMP queue
-  BA ->> AS: SKEY: secure queue (this command needs to be proxied)
-  note over BA: status: NONE/SECURED
-
-  note over BA, BS: 6. create Bob's SMP queue
-  BA ->> BS: NEW: create SMP queue<br>allow sender to secure
-  BS ->> BA: IDS: SMP queue IDs
-  note over BA: status: NEW/SECURED
-
-  note over BA, AA: 7. confirm Alice's SMP queue
-  BA ->> AS: SEND: Bob's info without sender's key (SMP confirmation with reply queues)
-  note over BA: status: NEW/CONFIRMED
-
-  AS ->> AA: MSG: Bob's info without<br>sender server key
-  note over AA: status: CONFIRMED/NEW
-  AA ->> AS: ACK: confirm message
-  AA ->> A: CONF: connection request ID<br>and Bob's info
-  A -> AA: allowConnection: accept connection request,<br>send Alice's info
-  
-  note over AA, BS: 8. secure Bob's SMP queue
-  AA ->> BS: SKEY: secure queue (this command needs to be proxied)
-  note over BA: status: CONFIRMED/SECURED
-
-  AA ->> BS: SEND: Alice's info without sender's server key (SMP confirmation without reply queues)
-  note over AA: status: CONFIRMED/CONFIRMED
-
-  note over AA, A: 9. notify Alice<br>about connection success<br>(no HELLO needed in v6)
-  AA ->> A: CON: connected
-  note over AA: status: ACTIVE/ACTIVE
-
-  note over BA, B: 10. notify Bob<br>about connection success
-  BS ->> BA: MSG: Alice's info without<br>sender's server key
-  note over BA: status: CONFIRMED/CONFIRMED
-  BA ->> B: INFO: Alice's info
-  BA ->> BS: ACK: confirm message
-
-  BA ->> B: CON: connected
-  note over BA: status: ACTIVE/ACTIVE

protocol/diagrams/duplex-messaging/duplex-creating-v2.mmd

@@ -0,0 +1,71 @@
+sequenceDiagram
+  participant A as Alice
+  participant AA as Alice's<br>agent
+  participant AS as Alice's<br>server
+  participant BS as Bob's<br>server
+  participant BA as Bob's<br>agent
+  participant B as Bob
+
+  note over AA, BA: status (receive/send): NONE/NONE
+
+  note over A, AA: 1. request connection<br>from agent
+  A ->> AA: NEW: create<br>duplex connection
+ 
+  note over AA, AS: 2. create Alice's SMP queue
+  AA ->> AS: NEW: create SMP queue
+  AS ->> AA: IDS: SMP queue IDs
+  note over AA: status: NEW/NONE
+
+  AA ->> A: INV: invitation<br>to connect
+
+  note over A, B: 3. out-of-band invitation
+  A ->> B: OOB: invitation to connect
+
+  note over BA, B: 4. accept connection
+  B ->> BA: JOIN:<br>via invitation info
+  note over BA: status: NONE/NEW
+
+  note over BA, BS: 5. create Bob's SMP queue
+  BA ->> BS: NEW: create SMP queue
+  BS ->> BA: IDS: SMP queue IDs
+  note over BA: status: NEW/NEW
+
+  note over BA, AA: 6. establish Alice's SMP queue
+  BA ->> AS: SEND: Bob's info and sender server key (SMP confirmation with reply queues)
+  note over BA: status: NEW/CONFIRMED
+
+  AS ->> AA: MSG: Bob's info and<br>sender server key
+  note over AA: status: CONFIRMED/NONE
+  AA ->> AS: ACK: confirm message
+  AA ->> A: CONF: connection request ID<br>and Bob's info
+  A ->> AA: LET: accept connection request,<br>send Alice's info
+  AA ->> AS: KEY: secure queue
+  note over AA: status: SECURED/NONE
+
+  AA ->> BS: SEND: Alice's info and sender's server key (SMP confirmation without reply queues)
+  note over AA: status: SECURED/CONFIRMED
+
+  BS ->> BA: MSG: Alice's info and<br>sender's server key
+  note over BA: status: CONFIRMED/CONFIRMED
+  BA ->> B: INFO: Alice's info
+  BA ->> BS: ACK: confirm message
+  BA ->> BS: KEY: secure queue
+  note over BA: status: SECURED/CONFIRMED
+
+  BA ->> AS: SEND: HELLO: only needs to be sent once in v2
+
+  note over BA: status: SECURED/ACTIVE
+  note over BA, B: 7a. notify Bob<br>about connection success
+  BA ->> B: CON: connected
+
+  AS ->> AA: MSG: HELLO: Alice's agent<br>knows Bob can send
+  note over AA: status: SECURED/ACTIVE
+  AA ->> AS: ACK: confirm message
+  note over A, AA: 7a. notify Alice<br>about connection success
+  AA ->> A: CON: connected
+
+  AA ->> BS: SEND: HELLO: only needs to be sent once in v2
+  note over AA: status: ACTIVE/ACTIVE
+  BS ->> BA: MSG: HELLO: Bob's agent<br>knows Alice can send
+  note over BA: status: ACTIVE/ACTIVE
+  BA ->> BS: ACK: confirm message

protocol/diagrams/duplex-messaging/duplex-creating.mmd

@@ -8,8 +8,8 @@ sequenceDiagram
 
   note over AA, BA: status (receive/send): NONE/NONE
 
-  note over A, AA: 1. request connection<br>from agent
-  A ->> AA: createConnection
+  note over A, AA: 1. request connection from agent
+  A ->> AA: NEW: create<br>duplex connection
  
   note over AA, AS: 2. create Alice's SMP queue
   AA ->> AS: NEW: create SMP queue
@@ -17,58 +17,63 @@ sequenceDiagram
   note over AA: status: NEW/NONE
 
   AA ->> A: INV: invitation<br>to connect
+  note over AA: status: PENDING/NONE
 
   note over A, B: 3. out-of-band invitation
   A ->> B: OOB: invitation to connect
 
   note over BA, B: 4. accept connection
-  B ->> BA: joinConnection:<br>via invitation info
+  B ->> BA: JOIN:<br>via invitation info
   note over BA: status: NONE/NEW
 
-  note over BA, BS: 5. create Bob's SMP queue
-  BA ->> BS: NEW: create SMP queue
-  BS ->> BA: IDS: SMP queue IDs
-  note over BA: status: NEW/NEW
-
-  note over BA, AA: 6. confirm Alice's SMP queue
-  BA ->> AS: SEND: Bob's info and sender server key (SMP confirmation with reply queues)
-  note over BA: status: NEW/CONFIRMED
-
+  note over BA, AA: 5. establish Alice's SMP queue
+  BA ->> AS: SEND: Bob's info and sender server key (SMP confirmation)
+  note over BA: status: NONE/CONFIRMED
+  activate BA
   AS ->> AA: MSG: Bob's info and<br>sender server key
   note over AA: status: CONFIRMED/NONE
   AA ->> AS: ACK: confirm message
   AA ->> A: CONF: connection request ID<br>and Bob's info
-  A ->> AA: allowConnection: accept connection request,<br>send Alice's info
+  A ->> AA: LET: accept connection request,<br>send Alice's info
   AA ->> AS: KEY: secure queue
   note over AA: status: SECURED/NONE
 
-  AA ->> BS: SEND: Alice's info and sender's server key (SMP confirmation without reply queues)
-  note over AA: status: SECURED/CONFIRMED
+  BA ->> AS: SEND: HELLO: try sending until successful
+  deactivate BA
+  note over BA: status: NONE/ACTIVE
+  AS ->> AA: MSG: HELLO: Alice's agent<br>knows Bob can send
+  note over AA: status: ACTIVE/NONE
+  AA ->> AS: ACK: confirm message
 
-  note over BA, AA: 7. confirm Bob's SMP queue
+  note over BA, BS: 6. create Bob's SMP queue
+  BA ->> BS: NEW: create SMP queue
+  BS ->> BA: IDS: SMP queue IDs
+  note over BA: status: NEW/ACTIVE
+
+  note over AA, BA: 7. establish Bob's SMP queue
+  BA ->> AS: SEND: REPLY: invitation to the connect
+  note over BA: status: PENDING/ACTIVE
+  AS ->> AA: MSG: REPLY: invitation<br>to connect
+  note over AA: status: ACTIVE/NEW
+  AA ->> AS: ACK: confirm message
+
+  AA ->> BS: SEND: Alice's info and sender's server key
+  note over AA: status: ACTIVE/CONFIRMED
+  activate AA
   BS ->> BA: MSG: Alice's info and<br>sender's server key
-  note over BA: status: CONFIRMED/CONFIRMED
+  note over BA: status: CONFIRMED/ACTIVE
   BA ->> B: INFO: Alice's info
   BA ->> BS: ACK: confirm message
   BA ->> BS: KEY: secure queue
-  note over BA: status: SECURED/CONFIRMED
-
-  BA ->> AS: SEND: HELLO message
-
   note over BA: status: SECURED/ACTIVE
 
-  AS ->> AA: MSG: HELLO: Alice's agent<br>knows Bob can send
-  note over AA: status: SECURED/ACTIVE
-  AA ->> AS: ACK: confirm message
-  AA ->> BS: SEND: HELLO
-
-  note over A, AA: 8. notify Alice<br>about connection success
-  AA ->> A: CON: connected
+  AA ->> BS: SEND: HELLO: try sending until successful
+  deactivate AA
   note over AA: status: ACTIVE/ACTIVE
-
   BS ->> BA: MSG: HELLO: Bob's agent<br>knows Alice can send
   note over BA: status: ACTIVE/ACTIVE
   BA ->> BS: ACK: confirm message
 
-  note over BA, B: 9. notify Bob<br>about connection success
+  note over A, B: 8. notify users about connection success
+  AA ->> A: CON: connected
   BA ->> B: CON: connected

protocol/diagrams/duplex-messaging/queue-rotation-fast.mmd

@@ -1,17 +0,0 @@
-sequenceDiagram
-  participant A as Alice
-  participant R as Current server<br>that has A's<br>receive queue
-  participant R' as New server<br>that has the new A's<br>receive queue
-  participant S as Server<br>that has A's send queue<br>(B's receive queue)
-  participant B as Bob
-
-  A ->> R': NEW: create new queue<br>(allow SKEY)
-  A ->> S: SEND: QADD (R'): send address<br>of the new queue(s)
-  S ->> B: MSG: QADD (R')
-  B ->> R': SKEY: secure new queue
-  B ->> R': SEND: QTEST
-  R' ->> A: MSG: QTEST
-  A ->> R: DEL: delete the old queue
-  B ->> R': SEND: send messages to the new queue
-  R' ->> A: MSG: receive messages from the new queue
-  

protocol/diagrams/duplex-messaging/queue-rotation.mmd

@@ -1,21 +0,0 @@
-sequenceDiagram
-  participant A as Alice
-  participant R as Current server<br>that has A's<br>receive queue
-  participant R' as New server<br>that has the new A's<br>receive queue
-  participant S as Server<br>that has A's send queue<br>(B's receive queue)
-  participant B as Bob
-
-  A ->> R': NEW: create new queue
-  A ->> S: SEND: QADD (R'): send address<br>of the new queue(s)
-  S ->> B: MSG: QADD (R')
-  B ->> R: SEND: QKEY (R'): sender's key<br>for the new queue(s)
-  R ->> A: MSG: QKEY(R')
-  A ->> R': KEY: secure new queue
-  A ->> S: SEND: QUSE (R'): instruction to use new queue(s)
-  S ->> B: MSG: QUSE (R')
-  B ->> R': SEND: QTEST
-  R' ->> A: MSG: QTEST
-  A ->> R: DEL: delete the old queue
-  B ->> R': SEND: send messages to the new queue
-  R' ->> A: MSG: receive messages from the new queue
-  

protocol/diagrams/notifications/register-token-detailed.mmd

@@ -1,30 +0,0 @@
-sequenceDiagram
-  participant M as mobile app
-  participant C as chat core
-  participant A as agent
-  participant P as push server
-  participant APN as APN
-
-  note over M, APN: get device token
-  M ->> APN: registerForRemoteNotifications()
-  APN ->> M: device token
-
-  note over M, P: register device token with push server
-  M ->> C: /_ntf register <token>
-  C ->> A: registerNtfToken(<token>)
-  A ->> P: TNEW
-  P ->> A: ID (tokenId)
-  A ->> C: registered
-  C ->> M: registered
-
-  note over M, APN: verify device token
-  P ->> APN: E2E encrypted code<br>in background<br>notification
-  APN ->> M: deliver background notification with e2ee verification token
-  M ->> C: /_ntf verify <e2ee code>
-  C ->> A: verifyNtfToken(<e2ee code>)
-  A ->> P: TVFY code
-  P ->> A: OK / ERR
-  A ->> C: verified
-  C ->> M: verified
-
-  note over M, APN: now token ID can be used

protocol/diagrams/notifications/register-token.mmd

@@ -1,26 +1,30 @@
 sequenceDiagram
-  participant C as client app
+  participant M as mobile app
+  participant C as chat core
   participant A as agent
-  participant P as SimpleX<br>Notification<br>Server
-  participant APN as Apple<br>Push Notifications<br>Server
+  participant P as push server
+  participant APN as APN
 
-  note over C, APN: get device token
-  C ->> APN: registerForRemoteNotifications()
-  APN ->> C: device token
+  note over M, APN: get device token
+  M ->> APN: registerForRemoteNotifications()
+  APN ->> M: device token
 
-  note over C, P: register device token with push server
-  C ->> A: registerToken
+  note over M, P: register device token with push server
+  M ->> C: /_ntf register <token>
+  C ->> A: registerNtfToken(<token>)
   A ->> P: TNEW
   P ->> A: ID (tokenId)
   A ->> C: registered
+  C ->> M: registered
 
-  note over C, APN: verify device token
+  note over M, APN: verify device token
   P ->> APN: E2E encrypted code<br>in background<br>notification
-  APN ->> C: deliver background notification with e2ee verification token
-  C ->> A: verifyToken<br>(<e2ee code>)
+  APN ->> M: deliver background notification with e2ee verification token
+  M ->> C: /_ntf verify <e2ee code>
+  C ->> A: verifyNtfToken(<e2ee code>)
   A ->> P: TVFY code
   P ->> A: OK / ERR
   A ->> C: verified
+  C ->> M: verified
 
-  note over C, APN: now token ID can be used
-  
+  note over M, APN: now token ID can be used

protocol/diagrams/notifications/subscription-detailed.mmd

@@ -1,40 +0,0 @@
-sequenceDiagram
-  participant M as mobile app
-  participant C as chat core
-  participant A as agent
-  participant S as SMP server
-  participant N as NTF server
-  participant APN as APN
-
-  note over M, APN: register subscription
-
-  alt register existing
-    M -->> A: on /_ntf register, for subscribed queues
-  else create new connection
-    A -->> S: NEW / JOIN
-    note over A, S: ...<br>Connection handshake<br>...
-    S -->> A: CON
-  end
-  A ->> S: NKEY nKey
-  S ->> A: NID nId
-  A ->> N: SNEW tknId dhKey (smpServer, nId, nKey)
-  N ->> A: ID subId dhKey
-  N ->> S: NSUB nId
-  S ->> N: OK [/ NMSG]
-
-  note over M, APN: notify about message
-
-  S ->> N: NMSG
-  N ->> APN: APNSMutableContent<br>ntfQueue, nonce
-  APN ->> M: UNMutableNotificationContent
-  note over M, S: ...<br>Client awaken, message is received<br>...
-  S ->> M: message
-  note over M: mutate notification
-
-  note over M, APN: change APN token
-
-  APN ->> M: new device token
-  M -->> C: /_ntf_sub update tkn
-  C -->> A: updateNtfToken()
-  A -->> N: TUPD tknId newDeviceToken
-  note over M, N: ...<br>Verify token<br>...

protocol/diagrams/notifications/subscription.mmd

@@ -1,16 +1,17 @@
 sequenceDiagram
-  participant C as client app
+  participant M as mobile app
+  participant C as chat core
   participant A as agent
   participant S as SMP server
   participant N as NTF server
   participant APN as APN
 
-  note over C, APN: register subscription
+  note over M, APN: register subscription
 
   alt register existing
-    C -->> A: registerToken
+    M -->> A: on /_ntf register, for subscribed queues
   else create new connection
-    A -->> S: create/joinConnection
+    A -->> S: NEW / JOIN
     note over A, S: ...<br>Connection handshake<br>...
     S -->> A: CON
   end
@@ -19,20 +20,21 @@ sequenceDiagram
   A ->> N: SNEW tknId dhKey (smpServer, nId, nKey)
   N ->> A: ID subId dhKey
   N ->> S: NSUB nId
-  S ->> N: OK / NMSG:<br>confirm subscription
+  S ->> N: OK [/ NMSG]
 
-  note over C, APN: notify about message
+  note over M, APN: notify about message
 
   S ->> N: NMSG
   N ->> APN: APNSMutableContent<br>ntfQueue, nonce
-  APN ->> C: UNMutableNotificationContent
-  note over C, S: ...<br>Client awaken, message is received<br>...
-  S ->> C: message
-  note over C: show notification
+  APN ->> M: UNMutableNotificationContent
+  note over M, S: ...<br>Client awaken, message is received<br>...
+  S ->> M: message
+  note over M: mutate notification
 
-  note over C, APN: change APN token
+  note over M, APN: change APN token
 
-  APN ->> C: new device token
-  C -->> A: updateToken()
+  APN ->> M: new device token
+  M -->> C: /_ntf_sub update tkn
+  C -->> A: updateNtfToken()
   A -->> N: TUPD tknId newDeviceToken
-  note over C, N: ...<br>Verify token<br>...
+  note over M, N: ...<br>Verify token<br>...

protocol/diagrams/simplex-messaging/simplex-creating-fast.mmd

@@ -1,23 +0,0 @@
-sequenceDiagram
-  participant B as Bob (sender)
-  participant S as server (queue RID)
-  participant A as Alice (recipient)
-
-  note over A: creating queue<br>("public" key RK<br>for msg retrieval)
-  A ->> S: 1. create queue ("NEW")
-  S ->> A: respond with queue RID and SID ("IDS")
-
-  note over A: out-of-band msg<br>(sender's queue SID<br>and "public" key EK<br>to encrypt msgs)
-  A -->> B: 2. send out-of-band message
-
-  note over B: secure queue<br>(with "public" key SK for<br>sending messages)
-  B ->> S: 3. confirm queue ("SKEY" command authorized with SK)
-
-  note over B: confirm queue<br>(public key<br>for e2e encryption<br>and any optional<br>encrypted info.)
-  B ->> S: 4. confirm queue ("SEND" command authorized with SK)
-
-  S ->> A: 5. deliver Bob's message (MSG)
-  note over A: decrypt message<br>("private" key EK)
-  A ->> S: acknowledge message (ACK)
-
-  note over S: 6. simplex<br>queue RID<br>is ready to use!

protocol/diagrams/simplex-messaging/simplex-creating.mmd

@@ -10,13 +10,11 @@ sequenceDiagram
   note over A: out-of-band msg<br>(sender's queue SID<br>and "public" key EK<br>to encrypt msgs)
   A -->> B: 2. send out-of-band message
 
-  note over B: confirm queue<br>("public" key SK for<br>sending messages,<br>public key for<br>e2e encryption<br>and any optional<br>encrypted info)
+  note over B: confirm queue<br>("public" key SK for<br>sending messages<br>and any optional<br>info encrypted with<br>"public" key EK)
   B ->> S: 3. confirm queue ("SEND" command not signed)
 
-  S ->> A: 4. deliver Bob's message (MSG)
+  S ->> A: 4. deliver Bob's message
   note over A: decrypt message<br>("private" key EK)
-  A ->> S: acknowledge message (ACK)
-
   A ->> S: 5. secure queue ("KEY", RK-signed)
 
   note over S: 6. simplex<br>queue RID<br>is ready to use!

protocol/diagrams/xftp/xftp-receiving-file.mmd

@@ -1,18 +0,0 @@
-sequenceDiagram
-  participant B as Bob (recipient)
-  participant S as XFTP server(s)
-
-  note over B: having received file description<br>from sender
-
-  loop for each chunk
-    B ->> S: 1a. download chunk ("FGET")
-    S ->> B: send chunk body ("FILE")
-
-    opt
-      B ->> S: 1b. acknowledge chunk reception ("FACK")
-      note over S: delete recipient ID
-      S ->> B: respond with ok ("OK")
-    end
-  end
-
-  note over B: 2. combine chunks into a file<br>3. decrypt file using key from file description<br>4. extract file name and unpad the file<br>5. validate file digest with the file description

protocol/diagrams/xftp/xftp-sending-file.mmd

@@ -1,23 +0,0 @@
-sequenceDiagram
-  participant A as Alice (sender)
-  participant S as XFTP server(s)
-  participant B as recipient(s)
-
-  note over A: 1. prepare file:<br>encrypt,<br>split into chunks,<br>generate recipient<br>keys, etc.
-
-  loop for each chunk
-    A ->> S: 2a. register chunk ("FNEW")
-    S ->> A: respond with sender's and recipients' chunk IDs ("SIDS")
-
-    opt
-      A ->> S: 2b. request additional recipient IDs ("FADD")
-      S ->> A: respond with added recipients' chunk IDs ("RIDS")
-    end
-
-    A ->> S: 2c. upload chunk to chosen server ("FPUT")
-    S ->> A: respond with ok ("OK")
-  end
-
-  note over A: 3. prepare file description(s)
-
-  A -->> B: 4. send file description(s) out-of-band

protocol/diagrams/xrcp/session.mmd

@@ -1,44 +0,0 @@
-sequenceDiagram
-  participant CI as Controller UI
-  participant CC as Controller Core
-  participant HC as Host Core
-  participant HI as Host UI
-
-note over CI, HI: 1. Session invitation
-CI->>CC: "Link a mobile"
-CC-->>CI: Session invitation URI
-note over CC: Listen for TCP connection
-activate CC
-HI->>HC: Session invitation URI
-
-note over CI, HI: 2. Establishing TLS connection
-HC-->>CC: TCP connect
-note over CC, HC: TLS handshake
-par
-    note over CC: validate client X509 credentials
-    CC->>CI: session code from tlsUnique
-    CI-->>CC: user confirmation
-and
-    note over HC: validate server X509 credentials
-    HC->>HI: session code from tlsUnique
-    HI-->>HC: user confirmation
-end
-
-note over CI, HI: 3. Session verification and protocol negotiation
-HC->>CC: host HELLO
-note over CC: validate version, CA fingerprint
-alt
-    CC-->>HC: controller ERROR
-else
-    CC-->>HC: controller HELLO
-    note over CC, HC: update stored keys
-end
-deactivate CC
-
-note over CI, HI: 4. Session operation
-loop
-    CI->>CC: command
-    CC->>HC: XRCP command
-    HC-->>CC: XRCP response
-    CC-->>CI: response
-end

protocol/overview-tjr.md

@@ -1,4 +1,4 @@
-Revision 4, 2026-03-09
+Revision 1, 2022-01-01
 
 Evgeny Poberezkin
 
@@ -8,47 +8,40 @@ Evgeny Poberezkin
 
 - [Introduction](#introduction)
   - [What is SimpleX](#what-is-simplex)
-  - [Network model](#network-model)
-  - [Applications](#applications)
   - [SimpleX objectives](#simplex-objectives)
   - [In Comparison](#in-comparison)
 - [Technical Details](#technical-details)
-  - [Trust in Routers](#trust-in-routers)
-  - [Client -> Router Communication](#client---router-communication)
-  - [2-hop Onion Message Routing](#2-hop-onion-message-routing)
+  - [Trust in Servers](#trust-in-servers)
+  - [Client -> Server Communication](#client---server-communication)
   - [SimpleX Messaging Protocol](#simplex-messaging-protocol)
   - [SimpleX Agents](#simplex-agents)
-- [Security](#security)
+  - [Encryption Primitives Used](#encryption-primitives-used)
+- [Threat model](#threat-model)
 - [Acknowledgements](#acknowledgements)
 
-
 ## Introduction
 
 #### What is SimpleX
 
 SimpleX as a whole is a platform upon which applications can be built. [SimpleX Chat](https://github.com/simplex-chat/simplex-chat) is one such application that also serves as an example and reference application.
 
- - [SimpleX Messaging Protocol](./simplex-messaging.md) (SMP) is a protocol to send messages in one direction to a recipient, relying on a router in-between. The messages are delivered via uni-directional queues created by recipients.
-
- - SMP protocol allows to send message via a SMP router playing proxy role using 2-hop onion routing (referred to as "private routing" in messaging clients) to protect transport information of the sender (IP address and session) from the router chosen (and possibly controlled) by the recipient.
+ - [SimpleX Messaging Protocol](https://github.com/simplex-chat/simplexmq/blob/master/protocol/simplex-messaging.md) (SMP) is a protocol to send messages in one direction to a recipient, relying on a server in-between. The messages are delivered via uni-directional queues created by recipients.
 
  - SMP runs over a transport protocol (shown below as TLS) that provides integrity, server authentication, confidentiality, and transport channel binding.
 
- - A SimpleX router is one of those routers.
+ - A SimpleX Server is one of those servers.
 
- - The SimpleX Network is the term used for the collective of SimpleX routers that facilitate SMP.
+ - The SimpleX Network is the term used for the collective of SimpleX Servers that facilitate SMP.
 
- - SimpleX Client libraries speak SMP to SimpleX routers and provide a low-level API not generally intended to be used by applications.
+ - SimpleX Client libraries speak SMP to SimpleX Servers and provide a low-level API not generally intended to be used by applications.
 
- - SimpleX Agents interface with SimpleX Clients to provide a more high-level API intended to be used by applications. Typically they are embedded as libraries, but can also be abstracted into local services.
-
- - SimpleX Agents communicate with other agents inside e2e encrypted envelopes provided by SMP protocol - the syntax and semantics of the messages exchanged by the agent are defined by [SMP agent protocol](./agent-protocol.md)
+ - SimpleX Agents interface with SimpleX Clients to provide a more high-level API intended to be used by applications. Typically they are embedded as libraries, but are designed so they can also be abstracted into local services.
 
 
-*Diagram showing the SimpleX Chat app, with logical layers of the chat application interfacing with a SimpleX Agent library, which in turn interfaces with a SimpleX Client library. The Client library in turn speaks the Messaging Protocol to a SimpleX router.*
+*Diagram showing the SimpleX Chat app, with logical layers of the chat application interfacing with a SimpleX Agent library, which in turn interfaces with a SimpleX Client library. The Client library in turn speaks the Messaging Protocol to a SimpleX Server.*
 
 ```
-  User's Computer                 Internet                    Third-Party Router
+  User's Computer                 Internet                    Third-Party Server
 ------------------     |   ----------------------     |   -------------------------
                        |                              |
    SimpleX Chat        |                              |
@@ -58,43 +51,11 @@ SimpleX as a whole is a platform upon which applications can be built. [SimpleX
 +----------------+     |                              |
 |  SimpleX Agent |     |                              |
 +----------------+    -------------- TLS ----------------    +----------------+
-| SimpleX Client | ------ SimpleX Messaging Protocol ------> | SimpleX router |
+| SimpleX Client | ------ SimpleX Messaging Protocol ------> | SimpleX Server |
 +----------------+    -----------------------------------    +----------------+
                        |                              |
 ```
 
-#### Network model
-
-SimpleX is a general-purpose packet routing network built on top of the Internet. Network endpoints — end-user devices, automated services, AI-enabled applications, IoT devices — exchange data packets through SimpleX network nodes (SMP routers), which accept, buffer, and deliver packets. Each router operates independently and can be operated by any party on standard computing hardware.
-
-SimpleX routers use resource-based addressing: each address identifies a resource on a router, similar to how the World Wide Web addresses resources via URLs. Internet routers, by comparison, use endpoint-based addressing, where IP addresses identify destination devices. Because of this design, SimpleX network participants do not need globally unique addresses to communicate.
-
-SimpleX network has two resource-based addressing schemes:
-
-- *Messaging queues* ([SMP](./simplex-messaging.md)). A queue is a unidirectional, ordered sequence of fixed-size data packets (16,384 bytes each). Each queue has a resource address on a specific router, gated by cryptographic credentials that separately authorize sending and receiving.
-
-- *Data packets* ([XFTP](./xftp.md)). A data packet is an individually addressed block in one of the standard sizes. Each packet has a unique resource address on a specific router, gated by cryptographic credentials. Data packet addressing is more efficient for delivery of larger payloads than queues.
-
-Packet delivery follows a two-router path. The sending endpoint submits a packet to a first router, which forwards it to a second router, where the receiving endpoint retrieves it. The sending endpoint's IP address is known only to the first router; the receiving endpoint's IP address is known only to the second router. See [2-hop Onion Message Routing](#2-hop-onion-message-routing) for details.
-
-Routers buffer packets between submission and retrieval — from seconds to days, enabling asynchronous delivery when endpoints are online at different times. Packets are removed after delivery or after a configured expiration period.
-
-
-#### Applications
-
-Applications currently using SimpleX network:
-
-- **SimpleX Chat** — a peer-to-peer messenger using SimpleX network as a transport layer, in the same way that communication applications use WebRTC, Tor, i2p, or Nym. All communication logic — contacts, conversations, groups, message formats, end-to-end encryption — runs on endpoint devices.
-
-- **IoT devices** — using the SimpleX queue protocol directly for sensor data collection and device control.
-
-- **AI-based services** — automated services built on the SimpleX Chat application core.
-
-- **Secure monitoring and control systems** — applications for equipment monitoring and control, including robotics, using the network for command delivery and telemetry collection.
-
-[SimpleGo](https://simplego.dev), developed by an independent organization, is a microcontroller-based device running a SimpleX Chat-compatible messenger directly on a microcontroller without a general-purpose operating system. Running over 20 days on a single battery charge, it demonstrates the energy efficiency of resource-based addressing: the device receives packets without continuous polling. A microcontroller-based router implementation that functions simultaneously as a WiFi router is also in development.
-
-
 #### SimpleX objectives
 
 1. Provide messaging infrastructure for distributed applications. This infrastructure needs to have the following qualities:
@@ -103,7 +64,7 @@ Applications currently using SimpleX network:
 
    - Privacy: protect against traffic correlation attacks to determine the contacts that the users communicate with.
 
-   - Reliability: the messages should be delivered even if some participating network routers or receiving clients fail, with "at least once" delivery guarantee.
+   - Reliability: the messages should be delivered even if some participating network servers or receiving clients fail, with “at least once” delivery guarantee.
 
    - Integrity: the messages sent in one direction are ordered in a way that sender and recipient agree on; the recipient can detect when a message was removed or changed.
 
@@ -111,104 +72,82 @@ Applications currently using SimpleX network:
 
    - Low latency: the delay introduced by the network should not be higher than 100ms-1s in addition to the underlying TCP network latency.
 
-2. Provide better communication security and privacy than the alternative instant messaging solutions. In particular SimpleX provides better privacy of metadata (who talks to whom and when) and better security against active network attackers and malicious routers.
+2. Provide better communication security and privacy than the alternative instant messaging solutions.  In particular SimpleX provides better privacy of metadata (who talks to whom and when) and better security against active network attackers and malicious servers.
 
 3. Balance user experience with privacy requirements, prioritizing experience of mobile device users.
 
-
 #### In Comparison
 
-SimpleX network has a design similar to P2P networks, but unlike most P2P networks it consists of clients and routers without depending on any centralized component.
+SimpleX network has a design similar to P2P networks, but unlike most P2P networks it consists of clients and servers without depending on any centralized component.
 In comparison to more traditional messaging applications (e.g. WhatsApp, Signal, Telegram) the key differences of SimpleX network are:
 
 - participants do not need to have globally unique addresses to communicate, instead they use redundant unidirectional (simplex) messaging queues, with a separate set of queues for each contact.
 
 - connection requests are passed out-of-band, non-optionally protecting key exchange against man-in-the-middle attack.
 
-- simple message queues provided by network routers are used by the clients to create more complex communication scenarios, such as duplex one-to-one communication, transmitting files, group communication without central routers, and content/communication channels.
+- simple message queues provided by network servers are used by the clients to create more complex communication scenarios, such as duplex one-to-one communication, transmitting files, group communication without central servers, and content/communication channels.
 
-- routers do not store any user information (no user profiles or contacts, or messages once they are delivered), and primarily use in-memory persistence.
-
-- users can change routers with minimal disruption - even after an in-use router disappears, simply by changing the configuration on which routers the new queues are created.
+- servers do not store any user information (no user profiles or contacts, or messages once they are delivered), and primarily use in-memory persistence.
 
+- users can change servers with minimal disruption - even after an in-use server disappears, simply by changing the configuration on which servers the new queues are created.
 
 ## Technical Details
 
-#### Trust in Routers
+#### Trust in Servers
 
-Clients communicate directly with routers (but not with other clients) using SimpleX Messaging Protocol (SMP) running over some transport protocol that provides integrity, server authentication, confidentiality, and transport channel binding. By default, we assume this transport protocol is TLS.
+Clients communicate directly with servers (but not with other clients) using SimpleX Messaging Protocol (SMP) running over some transport protocol that provides integrity, server authentication, confidentiality, and transport channel binding. By default, we assume this transport protocol is TLS.
 
-Users use multiple routers, and choose where to receive their messages. Accordingly, they send messages to their communication partners' chosen routers either directly, if this is a known/trusted router, or via another SMP router providing proxy functionality to protect IP address and session of the sender.
+Users use multiple servers, and choose where to receive their messages. Accordingly, they send messages to their communication partners' chosen servers.
 
-Although end-to-end encryption is always present, users place a degree of trust in routers they connect to. This trust decision is very similar to a user's choice of email provider; however the trust placed in a SimpleX router is significantly less. Notably, there is no re-used identifier or credential between queues on the same (or different) routers. While a user *may* re-use a transport connection to fetch messages from multiple queues, or connect to a router from the same IP address, both are choices a user may opt into to break the promise of un-correlatable queues.
+Although end-to-end encryption is always present, users place a degree of trust in servers. This trust decision is very similar to a user's choice of email provider; however the trust placed in a SimpleX server is significantly less. Notably, there is no re-used identifier or credential between queues on the same (or different) servers. While a user *may* re-use a connection to fetch from multiple queues, or connect to a server from the same IP address, both are choices a user may opt into to break the promise of un-correlatable queues.
 
-Users may trust a router because:
+Users may trust a server because:
 
-- They deploy and control the routers themselves from the available open-source code. This has the trade-offs of strong trust in the router but limited metadata obfuscation to a passive network observer. Techniques such as noise traffic, traffic mixing (incurring latency), and using an onion routing transport protocol can mitigate that.
+- They deploy and control the servers themselves from the available open-source code. This has the trade-offs of strong trust in the server but limited metadata obfuscation to a passive network observer. Techniques such as noise traffic, traffic mixing (incurring latency), and using an onion routing transport protocol can mitigate that latter.
 
-- They use routers from a trusted commercial provider. The more clients the provider has, the less metadata about the communication times is leaked to the network observers.
+- They use servers from a trusted commercial provider. The more clients the provider has, the less metadata about the communication times is leaked to the network observers.
 
-By default, routers do not retain access logs, and permanently delete messages and queues when requested. Messages persist in memory or in a database until they cross a threshold of time, typically on the order of days.[0] There is still a risk that a router maliciously records all queues and messages (even though encrypted) sent via the same transport connection to gain a partial knowledge of the user's communications graph and other meta-data.
+- Users trust their contacts and the servers they chose.
 
-SimpleX supports measures (managed transparently to the user at the agent level) to mitigate the trust placed in routers.  These include rotating the queues in use between users, noise traffic, supporting overlay networks such as Tor, and isolating traffic to different queues to different transport connections (and Tor circuits, if Tor is used).
+By default, servers do not retain access logs, and permanently delete messages and queues when requested.  Messages persist only in memory until they cross a threshold of time, typically on the order of days.[0] There is still a risk that a server maliciously records all queues and messages (even though encrypted) sent via the same transport connection to gain a partial knowledge of the user’s communications graph and other meta-data.
 
-[0] While configurable by routers, a minimum value is enforced by the default software. SimpleX Agents can provide redundant routing over queues to mitigate against message loss.
+SimpleX supports measures (managed transparently to the user at the agent level) to mitigate the trust placed in servers.  These include rotating the queues in use between users, noise traffic, and supporting overlay networks such as Tor.
+
+[0] While configurable by servers, a minimum value is enforced by the default software. SimpleX Agents provide redundant routing over queues to mitigate against message loss.
 
 
-#### Client -> Router Communication
+#### Client -> Server Communication
 
 Utilizing TLS grants the SimpleX Messaging Protocol (SMP) server authentication and metadata protection to a passive network observer. But SMP does not rely on the transport protocol for message confidentiality or client authentication. The SMP protocol itself provides end-to-end confidentiality, authentication, and integrity of messages between communicating parties.
 
-Routers have long-lived, self-signed, offline certificates whose hash is pre-shared with clients over secure channels - either provided with the client library or provided in the secure introduction between clients, as part of the router address.  The offline certificate signs an online certificate used in the transport protocol handshake. [0]
+Servers have long-lived, self-signed, offline certificates whose hash is pre-shared with clients over secure channels - either provided with the client library or provided in the secure introduction between clients.  The offline certificate signs an online certificate used in the transport protocol handshake. [0]
 
-If the transport protocol's confidentiality is broken, incoming and outgoing messages to the router cannot be correlated by message contents. Additionally, because of encryption at the SMP layer, impersonating the router is not sufficient to pass (and therefore correlate) a message from a sender to recipient - the only attack possible is to drop the messages. Only by additionally *compromising* the router can one pass and correlate messages.
+If the transport protocol's confidentiality is broken, incoming and outgoing messages to the server cannot be correlated by message contents. Additionally, because of encryption at the SMP layer, impersonating the server is not sufficient to pass (and therefore correlate) a message from a sender to recipient - the only attack possible is to drop the messages. Only by additionally *compromising* the server can one pass and correlate messages.
 
-It's important to note that the SMP protocol does not do server authentication. Instead we rely upon the fact that an attacker who tricks the transport protocol into authenticating the router incorrectly cannot do anything with the SMP messages except drop them.
+It's important to note that the SMP protocol does not do server authentication. Instead we rely upon the fact that an attacker who tricks the transport protocol into authenticating the server incorrectly cannot do anything with the SMP messages except drop them.
 
-After the connection is established, the client sends blocks of a fixed size 16KB, and the router replies with the blocks of the same size to reduce metadata observable to a network adversary. The protocol has been designed to make traffic correlation attacks difficult, adapting ideas from Tor, remailers, and more general onion and mix networks. It does not try to replace Tor though - SimpleX routers can be deployed as onion services and SimpleX clients can communicate with routers over Tor to further improve participants privacy.
+After the connection is established, the client sends blocks of a fixed size 16Kb, and the server replies with the blocks of the same size to reduce metadata observable to a network adversary. The protocol has been designed to make traffic correlation attacks difficult, adapting ideas from Tor, remailers, and more general onion and mix networks. It does not try to replace Tor though - SimpleX servers can be deployed as onion services and SimpleX clients can communicate with servers over Tor to further improve participants privacy.
 
-By using fixed-size blocks, oversized for the expected content, the vast majority of traffic is uniform in nature. When enough traffic is transiting a router simultaneously, the router acts as a low-latency mix node. We can't rely on this behavior to make a security claim, but we have engineered to take advantage of it when we can. As mentioned, this holds true even if the transport connection is compromised.
+By using fixed-size blocks, oversized for the expected content, the vast majority of traffic is uniform in nature. When enough traffic is transiting a server simultaneously, the server acts as a (very) low-latency mix node.  We can't rely on this behavior to make a security claim, but we have engineered to take advantage of it when we can. As mentioned, this holds true even if the transport connection is compromised.
 
-The protocol does not protect against attacks targeted at particular users with known identities - e.g., if the attacker wants to prove that two known users are communicating, they can achieve it by observing their local traffic. At the same time, it substantially complicates large-scale traffic correlation, making determining the real user identities much less effective.
+The protocol does not protect against attacks targeted at particular users with known identities - e.g., if the attacker wants to prove that two known users are communicating, they can achieve it. At the same time, it substantially complicates large-scale traffic correlation, making determining the real user identities much less effective.
 
 [0] Future versions of SMP may add support for revocation lists of certificates, presently this risk is mitigated by the SMP protocol itself.
 
 
-#### 2-hop Onion Message Routing
-
-As SimpleX Messaging Protocol routers providing messaging queues are chosen by the recipients, in case senders connect to these routers directly the router owners (who potentially can be the recipients themselves) can learn senders' IP addresses (if Tor is not used) and which other queues on the same router are accessed by the user in the same transport connection (even if Tor is used).
-
-While the clients support isolating the messages sent to different queues into different transport connections (and Tor circuits), this is not practical, as it consumes additional traffic and system resources.
-
-To mitigate this problem SimpleX Messaging Protocol routers support 2-hop onion message routing when the SMP router chosen by the sender forwards the messages to the routers chosen by the recipients, thus protecting both the senders IP addresses and sessions, even if connection isolation and Tor are not used.
-
-The design of 2-hop onion message routing prevents these potential attacks:
-
-- MITM by proxy (SMP router that forwards the messages).
-
-- Identification by the proxy which and how many queues the sender sends messages to (as messages are additionally e2e encrypted between the sender and the destination SMP router).
-
-- Correlation of messages sent to different queues via the same user session (as random correlation IDs and keys are used for each message).
-
-See more details about 2-hop onion message routing design in [SimpleX Messaging Protocol](./simplex-messaging.md#proxying-sender-commands)
-
-Also see [Security](./security.md)
-
-
 #### SimpleX Messaging Protocol
 
-SMP is initialized with an in-person or out-of-band introduction message, where Alice provides Bob with details of a router (including IP address or host name, port, and hash of the long-lived offline certificate), a queue ID, and Alice's public keys to agree e2e encryption. These introductions are similar to the PANDA key-exchange, in that if observed, the adversary can race to establish the communication channel instead of the intended participant. [0]
+SMP is initialized with an in-person or out-of-band introduction message, where Alice provides Bob with details of a server (including IP, port, and hash of the long-lived offline certificate), a queue ID, and Alice's public key for her receiving queue. These introductions are similar to the PANDA key-exchange, in that if observed, the adversary can race to establish the communication channel instead of the intended participant. [0]
 
 Because queues are uni-directional, Bob provides an identically-formatted introduction message to Alice over Alice's now-established receiving queue.
 
-When setting up a queue, the router will create separate sender and recipient queue IDs (provided to Alice during set-up and Bob during initial connection). Additionally, during set-up Alice will perform a DH exchange with the router to agree upon a shared secret. This secret will be used to re-encrypt Bob's incoming message before Alice receives it, creating the anti-correlation property earlier-described should the transport encryption be compromised.
-
-[0] Users can additionally create public 'contact queues' that are only used to receive connection requests.
+When setting up a queue, the server will create separate sender and recipient queue IDs (provided to Alice during set-up and Bob during initial connection). Additionally, during set-up Alice will perform a DH exchange with the server to agree upon a shared secret. This secret will be used to re-encrypt Bob's incoming message before Alice receives it, creating the anti-correlation property earlier-described should the transport encryption be compromised.
 
+[0] Users can additionally create public 'contact queues' that are only used to receive connection requests.  
 
 #### SimpleX Agents
 
-SimpleX agents provide higher-level operations compared to SimpleX Clients, who are primarily concerned with creating queues and communicating with routers using SMP.  Agent operations include:
+SimpleX agents provide higher-level operations compared to SimpleX Clients, who are primarily concerned with creating queues and communicating with servers using SMP.  Agent operations include:
 
 - Managing sets of bi-directional, redundant queues for communication partners
 
@@ -218,22 +157,153 @@ SimpleX agents provide higher-level operations compared to SimpleX Clients, who
 
 - Noise traffic
 
+#### Encryption Primitives Used
 
-## Security
+- Ed448 to sign/verify commands to SMP servers (Ed25519 is also supported via client/server configuration).
+- Curve25519 for DH exchange to agree:
+  - the shared secret between server and recipient (to encrypt message bodies - it avoids shared cipher-text in sender and recipient traffic)
+  - the shared secret between sender and recipient (to encrypt messages end-to-end in each queue - it avoids shared cipher-text in redundant queues).
+- [NaCl crypto_box](https://nacl.cr.yp.to/box.html) encryption scheme (curve25519xsalsa20poly1305) for message body encryption between server and recipient and for E2E per-queue encryption.
+- SHA256 to validate server offline certificates.
+- [double ratchet](https://signal.org/docs/specifications/doubleratchet/) protocol for end-to-end message encryption between the agents:
+  - Curve448 keys to agree shared secrets required for double ratchet initialization (using [X3DH](https://signal.org/docs/specifications/x3dh/) key agreement with 2 ephemeral keys for each side),
+  - AES-GCM AEAD cipher,
+  - SHA512-based HKDF for key derivation.
 
-For encryption primitives, threat model, and detailed security analysis, see [Security](./security.md).
+## Threat Model
 
-SimpleX provides these security properties:
+#### Global Assumptions
 
-- **End-to-end encryption** with forward secrecy via double ratchet protocol, with optional post-quantum protection.
+ - A user protects their local database and key material
+ - The user's application is authentic, and no local malware is running
+ - The cryptographic primitives in use are not broken
+ - A user's choice of servers is not directly tied to their identity or otherwise represents distinguishing information about the user.
 
-- **No shared identifiers** across connections — contacts cannot prove they communicate with the same user.
+#### A passive adversary able to monitor the traffic of one user
 
-- **Sender deniability** — neither routers nor recipients can cryptographically prove message origin.
+*can:*
 
-- **Transport metadata protection** — fixed-size blocks, 2-hop onion routing, and connection isolation frustrate traffic correlation.
+ - identify that and when a user is using SimpleX
 
-- **Out-of-band key exchange** — connection requests passed outside the network protect against MITM attacks.
+ - block SimpleX traffic
+
+ - determine which servers the user communicates with
+
+ - observe how much traffic is being sent, and make guesses as to its purpose.
+
+*cannot:*
+
+ - see who sends messages to the user and who the user sends the messages to
+
+#### A passive adversary able to monitor a set of senders and recipients
+
+ *can:*
+
+ - identify who and when is using SimpleX
+
+ - learn which SimpleX Messaging Protocol servers are used as receive queues for which users
+
+ - learn when messages are sent and received
+
+ - perform traffic correlation attacks against senders and recipients and correlate senders and recipients within the monitored set, frustrated by the number of users on the servers
+
+ - observe how much traffic is being sent, and make guesses as to its purpose
+
+*cannot, even in case of a compromised transport protocol:*
+
+ - perform traffic correlation attacks with any increase in efficiency over a non-compromised transport protocol
+
+#### SimpleX Messaging Protocol server
+
+*can:*
+
+- learn when a queue recipient or sender is online
+
+- know how many messages are sent via the queue (although some may be noise)
+
+- perform queue correlation (matching multiple queues to a single user) via either a re-used transport connection, user's IP Address, or connection timing regularities
+
+- learn a user's IP address, track them through other IP addresses they use to access the same queue, and infer information (e.g. employer) based on the IP addresses, as long as Tor is not used.
+
+- drop all future messages inserted into a queue, detectable only over other, redundant queues
+
+- lie about the state of a queue to the recipient and/or to the sender  (e.g. suspended or deleted when it is not).
+
+- spam a user with invalid messages
+
+*cannot:*
+
+- undetectably add, duplicate, or corrupt individual messages
+
+- undetectably drop individual messages, so long as a subsequent message is delivered
+
+- learn the contents of messages
+
+- distinguish noise messages from regular messages except via timing regularities
+
+- compromise the user's end-to-end encryption with an active attack
+
+#### An attacker who obtained Alice's (decrypted) chat database
+
+*can:*
+
+- see the history of all messages exchanged by Alice with her communication partners
+
+- see shared profiles of contacts and groups
+
+- surreptitiously receive new messages sent to Alice via existing queues; until communication queues are rotated or the Double-Ratchet advances forward
+
+- prevent Alice from receiving all new messages sent to her - either surreptitiously by emptying the queues regularly or overtly by deleting them
+
+- send messages from the user to their contacts; recipients will detect it as soon as the user sends the next message, because the previous message hash won’t match (and potentially won’t be able to decrypt them in case they don’t keep the previous ratchet keys).
+
+*cannot:*
+
+- impersonate a sender and send messages to the user whose database was stolen. Doing so requires also compromising the server (to place the message in the queue, that is possible until the Double-Ratchet advances forward) or the user's device at a subsequent time (to place the message in the database).
+
+- undetectably communicate at the same time as Alice with her contacts. Doing so would result in the contact getting different messages with repeated IDs.
+
+- undetectably monitor message queues in realtime without alerting the user they are doing so, as a second subscription request unsubscribes the first and notifies the second.
+
+#### A user’s contact
+
+*can:*
+
+- spam the user with messages
+
+- forever retain messages from the user
+
+*cannot:*
+
+- cryptographically prove to a third-party that a message came from a user (assuming the user’s device is not seized)
+
+- prove that two contacts they have is the same user
+
+- cannot collaborate with another of the user's contacts to confirm they are communicating with the same user
+
+#### An attacker who observes Alice showing an introduction message to Bob
+
+*can:*
+
+ - Impersonate Bob to Alice
+
+*cannot:*
+
+ - Impersonate Alice to Bob
+
+#### An attacker with Internet access
+
+*can:*
+
+- Denial of Service SimpleX messaging servers
+
+- spam a user's public “contact queue” with connection requests
+
+*cannot:*
+
+- send messages to a user who they are not connected with
+
+- enumerate queues on a SimpleX server
 
 
 ## Acknowledgements

protocol/pqdr.md

@@ -1,299 +0,0 @@
-Version 1, 2024-06-22
-
-# Post-quantum resistant augmented double ratchet algorithm (PQDR)
-
-## Table of contents
-
-- [Overview](#overview)
-- [Comparison with the other approaches](#comparison-with-the-other-approaches)
-  - [PQXDH for post-quantum key agreement](#pqxdh-for-post-quantum-key-agreement) (Signal)
-  - [Hybrid Signal protocol for post-quantum encryption](#hybrid-signal-protocol-for-post-quantum-encryption) (Tutanota)
-- [Augmented double ratchet algorithm](#augmented-double-ratchet-algorithm)
-- [Double ratchet with encrypted headers augmented with double PQ KEM](#double-ratchet-with-encrypted-headers-augmented-with-double-pq-kem)
-  - [Initialization](#initialization)
-  - [Encrypting messages](#encrypting-messages)
-  - [Decrypting messages](#decrypting-messages)
-- [Ratchet message wire format](#ratchet-message-wire-format)
-  - [Encrypted ratchet message](#encrypted-ratchet-message)
-  - [Encrypted message header](#encrypted-message-header)
-  - [Plaintext message header](#plaintext-message-header)
-  - [KEM state machine](#kem-state-machine)
-- [Implementation considerations](#implementation-considerations)
-- [Chosen KEM algorithm](#chosen-kem-algorithm)
-- [Summary](#summary)
-
-## Overview
-
-It is a reasonable assumption that "record-now-decrypt-later" attacks are ongoing, so the users want to use cryptographic schemes for end-to-end encryption that are augmented with some post-quantum algorithm that is believed to be resistant to quantum computers.
-
-SimpleX Chat uses [double-ratchet with header encryption](https://signal.org/docs/specifications/doubleratchet/#double-ratchet-with-header-encryption) to provide end-to-end encryption to messages and files. This document describes augmented algorithm with post-quantum key encapsulation mechanism (KEM) making it resistant to quantum computers.
-
-Double-ratchet algorithm is a state of the art solution for end to end encryption offering a set of qualities that is not present in any other algorithm:
-
-- perfect forward secrecy, i.e. compromise of session or long term keys does not lead to the ability to decrypt any of the past messages.
-- deniability (also known as repudiation), i.e. the fact that the recipient of the message while having the proof of message authenticity, cannot prove to a third party that the sender actually sent this message.
-- break-in recovery (also know as post-compromise security or future secrecy), i.e. the ability of the end-to-end encryption security to recover from the compromise of the long term keys. This is achieved by generating a new random key pair whenever a new DH key is received (DH ratchet step).
-
-It is desirable to preserve all these qualities when augmenting the algorithm with a post-quantum algorithm, and having these qualities resistant to both conventional and quantum computers.
-
-## Comparison with the other approaches
-
-### PQXDH for post-quantum key agreement
-
-[The solution](https://signal.org/docs/specifications/pqxdh/) recently [introduced by Signal](https://signal.org/blog/pqxdh/) augments the initial key agreement ([X3DH](https://signal.org/docs/specifications/x3dh/)) that is made prior to double ratchet algorithm. This is believed to provide protection from "record-now-decrypt-later" attack, but if the attacker at any point obtains long term keys from any of the devices, the break-in recovery will not be post-quantum resistant, and the attacker with quantum computer will be able to decrypt all the subsequent messages.
-
-### Hybrid Signal protocol for post-quantum encryption
-
-[The solution](https://eprint.iacr.org/2021/875.pdf) [proposed by Tutanota](https://tutanota.com/blog/posts/pqmail-update/) aims to preserve the break-in recovery property of double ratchet, but in doing so it:
-- replaces rather than augments DH key agreement with post-quantum KEM mechanism, making it potentially vulnerable to conventional computers.
-- adds signature to the DH ratchet step, to compensate for not keeping DH key agreement, but losing the deniability property for some of the messages.
-
-## Augmented double ratchet algorithm
-
-The double ratchet algorithm is augmented with post-quantum KEM mechanism, preserving all properties of the double ratchet algorithm.
-
-It is possible, because although double ratchet uses DH (which is a non-interactive key exchanges), it uses it "interactively", when the new DH keys are generated by both parties in turns. Parties of double-ratchet encrypted communication can run two post-quantum key encapsulation mechanisms in parallel with both DH and KEM key agreements in each DH ratchet step, making break-in recovery of double ratchet algorithm post-quantum resistant, without losing deniability or resistance to conventional computers.
-
-Specifically, [double ratchet with encrypted headers](https://signal.org/docs/specifications/doubleratchet/#double-ratchet-with-header-encryption) is augmented with some post-quantum key encapsulation mechanism (KEM) as described below. A possible algorithm for PQ KEM is [NTRU-prime](https://ntruprime.cr.yp.to), that is currently adopted in SSH and has available implementations. It is important though that the proposed scheme can be used with any PQ KEM algorithm.
-
-The downside of the scheme is its substantial size overhead, as the encapsulation key and encapsulated shared secret are added to the header of each message. For the algorithm described below NTRU-prime adds ~2-4kb to each message (depending on the key size and the chosen variant). See [this table](https://ntruprime.cr.yp.to/security.html) for key and ciphertext sizes and the assessment of the security level for various key sizes.
-
-It is possible to reduce size overhead by using only one KEM agreement and making only one of two ratchet steps providing post-quantum resistant break-in recovery.
-
-## Double ratchet with encrypted headers augmented with double PQ KEM
-
-Algorithm below assumes that in addition to shared secret from the initial key agreement, there will be an encapsulation key available from the party that published its keys (Bob).
-
-### Initialization
-
-The double ratchet initialization is defined in pseudo-code. This pseudo-code is identical to Signal algorithm specification except for that parts that add post-quantum key agreement.
-
-```
-// Alice obtained Bob's keys and initializes ratchet first
-def RatchetInitAlicePQ2HE(state, SK, bob_dh_public_key, shared_hka, shared_nhkb, bob_pq_kem_encapsulation_key):
-    state.DHRs = GENERATE_DH()
-    state.DHRr = bob_dh_public_key
-    // below added for post-quantum KEM
-    state.PQRs = GENERATE_PQKEM()
-    state.PQRr = bob_pq_kem_encapsulation_key
-    state.PQRct, state.PQRss = PQKEM-ENC(state.PQRr) // encapsulate: generates shared secret and ciphertext
-    // above added for KEM
-    // the next line augments DH key agreement with PQ shared secret
-    state.RK, state.CKs, state.NHKs = KDF_RK_HE(SK, DH(state.DHRs, state.DHRr) || state.PQRss)
-    state.CKr = None
-    state.Ns = 0
-    state.Nr = 0
-    state.PN = 0
-    state.MKSKIPPED = {}
-    state.HKs = shared_hka
-    state.HKr = None
-    state.NHKr = shared_nhkb
-
-// Bob initializes ratchet second, having received Alice's connection request
-def RatchetInitBobPQ2HE(state, SK, bob_dh_key_pair, shared_hka, shared_nhkb, bob_pq_kem_key_pair):
-    state.DHRs = bob_dh_key_pair
-    state.DHRr = None
-    // below added for KEM
-    state.PQRs = bob_pq_kem_key_pair
-    state.PQRr = None
-    state.PQRss = None
-    state.PQRct = None
-    // above added for KEM
-    state.RK = SK 
-    state.CKs = None
-    state.CKr = None
-    state.Ns = 0
-    state.Nr = 0
-    state.PN = 0
-    state.MKSKIPPED = {}
-    state.HKs = None
-    state.NHKs = shared_nhkb
-    state.HKr = None
-    state.NHKr = shared_hka
-```
-
-`GENERATE_PQKEM` generates decapsulation/encapsulation key pair.
-
-`PQKEM-ENC` is key encapsulation algorithm.
-
-Other than commented lines, the above adds parameters `bob_pq_kem_encapsulation_key` and `bob_pq_kem_key_pair` to the ratchet initialization. Otherwise it is identical to the original double ratchet initialization.
-
-### Encrypting messages
-
-```
-def RatchetEncryptPQ2HE(state, plaintext, AD):
-    state.CKs, mk = KDF_CK(state.CKs)
-    // encapsulation key from PQRs and encapsulated shared secret is added to header
-    header = HEADER_PQ2(
-      dh = state.DHRs.public,
-      kem = state.PQRs.public, // added for KEM #2
-      ct = state.PQRct // added for KEM #1
-      pn = state.PN,
-      n = state.Ns,
-    )
-    enc_header = HENCRYPT(state.HKs, header)
-    state.Ns += 1
-    return enc_header, ENCRYPT(mk, plaintext, CONCAT(AD, enc_header))
-```
-
-Other than adding encapsulation key and encapsulated shared secret into the header, the above is identical to the original double ratchet message encryption step.
-
-### Decrypting messages
-
-```
-def RatchetDecryptPQ2HE(state, enc_header, ciphertext, AD):
-    plaintext = TrySkippedMessageKeysHE(state, enc_header, ciphertext, AD)
-    if plaintext != None:
-        return plaintext
-    header, dh_ratchet = DecryptHeader(state, enc_header) // DecryptHeader is the same as in double ratchet specification
-    if dh_ratchet:
-        SkipMessageKeysHE(state, header.pn) // SkipMessageKeysHE is the same as in double ratchet specification
-        DHRatchetPQ2HE(state, header)
-    SkipMessageKeysHE(state, header.n)
-    state.CKr, mk = KDF_CK(state.CKr)
-    state.Nr += 1
-    return DECRYPT(mk, ciphertext, CONCAT(AD, enc_header))
-
-// DecryptHeader is the same as in double ratchet specification
-def DecryptHeader(state, enc_header):
-    header = HDECRYPT(state.HKr, enc_header)
-    if header != None:
-        return header, False
-    header = HDECRYPT(state.NHKr, enc_header)
-    if header != None:
-        return header, True
-    raise Error()
-
-def DHRatchetPQ2HE(state, header):
-    state.PN = state.Ns
-    state.Ns = 0
-    state.Nr = 0
-    state.HKs = state.NHKs
-    state.HKr = state.NHKr
-    state.DHRr = header.dh
-    // save new encapsulation key from header
-    state.PQRr = header.kem
-    // decapsulate shared secret from header - KEM #2
-    ss = PQKEM-DEC(state.PQRs.private, header.ct)
-    // use decapsulated shared secret with receiving ratchet
-    state.RK, state.CKr, state.NHKr = KDF_RK_HE(state.RK, DH(state.DHRs, state.DHRr) || ss)
-    state.DHRs = GENERATE_DH()
-    // below is added for KEM
-    state.PQRs = GENERATE_PQKEM() // generate new PQ key pair
-    state.PQRct, state.PQRss = PQKEM-ENC(state.PQRr) // encapsulate: generates shared secret and ciphertext KEM #1
-    // above is added for KEM
-    // use new shared secret with sending ratchet
-    state.RK, state.CKs, state.NHKs = KDF_RK_HE(state.RK, DH(state.DHRs, state.DHRr) || state.PQRss)
-```
-
-`PQKEM-DEC` is key decapsulation algorithm.
-
-`DHRatchetPQ2HE` augments both DH agreements with decapsulated shared secret from the received header and with the new shared secret, respectively. The new shared secret together with the new encapsulation key are saved in the state and will be added to the header in the next sent message.
-
-Other than augmenting DH key agreements with the shared secrets from KEM, the above is identical to the original double ratchet DH ratchet step.
-
-It is worth noting that while DH agreements work as ping-pong, when the new received DH key is used for both DH agreements (and only the sent DH key is updated for the second DH key agreement), PQ KEM agreements in the proposed scheme work as a "parallel ping-pong", with two balls in play all the time (two KEM agreements run in parallel).
-
-## Ratchet message wire format
-
-The pseudocode above describes the algorithm. This section specifies the actual binary encoding used in SimpleX implementation with Curve448 DH keys, sntrup761 KEM and AES-256-GCM AEAD.
-
-The ratchet-encrypted message has three encoding layers, from outermost to innermost:
-
-1. **Encrypted ratchet message** — the complete ratchet message envelope, referenced as an opaque encrypted body in [agent protocol](./agent-protocol.md).
-2. **Encrypted message header** — the encrypted header within the ratchet message, used as associated data for message body encryption.
-3. **Plaintext message header** — the DH and KEM ratchet keys and counters.
-
-### Encrypted ratchet message
-
-The outer envelope contains the encrypted header (used as associated data for body authentication), the body authentication tag, and the encrypted message body.
-
-The message body is encrypted with AES-256-GCM using the message key derived from the sending chain key (`KDF_CK`). The associated data for body encryption is the concatenation of the ratchet associated data and the encoded encrypted header.
-
-```abnf
-encRatchetMessage = versionedLength encMessageHeader msgAuthTag encMsgBody
-; encMessageHeader is used as associated data for body decryption: AD = rcAD || encMessageHeader
-msgAuthTag = 16*16 OCTET ; AES-256-GCM authentication tag for the message body
-encMsgBody = *OCTET ; AES-256-GCM encrypted padded message body (remaining bytes)
-```
-
-### Encrypted message header
-
-The encrypted header wraps the current ratchet e2e encryption version, an initialization vector, an authentication tag, and the encrypted padded header body.
-
-The header body is encrypted with AES-256-GCM using the header key (`HKs`). The associated data for header encryption is the ratchet associated data. The header is padded before encryption to a fixed size to prevent leaking information about the KEM state.
-
-```abnf
-encMessageHeader = currentVersion headerIV headerAuthTag versionedLength encHeaderBody
-currentVersion = 2*2 OCTET ; Word16, current ratchet e2e encryption version
-headerIV = 16*16 OCTET ; AES-256 initialization vector for header encryption
-headerAuthTag = 16*16 OCTET ; AES-256-GCM authentication tag for the header
-encHeaderBody = *OCTET ; AES-256-GCM encrypted padded header (see plaintext format below)
-```
-
-`versionedLength` uses a 2-byte length prefix (Word16) when the current e2e version supports PQ encryption, or a 1-byte length prefix otherwise. The parser distinguishes the two encodings by peeking at the first byte: values below 32 indicate a 2-byte prefix (as the header is always at least 69 bytes).
-
-```abnf
-versionedLength = largeLength / length ; 2-byte for PQ versions, 1-byte for pre-PQ versions
-```
-
-The padded header sizes before encryption are: 2310 bytes when PQ is supported, 88 bytes when PQ is not supported. Padding uses a 2-byte big-endian length prefix followed by the plaintext header and `#` fill bytes.
-
-### Plaintext message header
-
-```abnf
-msgHeader = maxVersion dhPublicKey [kemParams] prevMsgCount msgCount
-maxVersion = 2*2 OCTET ; Word16, max supported e2e encryption version
-dhPublicKey = length x509encoded ; Curve448 public DH ratchet key
-kemParams = noKEM / proposedKEM / acceptedKEM
-  ; present only when current ratchet version >= pqRatchetE2EEncryptVersion
-noKEM = %x30 ; "0" - no KEM parameters
-proposedKEM = %x31 %s"P" kemEncapsulationKey ; KEM proposed, not yet accepted
-acceptedKEM = %x31 %s"A" kemCiphertext kemEncapsulationKey ; KEM accepted
-kemEncapsulationKey = largeLength 1158*1158 OCTET ; sntrup761 encapsulation key
-kemCiphertext = largeLength 1039*1039 OCTET ; sntrup761 ciphertext
-prevMsgCount = 4*4 OCTET ; Word32, number of messages in previous sending chain
-msgCount = 4*4 OCTET ; Word32, message number in current sending chain
-length = 1*1 OCTET
-largeLength = 2*2 OCTET ; Word16
-```
-
-### KEM state machine
-
-PQ encryption can be enabled or disabled during a connection's lifetime. The KEM parameters in the header reflect three states:
-
-- **No KEM** (`noKEM`): PQ encryption is not active. The header contains only the DH key, as in the original double ratchet.
-- **Proposed** (`proposedKEM`): One party generated a KEM key pair and includes the encapsulation key in the header, proposing PQ encryption. No ciphertext is included because the other party has not yet sent its encapsulation key.
-- **Accepted** (`acceptedKEM`): The party received the other's encapsulation key, performed encapsulation (KEM #1), and includes both the ciphertext and its own new encapsulation key (for KEM #2). This is the steady state for active PQ encryption.
-
-The transition from Proposed to Accepted happens when a party receives a message containing KEM parameters (either Proposed or Accepted) and responds with its own Accepted parameters. Once both parties are in Accepted state, the double PQ KEM augmentation described in the algorithm above operates in each DH ratchet step.
-
-## Implementation considerations for SimpleX Messaging Protocol
-
-As SimpleX Messaging Protocol pads messages to a fixed size, using 16kb transport blocks, the size increase introduced by this scheme can be compensated for by using ZSTD encryption of JSON bodies and image previews encoded as base64. While there may be some rare cases of random texts that would fail to compress, in all real scenarios it would not cause the message size reduction.
-
-Sharing the initial keys in case of SimpleX Chat it is equivalent to sharing the invitation link. As encapsulation key is large, it may be inconvenient to share it in the link in some contexts, e.g. when QR codes are used.
-
-It is possible to postpone sharing the encapsulation key until the first message from Alice (confirmation message in SMP protocol), the party sending connection request. The upside here is that the invitation link size would not increase. The downside is that the user profile shared in this confirmation will not be encrypted with PQ-resistant algorithm.
-
-Another consideration is pairwise ratchets in groups. Key generation in sntrup761 is quite slow - on slow devices it can be as slow as 10-20 keys per second, so using this primitive in groups larger than 10-20 members would result in slow performance.
-
-For backward compatibility the implementation must support adding PQ-resistant key agreement to the existing connections.
-
-It is also beneficial to support removing PQ-resistant key agreement from the connections that have them, e.g. as the group size grows.
-
-### Chosen KEM algorithm
-
-The implementation uses Streamlined NTRU-Prime 761 (sntrup761) that was also used for OpenSSH for a long time.
-
-It was chosen over ML-KEM (Kyber) standardized by NIST for several reasons:
-
-- sntrup761 was used in OpenSSH for a long period of time.
-- ML-KEM standardization process raised [concerns](https://groups.google.com/a/list.nist.gov/g/pqc-forum/c/WFRDl8DqYQ4) [amongst](https://blog.cr.yp.to/20231003-countcorrectly.html) the experts.
-- ML-KEM (if modified) is likely to have conflicts with the existing patents, unlike sntrup761.
-
-It was chosen over non-interactive CTIDH due to its slower implementation, and lack of optimized code for aarch64 CPUs used in mobile devices.
-
-## Summary
-
-If chosen PQ KEM proves secure against quantum computer attacks, then the proposed augmented double ratchet will also be secure against quantum computer attack, including break-in recovery property, while keeping deniability and forward secrecy, because the [same proof](https://eprint.iacr.org/2016/1013.pdf) as for double ratchet algorithm would hold here, provided chosen KEM is secure.

protocol/push-notifications.md

@@ -1,420 +0,0 @@
-Version 3, 2025-01-24
-
-# Overview of push notifications for SimpleX Messaging Routers
-
-This document describes Notification Router protocol version 3. Version history:
-- v1: initial version
-- v2: authenticated commands, command batching
-- v3: detailed invalid token reason
-
-## Table of contents
-
-- [Introduction](#introduction)
-- [Participating routers](#participating-routers)
-- [Register device token to receive push notifications](#register-device-token-to-receive-push-notifications)
-- [Subscribe to connection notifications](#subscribe-to-connection-notifications)
-- [SimpleX Notification Router protocol](#simplex-notification-router-protocol)
-  - [Register new notification token](#register-new-notification-token)
-  - [Verify notification token](#verify-notification-token)
-  - [Check notification token status](#check-notification-token-status)
-  - [Replace notification token](#replace-notification-token)
-  - [Delete notification token](#delete-notification-token)
-  - [Subscribe to periodic notifications](#subscribe-to-periodic-notifications)
-  - [Create SMP message notification subscription](#create-smp-message-notification-subscription)
-  - [Check notification subscription status](#check-notification-subscription-status)
-  - [Delete notification subscription](#delete-notification-subscription)
-  - [Error responses](#error-responses)
-- [Threat model](#threat-model)
-
-## Introduction
-
-SimpleX Messaging routers already operate as push routers and deliver the messages to subscribed clients as soon as they are sent to the routers.
-
-The reason for push notifications is to support instant message notifications on iOS that does not allow background services.
-
-## Participating routers
-
-The diagram below shows which routers participate in message notification delivery.
-
-While push provider (e.g., APN) can learn how many notifications are delivered to the user, it cannot access message content, even encrypted, or any message metadata - the notifications are e2e encrypted between SimpleX Notification Router and the user's device.
-
-```
-  User's iOS device                Internet                           Routers
----------------------   .   ------------------------   .   -----------------------------
-                        .                              .
-                        .                              .       can be self-hosted now
-+--------------+        .                              .         +----------------+
-| SimpleX Chat |       -------------- TLS ---------------        | SimpleX        |
-|    client    |------> SimpleX Messaging Protocol (SMP) ------> | Messaging      |
-+--------------+       ----------------------------------        | Router         |
-     ^    |             .                              .         +----------------+
-     |    |             .                              .          . . .  |   . . .
-     |    |             .                              .               | V |
-     |    |             .                              .               |SMP| TLS
-     |    |             .                              .               | | |               SimpleX
-     |    |             .                              .          . . .  V   . . .      NTF Router
-     |    |             .                              .       +----------------------------------+
-     |    |             .                              .       | +---------------+                |
-     |    |            -------------- TLS ---------------      | | SimpleX       | can be         | 
-     |    |----------->   Notification Router Protocol  -----> | | Notifications | self-hosted    |
-     |                 ----------------------------------      | | Subscriber    | in the future  |
-     |                  .                              .       | +---------------+                |
-     |                  .                              .       |         |                        |
-     |                  .                              .       |         V                        |
-     |                  .                              .       | +---------------+                |
-     |                  .                              .       | | SimpleX       |                |
-     |                  .                              .       | | Push          |                |
-     |                  .                              .       | | Router        |                |
-     |                  .                              .       | +---------------+                |
-     |                  .                              .       +----------------------------------+
-     |                  .                              .          . . .  |   . . .
-     |                  .                              .               | V |
-     |                  .                              .               |SMP| TLS
-     |                  .                              .               | | |
-     |                  .                              .          . . .  V   . . .
-     |                 -------------- TLS ---------------       +-----------------+
-     |-----------------       Notification delivery     <-------| Apple PN server |
-                       ----------------------------------       +-----------------+
-                        .                              .
-```
-
-## Register device token to receive push notifications
-
-This diagram shows the process of registering a device to receive PUSH notifications via Apple Push Notification (APN) servers.
-
-![Register device notification token](./diagrams/notifications/register-token.svg)
-
-## Subscribe to connection notifications
-
-This diagram shows the process of subscription to notifications, notification delivery and device token update.
-
-![Subscribe to notifications](./diagrams/notifications/subscription.svg)
-
-## SimpleX Notification Router protocol
-
-To manage notification subscriptions to SMP routers, SimpleX Notification Router provides an RPC protocol with a similar design to SimpleX Messaging Protocol router.
-
-This protocol sends requests and responses in a fixed size blocks of 512 bytes over TLS, uses the same [syntax of protocol transmissions](./simplex-messaging.md#smp-transmission-and-transport-block-structure) as SMP protocol, and has the same transport [handshake syntax](./simplex-messaging.md#transport-handshake) (except the router certificate is not included in the handshake).
-
-The client and router use ALPN extension with `ntf/1` protocol name to agree handshake version.
-
-Protocol commands have this syntax:
-
-```abnf
-ntfRouterTransmission = authorization corrId entityId ntfRouterCmd
-  ; same transmission structure as SMP, see simplex-messaging.md
-ntfRouterCmd = newTokenCmd / verifyTokenCmd / checkTokenCmd /
-               replaceTokenCmd / deleteTokenCmd / cronCmd /
-               newSubCmd / checkSubCmd / deleteSubCmd / pingCmd
-```
-### Register new notification token
-
-This command should be used after the client app obtains a token from push notifications provider to register the token with the router.
-
-Having received this command the router will deliver a test notification via the push provider to validate that the client has this token.
-
-The command syntax:
-
-```abnf
-newTokenCmd = %s"TNEW" SP newToken
-newToken = %s"T" deviceToken authPubKey clientDhPubKey
-deviceToken = pushProvider tokenString
-pushProvider = apnsDev / apnsProd / apnsTest / apnsNull
-apnsDev = "AD" ; APNS token for development environment
-apnsProd = "AP" ; APNS token for production environment
-apnsTest = "AT" ; APNS token for test environment (mock server)
-apnsNull = "AN" ; token that does not trigger any notification delivery - used for router testing
-tokenString = shortString
-authPubKey = length x509encoded ; Ed25519 key used to verify clients commands
-clientDhPubKey = length x509encoded ; X25519 key to agree e2e encryption between the router and client
-shortString = length *OCTET
-length = 1*1 OCTET
-```
-
-The router response syntax:
-
-```abnf
-tokenIdResp = %s"IDTKN" SP entityId routerDhPubKey
-entityId = shortString
-routerDhPubKey = length x509encoded ; X25519 key to agree e2e encryption between the router and client
-```
-
-### Verify notification token
-
-This command is used to verify the token after the device receives the test notification from the push provider.
-
-The command syntax:
-
-```abnf
-verifyTokenCmd = %s"TVFY" SP regCode
-regCode = shortString
-```
-
-The response to this command is `okResp` or `errorResp`
-
-```abnf
-okResp = %s"OK"
-```
-
-### Check notification token status
-
-This command is used to check the token status:
-
-```abnf
-checkTokenCmd = %s"TCHK"
-```
-
-The response to this command:
-
-```abnf
-tokenStatusResp = %s"TKN" SP tokenStatus
-tokenStatus = %s"NEW" / %s"REGISTERED" / tokenInvalid / %s"CONFIRMED" / %s"ACTIVE" / %s"EXPIRED"
-tokenInvalid = %s"INVALID" ["," invalidReason] ; optional reason added in v3
-invalidReason = %s"BAD" / %s"TOPIC" / %s"EXPIRED" / %s"UNREGISTERED"
-```
-
-### Replace notification token
-
-This command should be used when push provider issues a new notification token.
-
-It happens when:
-- the app data is migrated to another device.
-- the app is re-installed on the same device.
-- can happen periodically, at push provider discretion.
-
-This command allows to replace the token without re-registering and re-subscribing all notification subscriptions.
-
-Using this command triggers the same verification flow as registering a new token.
-
-The command syntax:
-
-```abnf
-replaceTokenCmd = %s"TRPL" SP deviceToken
-```
-
-The response to this command is `okResp` or `errorResp`.
-
-### Delete notification token
-
-The command syntax:
-
-```abnf
-deleteTokenCmd = %s"TDEL"
-```
-
-The response to this command is `okResp` or `errorResp`.
-
-After this command all message notification subscriptions will be removed and no more notifications will be sent.
-
-### Subscribe to periodic notifications
-
-This command enables or disables periodic notifications sent to the client device irrespective of message notifications.
-
-This is useful for two reasons:
-- it provides better privacy from notification router, as while the router learns the device token, it doesn't learn anything else about user communications.
-- it allows to receive messages when notifications were dropped by push provider, e.g. while the device was offline, or lost by notification router, e.g. while it was restarting.
-
-The command syntax:
-
-```abnf
-cronCmd = %s"TCRN" SP interval
-interval = 2*2 OCTET ; Word16, minutes
-```
-
-The interval for periodic notifications is set in minutes, with the minimum of 20 minutes. The client should pass `0` to disable periodic notifications.
-
-### Create SMP message notification subscription
-
-This command makes notification router subscribe to message notifications from SMP router and to deliver them to push provider:
-
-```abnf
-newSubCmd = %s"SNEW" SP newSub
-newSub = %s"S" tokenId smpRouter notifierId notifierKey
-tokenId = shortString ; returned in response to `TNEW` command
-smpRouter = hosts port fingerprint
-hosts = length 1*host
-host = shortString
-port = shortString
-fingerprint = shortString
-notifierId = shortString ; returned by SMP router in response to `NKEY` SMP command
-notifierKey = length x509encoded ; private key used to authorize requests to subscribe to message notifications
-```
-
-The response syntax:
-
-```abnf
-subIdResp = %s"IDSUB" SP entityId
-```
-
-### Check notification subscription status
-
-This command syntax:
-
-```abnf
-checkSubCmd = %s"SCHK"
-```
-
-The response:
-
-```abnf
-subStatusResp = %s"SUB" SP subStatus
-subStatus = %s"NEW" / %s"PENDING" / ; e.g., after SMP router disconnect/timeout while ntf router is retrying to connect
-            %s"ACTIVE" / %s"INACTIVE" / %s"END" / ; if another router subscribed to notifications
-            %s"AUTH" / %s"DELETED" / %s"SERVICE" / subErrStatus
-subErrStatus = %s"ERR" SP *OCTET
-```
-
-### Delete notification subscription
-
-The command syntax:
-
-```abnf
-deleteSubCmd = %s"SDEL"
-```
-
-The response to this command is `okResp` or `errorResp`.
-
-After this command no more message notifications will be sent from this queue.
-
-### Keep-alive command
-
-To keep the transport connection alive the clients should use `PING` command:
-
-```abnf
-pingCmd = %s"PING"
-pongResp = %s"PONG"
-```
-
-This command is sent unsigned and without entity ID.
-
-### Error responses
-
-All commands can return error response:
-
-```abnf
-errorResp = %s"ERR" SP errorType
-```
-
-Where `errorType` has the same syntax as in [SimpleX Messaging Protocol](./simplex-messaging.md#error-responses)
-
-## Threat Model
-
-This threat model compliments SimpleX Messaging Protocol [threat model](./security.md#threat-model)
-
-#### A passive adversary able to monitor the traffic of one user
-
-*can:*
-
- - identify that and a user is using SimpleX push notifications.
-
-*cannot:*
-
- - determine which routers a user subscribed to the notifications from.
-
-#### A passive adversary able to monitor a set of senders and recipients
-
- *can:*
-
- - perform more efficient traffic correlation attacks against senders and recipients and correlate senders and recipients within the monitored set, frustrated by the number of users on the routers.
-
-#### SimpleX Messaging Protocol router
-
-*can:*
-
-- learn which messages trigger push notifications.
-
-- learn IP address of SimpleX notification routers used by the user.
-
-- drop message notifications.
-
-- spam a user with invalid notifications.
-
-*cannot:*
-
-- learn user device token for push notifications.
-
-- learn which queues belong to the same users with any additional efficiency compared with not using push notifications.
-
-#### SimpleX Notification Router subscribed to message notifications
-
-*can:*
-
-- learn a user device token.
-
-- learn how many messaging queues and routers a user receives messages from.
-
-- learn how many message notifications are delivered to the user from each queue.
-
-- undetectably drop notifications.
-
-- spam a user with background notifications.
-
-*cannot:*
-
-- learn queue addresses for receiving or sending messages.
-
-- learn the contents or type of messages (not even encrypted).
-
-- learn anything about messages sent without notification flag.
-
-- spam a user with visible notifications (provided the client app can filter push notifications).
-
-- add, duplicate, or corrupt individual messages that will be shown to the user.
-
-#### SimpleX Notification Router subscribed ONLY to periodic notifications
-
-*can:*
-
-- learn a user device token.
-
-- drop periodic notifications.
-
-- spam a user with background notifications.
-
-*cannot:*
-
-- learn how many messaging queues and routers a user receives messages from.
-
-- learn how many message notifications are delivered to the user from each queue.
-
-- learn queue addresses for receiving or sending messages.
-
-- learn the contents or type of messages (not even encrypted).
-
-- learn anything about messages sent without notification flag.
-
-- spam a user with visible notifications (provided the client app can filter push notifications).
-
-- add, duplicate, or corrupt individual messages that will be shown to the user.
-
-#### A user’s contact
-
-*cannot:*
-
-- determine if a user uses push notifications or not.
-
-#### Push notification provider (e.g., APN)
-
-*can:*
-
-- learn that a user uses SimpleX app.
-
-- learn how many notifications are delivered to user's device.
-
-- drop notifications (in fact, APN coalesces notifications delivered while user's device is offline, delivering only the last one).
-
-*cannot:*
-
-- learn which SimpleX Messaging Protocol routers are used by a user (notifications are e2e encrypted).
-
-- learn which or how many messaging queues a user receives notifications from.
-
-- learn the contents or type of messages (not even encrypted, notifications only contain encrypted metadata).
-
-#### An attacker with Internet access
-
-*cannot:*
-
-- register notification token not present on attacker's device.
-
-- enumerate tokens or subscriptions on a SimpleX Notification Router.