inbuxa:ProtocolPolicy over JMAP

The switch is now reachable. /get and /set on a server-level singleton, wired through jmap-proto the way inbuxa:AiLimits is: object, method names, request and response variants, reference resolution and evaluation. /set does not write the policy. It hands what was asked to Server::set_protocol_policy, which applies the locks, moves the listener objects and opens or closes their sockets, and reports what happened. So the method cannot drift from what the switch actually does. Two properties exist for the screen rather than the server. lockedProtocols serves LP-21's locked set, so the selector renders SMTP and JMAP locked from what the server says instead of a list the front end carries -- and unlocking later needs no admin release. wouldClose answers LP-16: exactly which listeners turning the switch on would close, by name and port, before anything happens. It is computed against a hypothetical disabled policy, so it reads the same whichever way the switch is set, and the registry is only asked when the property was requested. savedListeners, changedAt, changedBy and both of those are the server's to say; a client that sets one gets invalidProperties naming it. closeSubmission is different: locked, not immutable, so it is overruled rather than refused and the response hands back what was really stored (false). JMAP already has the place for that, the value beside an updated id. Permissions reuse SysNetworkListenerGet and SysNetworkListenerUpdate rather than adding to a schema-generated enum -- the same choice AiLimits made with the classifier's. It also reads right: this takes listeners away and puts them back, so whoever may edit a listener may turn the switch. changedBy stores the account id, not the name, which survives a rename. Still no screen, no sign-in refusal (LP-6) and no event (LP-8).
2026-09-20 15:38:32 -07:00
parent 3b29ca3571
commit 1b3ec64862
13 changed files with 586 additions and 1 deletions
@@ -0,0 +1,195 @@
+/*
+ * SPDX-FileCopyrightText: 2026 Coffey Labs
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only
+ */
+
+//! `inbuxa:ProtocolPolicy/get` and `/set` under `urn:inbuxa:jmap`: the
+//! server-wide legacy mail protocols switch (legacy-protocols spec). A
+//! singleton, id `singleton`.
+//!
+//! Three of its properties are the server's to say, not the client's:
+//! `savedListeners` (LP-1), `lockedProtocols` (LP-21) and `wouldClose`
+//! (LP-16). A client that sets them is answered with `invalidProperties`.
+
+use crate::object::{AnyId, JmapObject, JmapObjectId};
+use jmap_tools::{Element, Key, Property};
+use std::{borrow::Cow, str::FromStr};
+use types::id::Id;
+
+#[derive(Debug, Clone, Default)]
+pub struct ProtocolPolicy;
+
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub enum ProtocolPolicyProperty {
+    Id,
+    /// The switch: `enabled` or `disabled`.
+    LegacyProtocols,
+    /// Whether submission closes with it. Forced false while SMTP is locked.
+    CloseSubmission,
+    /// Server-set: the listeners taken away, for LP-5.
+    SavedListeners,
+    ChangedAt,
+    ChangedBy,
+    /// Server-set: the protocols that cannot be closed, so the selector can
+    /// render them locked rather than carry its own list (LP-21).
+    LockedProtocols,
+    /// Server-set: exactly which listeners turning the switch would close,
+    /// by name and port, for the confirmation (LP-16).
+    WouldClose,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub enum ProtocolPolicyValue {
+    Id(Id),
+}
+
+impl Property for ProtocolPolicyProperty {
+    fn try_parse(_: Option<&Key<'_, Self>>, value: &str) -> Option<Self> {
+        ProtocolPolicyProperty::parse(value)
+    }
+
+    fn to_cow(&self) -> Cow<'static, str> {
+        match self {
+            ProtocolPolicyProperty::Id => "id",
+            ProtocolPolicyProperty::LegacyProtocols => "legacyProtocols",
+            ProtocolPolicyProperty::CloseSubmission => "closeSubmission",
+            ProtocolPolicyProperty::SavedListeners => "savedListeners",
+            ProtocolPolicyProperty::ChangedAt => "changedAt",
+            ProtocolPolicyProperty::ChangedBy => "changedBy",
+            ProtocolPolicyProperty::LockedProtocols => "lockedProtocols",
+            ProtocolPolicyProperty::WouldClose => "wouldClose",
+        }
+        .into()
+    }
+}
+
+impl ProtocolPolicyProperty {
+    fn parse(value: &str) -> Option<Self> {
+        hashify::tiny_map!(value.as_bytes(),
+            b"id" => ProtocolPolicyProperty::Id,
+            b"legacyProtocols" => ProtocolPolicyProperty::LegacyProtocols,
+            b"closeSubmission" => ProtocolPolicyProperty::CloseSubmission,
+            b"savedListeners" => ProtocolPolicyProperty::SavedListeners,
+            b"changedAt" => ProtocolPolicyProperty::ChangedAt,
+            b"changedBy" => ProtocolPolicyProperty::ChangedBy,
+            b"lockedProtocols" => ProtocolPolicyProperty::LockedProtocols,
+            b"wouldClose" => ProtocolPolicyProperty::WouldClose,
+        )
+    }
+}
+
+impl ProtocolPolicyProperty {
+    /// Whether this property is the server's to say. A client that sets one
+    /// is answered with `invalidProperties`.
+    pub fn is_server_set(&self) -> bool {
+        matches!(
+            self,
+            ProtocolPolicyProperty::SavedListeners
+                | ProtocolPolicyProperty::ChangedAt
+                | ProtocolPolicyProperty::ChangedBy
+                | ProtocolPolicyProperty::LockedProtocols
+                | ProtocolPolicyProperty::WouldClose
+        )
+    }
+}
+
+impl FromStr for ProtocolPolicyProperty {
+    type Err = ();
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        ProtocolPolicyProperty::parse(s).ok_or(())
+    }
+}
+
+impl Element for ProtocolPolicyValue {
+    type Property = ProtocolPolicyProperty;
+
+    fn try_parse<P>(key: &Key<'_, Self::Property>, value: &str) -> Option<Self> {
+        match key {
+            Key::Property(ProtocolPolicyProperty::Id) => Id::from_str(value).ok().map(ProtocolPolicyValue::Id),
+            _ => None,
+        }
+    }
+
+    fn to_cow(&self) -> Cow<'static, str> {
+        match self {
+            ProtocolPolicyValue::Id(id) => id.to_string().into(),
+        }
+    }
+}
+
+impl JmapObject for ProtocolPolicy {
+    type Property = ProtocolPolicyProperty;
+
+    type Element = ProtocolPolicyValue;
+
+    type Id = Id;
+
+    type Filter = ();
+
+    type Comparator = ();
+
+    type GetArguments = ();
+
+    type SetArguments<'de> = ();
+
+    type QueryArguments = ();
+
+    type CopyArguments = ();
+
+    type ParseArguments = ();
+
+    const ID_PROPERTY: Self::Property = ProtocolPolicyProperty::Id;
+}
+
+impl From<Id> for ProtocolPolicyValue {
+    fn from(id: Id) -> Self {
+        ProtocolPolicyValue::Id(id)
+    }
+}
+
+impl JmapObjectId for ProtocolPolicyValue {
+    fn as_id(&self) -> Option<Id> {
+        match self {
+            ProtocolPolicyValue::Id(id) => Some(*id),
+        }
+    }
+
+    fn as_any_id(&self) -> Option<AnyId> {
+        match self {
+            ProtocolPolicyValue::Id(id) => Some(AnyId::Id(*id)),
+        }
+    }
+
+    fn as_id_ref(&self) -> Option<&str> {
+        None
+    }
+
+    fn try_set_id(&mut self, new_id: AnyId) -> bool {
+        if let AnyId::Id(id) = new_id {
+            *self = ProtocolPolicyValue::Id(id);
+            true
+        } else {
+            false
+        }
+    }
+}
+
+impl JmapObjectId for ProtocolPolicyProperty {
+    fn as_id(&self) -> Option<Id> {
+        None
+    }
+
+    fn as_any_id(&self) -> Option<AnyId> {
+        None
+    }
+
+    fn as_id_ref(&self) -> Option<&str> {
+        None
+    }
+
+    fn try_set_id(&mut self, _: AnyId) -> bool {
+        false
+    }
+}