Rename the identifiers that carried the upstream name

Everything clients, users and operators meet now carries the fork's name,
with no aliases (SPEC.md §2.4, changed here from "protocol identifiers
stay"):

- JMAP: upstream's registry capability is urn:inbuxa:jmap:registry, beside
  the fork's own urn:inbuxa:jmap.
- WebDAV lock and sync tokens are urn:inbuxa:dav*; clients resync once.
- Sieve: vnd.inbuxa.while and vnd.inbuxa.expressions. sieve-rs spells these
  into its compiler, so it's vendored (vendor/sieve-rs, 0.7.3) and patched in;
  a unit test fails if Cargo.lock ever moves past the vendored copy. The
  trusted runtime now names itself too, rather than answering sieve-rs's
  default.
- The web interface's OAuth client is inbuxa-webui. On every start the old
  stalwart-webui client is removed and any application naming it is moved
  over.
- The spam filter's blobs are INBUXA_SPAM_*; every start moves any left
  under the old keys, so a trained model survives.
- SQL stores and log files default to inbuxa, in the code and in the
  schema served to the admin (checksum regenerated).
- Settings are INBUXA_* only. A STALWART_* variable that's set where its
  INBUXA_* one isn't stops the server at startup, naming it.
- The version-upgrade messages link docs.inbuxa.org's migration page, and
  the OpenAPI description, smtp crate metadata and web-push test fixtures
  lose the name.

Kept on purpose, allowlisted with reasons: the OAuth key-derivation
contexts (renaming them would end every session and invalidate every
sealed client id) and the hashed application prefix.

Also fixes a latent start-up failure: ensure_client updated an existing
first-party client with a revision of 0, which the registry's assertion
never matches, so adding a redirect URI or changing the webmail secret
failed start-up. And the principal session test now expects
legacyProtocols (C-1, added 2026-09-21), which it had missed.

Tested: the server builds without warnings; common's 106 unit tests,
including the vendoring check; a new integration test for the two
start-up migrations; and the webdav, jmap, imap and SMTP Sieve suites.

vendor/sieve-rs/src/runtime/actions/action_flags.rs

@@ -0,0 +1,140 @@
+/*
+ * SPDX-FileCopyrightText: 2020 Stalwart Labs Ltd <[email protected]>
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-SEL
+ */
+
+use crate::{
+    Context,
+    compiler::{
+        Value, VariableType,
+        grammar::actions::action_flags::{Action, EditFlags},
+    },
+};
+
+impl EditFlags {
+    pub(crate) fn exec(&self, ctx: &mut Context) {
+        let mut var_name_ = None;
+        let var_name = self.name.as_ref().unwrap_or_else(|| {
+            var_name_.get_or_insert_with(|| VariableType::Global("__flags".to_string()))
+        });
+
+        match &self.action {
+            Action::Set => {
+                let mut flags_lc = Vec::new();
+                let mut flags = String::new();
+                ctx.tokenize_flags(&self.flags, |flag| {
+                    let flag_lc = flag.to_lowercase();
+                    if !flags_lc.contains(&flag_lc) {
+                        if !flags.is_empty() {
+                            flags.push(' ');
+                        }
+                        flags.push_str(flag);
+                        flags_lc.push(flag_lc);
+                    }
+                    false
+                });
+                ctx.set_variable(var_name, flags.into());
+            }
+            Action::Add => {
+                let mut new_flags = ctx
+                    .get_variable(var_name)
+                    .map(|v| v.to_string())
+                    .unwrap_or_default()
+                    .into_owned();
+                let mut current_flags = new_flags
+                    .split(' ')
+                    .map(|f| f.to_lowercase())
+                    .collect::<Vec<_>>();
+
+                ctx.tokenize_flags(&self.flags, |flag| {
+                    let flag_lc = flag.to_lowercase();
+                    if !current_flags.contains(&flag_lc) {
+                        if !new_flags.is_empty() {
+                            new_flags.push(' ');
+                        }
+                        new_flags.push_str(flag);
+                        current_flags.push(flag_lc);
+                    }
+                    false
+                });
+                ctx.set_variable(var_name, new_flags.into());
+            }
+            Action::Remove => {
+                let mut current_flags = Vec::new();
+                let mut current_flags_lc = Vec::new();
+                let flags = ctx
+                    .get_variable(var_name)
+                    .map(|v| v.to_string().into_owned())
+                    .unwrap_or_default();
+
+                for flag in flags.split(' ') {
+                    current_flags.push(flag);
+                    current_flags_lc.push(flag.to_lowercase());
+                }
+                ctx.tokenize_flags(&self.flags, |flag| {
+                    let flag = flag.to_lowercase();
+                    if let Some(pos) = current_flags_lc.iter().position(|lflag| lflag == &flag) {
+                        current_flags.swap_remove(pos);
+                        current_flags_lc.swap_remove(pos);
+                    }
+                    false
+                });
+                ctx.set_variable(var_name, current_flags.join(" ").into());
+            }
+        }
+    }
+}
+
+impl Context<'_> {
+    pub(crate) fn tokenize_flags(
+        &self,
+        strings: &[Value],
+        mut cb: impl FnMut(&str) -> bool,
+    ) -> bool {
+        for (pos, string) in strings.iter().enumerate() {
+            let flag_ = self.eval_value(string);
+            let flag = flag_.to_string();
+            if !flag.is_empty() {
+                if pos == 0 && strings.len() == 1 {
+                    for flag in flag.split_ascii_whitespace() {
+                        if !flag.is_empty() && cb(flag) {
+                            return true;
+                        }
+                    }
+                } else if cb(flag.trim()) {
+                    return true;
+                }
+            }
+        }
+        false
+    }
+
+    pub(crate) fn get_local_flags(&self, strings: &[Value]) -> Vec<String> {
+        let mut flags = Vec::new();
+        self.tokenize_flags(strings, |flag| {
+            flags.push(flag.to_string());
+            false
+        });
+        flags
+    }
+
+    pub(crate) fn get_global_flags(&self) -> Vec<String> {
+        match self.vars_global.get("__flags") {
+            Some(flags) if !flags.is_empty() => flags
+                .to_string()
+                .split(' ')
+                .map(|s| s.to_string())
+                .collect::<Vec<String>>(),
+            _ => Vec::new(),
+        }
+    }
+
+    pub(crate) fn get_local_or_global_flags(&self, strings: &[Value]) -> Vec<String> {
+        if strings.is_empty() {
+            self.get_global_flags()
+        } else {
+            self.get_local_flags(strings)
+        }
+    }
+}