chore(release): prepare for 1.138.2

ci: add npm token to publish deltachat-rpc-server packages
api(deltachat-rpc-client): add CONFIG_SYNCED constant
2026-04-09 09:02:10 +03:00 · 2024-05-15 18:34:06 +00:00 · 2024-05-15 18:08:58 +00:00 · 2024-05-15 17:20:06 +00:00 · 2024-05-15 06:30:17 +00:00 · 2024-05-15 06:27:57 +00:00
59 changed files with 1376 additions and 132 deletions
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -113,6 +113,9 @@ jobs:
      - name: Tests
        env:
          RUST_BACKTRACE: 1
+
+          # Workaround for <https://github.com/nextest-rs/nextest/issues/1493>.
+          RUSTUP_WINDOWS_PATH_ADD_BIN: 1
        run: cargo nextest run --workspace

      - name: Doc-Tests
--- a/.github/workflows/deltachat-rpc-server.yml
+++ b/.github/workflows/deltachat-rpc-server.yml
@@ -266,3 +266,133 @@ jobs:
      - name: Publish deltachat-rpc-client to PyPI
        if: github.event_name == 'release'
        uses: pypa/gh-action-pypi-publish@release/v1
+
+  publish_npm_package:
+    name: Build & Publish npm prebuilds and deltachat-rpc-server
+    needs: ["build_linux", "build_windows", "build_macos"]
+    runs-on: "ubuntu-latest"
+    permissions:
+      id-token: write
+      contents: read
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          show-progress: false
+      - uses: actions/setup-python@v5
+        with:
+          python-version: '3.11' 
+
+      - name: Download Linux aarch64 binary
+        uses: actions/download-artifact@v4
+        with:
+          name: deltachat-rpc-server-aarch64-linux
+          path: deltachat-rpc-server-aarch64-linux.d
+
+      - name: Download Linux armv7l binary
+        uses: actions/download-artifact@v4
+        with:
+          name: deltachat-rpc-server-armv7l-linux
+          path: deltachat-rpc-server-armv7l-linux.d
+
+      - name: Download Linux armv6l binary
+        uses: actions/download-artifact@v4
+        with:
+          name: deltachat-rpc-server-armv6l-linux
+          path: deltachat-rpc-server-armv6l-linux.d
+
+      - name: Download Linux i686 binary
+        uses: actions/download-artifact@v4
+        with:
+          name: deltachat-rpc-server-i686-linux
+          path: deltachat-rpc-server-i686-linux.d
+
+      - name: Download Linux x86_64 binary
+        uses: actions/download-artifact@v4
+        with:
+          name: deltachat-rpc-server-x86_64-linux
+          path: deltachat-rpc-server-x86_64-linux.d
+
+      - name: Download Win32 binary
+        uses: actions/download-artifact@v4
+        with:
+          name: deltachat-rpc-server-win32
+          path: deltachat-rpc-server-win32.d
+
+      - name: Download Win64 binary
+        uses: actions/download-artifact@v4
+        with:
+          name: deltachat-rpc-server-win64
+          path: deltachat-rpc-server-win64.d
+
+      - name: Download macOS binary for x86_64
+        uses: actions/download-artifact@v4
+        with:
+          name: deltachat-rpc-server-x86_64-macos
+          path: deltachat-rpc-server-x86_64-macos.d
+
+      - name: Download macOS binary for aarch64
+        uses: actions/download-artifact@v4
+        with:
+          name: deltachat-rpc-server-aarch64-macos
+          path: deltachat-rpc-server-aarch64-macos.d
+
+      - name: Download Android binary for arm64-v8a
+        uses: actions/download-artifact@v4
+        with:
+          name: deltachat-rpc-server-arm64-v8a-android
+          path: deltachat-rpc-server-arm64-v8a-android.d
+
+      - name: Download Android binary for armeabi-v7a
+        uses: actions/download-artifact@v4
+        with:
+          name: deltachat-rpc-server-armeabi-v7a-android
+          path: deltachat-rpc-server-armeabi-v7a-android.d
+
+      - name: make npm packets for prebuilds and `@deltachat/stdio-rpc-server`
+        run: |
+          cd deltachat-rpc-server/npm-package
+
+          python --version
+
+          python scripts/pack_binary_for_platform.py aarch64-unknown-linux-musl     ../../deltachat-rpc-server-aarch64-linux.d/deltachat-rpc-server
+          python scripts/pack_binary_for_platform.py armv7-unknown-linux-musleabihf ../../deltachat-rpc-server-armv7l-linux.d/deltachat-rpc-server 
+          python scripts/pack_binary_for_platform.py arm-unknown-linux-musleabihf   ../../deltachat-rpc-server-armv6l-linux.d/deltachat-rpc-server 
+          python scripts/pack_binary_for_platform.py i686-unknown-linux-musl        ../../deltachat-rpc-server-i686-linux.d/deltachat-rpc-server 
+          python scripts/pack_binary_for_platform.py x86_64-unknown-linux-musl      ../../deltachat-rpc-server-x86_64-linux.d/deltachat-rpc-server
+          python scripts/pack_binary_for_platform.py i686-pc-windows-gnu            ../../deltachat-rpc-server-win32.d/deltachat-rpc-server.exe 
+          python scripts/pack_binary_for_platform.py x86_64-pc-windows-gnu          ../../deltachat-rpc-server-win64.d/deltachat-rpc-server.exe 
+          python scripts/pack_binary_for_platform.py x86_64-apple-darwin            ../../deltachat-rpc-server-x86_64-macos.d/deltachat-rpc-server 
+          python scripts/pack_binary_for_platform.py aarch64-apple-darwin           ../../deltachat-rpc-server-aarch64-macos.d/deltachat-rpc-server 
+          python scripts/pack_binary_for_platform.py aarch64-linux-android          ../../deltachat-rpc-server-arm64-v8a-android.d/deltachat-rpc-server
+          python scripts/pack_binary_for_platform.py armv7-linux-androideabi        ../../deltachat-rpc-server-armeabi-v7a-android.d/deltachat-rpc-server
+
+          ls -lah platform_package
+
+          for platform in ./platform_package/*; do npm pack "$platform"; done
+          npm pack    
+          ls -lah
+      
+      - name: Upload to artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: deltachat-rpc-server-npm-package
+          path: deltachat-rpc-server/npm-package/*.tgz
+          if-no-files-found: error
+
+      - name: Upload npm packets to the GitHub release
+        if: github.event_name == 'release'
+        env:
+          GITHUB_TOKEN: "${{ secrets.GITHUB_TOKEN }}"
+        run: |
+          gh release upload ${{ github.ref_name }} \
+            --repo ${{ github.repository }} \
+            deltachat-rpc-server/npm-package/*.tgz
+
+      - name: Publish npm packets for prebuilds and `@deltachat/stdio-rpc-server`
+        if: github.event_name == 'release'
+        working-directory: deltachat-rpc-server/npm-package
+        run: |
+          ls -lah platform_package
+          for platform in *.tgz; do npm publish --provenance "$platform"; done
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
--- a/.gitignore
+++ b/.gitignore
@@ -33,6 +33,7 @@ deltachat-ffi/xml

 coverage/
 .DS_Store
+.vscode
 .vscode/launch.json
 python/accounts.txt
 python/all-testaccounts.txt
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,144 @@
 # Changelog

+## [1.138.2] - 2024-05-15
+
+### API-Changes
+
+- deltachat-rpc-client: Add CONFIG_SYNCED constant.
+
+### CI
+
+- Add npm token to publish deltachat-rpc-server packages.
+
+### Features / Changes
+
+- Reset more settings when configuring a chatmail account.
+
+### Tests
+
+- Set configuration after configure() finishes.
+
+## [1.138.1] - 2024-05-14
+
+### Features / Changes
+
+- Detect XCHATMAIL capability and expose it as `is_chatmail` config.
+
+### Fixes
+
+- Never treat message with Chat-Group-ID as a private reply.
+- Always prefer Chat-Group-ID over In-Reply-To and References.
+- Ignore parent message if message references itself.
+
+### CI
+
+- Set RUSTUP_WINDOWS_PATH_ADD_BIN to work around `nextest` issue <https://github.com/nextest-rs/nextest/issues/1493>.
+- deltachat-rpc-server: Fix upload of npm packages to github releases ([#5564](https://github.com/deltachat/deltachat-core-rust/pull/5564)).
+
+### Refactor
+
+- Add MimeMessage.get_chat_group_id().
+- Make MimeMessage.get_header() return Option<&str>.
+- sql: Make open flags immutable.
+- Resultify token::lookup_or_new().
+
+### Miscellaneous Tasks
+
+- cargo: Bump parking_lot from 0.12.1 to 0.12.2.
+- cargo: Bump libc from 0.2.153 to 0.2.154.
+- cargo: Bump hickory-resolver from 0.24.0 to 0.24.1.
+- cargo: Bump serde_json from 1.0.115 to 1.0.116.
+- cargo: Bump human-panic from 1.2.3 to 2.0.0.
+- cargo: Bump brotli from 5.0.0 to 6.0.0.
+
+## [1.138.0] - 2024-05-13
+
+### API-Changes
+
+- Add dc_msg_save_file() which saves file copy at the provided path ([#4309](https://github.com/deltachat/deltachat-core-rust/pull/4309)).
+- Api!(jsonrpc): replace EphemeralTimer tag "variant" with "kind"
+
+### CI
+
+- Use rsync instead of 3rd party github action.
+- Replace `black` with `ruff format`.
+- Update Rust to 1.78.0.
+
+### Documentation
+
+- Fix references in Message.set_location() documentation.
+- Remove Doxygen markup from Message.has_location().
+- Add `location` module documentation.
+
+### Features / Changes
+
+- Delete expired path locations in ephemeral loop.
+- Delete orphaned POI locations during housekeeping.
+- Parsing vCards for contacts sharing ([#5482](https://github.com/deltachat/deltachat-core-rust/pull/5482)).
+- contact-tools: Support parsing profile images from "PHOTO:data:image/jpeg;base64,...".
+- contact-tools: Add make_vcard().
+- Do not add location markers to messages with non-POI location.
+- Make one-to-one chats read-only the first seconds of a SecureJoin ([#5512](https://github.com/deltachat/deltachat-core-rust/pull/5512)).
+
+### Fixes
+
+- Message::set_file_from_bytes(): Set Param::Filename.
+- Do not fail to send encrypted quotes to unencrypted chats.
+- Never prepend subject to message text when bot receives it.
+- Interrupt location loop when new location is stored.
+- Correct message viewtype before recoding image blob ([#5496](https://github.com/deltachat/deltachat-core-rust/pull/5496)).
+- Delete POI location when disappearing message expires.
+- Delete non-POI locations after `delete_device_after`, not immediately.
+- Update special chats icons even if they are blocked ([#5509](https://github.com/deltachat/deltachat-core-rust/pull/5509)).
+- Use ChatIdBlocked::lookup_by_contact() instead of ChatId's method when applicable.
+
+### Miscellaneous Tasks
+
+- cargo: Bump quote from 1.0.35 to 1.0.36.
+- cargo: Bump base64 from 0.22.0 to 0.22.1.
+- cargo: Bump serde from 1.0.197 to 1.0.200.
+- cargo: Bump async-channel from 2.2.0 to 2.2.1.
+- cargo: Bump thiserror from 1.0.58 to 1.0.59.
+- cargo: Bump anyhow from 1.0.81 to 1.0.82.
+- cargo: Bump chrono from 0.4.37 to 0.4.38.
+- cargo: Bump imap-proto from 0.16.4 to 0.16.5.
+- cargo: Bump syn from 2.0.57 to 2.0.60.
+- cargo: Bump mailparse from 0.14.1 to 0.15.0.
+- cargo: Bump schemars from 0.8.16 to 0.8.19.
+
+### Other
+
+- Build ts docs with ci + nix.
+- Push docs to delta.chat instead of codespeak
+- Implement jsonrpc-docs build in github action
+- Rm unneeded rust install from ts docs ci
+- Correct folder for js.jsonrpc docs
+- Add npm install to upload-docs.yml
+- Add : to upload-docs.yml
+- Upload-docs npm run => npm run build
+- Rm leading slash
+- Rm npm install
+- Merge pull request #5515 from deltachat/dependabot/cargo/quote-1.0.36
+- Merge pull request #5522 from deltachat/dependabot/cargo/chrono-0.4.38
+- Merge pull request #5523 from deltachat/dependabot/cargo/mailparse-0.15.0
+- Add webxdc internal integration commands in jsonrpc ([#5541](https://github.com/deltachat/deltachat-core-rust/pull/5541))
+- Limit quote replies ([#5543](https://github.com/deltachat/deltachat-core-rust/pull/5543))
+- Stdio jsonrpc server npm package ([#5332](https://github.com/deltachat/deltachat-core-rust/pull/5332))
+
+### Refactor
+
+- python: Fix ruff 0.4.2 warnings.
+- Move `delete_poi_location` to location module and document it.
+- Remove allow_keychange.
+
+### Tests
+
+- Explain test_was_seen_recently false-positive and give workaround instructions ([#5474](https://github.com/deltachat/deltachat-core-rust/pull/5474)).
+- Test that member is added even if "Member added" is lost.
+- Test that POIs are deleted when ephemeral message expires.
+- Test ts build on branch
+
+
 ## [1.137.4] - 2024-04-24

 ### API-Changes
@@ -3983,3 +4122,6 @@ https://github.com/deltachat/deltachat-core-rust/pulls?q=is%3Apr+is%3Aclosed
 [1.137.2]: https://github.com/deltachat/deltachat-core-rust/compare/v1.137.1...v1.137.2
 [1.137.3]: https://github.com/deltachat/deltachat-core-rust/compare/v1.137.2...v1.137.3
 [1.137.4]: https://github.com/deltachat/deltachat-core-rust/compare/v1.137.3...v1.137.4
+[1.138.0]: https://github.com/deltachat/deltachat-core-rust/compare/v1.137.4...v1.138.0
+[1.138.1]: https://github.com/deltachat/deltachat-core-rust/compare/v1.138.0...v1.138.1
+[1.138.2]: https://github.com/deltachat/deltachat-core-rust/compare/v1.138.1...v1.138.2
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -567,9 +567,9 @@ dependencies = [

 [[package]]
 name = "brotli"
-version = "5.0.0"
+version = "6.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "19483b140a7ac7174d34b5a581b406c64f84da5409d3e09cf4fff604f9270e67"
+checksum = "74f7971dbd9326d58187408ab83117d8ac1bb9c17b085fdacd1cf2f598719b6b"
 dependencies = [
 "alloc-no-stdlib",
 "alloc-stdlib",
@@ -1157,7 +1157,7 @@ dependencies = [

 [[package]]
 name = "deltachat"
-version = "1.137.4"
+version = "1.138.2"
 dependencies = [
 "ansi_term",
 "anyhow",
@@ -1250,7 +1250,7 @@ dependencies = [

 [[package]]
 name = "deltachat-jsonrpc"
-version = "1.137.4"
+version = "1.138.2"
 dependencies = [
 "anyhow",
 "async-channel 2.2.1",
@@ -1274,7 +1274,7 @@ dependencies = [

 [[package]]
 name = "deltachat-repl"
-version = "1.137.4"
+version = "1.138.2"
 dependencies = [
 "ansi_term",
 "anyhow",
@@ -1289,7 +1289,7 @@ dependencies = [

 [[package]]
 name = "deltachat-rpc-server"
-version = "1.137.4"
+version = "1.138.2"
 dependencies = [
 "anyhow",
 "deltachat",
@@ -1318,7 +1318,7 @@ dependencies = [

 [[package]]
 name = "deltachat_ffi"
-version = "1.137.4"
+version = "1.138.2"
 dependencies = [
 "anyhow",
 "deltachat",
@@ -2363,9 +2363,9 @@ dependencies = [

 [[package]]
 name = "hickory-resolver"
-version = "0.24.0"
+version = "0.24.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "35b8f021164e6a984c9030023544c57789c51760065cd510572fedcfb04164e8"
+checksum = "28757f23aa75c98f254cf0405e6d8c25b831b32921b050a66692427679b1f243"
 dependencies = [
 "cfg-if",
 "futures-util",
@@ -2468,9 +2468,9 @@ checksum = "df3b46402a9d5adb4c86a0cf463f42e19994e3ee891101b1841f30a545cb49a9"

 [[package]]
 name = "human-panic"
-version = "1.2.3"
+version = "2.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c4f016c89920bbb30951a8405ecacbb4540db5524313b9445736e7e1855cf370"
+checksum = "a4c5d0e9120f6bca6120d142c7ede1ba376dd6bf276d69dd3dbe6cbeb7824179"
 dependencies = [
 "backtrace",
 "os_info",
@@ -2835,9 +2835,9 @@ dependencies = [

 [[package]]
 name = "libc"
-version = "0.2.153"
+version = "0.2.154"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9c198f91728a82281a64e1f4f9eeb25d82cb32a5de251c6bd1b5154d63a8e7bd"
+checksum = "ae743338b92ff9146ce83992f766a31066a91a8c84a45e0e9f21e7cf6de6d346"

 [[package]]
 name = "libm"
@@ -3398,9 +3398,9 @@ checksum = "bb813b8af86854136c6922af0598d719255ecb2179515e6e7730d468f05c9cae"

 [[package]]
 name = "parking_lot"
-version = "0.12.1"
+version = "0.12.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3742b2c103b9f06bc9fff0a37ff4912935851bee6d36f3c02bcc755bcfec228f"
+checksum = "7e4af0ca4f6caed20e900d564c242b8e5d4903fdacf31d3daf527b66fe6f42fb"
 dependencies = [
 "lock_api",
 "parking_lot_core",
@@ -4550,9 +4550,9 @@ dependencies = [

 [[package]]
 name = "serde_json"
-version = "1.0.115"
+version = "1.0.116"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "12dc5c46daa8e9fdf4f5e71b6cf9a53f2487da0e86e55808e2d35539666497dd"
+checksum = "3e17db7126d17feb94eb3fad46bf1a96b034e8aacbc2e775fe81505f8b0b2813"
 dependencies = [
 "itoa",
 "ryu",
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "deltachat"
-version = "1.137.4"
+version = "1.138.2"
 edition = "2021"
 license = "MPL-2.0"
 rust-version = "1.77"
@@ -47,7 +47,7 @@ async-smtp = { version = "0.9", default-features = false, features = ["runtime-t
 async_zip = { version = "0.0.12", default-features = false, features = ["deflate", "fs"] }
 backtrace = "0.3"
 base64 = "0.22"
-brotli = { version = "5", default-features=false, features = ["std"] }
+brotli = { version = "6", default-features=false, features = ["std"] }
 chrono = { workspace = true }
 email = { git = "https://github.com/deltachat/rust-email", branch = "master" }
 encoded-words = { git = "https://github.com/async-email/encoded-words", branch = "master" }
--- a/deltachat-ffi/Cargo.toml
+++ b/deltachat-ffi/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "deltachat_ffi"
-version = "1.137.4"
+version = "1.138.2"
 description = "Deltachat FFI"
 edition = "2018"
 readme = "README.md"
@@ -17,7 +17,7 @@ crate-type = ["cdylib", "staticlib"]
 deltachat = { path = "../", default-features = false }
 deltachat-jsonrpc = { path = "../deltachat-jsonrpc", optional = true }
 libc = "0.2"
-human-panic = { version = "1", default-features = false }
+human-panic = { version = "2", default-features = false }
 num-traits = "0.2"
 serde_json = "1.0"
 tokio = { version = "1.37.0", features = ["rt-multi-thread"] }
--- a/deltachat-ffi/deltachat.h
+++ b/deltachat-ffi/deltachat.h
@@ -517,6 +517,7 @@ char*           dc_get_blobdir               (const dc_context_t* context);
 *                    0=Nothing else happens when the key changes.
 *                    1=After the key changed, `dc_chat_can_send()` returns false and `dc_chat_is_protection_broken()` returns true
 *                    until `dc_accept_chat()` is called.
+ * - `is_chatmail` = 1 if the the server is a chatmail server, 0 otherwise.
 * - `ui.*`         = All keys prefixed by `ui.` can be used by the user-interfaces for system-specific purposes.
 *                    The prefix should be followed by the system and maybe subsystem,
 *                    e.g. `ui.desktop.foo`, `ui.desktop.linux.bar`, `ui.android.foo`, `ui.dc40.bar`, `ui.bot.simplebot.baz`.
@@ -7327,6 +7328,16 @@ void dc_event_unref(dc_event_t* event);
 /// Used in summaries.
 #define DC_STR_REACTED_BY 177

+/// "Establishing guaranteed end-to-end encryption, please wait…"
+///
+/// Used as info message.
+#define DC_STR_SECUREJOIN_WAIT 190
+
+/// "Could not yet establish guaranteed end-to-end encryption, but you may already send a message."
+///
+/// Used as info message.
+#define DC_STR_SECUREJOIN_WAIT_TIMEOUT 191
+
 /**
 * @}
 */
--- a/deltachat-jsonrpc/Cargo.toml
+++ b/deltachat-jsonrpc/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "deltachat-jsonrpc"
-version = "1.137.4"
+version = "1.138.2"
 description = "DeltaChat JSON-RPC API"
 edition = "2021"
 default-run = "deltachat-jsonrpc-server"
--- a/deltachat-jsonrpc/src/api/types/message.rs
+++ b/deltachat-jsonrpc/src/api/types/message.rs
@@ -346,6 +346,14 @@ pub enum SystemMessageType {
    LocationOnly,
    InvalidUnencryptedMail,

+    /// 1:1 chats info message telling that SecureJoin has started and the user should wait for it
+    /// to complete.
+    SecurejoinWait,
+
+    /// 1:1 chats info message telling that SecureJoin is still running, but the user may already
+    /// send messages.
+    SecurejoinWaitTimeout,
+
    /// Chat ephemeral message timer is changed.
    EphemeralTimerChanged,

@@ -386,6 +394,8 @@ impl From<deltachat::mimeparser::SystemMessage> for SystemMessageType {
            SystemMessage::WebxdcStatusUpdate => SystemMessageType::WebxdcStatusUpdate,
            SystemMessage::WebxdcInfoMessage => SystemMessageType::WebxdcInfoMessage,
            SystemMessage::InvalidUnencryptedMail => SystemMessageType::InvalidUnencryptedMail,
+            SystemMessage::SecurejoinWait => SystemMessageType::SecurejoinWait,
+            SystemMessage::SecurejoinWaitTimeout => SystemMessageType::SecurejoinWaitTimeout,
        }
    }
 }
@@ -635,7 +645,7 @@ impl MessageInfo {
 #[derive(
    Debug, PartialEq, Eq, Copy, Clone, Serialize, Deserialize, TypeDef, schemars::JsonSchema,
 )]
-#[serde(rename_all = "camelCase", tag = "variant")]
+#[serde(rename_all = "camelCase", tag = "kind")]
 pub enum EphemeralTimer {
    /// Timer is disabled.
    Disabled,
--- a/deltachat-jsonrpc/typescript/package.json
+++ b/deltachat-jsonrpc/typescript/package.json
@@ -25,7 +25,8 @@
  "exports": {
    ".": {
      "import": "./dist/deltachat.js",
-      "require": "./dist/deltachat.cjs"
+      "require": "./dist/deltachat.cjs",
+      "types": "./dist/deltachat.d.ts"
    }
  },
  "license": "MPL-2.0",
@@ -53,5 +54,5 @@
  },
  "type": "module",
  "types": "dist/deltachat.d.ts",
-  "version": "1.137.4"
+  "version": "1.138.2"
 }
--- a/deltachat-repl/Cargo.toml
+++ b/deltachat-repl/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "deltachat-repl"
-version = "1.137.4"
+version = "1.138.2"
 license = "MPL-2.0"
 edition = "2021"
 repository = "https://github.com/deltachat/deltachat-core-rust"
--- a/deltachat-rpc-client/pyproject.toml
+++ b/deltachat-rpc-client/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"

 [project]
 name = "deltachat-rpc-client"
-version = "1.137.4"
+version = "1.138.2"
 description = "Python client for Delta Chat core JSON-RPC interface"
 classifiers = [
    "Development Status :: 5 - Production/Stable",
--- a/deltachat-rpc-client/src/deltachat_rpc_client/const.py
+++ b/deltachat-rpc-client/src/deltachat_rpc_client/const.py
@@ -61,6 +61,7 @@ class EventType(str, Enum):
    WEBXDC_INSTANCE_DELETED = "WebxdcInstanceDeleted"
    CHATLIST_CHANGED = "ChatlistChanged"
    CHATLIST_ITEM_CHANGED = "ChatlistItemChanged"
+    CONFIG_SYNCED = "ConfigSynced"


 class ChatId(IntEnum):
--- a/deltachat-rpc-client/tests/test_something.py
+++ b/deltachat-rpc-client/tests/test_something.py
@@ -508,8 +508,8 @@ def test_reactions_for_a_reordering_move(acfactory):
    """
    (ac1,) = acfactory.get_online_accounts(1)
    ac2 = acfactory.new_preconfigured_account()
-    ac2.set_config("mvbox_move", "1")
    ac2.configure()
+    ac2.set_config("mvbox_move", "1")
    ac2.bring_online()
    chat1 = acfactory.get_accepted_chat(ac1, ac2)
    ac2.stop_io()
--- a/deltachat-rpc-server/Cargo.toml
+++ b/deltachat-rpc-server/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "deltachat-rpc-server"
-version = "1.137.4"
+version = "1.138.2"
 description = "DeltaChat JSON-RPC server"
 edition = "2021"
 readme = "README.md"
--- a/deltachat-rpc-server/npm-package/.gitignore
+++ b/deltachat-rpc-server/npm-package/.gitignore
@@ -0,0 +1,2 @@
+platform_package
+*.tgz
--- a/deltachat-rpc-server/npm-package/.npmignore
+++ b/deltachat-rpc-server/npm-package/.npmignore
@@ -0,0 +1,3 @@
+platform_package/*
+scripts/
+*.tgz
--- a/deltachat-rpc-server/npm-package/README.md
+++ b/deltachat-rpc-server/npm-package/README.md
@@ -0,0 +1,77 @@
+## npm package for deltachat-rpc-server
+
+This is the successor of `deltachat-node`,
+it does not use NAPI bindings but instead uses stdio executables
+to let you talk to core over jsonrpc over stdio.
+This simplifies cross-compilation and even reduces binary size (no CFFI layer and no NAPI layer).
+
+## Usage
+
+> The **minimum** nodejs version for this package is `20.11`
+
+```
+npm i @deltachat/stdio-rpc-server @deltachat/jsonrpc-client
+```
+
+```js
+import { startDeltaChat } from "@deltachat/stdio-rpc-server";
+import { C } from "@deltachat/jsonrpc-client";
+
+async function main() {
+    const dc = await startDeltaChat("deltachat-data");
+    console.log(await dc.rpc.getSystemInfo());
+}
+```
+
+For a more complete example refer to https://github.com/deltachat-bot/echo/pull/69/files (TODO change link when pr is merged).
+
+## How to use on an unsupported platform
+
+<!-- todo instructions, will uses an env var for pointing to `deltachat-rpc-server` binary -->
+
+<!-- todo copy parts from https://github.com/deltachat/deltachat-desktop/blob/7045c6f549e4b9d5caa0709d5bd314bbd9fd53db/docs/UPDATE_CORE.md -->
+
+## How does it work when you install it
+
+NPM automatically installs platform dependent optional dependencies when `os` and `cpu` fields are set correctly.
+
+references:
+
+- https://napi.rs/docs/deep-dive/release#3-the-native-addon-for-different-platforms-is-distributed-through-different-npm-packages, [webarchive version](https://web.archive.org/web/20240309234250/https://napi.rs/docs/deep-dive/release#3-the-native-addon-for-different-platforms-is-distributed-through-different-npm-packages)
+- https://docs.npmjs.com/cli/v6/configuring-npm/package-json#cpu
+- https://docs.npmjs.com/cli/v6/configuring-npm/package-json#os
+
+When you import this package it searches for the rpc server in the following locations and order:
+
+1. `DELTA_CHAT_RPC_SERVER` environment variable
+2. in PATH
+   - unless `DELTA_CHAT_SKIP_PATH=1` is specified
+   - searches in .cargo/bin directory first
+   - but there an additional version check is performed
+3. prebuilds in npm packages
+
+## How do you built this package in CI
+
+- To build platform packages, run the `build_platform_package.py` script:
+  ```
+  python3 build_platform_package.py <cargo-target>
+  # example
+  python3 build_platform_package.py x86_64-apple-darwin
+  ```
+- Then pass it as an artifact to the last CI action that publishes the main package.
+- upload all packages from `deltachat-rpc-server/npm-package/platform_package`.
+- then publish `deltachat-rpc-server/npm-package`,
+  - this will run `update_optional_dependencies_and_version.js` (in the `prepack` script),
+    which puts all platform packages into `optionalDependencies` and updates the `version` in `package.json`
+
+## How to build a version you can use localy on your host machine for development
+
+You can not install the npm packet from the previous section locally, unless you have a local npm registry set up where you upload it too. This is why we have seperate scripts for making it work for local installation.
+
+- If you just need your host platform run `python scripts/make_local_dev_version.py`
+- note: this clears the `platform_package` folder
+- (advanced) If you need more than one platform for local install you can just run `node scripts/update_optional_dependencies_and_version.js` after building multiple plaftorms with `build_platform_package.py`
+
+## Thanks to nlnet
+
+The initial work on this package was funded by nlnet as part of the [Delta Tauri](https://nlnet.nl/project/DeltaTauri/) Project.
--- a/deltachat-rpc-server/npm-package/index.d.ts
+++ b/deltachat-rpc-server/npm-package/index.d.ts
@@ -0,0 +1,39 @@
+import { StdioDeltaChat } from "@deltachat/jsonrpc-client";
+
+export interface SearchOptions {
+  /** whether to disable looking for deltachat-rpc-server inside of $PATH */
+  skipSearchInPath: boolean;
+
+  /** whether to disable the DELTA_CHAT_RPC_SERVER environment variable */
+  disableEnvPath: boolean;
+}
+
+/**
+ * 
+ * @returns absolute path to deltachat-rpc-server binary
+ * @throws when it is not found
+ */
+export function getRPCServerPath(
+  options?: Partial<SearchOptions>
+): Promise<string>;
+
+
+
+export type DeltaChatOverJsonRpcServer = StdioDeltaChat & {
+    shutdown: () => Promise<void>;
+    readonly pathToServerBinary: string;
+};
+
+
+/**
+ * 
+ * @param directory directory for accounts folder
+ * @param options 
+ */
+export function startDeltaChat(directory: string, options?: Partial<SearchOptions> ): Promise<DeltaChatOverJsonRpcServer>
+
+
+export namespace FnTypes {
+    export type getRPCServerPath = typeof getRPCServerPath
+    export type startDeltaChat = typeof startDeltaChat
+}
--- a/deltachat-rpc-server/npm-package/index.js
+++ b/deltachat-rpc-server/npm-package/index.js
@@ -0,0 +1,143 @@
+//@ts-check
+import { execFile, spawn } from "node:child_process";
+import { stat, readdir } from "node:fs/promises";
+import os from "node:os";
+import { join, basename } from "node:path";
+import process from "node:process";
+import { promisify } from "node:util";
+import {
+  ENV_VAR_NAME,
+  PATH_EXECUTABLE_NAME,
+  SKIP_SEARCH_IN_PATH,
+} from "./src/const.js";
+import {
+  ENV_VAR_LOCATION_NOT_FOUND,
+  FAILED_TO_START_SERVER_EXECUTABLE,
+  NPM_NOT_FOUND_SUPPORTED_PLATFORM_ERROR,
+  NPM_NOT_FOUND_UNSUPPORTED_PLATFORM_ERROR,
+} from "./src/errors.js";
+
+// Because this is not compiled by typescript, esm needs this stuff (` with { type: "json" };`,
+// nodejs still complains about it being experimental, but deno also uses it, so treefit bets taht it will become standard)
+import package_json from "./package.json" with { type: "json" };
+import { createRequire } from "node:module";
+
+// exports
+// - [ ] a raw starter that has a stdin/out handle thingie like desktop uses
+// - [X] a function that already wraps the stdio handle from above into the deltachat jsonrpc bindings
+
+function findRPCServerInNodeModules() {
+  const arch = os.arch();
+  const operating_system = process.platform;
+  const package_name = `@deltachat/stdio-rpc-server-${operating_system}-${arch}`;
+  try {
+    const { resolve } = createRequire(import.meta.url);
+    return resolve(package_name);
+  } catch (error) {
+    console.debug("findRpcServerInNodeModules", error);
+    if (Object.keys(package_json.optionalDependencies).includes(package_name)) {
+      throw new Error(NPM_NOT_FOUND_SUPPORTED_PLATFORM_ERROR(package_name));
+    } else {
+      throw new Error(NPM_NOT_FOUND_UNSUPPORTED_PLATFORM_ERROR());
+    }
+  }
+}
+
+/** @type {import("./index").FnTypes.getRPCServerPath} */
+export async function getRPCServerPath(
+  options = { skipSearchInPath: false, disableEnvPath: false }
+) {
+  // @TODO: improve confusing naming of these options
+  const { skipSearchInPath, disableEnvPath } = options;
+  // 1. check if it is set as env var
+  if (process.env[ENV_VAR_NAME] && !disableEnvPath) {
+    try {
+      if (!(await stat(process.env[ENV_VAR_NAME])).isFile()) {
+        throw new Error(
+          `expected ${ENV_VAR_NAME} to point to the deltachat-rpc-server executable`
+        );
+      }
+    } catch (error) {
+      throw new Error(ENV_VAR_LOCATION_NOT_FOUND());
+    }
+    return process.env[ENV_VAR_NAME];
+  }
+
+  // 2. check if it can be found in PATH
+  if (!process.env[SKIP_SEARCH_IN_PATH] && !skipSearchInPath) {
+    const exec = promisify(execFile);
+
+    const { stdout: executable } =
+      os.platform() !== "win32"
+        ? await exec("command", ["-v", PATH_EXECUTABLE_NAME])
+        : await exec("where", [PATH_EXECUTABLE_NAME]);
+
+    // by just trying to execute it and then use "command -v deltachat-rpc-server" (unix) or "where deltachat-rpc-server" (windows) to get the path to the executable
+    if (executable.length > 1) {
+      // test if it is the right version
+      try {
+        // for some unknown reason it is in stderr and not in stdout
+        const { stderr } = await promisify(execFile)(executable, ["--version"]);
+        const version = stderr.slice(0, stderr.indexOf("\n"));
+        if (package_json.version !== version) {
+          throw new Error(
+            `version mismatch: (npm package: ${package_json.version})  (installed ${PATH_EXECUTABLE_NAME} version: ${version})`
+          );
+        } else {
+          return executable;
+        }
+      } catch (error) {
+        console.error(
+          "Found executable in PATH, but there was an error: " + error
+        );
+        console.error("So falling back to using prebuild...");
+      }
+    }
+  }
+  // 3. check for prebuilds
+
+  return findRPCServerInNodeModules();
+}
+
+import { StdioDeltaChat } from "@deltachat/jsonrpc-client";
+
+/** @type {import("./index").FnTypes.startDeltaChat} */
+export async function startDeltaChat(directory, options) {
+  const pathToServerBinary = await getRPCServerPath(options);
+  const server = spawn(pathToServerBinary, {
+    env: {
+      RUST_LOG: process.env.RUST_LOG || "info",
+      DC_ACCOUNTS_PATH: directory,
+    },
+  });
+
+  server.on("error", (err) => {
+    throw new Error(FAILED_TO_START_SERVER_EXECUTABLE(pathToServerBinary, err));
+  });
+  let shouldClose = false;
+
+  server.on("exit", () => {
+    if (shouldClose) {
+      return;
+    }
+    throw new Error("Server quit");
+  });
+
+  server.stderr.pipe(process.stderr);
+
+  /** @type {import('./index').DeltaChatOverJsonRpcServer} */
+  //@ts-expect-error
+  const dc = new StdioDeltaChat(server.stdin, server.stdout, true);
+
+  dc.shutdown = async () => {
+    shouldClose = true;
+    if (!server.kill()) {
+      console.log("server termination failed");
+    }
+  };
+
+  //@ts-expect-error
+  dc.pathToServerBinary = pathToServerBinary;
+
+  return dc;
+}
--- a/deltachat-rpc-server/npm-package/package.json
+++ b/deltachat-rpc-server/npm-package/package.json
@@ -0,0 +1,15 @@
+{
+  "license": "MPL-2.0",
+  "main": "index.js",
+  "name": "@deltachat/stdio-rpc-server",
+  "optionalDependencies": {},
+  "peerDependencies": {
+    "@deltachat/jsonrpc-client": "*"
+  },
+  "scripts": {
+    "prepack": "node scripts/update_optional_dependencies_and_version.js"
+  },
+  "type": "module",
+  "types": "index.d.ts",
+  "version": "1.138.2"
+}
--- a/deltachat-rpc-server/npm-package/scripts/build_platform_package.py
+++ b/deltachat-rpc-server/npm-package/scripts/build_platform_package.py
@@ -0,0 +1,53 @@
+#!/usr/bin/env python3
+import subprocess
+from sys import argv
+from os import path, makedirs, chdir
+from shutil import copy
+from src.make_package import write_package_json
+
+# ensure correct working directory
+chdir(path.join(path.dirname(path.abspath(__file__)), "../"))
+
+if len(argv) < 2:
+    print("First argument should be target architecture as required by cargo")
+    exit(1)
+
+target = argv[1].strip()
+
+subprocess.run(
+    ["cargo", "build", "--release", "-p", "deltachat-rpc-server", "--target", target],
+    check=True,
+)
+
+newpath = "platform_package"
+if not path.exists(newpath):
+    makedirs(newpath)
+
+# make new folder
+
+platform_path = "platform_package/" + target
+if not path.exists(platform_path):
+    makedirs(platform_path)
+
+# copy binary it over
+
+
+def binary_path(binary_name):
+    return "../../target/" + target + "/release/" + binary_name
+
+
+my_binary_name = "deltachat-rpc-server"
+
+if not path.isfile(binary_path("deltachat-rpc-server")):
+    my_binary_name = "deltachat-rpc-server.exe"
+    if not path.isfile(binary_path("deltachat-rpc-server.exe")):
+        print("Did not find the build")
+        exit(1)
+
+my_binary_path = binary_path(my_binary_name)
+
+copy(my_binary_path, platform_path + "/" + my_binary_name)
+
+# make a package.json for it
+
+write_package_json(platform_path, target, my_binary_name)
--- a/deltachat-rpc-server/npm-package/scripts/make_local_dev_version.py
+++ b/deltachat-rpc-server/npm-package/scripts/make_local_dev_version.py
@@ -0,0 +1,31 @@
+# This script is for making a version of the npm packet that you can install locally
+
+import subprocess
+from sys import argv
+from os import path, makedirs, chdir
+import re
+import json
+import tomllib
+from shutil import copy, rmtree
+
+# ensure correct working directory
+chdir(path.join(path.dirname(path.abspath(__file__)), "../"))
+
+# get host target with "rustc -vV"
+output = subprocess.run(["rustc", "-vV"], capture_output=True)
+host_target = re.search('host: ([-\\w]*)', output.stdout.decode("utf-8")).group(1)
+print("host target to build for is:", host_target)
+
+# clean platform_package folder
+newpath = r'platform_package' 
+if not path.exists(newpath):
+    makedirs(newpath)
+else:
+    rmtree(path.join(path.dirname(path.abspath(__file__)), "../platform_package/"))
+    makedirs(newpath)
+
+# run build_platform_package.py with the host's target to build it
+subprocess.run(["python", "scripts/build_platform_package.py", host_target], capture_output=False, check=True)
+
+# run update_optional_dependencies_and_version.js to adjust the package / make it installable locally
+subprocess.run(["node", "scripts/update_optional_dependencies_and_version.js", "--local"], capture_output=False, check=True)
--- a/deltachat-rpc-server/npm-package/scripts/pack_binary_for_platform.py
+++ b/deltachat-rpc-server/npm-package/scripts/pack_binary_for_platform.py
@@ -0,0 +1,46 @@
+import subprocess
+from sys import argv
+from os import path, makedirs, chdir, chmod, stat
+import json
+from shutil import copy
+from src.make_package import write_package_json
+
+# ensure correct working directory
+chdir(path.join(path.dirname(path.abspath(__file__)), "../"))
+
+if len(argv) < 3:
+    print("First argument should be target architecture as required by cargo")
+    print("Second argument should be the location of th built binary (binary_path)")
+    exit(1)
+
+target = argv[1].strip()
+binary_path = argv[2].strip()
+
+output = subprocess.run(["rustc","--print","target-list"], capture_output=True, check=True)
+available_targets = output.stdout.decode("utf-8")
+
+if available_targets.find(target) == -1:
+    print("target", target, "is not known / not valid")
+    exit(1)
+
+
+newpath = r'platform_package' 
+if not path.exists(newpath):
+    makedirs(newpath)
+
+# make new folder
+
+platform_path = 'platform_package/' + target
+if not path.exists(platform_path):
+    makedirs(platform_path)
+
+# copy binary it over
+
+my_binary_name = path.basename(binary_path)
+new_binary_path = platform_path + "/" + my_binary_name
+copy(binary_path, new_binary_path)
+chmod(new_binary_path, 0o555) # everyone can read & execute, nobody can write
+
+# make a package.json for it
+
+write_package_json(platform_path, target, my_binary_name)
--- a/deltachat-rpc-server/npm-package/scripts/src/convert_platform.py
+++ b/deltachat-rpc-server/npm-package/scripts/src/convert_platform.py
@@ -0,0 +1,21 @@
+def convert_cpu_arch_to_npm_cpu_arch(arch):
+    if arch == "x86_64":
+        return "x64"
+    if arch == "i686":
+        return "i32"
+    if arch == "aarch64":
+        return "arm64"
+    if arch == "armv7" or arch == "arm":
+        return "arm"
+    print("architecture might not be known by nodejs, please make sure it can be returned by 'process.arch':", arch)
+    return arch
+
+def convert_os_to_npm_os(os):
+    if os == "windows":
+        return "win32"
+    if os == "darwin" or os == "linux":
+        return os
+    if os.startswith("android"):
+        return "android"
+    print("architecture might not be known by nodejs, please make sure it can be returned by 'process.platform':", os)
+    return os
--- a/deltachat-rpc-server/npm-package/scripts/src/make_package.py
+++ b/deltachat-rpc-server/npm-package/scripts/src/make_package.py
@@ -0,0 +1,27 @@
+import tomllib
+import json
+
+from .convert_platform import convert_cpu_arch_to_npm_cpu_arch, convert_os_to_npm_os
+
+def write_package_json(platform_path, rust_target, my_binary_name):
+    if len(rust_target.split("-")) == 3:
+        [cpu_arch, vendor, os] = rust_target.split("-")
+    else:
+        [cpu_arch, vendor, os, _env] = rust_target.split("-")
+
+    # read version
+    tomlfile = open("../../Cargo.toml", 'rb')
+    version = tomllib.load(tomlfile)['package']['version']
+
+    package_json = dict({
+        "name": "@deltachat/stdio-rpc-server-" + convert_os_to_npm_os(os) + "-" + convert_cpu_arch_to_npm_cpu_arch(cpu_arch),
+        "version": version,
+        "os": [convert_os_to_npm_os(os)],
+        "cpu": [convert_cpu_arch_to_npm_cpu_arch(cpu_arch)],
+        "main": my_binary_name,
+        "license": "MPL-2.0"
+    })
+
+    file = open(platform_path + "/package.json", 'w')
+    file.write(json.dumps(package_json, indent=4))
+
--- a/deltachat-rpc-server/npm-package/scripts/update_optional_dependencies_and_version.js
+++ b/deltachat-rpc-server/npm-package/scripts/update_optional_dependencies_and_version.js
@@ -0,0 +1,57 @@
+import fs from "node:fs/promises";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const expected_cwd = join(dirname(fileURLToPath(import.meta.url)), "..");
+
+if (process.cwd() !== expected_cwd) {
+  console.error(
+    "CWD missmatch: this script needs to be run from " + expected_cwd,
+    { actual: process.cwd(), expected: expected_cwd }
+  );
+  process.exit(1);
+}
+
+// whether to use local paths instead of npm registry version number for the prebuilds in optionalDependencies
+// useful for local development
+const is_local = process.argv.includes("--local");
+
+const package_json = JSON.parse(await fs.readFile("./package.json", "utf8"));
+
+const cargo_toml = await fs.readFile("../Cargo.toml", "utf8");
+const version = cargo_toml
+  .split("\n")
+  .find((line) => line.includes("version"))
+  .split('"')[1];
+
+const platform_packages_dir = "./platform_package";
+
+const platform_package_names = await Promise.all(
+  (await fs.readdir(platform_packages_dir)).map(async (name) => {
+    const p = JSON.parse(
+      await fs.readFile(
+        join(platform_packages_dir, name, "package.json"),
+        "utf8"
+      )
+    );
+    if (p.version !== version) {
+      console.error(
+        name,
+        "has a different version than the version of the rpc server.",
+        { rpc_server: version, platform_package: p.version }
+      );
+      throw new Error("version missmatch");
+    }
+    return { folder_name: name, package_name: p.name };
+  })
+);
+
+package_json.version = version;
+package_json.optionalDependencies = {};
+for (const { folder_name, package_name } of platform_package_names) {
+  package_json.optionalDependencies[package_name] = is_local
+    ? `file:${expected_cwd}/platform_package/${folder_name}` // npm seems to work better with an absolute path here
+    : version;
+}
+
+await fs.writeFile("./package.json", JSON.stringify(package_json, null, 4));
--- a/deltachat-rpc-server/npm-package/src/const.js
+++ b/deltachat-rpc-server/npm-package/src/const.js
@@ -0,0 +1,6 @@
+//@ts-check
+
+export const PATH_EXECUTABLE_NAME = 'deltachat-rpc-server'
+
+export const ENV_VAR_NAME = "DELTA_CHAT_RPC_SERVER"
+export const SKIP_SEARCH_IN_PATH = "DELTA_CHAT_SKIP_PATH"
--- a/deltachat-rpc-server/npm-package/src/errors.js
+++ b/deltachat-rpc-server/npm-package/src/errors.js
@@ -0,0 +1,41 @@
+//@ts-check
+import { ENV_VAR_NAME } from "./const.js";
+
+const cargoInstallCommand =
+  "cargo install --git https://github.com/deltachat/deltachat-core-rust deltachat-rpc-server";
+
+export function NPM_NOT_FOUND_SUPPORTED_PLATFORM_ERROR(package_name) {
+  return `deltachat-rpc-server not found:
+
+- Install it with "npm i ${package_name}"
+- or download/compile deltachat-rpc-server for your platform and
+ - either put it into your PATH (for example with "${cargoInstallCommand}")
+ - or set the "${ENV_VAR_NAME}" env var to the path to deltachat-rpc-server"`;
+}
+
+export function NPM_NOT_FOUND_UNSUPPORTED_PLATFORM_ERROR() {
+  return `deltachat-rpc-server not found:
+
+Unfortunately no prebuild is available for your system, so you need to provide deltachat-rpc-server yourself.
+
+- Download or Compile deltachat-rpc-server for your platform and
+ - either put it into your PATH (for example with "${cargoInstallCommand}")
+ - or set the "${ENV_VAR_NAME}" env var to the path to deltachat-rpc-server"`;
+}
+
+export function ENV_VAR_LOCATION_NOT_FOUND(error) {
+  return `deltachat-rpc-server not found in ${ENV_VAR_NAME}:
+
+    Error: ${error}
+
+    Content of ${ENV_VAR_NAME}: "${process.env[ENV_VAR_NAME]}"`;
+}
+
+export function FAILED_TO_START_SERVER_EXECUTABLE(pathToServerBinary, error) {
+  return `Failed to start server executable at '${pathToServerBinary}',
+
+  Error: ${error}
+
+Make sure the deltachat-rpc-server binary exists at this location 
+and you can start it with \`${pathToServerBinary} --version\``;
+}
--- a/node/constants.js
+++ b/node/constants.js
@@ -266,6 +266,8 @@ module.exports = {
  DC_STR_REMOVE_MEMBER_BY_YOU: 130,
  DC_STR_REPLY_NOUN: 90,
  DC_STR_SAVED_MESSAGES: 69,
+  DC_STR_SECUREJOIN_WAIT: 190,
+  DC_STR_SECUREJOIN_WAIT_TIMEOUT: 191,
  DC_STR_SECURE_JOIN_GROUP_QR_DESC: 120,
  DC_STR_SECURE_JOIN_REPLIES: 118,
  DC_STR_SECURE_JOIN_STARTED: 117,
--- a/node/lib/constants.ts
+++ b/node/lib/constants.ts
@@ -266,6 +266,8 @@ export enum C {
  DC_STR_REMOVE_MEMBER_BY_YOU = 130,
  DC_STR_REPLY_NOUN = 90,
  DC_STR_SAVED_MESSAGES = 69,
+  DC_STR_SECUREJOIN_WAIT = 190,
+  DC_STR_SECUREJOIN_WAIT_TIMEOUT = 191,
  DC_STR_SECURE_JOIN_GROUP_QR_DESC = 120,
  DC_STR_SECURE_JOIN_REPLIES = 118,
  DC_STR_SECURE_JOIN_STARTED = 117,
--- a/package.json
+++ b/package.json
@@ -55,5 +55,5 @@
    "test:mocha": "mocha node/test/test.mjs --growl --reporter=spec --bail --exit"
  },
  "types": "node/dist/index.d.ts",
-  "version": "1.137.4"
+  "version": "1.138.2"
 }
--- a/python/pyproject.toml
+++ b/python/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"

 [project]
 name = "deltachat"
-version = "1.137.4"
+version = "1.138.2"
 description = "Python bindings for the Delta Chat Core library using CFFI against the Rust-implemented libdeltachat"
 readme = "README.rst"
 requires-python = ">=3.7"
--- a/python/src/deltachat/testplugin.py
+++ b/python/src/deltachat/testplugin.py
@@ -275,6 +275,7 @@ class ACSetup:
    def __init__(self, testprocess, init_time) -> None:
        self._configured_events = Queue()
        self._account2state: Dict[Account, str] = {}
+        self._account2config: Dict[Account, Dict[str, str]] = {}
        self._imap_cleaned: Set[str] = set()
        self.testprocess = testprocess
        self.init_time = init_time
@@ -336,6 +337,8 @@ class ACSetup:
        if not success:
            pytest.fail(f"configuring online account {acc} failed: {comment}")
        self._account2state[acc] = self.CONFIGURED
+        if acc in self._account2config:
+            acc.update_config(self._account2config[acc])
        return acc

    def _onconfigure_start_io(self, acc):
@@ -523,6 +526,7 @@ class ACFactory:
        configdict.setdefault("sentbox_watch", False)
        configdict.setdefault("sync_msgs", False)
        ac.update_config(configdict)
+        self._acsetup._account2config[ac] = configdict
        self._preconfigure_key(ac, configdict["addr"])
        return ac

--- a/release-date.in
+++ b/release-date.in
@@ -1 +1 @@
-2024-04-24
+2024-05-15
--- a/scripts/set_core_version.py
+++ b/scripts/set_core_version.py
@@ -66,7 +66,11 @@ def main():
    parser = ArgumentParser(prog="set_core_version")
    parser.add_argument("newversion")

-    json_list = ["package.json", "deltachat-jsonrpc/typescript/package.json"]
+    json_list = [
+        "package.json",
+        "deltachat-jsonrpc/typescript/package.json",
+        "deltachat-rpc-server/npm-package/package.json",
+    ]
    toml_list = [
        "Cargo.toml",
        "deltachat-ffi/Cargo.toml",
--- a/src/chat.rs
+++ b/src/chat.rs
@@ -12,6 +12,7 @@ use deltachat_contact_tools::{strip_rtlo_characters, ContactAddress};
 use deltachat_derive::{FromSql, ToSql};
 use serde::{Deserialize, Serialize};
 use strum_macros::EnumIter;
+use tokio::task;

 use crate::aheader::EncryptPreference;
 use crate::blob::BlobObject;
@@ -38,6 +39,7 @@ use crate::mimeparser::SystemMessage;
 use crate::param::{Param, Params};
 use crate::peerstate::Peerstate;
 use crate::receive_imf::ReceivedMsg;
+use crate::securejoin::BobState;
 use crate::smtp::send_msg_to_smtp;
 use crate::sql;
 use crate::stock_str;
@@ -126,6 +128,10 @@ pub(crate) enum CantSendReason {

    /// Not a member of the chat.
    NotAMember,
+
+    /// Temporary state for 1:1 chats while SecureJoin is in progress, after a timeout sending
+    /// messages (incl. unencrypted if we don't yet know the contact's pubkey) is allowed.
+    SecurejoinWait,
 }

 impl fmt::Display for CantSendReason {
@@ -145,6 +151,7 @@ impl fmt::Display for CantSendReason {
                write!(f, "mailing list does not have a know post address")
            }
            Self::NotAMember => write!(f, "not a member of the chat"),
+            Self::SecurejoinWait => write!(f, "awaiting SecureJoin for 1:1 chat"),
        }
    }
 }
@@ -610,7 +617,10 @@ impl ChatId {
        let sort_to_bottom = true;
        let ts = self
            .calc_sort_timestamp(context, timestamp_sent, sort_to_bottom, false)
-            .await?;
+            .await?
+            // Always sort protection messages below `SystemMessage::SecurejoinWait{,Timeout}` ones
+            // in case of race conditions.
+            .saturating_add(1);
        self.set_protection_for_timestamp_sort(context, protect, ts, contact_id)
            .await
    }
@@ -1407,6 +1417,18 @@ impl ChatId {

        Ok(sort_timestamp)
    }
+
+    /// Spawns a task checking after a timeout whether the SecureJoin has finished for the 1:1 chat
+    /// and otherwise notifying the user accordingly.
+    pub(crate) fn spawn_securejoin_wait(self, context: &Context, timeout: u64) {
+        let context = context.clone();
+        task::spawn(async move {
+            tokio::time::sleep(Duration::from_secs(timeout)).await;
+            let chat = Chat::load_from_db(&context, self).await?;
+            chat.check_securejoin_wait(&context, 0).await?;
+            Result::<()>::Ok(())
+        });
+    }
 }

 impl std::fmt::Display for ChatId {
@@ -1586,6 +1608,12 @@ impl Chat {
            Some(ReadOnlyMailingList)
        } else if !self.is_self_in_chat(context).await? {
            Some(NotAMember)
+        } else if self
+            .check_securejoin_wait(context, constants::SECUREJOIN_WAIT_TIMEOUT)
+            .await?
+            > 0
+        {
+            Some(SecurejoinWait)
        } else {
            None
        };
@@ -1599,6 +1627,69 @@ impl Chat {
        Ok(self.why_cant_send(context).await?.is_none())
    }

+    /// Returns the remaining timeout for the 1:1 chat in-progress SecureJoin.
+    ///
+    /// If the timeout has expired, notifies the user that sending messages is possible. See also
+    /// [`CantSendReason::SecurejoinWait`].
+    pub(crate) async fn check_securejoin_wait(
+        &self,
+        context: &Context,
+        timeout: u64,
+    ) -> Result<u64> {
+        if self.typ != Chattype::Single || self.protected != ProtectionStatus::Unprotected {
+            return Ok(0);
+        }
+        let (mut param0, mut param1) = (Params::new(), Params::new());
+        param0.set_cmd(SystemMessage::SecurejoinWait);
+        param1.set_cmd(SystemMessage::SecurejoinWaitTimeout);
+        let (param0, param1) = (param0.to_string(), param1.to_string());
+        let Some((param, ts_sort, ts_start)) = context
+            .sql
+            .query_row_optional(
+                "SELECT param, timestamp, timestamp_sent FROM msgs WHERE id=\
+                 (SELECT MAX(id) FROM msgs WHERE chat_id=? AND param IN (?, ?))",
+                (self.id, &param0, &param1),
+                |row| {
+                    let param: String = row.get(0)?;
+                    let ts_sort: i64 = row.get(1)?;
+                    let ts_start: i64 = row.get(2)?;
+                    Ok((param, ts_sort, ts_start))
+                },
+            )
+            .await?
+        else {
+            return Ok(0);
+        };
+        if param == param1 {
+            return Ok(0);
+        }
+        let now = time();
+        // Don't await SecureJoin if the clock was set back.
+        if ts_start <= now {
+            let timeout = ts_start
+                .saturating_add(timeout.try_into()?)
+                .saturating_sub(now);
+            if timeout > 0 {
+                return Ok(timeout as u64);
+            }
+        }
+        add_info_msg_with_cmd(
+            context,
+            self.id,
+            &stock_str::securejoin_wait_timeout(context).await,
+            SystemMessage::SecurejoinWaitTimeout,
+            // Use the sort timestamp of the "please wait" message, this way the added message is
+            // never sorted below the protection message if the SecureJoin finishes in parallel.
+            ts_sort,
+            Some(now),
+            None,
+            None,
+        )
+        .await?;
+        context.emit_event(EventType::ChatModified(self.id));
+        Ok(0)
+    }
+
    /// Checks if the user is part of a chat
    /// and has basically the permissions to edit the chat therefore.
    /// The function does not check if the chat type allows editing of concrete elements.
@@ -2235,8 +2326,9 @@ pub struct ChatInfo {
 }

 pub(crate) async fn update_saved_messages_icon(context: &Context) -> Result<()> {
-    // if there is no saved-messages chat, there is nothing to update. this is no error.
-    if let Some(chat_id) = ChatId::lookup_by_contact(context, ContactId::SELF).await? {
+    if let Some(ChatIdBlocked { id: chat_id, .. }) =
+        ChatIdBlocked::lookup_by_contact(context, ContactId::SELF).await?
+    {
        let icon = include_bytes!("../assets/icon-saved-messages.png");
        let blob = BlobObject::create(context, "icon-saved-messages.png", icon).await?;
        let icon = blob.as_name().to_string();
@@ -2249,8 +2341,9 @@ pub(crate) async fn update_saved_messages_icon(context: &Context) -> Result<()>
 }

 pub(crate) async fn update_device_icon(context: &Context) -> Result<()> {
-    // if there is no device-chat, there is nothing to update. this is no error.
-    if let Some(chat_id) = ChatId::lookup_by_contact(context, ContactId::DEVICE).await? {
+    if let Some(ChatIdBlocked { id: chat_id, .. }) =
+        ChatIdBlocked::lookup_by_contact(context, ContactId::DEVICE).await?
+    {
        let icon = include_bytes!("../assets/icon-device.png");
        let blob = BlobObject::create(context, "icon-device.png", icon).await?;
        let icon = blob.as_name().to_string();
@@ -2301,7 +2394,9 @@ async fn update_special_chat_name(
    contact_id: ContactId,
    name: String,
 ) -> Result<()> {
-    if let Some(chat_id) = ChatId::lookup_by_contact(context, contact_id).await? {
+    if let Some(ChatIdBlocked { id: chat_id, .. }) =
+        ChatIdBlocked::lookup_by_contact(context, contact_id).await?
+    {
        // the `!= name` condition avoids unneeded writes
        context
            .sql
@@ -2330,6 +2425,26 @@ pub(crate) async fn update_special_chat_names(context: &Context) -> Result<()> {
    Ok(())
 }

+/// Checks if there is a 1:1 chat in-progress SecureJoin for Bob and, if necessary, schedules a task
+/// unblocking the chat and notifying the user accordingly.
+pub(crate) async fn resume_securejoin_wait(context: &Context) -> Result<()> {
+    let Some(bobstate) = BobState::from_db(&context.sql).await? else {
+        return Ok(());
+    };
+    if !bobstate.in_progress() {
+        return Ok(());
+    }
+    let chat_id = bobstate.alice_chat();
+    let chat = Chat::load_from_db(context, chat_id).await?;
+    let timeout = chat
+        .check_securejoin_wait(context, constants::SECUREJOIN_WAIT_TIMEOUT)
+        .await?;
+    if timeout > 0 {
+        chat_id.spawn_securejoin_wait(context, timeout);
+    }
+    Ok(())
+}
+
 /// Handle a [`ChatId`] and its [`Blocked`] status at once.
 ///
 /// This struct is an optimisation to read a [`ChatId`] and its [`Blocked`] status at once
@@ -2583,7 +2698,9 @@ async fn prepare_msg_common(
    if let Some(reason) = chat.why_cant_send(context).await? {
        if matches!(
            reason,
-            CantSendReason::ProtectionBroken | CantSendReason::ContactRequest
+            CantSendReason::ProtectionBroken
+                | CantSendReason::ContactRequest
+                | CantSendReason::SecurejoinWait
        ) && msg.param.get_cmd() == SystemMessage::SecurejoinMessage
        {
            // Send out the message, the securejoin message is supposed to repair the verification.
@@ -4476,9 +4593,10 @@ impl Context {
                    }
                    _ => (),
                }
-                ChatId::lookup_by_contact(self, contact_id)
+                ChatIdBlocked::lookup_by_contact(self, contact_id)
                    .await?
                    .with_context(|| format!("No chat for addr '{addr}'"))?
+                    .id
            }
            SyncId::Grpid(grpid) => {
                if let SyncAction::CreateBroadcast(name) = action {
--- a/src/config.rs
+++ b/src/config.rs
@@ -254,6 +254,9 @@ pub enum Config {
    /// True if account is configured.
    Configured,

+    /// True if account is a chatmail account.
+    IsChatmail,
+
    /// All secondary self addresses separated by spaces
    /// (`addr1@example.org addr2@example.org addr3@example.org`)
    SecondaryAddrs,
@@ -1007,6 +1010,15 @@ mod tests {
            .set_config(Config::Selfavatar, Some(file.to_str().unwrap()))
            .await?;
        sync(&alice0, &alice1).await;
+        // There was a bug that a sync message creates the self-chat with the user avatar instead of
+        // the special icon and that remains so when the self-chat becomes user-visible. Let's check
+        // this.
+        let self_chat = alice0.get_self_chat().await;
+        let self_chat_avatar_path = self_chat.get_profile_image(&alice0).await?.unwrap();
+        assert_eq!(
+            self_chat_avatar_path,
+            alice0.get_blobdir().join("icon-saved-messages.png")
+        );
        assert!(alice1
            .get_config(Config::Selfavatar)
            .await?
--- a/src/configure.rs
+++ b/src/configure.rs
@@ -112,6 +112,11 @@ impl Context {

        let mut param = LoginParam::load_candidate_params(self).await?;
        let old_addr = self.get_config(Config::ConfiguredAddr).await?;
+
+        // Reset our knowledge about whether the server is a chatmail server.
+        // We will update it when we connect to IMAP.
+        self.set_config_internal(Config::IsChatmail, None).await?;
+
        let success = configure(self, &mut param).await;
        self.set_config_internal(Config::NotifyAboutWrongPw, None)
            .await?;
@@ -453,6 +458,14 @@ async fn configure(ctx: &Context, param: &mut LoginParam) -> Result<()> {

    progress!(ctx, 900);

+    if imap_session.is_chatmail() {
+        ctx.set_config(Config::SentboxWatch, None).await?;
+        ctx.set_config(Config::MvboxMove, Some("0")).await?;
+        ctx.set_config(Config::OnlyFetchMvbox, None).await?;
+        ctx.set_config(Config::ShowEmails, None).await?;
+        ctx.set_config(Config::E2eeEnabled, Some("1")).await?;
+    }
+
    let create_mvbox = ctx.should_watch_mvbox().await?;

    imap.configure_folders(ctx, &mut imap_session, create_mvbox)
--- a/src/constants.rs
+++ b/src/constants.rs
@@ -223,6 +223,11 @@ pub(crate) const DC_BACKGROUND_FETCH_QUOTA_CHECK_RATELIMIT: u64 = 12 * 60 * 60;
 /// in the group membership consistency algo to reject outdated membership changes.
 pub(crate) const TIMESTAMP_SENT_TOLERANCE: i64 = 60;

+/// How long a 1:1 chat can't be used for sending while the SecureJoin is in progress. This should
+/// be 10-20 seconds so that we are reasonably sure that the app remains active and receiving also
+/// on mobile devices. See also [`crate::chat::CantSendReason::SecurejoinWait`].
+pub(crate) const SECUREJOIN_WAIT_TIMEOUT: u64 = 15;
+
 #[cfg(test)]
 mod tests {
    use num_traits::FromPrimitive;
--- a/src/contact.rs
+++ b/src/contact.rs
@@ -20,7 +20,7 @@ use tokio::task;
 use tokio::time::{timeout, Duration};

 use crate::aheader::EncryptPreference;
-use crate::chat::{ChatId, ProtectionStatus};
+use crate::chat::{ChatId, ChatIdBlocked, ProtectionStatus};
 use crate::color::str_to_color;
 use crate::config::Config;
 use crate::constants::{Blocked, Chattype, DC_GCL_ADD_SELF, DC_GCL_VERIFIED_ONLY};
@@ -1315,7 +1315,9 @@ impl Contact {
    pub async fn is_profile_verified(&self, context: &Context) -> Result<bool> {
        let contact_id = self.id;

-        if let Some(chat_id) = ChatId::lookup_by_contact(context, contact_id).await? {
+        if let Some(ChatIdBlocked { id: chat_id, .. }) =
+            ChatIdBlocked::lookup_by_contact(context, contact_id).await?
+        {
            Ok(chat_id.is_protected(context).await? == ProtectionStatus::Protected)
        } else {
            // 1:1 chat does not exist.
--- a/src/context.rs
+++ b/src/context.rs
@@ -461,18 +461,10 @@ impl Context {
            return;
        }

-        {
-            if self
-                .get_config(Config::ConfiguredAddr)
-                .await
-                .unwrap_or_default()
-                .filter(|s| s.ends_with(".testrun.org"))
-                .is_some()
-            {
-                let mut lock = self.ratelimit.write().await;
-                // Allow at least 1 message every second + a burst of 3.
-                *lock = Ratelimit::new(Duration::new(3, 0), 3.0);
-            }
+        if self.is_chatmail().await.unwrap_or_default() {
+            let mut lock = self.ratelimit.write().await;
+            // Allow at least 1 message every second + a burst of 3.
+            *lock = Ratelimit::new(Duration::new(3, 0), 3.0);
        }
        self.scheduler.start(self.clone()).await;
    }
@@ -493,6 +485,11 @@ impl Context {
        self.scheduler.maybe_network().await;
    }

+    /// Returns true if an account is on a chatmail server.
+    pub async fn is_chatmail(&self) -> Result<bool> {
+        self.get_config_bool(Config::IsChatmail).await
+    }
+
    /// Does a background fetch
    /// pauses the scheduler and does one imap fetch, then unpauses and returns
    pub async fn background_fetch(&self) -> Result<()> {
@@ -799,6 +796,8 @@ impl Context {
            res.insert("imap_server_id", format!("{server_id:?}"));
        }

+        res.insert("is_chatmail", self.is_chatmail().await?.to_string());
+
        if let Some(metadata) = &*self.metadata.read().await {
            if let Some(comment) = &metadata.comment {
                res.insert("imap_server_comment", format!("{comment:?}"));
--- a/src/ephemeral.rs
+++ b/src/ephemeral.rs
@@ -74,7 +74,7 @@ use async_channel::Receiver;
 use serde::{Deserialize, Serialize};
 use tokio::time::timeout;

-use crate::chat::{send_msg, ChatId};
+use crate::chat::{send_msg, ChatId, ChatIdBlocked};
 use crate::constants::{DC_CHAT_ID_LAST_SPECIAL, DC_CHAT_ID_TRASH};
 use crate::contact::ContactId;
 use crate::context::Context;
@@ -378,11 +378,13 @@ WHERE
        .await?;

    if let Some(delete_device_after) = context.get_config_delete_device_after().await? {
-        let self_chat_id = ChatId::lookup_by_contact(context, ContactId::SELF)
+        let self_chat_id = ChatIdBlocked::lookup_by_contact(context, ContactId::SELF)
            .await?
+            .map(|c| c.id)
            .unwrap_or_default();
-        let device_chat_id = ChatId::lookup_by_contact(context, ContactId::DEVICE)
+        let device_chat_id = ChatIdBlocked::lookup_by_contact(context, ContactId::DEVICE)
            .await?
+            .map(|c| c.id)
            .unwrap_or_default();

        let threshold_timestamp = now.saturating_sub(delete_device_after);
@@ -490,11 +492,13 @@ pub(crate) async fn delete_expired_messages(context: &Context, now: i64) -> Resu
 /// `delete_device_after` setting being set.
 async fn next_delete_device_after_timestamp(context: &Context) -> Result<Option<i64>> {
    if let Some(delete_device_after) = context.get_config_delete_device_after().await? {
-        let self_chat_id = ChatId::lookup_by_contact(context, ContactId::SELF)
+        let self_chat_id = ChatIdBlocked::lookup_by_contact(context, ContactId::SELF)
            .await?
+            .map(|c| c.id)
            .unwrap_or_default();
-        let device_chat_id = ChatId::lookup_by_contact(context, ContactId::DEVICE)
+        let device_chat_id = ChatIdBlocked::lookup_by_contact(context, ContactId::DEVICE)
            .await?
+            .map(|c| c.id)
            .unwrap_or_default();

        let oldest_message_timestamp: Option<i64> = context
--- a/src/imap/capabilities.rs
+++ b/src/imap/capabilities.rs
@@ -32,6 +32,14 @@ pub(crate) struct Capabilities {
    /// This is supported by <https://github.com/deltachat/chatmail>
    pub can_push: bool,

+    /// True if the server has an XCHATMAIL capability
+    /// indicating that it is a <https://github.com/deltachat/chatmail> server.
+    ///
+    /// This can be used to hide some advanced settings in the UI
+    /// that are only interesting for normal email accounts,
+    /// e.g. the ability to move messages to Delta Chat folder.
+    pub is_chatmail: bool,
+
    /// Server ID if the server supports ID capability.
    pub server_id: Option<HashMap<String, String>>,
 }
--- a/src/imap/client.rs
+++ b/src/imap/client.rs
@@ -61,6 +61,7 @@ async fn determine_capabilities(
        can_condstore: caps.has_str("CONDSTORE"),
        can_metadata: caps.has_str("METADATA"),
        can_push: caps.has_str("XDELTAPUSH"),
+        is_chatmail: caps.has_str("XCHATMAIL"),
        server_id,
    };
    Ok(capabilities)
--- a/src/imap/session.rs
+++ b/src/imap/session.rs
@@ -94,6 +94,11 @@ impl Session {
        self.capabilities.can_push
    }

+    // Returns true if IMAP server has `XCHATMAIL` capability.
+    pub fn is_chatmail(&self) -> bool {
+        self.capabilities.is_chatmail
+    }
+
    /// Returns the names of all folders on the IMAP server.
    pub async fn list_folders(&mut self) -> Result<Vec<async_imap::types::Name>> {
        let list = self.list(Some(""), Some("*")).await?.try_collect().await?;
--- a/src/message.rs
+++ b/src/message.rs
@@ -9,7 +9,7 @@ use serde::{Deserialize, Serialize};
 use tokio::{fs, io};

 use crate::blob::BlobObject;
-use crate::chat::{Chat, ChatId};
+use crate::chat::{Chat, ChatId, ChatIdBlocked};
 use crate::chatlist_events;
 use crate::config::Config;
 use crate::constants::{
@@ -1813,8 +1813,9 @@ pub async fn estimate_deletion_cnt(
    from_server: bool,
    seconds: i64,
 ) -> Result<usize> {
-    let self_chat_id = ChatId::lookup_by_contact(context, ContactId::SELF)
+    let self_chat_id = ChatIdBlocked::lookup_by_contact(context, ContactId::SELF)
        .await?
+        .map(|c| c.id)
        .unwrap_or_default();
    let threshold_timestamp = time() - seconds;

--- a/src/mimeparser.rs
+++ b/src/mimeparser.rs
@@ -36,6 +36,7 @@ use crate::simplify::{simplify, SimplifiedText};
 use crate::sync::SyncItems;
 use crate::tools::{
    create_smeared_timestamp, get_filemeta, parse_receive_headers, smeared_time, truncate_by_lines,
+    validate_id,
 };
 use crate::{chatlist_events, location, stock_str, tools};

@@ -179,6 +180,14 @@ pub enum SystemMessage {
    /// which is sent by chatmail servers.
    InvalidUnencryptedMail = 13,

+    /// 1:1 chats info message telling that SecureJoin has started and the user should wait for it
+    /// to complete.
+    SecurejoinWait = 14,
+
+    /// 1:1 chats info message telling that SecureJoin is still running, but the user may already
+    /// send messages.
+    SecurejoinWaitTimeout = 15,
+
    /// Self-sent-message that contains only json used for multi-device-sync;
    /// if possible, we attach that to other messages as for locations.
    MultiDeviceSync = 20,
@@ -547,19 +556,25 @@ impl MimeMessage {

    /// Parses avatar action headers.
    async fn parse_avatar_headers(&mut self, context: &Context) {
-        if let Some(header_value) = self.get_header(HeaderDef::ChatGroupAvatar).cloned() {
-            self.group_avatar = self.avatar_action_from_header(context, header_value).await;
+        if let Some(header_value) = self.get_header(HeaderDef::ChatGroupAvatar) {
+            self.group_avatar = self
+                .avatar_action_from_header(context, header_value.to_string())
+                .await;
        }

-        if let Some(header_value) = self.get_header(HeaderDef::ChatUserAvatar).cloned() {
-            self.user_avatar = self.avatar_action_from_header(context, header_value).await;
+        if let Some(header_value) = self.get_header(HeaderDef::ChatUserAvatar) {
+            self.user_avatar = self
+                .avatar_action_from_header(context, header_value.to_string())
+                .await;
        }
    }

    fn parse_videochat_headers(&mut self) {
-        if let Some(value) = self.get_header(HeaderDef::ChatContent).cloned() {
+        if let Some(value) = self.get_header(HeaderDef::ChatContent) {
            if value == "videochat-invitation" {
-                let instance = self.get_header(HeaderDef::ChatWebrtcRoom).cloned();
+                let instance = self
+                    .get_header(HeaderDef::ChatWebrtcRoom)
+                    .map(|s| s.to_string());
                if let Some(part) = self.parts.first_mut() {
                    part.typ = Viewtype::VideochatInvitation;
                    part.param
@@ -806,8 +821,16 @@ impl MimeMessage {
            .map(|s| s.to_string())
    }

-    pub fn get_header(&self, headerdef: HeaderDef) -> Option<&String> {
-        self.headers.get(headerdef.get_headername())
+    pub fn get_header(&self, headerdef: HeaderDef) -> Option<&str> {
+        self.headers
+            .get(headerdef.get_headername())
+            .map(|s| s.as_str())
+    }
+
+    /// Returns `Chat-Group-ID` header value if it is a valid group ID.
+    pub fn get_chat_group_id(&self) -> Option<&str> {
+        self.get_header(HeaderDef::ChatGroupId)
+            .filter(|s| validate_id(s))
    }

    async fn parse_mime_recursive<'a>(
--- a/src/receive_imf.rs
+++ b/src/receive_imf.rs
@@ -37,7 +37,7 @@ use crate::simplify;
 use crate::sql;
 use crate::stock_str;
 use crate::sync::Sync::*;
-use crate::tools::{self, buf_compress, extract_grpid_from_rfc724_mid, validate_id};
+use crate::tools::{self, buf_compress, extract_grpid_from_rfc724_mid};
 use crate::{chatlist_events, location};
 use crate::{contact, imap};

@@ -703,7 +703,9 @@ async fn add_parts(
        better_msg = Some(stock_str::msg_location_enabled_by(context, from_id).await);
    }

-    let parent = get_parent_message(context, mime_parser).await?;
+    let parent = get_parent_message(context, mime_parser)
+        .await?
+        .filter(|p| Some(p.id) != replace_msg_id);

    let is_dc_message = if mime_parser.has_chat_version() {
        MessengerMessage::Yes
@@ -769,6 +771,18 @@ async fn add_parts(
            info!(context, "Message is an MDN (TRASH).",);
        }

+        // Try to assign to a chat based on Chat-Group-ID.
+        if chat_id.is_none() {
+            if let Some(grpid) = mime_parser.get_chat_group_id() {
+                if let Some((id, _protected, blocked)) =
+                    chat::get_chat_id_by_grpid(context, grpid).await?
+                {
+                    chat_id = Some(id);
+                    chat_id_blocked = blocked;
+                }
+            }
+        }
+
        if chat_id.is_none() {
            // try to assign to a chat based on In-Reply-To/References:

@@ -1035,6 +1049,18 @@ async fn add_parts(
            chat_id = Some(DC_CHAT_ID_TRASH);
        }

+        // Try to assign to a chat based on Chat-Group-ID.
+        if chat_id.is_none() {
+            if let Some(grpid) = mime_parser.get_chat_group_id() {
+                if let Some((id, _protected, blocked)) =
+                    chat::get_chat_id_by_grpid(context, grpid).await?
+                {
+                    chat_id = Some(id);
+                    chat_id_blocked = blocked;
+                }
+            }
+        }
+
        if chat_id.is_none() {
            // try to assign to a chat based on In-Reply-To/References:

@@ -1347,11 +1373,9 @@ async fn add_parts(

    let mime_in_reply_to = mime_parser
        .get_header(HeaderDef::InReplyTo)
-        .cloned()
        .unwrap_or_default();
    let mime_references = mime_parser
        .get_header(HeaderDef::References)
-        .cloned()
        .unwrap_or_default();

    // fine, so far.  now, split the message into simple parts usable as "short messages"
@@ -1411,7 +1435,7 @@ async fn add_parts(
            let reaction_str = simplify::remove_footers(part.msg.as_str());
            set_msg_reaction(
                context,
-                &mime_in_reply_to,
+                mime_in_reply_to,
                orig_chat_id.unwrap_or_default(),
                from_id,
                sort_timestamp,
@@ -1754,6 +1778,11 @@ async fn is_probably_private_reply(
        return Ok(false);
    }

+    // Message cannot be a private reply if it has an explicit Chat-Group-ID header.
+    if mime_parser.get_chat_group_id().is_some() {
+        return Ok(false);
+    }
+
    if !mime_parser.has_chat_version() {
        let chat_contacts = chat::get_chat_contacts(context, parent_chat_id).await?;
        if chat_contacts.len() == 2 && chat_contacts.contains(&ContactId::SELF) {
@@ -2431,11 +2460,8 @@ async fn apply_mailinglist_changes(
 }

 fn try_getting_grpid(mime_parser: &MimeMessage) -> Option<String> {
-    if let Some(optional_field) = mime_parser
-        .get_header(HeaderDef::ChatGroupId)
-        .filter(|s| validate_id(s))
-    {
-        return Some(optional_field.clone());
+    if let Some(optional_field) = mime_parser.get_chat_group_id() {
+        return Some(optional_field.to_string());
    }

    // Useful for undecipherable messages sent to known group.
--- a/src/receive_imf/tests.rs
+++ b/src/receive_imf/tests.rs
@@ -2693,6 +2693,103 @@ Second thread."#;
    Ok(())
 }

+/// Test that `Chat-Group-ID` is preferred over `In-Reply-To` and `References`.
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn test_chat_assignment_chat_group_id_preference() -> Result<()> {
+    let t = &TestContext::new_alice().await;
+
+    receive_imf(
+        t,
+        br#"Subject: Hello
+Chat-Group-ID: eJ_llQIXf0K
+Chat-Group-Name: Group name
+Chat-Version: 1.0
+Message-ID: <first@localhost>
+References: <first@localhost>
+Date: Fri, 28 May 2021 10:15:05 +0000
+From: Alice <alice@example.org>
+To: Bob <bob@example.com>, <claire@example.org>
+Content-Type: text/plain; charset=utf-8; format=flowed; delsp=no
+Content-Transfer-Encoding: quoted-printable
+
+Hello, I've just created a group for us."#,
+        false,
+    )
+    .await?;
+    let group_msg = t.get_last_msg().await;
+
+    receive_imf(
+        t,
+        br#"Subject: Hello
+Chat-Version: 1.0
+Message-ID: <second@localhost>
+References: <second@localhost>
+Date: Fri, 28 May 2021 10:15:05 +0000
+From: Bob <bob@example.com>
+To: Alice <alice@example.org>
+Content-Type: text/plain; charset=utf-8; format=flowed; delsp=no
+Content-Transfer-Encoding: quoted-printable
+
+Hello from Bob in 1:1 chat."#,
+        false,
+    )
+    .await?;
+
+    // References and In-Reply-To point to a message
+    // already assigned to 1:1 chat, but Chat-Group-ID is
+    // a stronger signal to assign message to a group.
+    receive_imf(
+        t,
+        br#"Subject: Hello
+Chat-Group-ID: eJ_llQIXf0K
+Chat-Group-Name: Group name
+Chat-Version: 1.0
+Message-ID: <third@localhost>
+In-Reply-To: <second@localhost>
+References: <second@localhost>
+Date: Fri, 28 May 2021 10:15:05 +0000
+From: Bob <bob@example.com>
+To: Alice <alice@example.org>, <claire@example.org>
+Content-Type: text/plain; charset=utf-8; format=flowed; delsp=no
+Content-Transfer-Encoding: quoted-printable
+
+Hello from Bob in a group."#,
+        false,
+    )
+    .await?;
+
+    let msg = t.get_last_msg().await;
+    assert_eq!(msg.text, "Hello from Bob in a group.");
+    assert_eq!(msg.chat_id, group_msg.chat_id);
+
+    // Test outgoing message as well.
+    receive_imf(
+        t,
+        br#"Subject: Hello
+Chat-Group-ID: eJ_llQIXf0K
+Chat-Group-Name: Group name
+Chat-Version: 1.0
+Message-ID: <fourth@localhost>
+In-Reply-To: <second@localhost>
+References: <second@localhost>
+Date: Fri, 28 May 2021 10:15:05 +0000
+From: Alice <alice@example.org>
+To: Bob <bob@example.com>, <claire@example.org>
+Content-Type: text/plain; charset=utf-8; format=flowed; delsp=no
+Content-Transfer-Encoding: quoted-printable
+
+Hello from Alice in a group."#,
+        false,
+    )
+    .await?;
+
+    let msg_outgoing = t.get_last_msg().await;
+    assert_eq!(msg_outgoing.text, "Hello from Alice in a group.");
+    assert_eq!(msg_outgoing.chat_id, group_msg.chat_id);
+
+    Ok(())
+}
+
 /// Test that read receipts don't create chats.
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn test_read_receipts_dont_create_chats() -> Result<()> {
--- a/src/scheduler.rs
+++ b/src/scheduler.rs
@@ -466,6 +466,12 @@ pub async fn convert_folder_meaning(
 }

 async fn inbox_fetch_idle(ctx: &Context, imap: &mut Imap, mut session: Session) -> Result<Session> {
+    ctx.set_config_internal(
+        Config::IsChatmail,
+        crate::config::from_bool(session.is_chatmail()),
+    )
+    .await?;
+
    // Update quota no more than once a minute.
    let quota_needs_update = {
        let quota = ctx.quota.read().await;
--- a/src/securejoin.rs
+++ b/src/securejoin.rs
@@ -29,7 +29,7 @@ mod bob;
 mod bobstate;
 mod qrinvite;

-use bobstate::BobState;
+pub(crate) use bobstate::BobState;
 use qrinvite::QrInvite;

 use crate::token::Namespace;
@@ -65,8 +65,8 @@ pub async fn get_securejoin_qr(context: &Context, group: Option<ChatId>) -> Resu
    let sync_token = token::lookup(context, Namespace::InviteNumber, group)
        .await?
        .is_none();
-    let invitenumber = token::lookup_or_new(context, Namespace::InviteNumber, group).await;
-    let auth = token::lookup_or_new(context, Namespace::Auth, group).await;
+    let invitenumber = token::lookup_or_new(context, Namespace::InviteNumber, group).await?;
+    let auth = token::lookup_or_new(context, Namespace::Auth, group).await?;
    let self_addr = context.get_primary_self_addr().await?;
    let self_name = context
        .get_config(Config::Displayname)
@@ -294,7 +294,7 @@ pub(crate) async fn handle_securejoin_handshake(

    let join_vg = step.starts_with("vg-");

-    if !matches!(step.as_str(), "vg-request" | "vc-request") {
+    if !matches!(step, "vg-request" | "vc-request") {
        let mut self_found = false;
        let self_fingerprint = load_self_public_key(context).await?.fingerprint();
        for (addr, key) in &mime_message.gossiped_keys {
@@ -311,7 +311,7 @@ pub(crate) async fn handle_securejoin_handshake(
        }
    }

-    match step.as_str() {
+    match step {
        "vg-request" | "vc-request" => {
            /*=======================================================
            ====             Alice - the inviter side            ====
@@ -487,7 +487,7 @@ pub(crate) async fn handle_securejoin_handshake(
        =======================================================*/
        "vc-contact-confirm" => {
            if let Some(mut bobstate) = BobState::from_db(&context.sql).await? {
-                if !bobstate.is_msg_expected(context, step.as_str()) {
+                if !bobstate.is_msg_expected(context, step) {
                    warn!(context, "Unexpected vc-contact-confirm.");
                    return Ok(HandshakeMessage::Ignore);
                }
@@ -498,9 +498,7 @@ pub(crate) async fn handle_securejoin_handshake(
            Ok(HandshakeMessage::Ignore)
        }
        "vg-member-added" => {
-            let Some(member_added) = mime_message
-                .get_header(HeaderDef::ChatGroupMemberAdded)
-                .map(|s| s.as_str())
+            let Some(member_added) = mime_message.get_header(HeaderDef::ChatGroupMemberAdded)
            else {
                warn!(
                    context,
@@ -516,7 +514,7 @@ pub(crate) async fn handle_securejoin_handshake(
                return Ok(HandshakeMessage::Propagate);
            }
            if let Some(mut bobstate) = BobState::from_db(&context.sql).await? {
-                if !bobstate.is_msg_expected(context, step.as_str()) {
+                if !bobstate.is_msg_expected(context, step) {
                    warn!(context, "Unexpected vg-member-added.");
                    return Ok(HandshakeMessage::Propagate);
                }
@@ -571,7 +569,7 @@ pub(crate) async fn observe_securejoin_on_other_device(
    info!(context, "Observing secure-join message {step:?}.");

    if !matches!(
-        step.as_str(),
+        step,
        "vg-request-with-auth" | "vc-request-with-auth" | "vg-member-added" | "vc-contact-confirm"
    ) {
        return Ok(HandshakeMessage::Ignore);
@@ -642,21 +640,21 @@ pub(crate) async fn observe_securejoin_on_other_device(

    ChatId::set_protection_for_contact(context, contact_id, mime_message.timestamp_sent).await?;

-    if step.as_str() == "vg-member-added" {
+    if step == "vg-member-added" {
        inviter_progress(context, contact_id, 800);
    }
-    if step.as_str() == "vg-member-added" || step.as_str() == "vc-contact-confirm" {
+    if step == "vg-member-added" || step == "vc-contact-confirm" {
        inviter_progress(context, contact_id, 1000);
    }

-    if step.as_str() == "vg-request-with-auth" || step.as_str() == "vc-request-with-auth" {
+    if step == "vg-request-with-auth" || step == "vc-request-with-auth" {
        // This actually reflects what happens on the first device (which does the secure
        // join) and causes a subsequent "vg-member-added" message to create an unblocked
        // verified group.
        ChatId::create_for_contact_with_blocked(context, contact_id, Blocked::Not).await?;
    }

-    if step.as_str() == "vg-member-added" {
+    if step == "vg-member-added" {
        Ok(HandshakeMessage::Propagate)
    } else {
        Ok(HandshakeMessage::Ignore)
@@ -764,7 +762,7 @@ mod tests {
    use crate::constants::Chattype;
    use crate::imex::{imex, ImexMode};
    use crate::receive_imf::receive_imf;
-    use crate::stock_str::chat_protection_enabled;
+    use crate::stock_str::{self, chat_protection_enabled};
    use crate::test_utils::get_chat_msg;
    use crate::test_utils::{TestContext, TestContextManager};
    use crate::tools::SystemTime;
@@ -961,7 +959,7 @@ mod tests {
            let expected_text = chat_protection_enabled(&alice).await;
            assert_eq!(msg.get_text(), expected_text);
            if case == SetupContactCase::CheckProtectionTimestamp {
-                assert_eq!(msg.timestamp_sort, vc_request_with_auth_ts_sent);
+                assert_eq!(msg.timestamp_sort, vc_request_with_auth_ts_sent + 1);
            }
        }

@@ -990,10 +988,12 @@ mod tests {

        // Check Bob got the verified message in his 1:1 chat.
        let chat = bob.create_chat(&alice).await;
-        let msg = get_chat_msg(&bob, chat.get_id(), 0, 1).await;
+        let msg = get_chat_msg(&bob, chat.get_id(), 0, 2).await;
        assert!(msg.is_info());
-        let expected_text = chat_protection_enabled(&bob).await;
-        assert_eq!(msg.get_text(), expected_text);
+        assert_eq!(msg.get_text(), stock_str::securejoin_wait(&bob).await);
+        let msg = get_chat_msg(&bob, chat.get_id(), 1, 2).await;
+        assert!(msg.is_info());
+        assert_eq!(msg.get_text(), chat_protection_enabled(&bob).await);
    }

    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
--- a/src/securejoin/bob.rs
+++ b/src/securejoin/bob.rs
@@ -9,11 +9,11 @@ use super::bobstate::{BobHandshakeStage, BobState};
 use super::qrinvite::QrInvite;
 use super::HandshakeMessage;
 use crate::chat::{is_contact_in_chat, ChatId, ProtectionStatus};
-use crate::constants::{Blocked, Chattype};
+use crate::constants::{self, Blocked, Chattype};
 use crate::contact::Contact;
 use crate::context::Context;
 use crate::events::EventType;
-use crate::mimeparser::MimeMessage;
+use crate::mimeparser::{MimeMessage, SystemMessage};
 use crate::sync::Sync::*;
 use crate::tools::{create_smeared_timestamp, time};
 use crate::{chat, stock_str};
@@ -69,7 +69,29 @@ pub(super) async fn start_protocol(context: &Context, invite: QrInvite) -> Resul
        QrInvite::Contact { .. } => {
            // For setup-contact the BobState already ensured the 1:1 chat exists because it
            // uses it to send the handshake messages.
-            Ok(state.alice_chat())
+            let chat_id = state.alice_chat();
+            // Calculate the sort timestamp before checking the chat protection status so that if we
+            // race with its change, we don't add our message below the protection message.
+            let sort_to_bottom = true;
+            let ts_sort = chat_id
+                .calc_sort_timestamp(context, 0, sort_to_bottom, false)
+                .await?;
+            if chat_id.is_protected(context).await? == ProtectionStatus::Unprotected {
+                let ts_start = time();
+                chat::add_info_msg_with_cmd(
+                    context,
+                    chat_id,
+                    &stock_str::securejoin_wait(context).await,
+                    SystemMessage::SecurejoinWait,
+                    ts_sort,
+                    Some(ts_start),
+                    None,
+                    None,
+                )
+                .await?;
+                chat_id.spawn_securejoin_wait(context, constants::SECUREJOIN_WAIT_TIMEOUT);
+            }
+            Ok(chat_id)
        }
    }
 }
--- a/src/securejoin/bobstate.rs
+++ b/src/securejoin/bobstate.rs
@@ -261,7 +261,7 @@ impl BobState {
                return Ok(None);
            }
        };
-        if !self.is_msg_expected(context, step.as_str()) {
+        if !self.is_msg_expected(context, step) {
            info!(context, "{} message out of sync for BobState", step);
            return Ok(None);
        }
@@ -341,6 +341,15 @@ impl BobState {
    async fn send_handshake_message(&self, context: &Context, step: BobHandshakeMsg) -> Result<()> {
        send_handshake_message(context, &self.invite, self.chat_id, step).await
    }
+
+    /// Returns whether we are waiting for a SecureJoin message from Alice, i.e. the protocol hasn't
+    /// yet completed.
+    pub(crate) fn in_progress(&self) -> bool {
+        !matches!(
+            self.next,
+            SecureJoinStep::Terminated | SecureJoinStep::Completed
+        )
+    }
 }

 /// Sends the requested handshake message to Alice.
--- a/src/sql.rs
+++ b/src/sql.rs
@@ -8,7 +8,7 @@ use rusqlite::{config::DbConfig, types::ValueRef, Connection, OpenFlags, Row};
 use tokio::sync::{Mutex, MutexGuard, RwLock};

 use crate::blob::BlobObject;
-use crate::chat::{add_device_msg, update_device_icon, update_saved_messages_icon};
+use crate::chat::{self, add_device_msg, update_device_icon, update_saved_messages_icon};
 use crate::config::Config;
 use crate::constants::DC_CHAT_ID_TRASH;
 use crate::context::Context;
@@ -289,21 +289,23 @@ impl Sql {
        let passphrase_nonempty = !passphrase.is_empty();
        if let Err(err) = self.try_open(context, &self.dbfile, passphrase).await {
            self.close().await;
-            Err(err)
-        } else {
-            info!(context, "Opened database {:?}.", self.dbfile);
-            *self.is_encrypted.write().await = Some(passphrase_nonempty);
-
-            // setup debug logging if there is an entry containing its id
-            if let Some(xdc_id) = self
-                .get_raw_config_u32(Config::DebugLogging.as_ref())
-                .await?
-            {
-                set_debug_logging_xdc(context, Some(MsgId::new(xdc_id))).await?;
-            }
-
-            Ok(())
+            return Err(err);
        }
+        info!(context, "Opened database {:?}.", self.dbfile);
+        *self.is_encrypted.write().await = Some(passphrase_nonempty);
+
+        // setup debug logging if there is an entry containing its id
+        if let Some(xdc_id) = self
+            .get_raw_config_u32(Config::DebugLogging.as_ref())
+            .await?
+        {
+            set_debug_logging_xdc(context, Some(MsgId::new(xdc_id))).await?;
+        }
+        chat::resume_securejoin_wait(context)
+            .await
+            .log_err(context)
+            .ok();
+        Ok(())
    }

    /// Changes the passphrase of encrypted database.
@@ -669,10 +671,9 @@ impl Sql {
 /// `passphrase` is the SQLCipher database passphrase.
 /// Empty string if database is not encrypted.
 fn new_connection(path: &Path, passphrase: &str) -> Result<Connection> {
-    let mut flags = OpenFlags::SQLITE_OPEN_NO_MUTEX;
-    flags.insert(OpenFlags::SQLITE_OPEN_READ_WRITE);
-    flags.insert(OpenFlags::SQLITE_OPEN_CREATE);
-
+    let flags = OpenFlags::SQLITE_OPEN_NO_MUTEX
+        | OpenFlags::SQLITE_OPEN_READ_WRITE
+        | OpenFlags::SQLITE_OPEN_CREATE;
    let conn = Connection::open_with_flags(path, flags)?;
    conn.execute_batch(
        "PRAGMA cipher_memory_security = OFF; -- Too slow on Android
--- a/src/stock_str.rs
+++ b/src/stock_str.rs
@@ -435,6 +435,14 @@ pub enum StockMessage {

    #[strum(props(fallback = "%1$s reacted %2$s to \"%3$s\""))]
    MsgReactedBy = 177,
+
+    #[strum(props(fallback = "Establishing guaranteed end-to-end encryption, please wait…"))]
+    SecurejoinWait = 190,
+
+    #[strum(props(
+        fallback = "Could not yet establish guaranteed end-to-end encryption, but you may already send a message."
+    ))]
+    SecurejoinWaitTimeout = 191,
 }

 impl StockMessage {
@@ -842,6 +850,16 @@ pub(crate) async fn secure_join_replies(context: &Context, contact_id: ContactId
        .replace1(&contact_id.get_stock_name(context).await)
 }

+/// Stock string: `Establishing guaranteed end-to-end encryption, please wait…`.
+pub(crate) async fn securejoin_wait(context: &Context) -> String {
+    translated(context, StockMessage::SecurejoinWait).await
+}
+
+/// Stock string: `Could not yet establish guaranteed end-to-end encryption, but you may already send a message.`.
+pub(crate) async fn securejoin_wait_timeout(context: &Context) -> String {
+    translated(context, StockMessage::SecurejoinWaitTimeout).await
+}
+
 /// Stock string: `Scan to chat with %1$s`.
 pub(crate) async fn setup_contact_qr_description(
    context: &Context,
--- a/src/tests/verified_chats.rs
+++ b/src/tests/verified_chats.rs
@@ -376,7 +376,7 @@ async fn test_old_message_2() -> Result<()> {
        SystemMessage::ChatProtectionEnabled
    );

-    // This creates protection-changed info message #2.
+    // This creates protection-changed info message #2 with `timestamp_sort` greater by 1.
    let first_email = receive_imf(
        &alice,
        b"From: Bob <bob@example.net>\n\
@@ -390,8 +390,7 @@ async fn test_old_message_2() -> Result<()> {
    .await?
    .unwrap();

-    // Both messages will get the same timestamp as the protection-changed
-    // message, so this one will be sorted under the previous one
+    // Both messages will get the same timestamp, so this one will be sorted under the previous one
    // even though it has an older timestamp.
    let second_email = receive_imf(
        &alice,
@@ -407,7 +406,10 @@ async fn test_old_message_2() -> Result<()> {
    .unwrap();

    assert_eq!(first_email.sort_timestamp, second_email.sort_timestamp);
-    assert_eq!(first_email.sort_timestamp, protection_msg.timestamp_sort);
+    assert_eq!(
+        first_email.sort_timestamp,
+        protection_msg.timestamp_sort + 1
+    );

    alice.golden_test_chat(chat.id, "test_old_message_2").await;

--- a/src/token.rs
+++ b/src/token.rs
@@ -93,14 +93,14 @@ pub async fn lookup_or_new(
    context: &Context,
    namespace: Namespace,
    foreign_id: Option<ChatId>,
-) -> String {
-    if let Ok(Some(token)) = lookup(context, namespace, foreign_id).await {
-        return token;
+) -> Result<String> {
+    if let Some(token) = lookup(context, namespace, foreign_id).await? {
+        return Ok(token);
    }

    let token = create_id();
-    save(context, namespace, foreign_id, &token).await.ok();
-    token
+    save(context, namespace, foreign_id, &token).await?;
+    Ok(token)
 }

 pub async fn exists(context: &Context, namespace: Namespace, token: &str) -> Result<bool> {
Author	SHA1	Message	Date
link2xt	97d2812644	chore(release): prepare for 1.138.2	2024-05-15 18:34:06 +00:00
link2xt	2ab713d968	ci: add npm token to publish deltachat-rpc-server packages	2024-05-15 18:08:58 +00:00
link2xt	b7a25d5092	api(deltachat-rpc-client): add CONFIG_SYNCED constant	2024-05-15 17:20:06 +00:00
link2xt	8cd85fa7a4	feat: reset more settings when configuring a chatmail account	2024-05-15 06:30:17 +00:00
link2xt	7cfab9a931	test: set configuration after configure() finishes This allows to overwrite settings changed when XCHATMAIL capability is detected.	2024-05-15 06:27:57 +00:00
link2xt	30086038e6	chore(release): prepare for 1.138.1	2024-05-14 22:25:13 +00:00
link2xt	eec1062619	feat: detect XCHATMAIL capability and expose it as `is_chatmail` config	2024-05-14 22:17:46 +00:00
link2xt	07ceabdf85	refactor: resultify token::lookup_or_new()	2024-05-14 20:32:23 +00:00
Simon Laux	c349bf8e0c	ci(deltachat-rpc-server): fix upload of npm packages to github releases (#5564 )	2024-05-14 18:48:34 +00:00
link2xt	21eb4f6648	chore(cargo): bump brotli from 5.0.0 to 6.0.0	2024-05-14 17:27:33 +00:00
dependabot[bot]	10fed7d7de	chore(cargo): bump human-panic from 1.2.3 to 2.0.0 Bumps [human-panic](https://github.com/rust-cli/human-panic) from 1.2.3 to 2.0.0. - [Changelog](https://github.com/rust-cli/human-panic/blob/master/CHANGELOG.md) - [Commits](https://github.com/rust-cli/human-panic/compare/v1.2.3...v2.0.0) --- updated-dependencies: - dependency-name: human-panic dependency-type: direct:production update-type: version-update:semver-major ... Signed-off-by: dependabot[bot] <support@github.com>	2024-05-14 16:29:22 +00:00
dependabot[bot]	b08a283fe5	chore(cargo): bump serde_json from 1.0.115 to 1.0.116 Bumps [serde_json](https://github.com/serde-rs/json) from 1.0.115 to 1.0.116. - [Release notes](https://github.com/serde-rs/json/releases) - [Commits](https://github.com/serde-rs/json/compare/v1.0.115...v1.0.116) --- updated-dependencies: - dependency-name: serde_json dependency-type: direct:production update-type: version-update:semver-patch ... Signed-off-by: dependabot[bot] <support@github.com>	2024-05-14 16:12:52 +00:00
dependabot[bot]	45a2805100	chore(cargo): bump hickory-resolver from 0.24.0 to 0.24.1 Bumps [hickory-resolver](https://github.com/hickory-dns/hickory-dns) from 0.24.0 to 0.24.1. - [Release notes](https://github.com/hickory-dns/hickory-dns/releases) - [Changelog](https://github.com/hickory-dns/hickory-dns/blob/main/CHANGELOG.md) - [Commits](https://github.com/hickory-dns/hickory-dns/compare/v0.24.0...v0.24.1) --- updated-dependencies: - dependency-name: hickory-resolver dependency-type: direct:production update-type: version-update:semver-patch ... Signed-off-by: dependabot[bot] <support@github.com>	2024-05-14 16:11:48 +00:00
dependabot[bot]	cc8157ecf1	chore(cargo): bump libc from 0.2.153 to 0.2.154 Bumps [libc](https://github.com/rust-lang/libc) from 0.2.153 to 0.2.154. - [Release notes](https://github.com/rust-lang/libc/releases) - [Commits](https://github.com/rust-lang/libc/compare/0.2.153...0.2.154) --- updated-dependencies: - dependency-name: libc dependency-type: direct:production update-type: version-update:semver-patch ... Signed-off-by: dependabot[bot] <support@github.com>	2024-05-14 16:11:30 +00:00
dependabot[bot]	0c98aca5f0	chore(cargo): bump parking_lot from 0.12.1 to 0.12.2 Bumps [parking_lot](https://github.com/Amanieu/parking_lot) from 0.12.1 to 0.12.2. - [Changelog](https://github.com/Amanieu/parking_lot/blob/master/CHANGELOG.md) - [Commits](https://github.com/Amanieu/parking_lot/compare/0.12.1...0.12.2) --- updated-dependencies: - dependency-name: parking_lot dependency-type: direct:production update-type: version-update:semver-patch ... Signed-off-by: dependabot[bot] <support@github.com>	2024-05-14 16:11:12 +00:00
link2xt	170e4b3530	refactor(sql): make open flags immutable	2024-05-14 14:55:04 +00:00
link2xt	5ed91e9f6e	refactor: make MimeMessage.get_header() return Option<&str>	2024-05-13 17:07:58 +00:00
link2xt	2779737c56	ci: set RUSTUP_WINDOWS_PATH_ADD_BIN This is a workaround for <https://github.com/nextest-rs/nextest/issues/1493>	2024-05-13 14:29:33 +00:00
link2xt	0d3c0a3d8f	fix: ignore parent message if message references itself When there are no parent references, Delta Chat inserts Message-ID into References. Such references should be ignored because otherwise fully downloaded message may be assigned to the same chat as previously incorrectly assigned partially downloaded message. Fixes receive_imf::tests::test_create_group_with_big_msg	2024-05-13 13:29:06 +00:00
link2xt	8e38e7220b	fix: always prefer Chat-Group-ID over In-Reply-To and References Chat-Group-ID always correctly identifies the chat message was sent to, while In-Reply-To and References may point to a message that has itself been incorrectly assigned to a chat.	2024-05-13 13:29:06 +00:00
link2xt	acfde3cb7b	fix: never treat message with Chat-Group-ID as a private reply	2024-05-13 13:29:06 +00:00
link2xt	b6a461e3b7	refactor: add MimeMessage.get_chat_group_id()	2024-05-13 13:29:06 +00:00
B. Petersen	0541ecf22c	chore(release): prepare for 1.138.0	2024-05-13 12:47:11 +02:00
B. Petersen	77af0a2114	update node constants	2024-05-13 12:47:11 +02:00
B. Petersen	2f679bc21a	add new securejoin strings to deltachat.h	2024-05-13 12:08:36 +02:00
iequidoo	518db9a20f	feat: Make one-to-one chats read-only the first seconds of a SecureJoin (#5512 ) This protects Bob (the joiner) of sending unexpected-unencrypted messages during an otherwise nicely running SecureJoin. If things get stuck, however, we do not want to block communication -- the chat is just opportunistic as usual, but that needs to be communicated: 1. If Bob's chat with Alice is `Unprotected` and a SecureJoin is started, then add info-message "Establishing guaranteed end-to-end encryption, please wait..." and let `Chat::can_send()` return `false`. 2. Once the info-message "Messages are guaranteed to be e2ee from now on" is added, let `Chat::can_send()` return `true`. 3. If after SECUREJOIN_WAIT_TIMEOUT seconds `2.` did not happen, add another info-message "Could not yet establish guaranteed end-to-end encryption but you may already send a message" and also let `Chat::can_send()` return `true`. Both `2.` and `3.` require the event `ChatModified` being sent out so that UI pick up the change wrt `Chat::can_send()` (this is the same way how groups become updated wrt `can_send()` changes). SECUREJOIN_WAIT_TIMEOUT should be 10-20 seconds so that we are reasonably sure that the app remains active and receiving also on mobile devices. If the app is killed during this time then we may need to do step 3 for any pending Bob-join chats (right now, Bob can only join one chat at a time).	2024-05-13 12:08:36 +02:00
link2xt	edf8aafbdc	api!(jsonrpc): replace EphemeralTimer tag "variant" with "kind" We use "kind" everywhere else.	2024-05-12 01:15:31 +00:00
iequidoo	ab1583eef9	fix: Use ChatIdBlocked::lookup_by_contact() instead of ChatId's method when applicable `ChatId::lookup_by_contact()` returns `None` for blocked chats, so it should be only used if we need to filter out blocked chats, e.g. when building a chatlist.	2024-05-11 17:37:12 -03:00
iequidoo	e3cb9b894b	fix: Update special chats icons even if they are blocked (#5509 ) E.g. the multi-device synchronisation creates the "Saved Messages" chat as blocked, in this case the chat icon wasn't updated before and the user avatar was displayed instead.	2024-05-11 17:37:12 -03:00
Simon Laux	c375c03d8e	stdio jsonrpc server npm package (#5332 ) - [x] figgure out how to build the packages (that it installs native optional package automatically) - [X] Make the gluecode - [x] expose both the lowerlevel api that desktop uses (~~send objects and receive objects~~, getting path of rpc-server is enough) - [X] and the higher level api needed for bots (jsonrpc client) - [X] typescript types - [x] automatically pick the right binary from npm or allow getting it from env var, or give out an error (throw error) - [x] find out how to dev locally (use local built core in dc desktop) - there is the question of how to link the typescript client and the task to add a search in the cargo target folder for a debug build or a different way, find out some good flow that we can use and document for dc desktop + locally built core development - [x] build the packages in ci - [x] fix that deltachat-rpc-server is not executable postponed: - [ ] publish from ci - [ ] add key/token to deploy to npm Closes #4694 ## Related prs - https://github.com/deltachat-bot/echo/pull/69 - https://github.com/deltachat/deltachat-desktop/pull/3567 --------- Co-authored-by: link2xt <link2xt@testrun.org>	2024-05-11 20:54:11 +02:00
@@ -1 +1 @@
 -04-24
 -05-15