agentirc-cli 0.3.1__tar.gz → 0.4.0__tar.gz

{agentirc_cli-0.3.1 → agentirc_cli-0.4.0}/CHANGELOG.md

@@ -4,6 +4,23 @@ All notable changes to this project will be documented in this file.
 
 Format follows [Keep a Changelog](https://keepachangelog.com/).
 
+## [0.4.0] - 2026-03-24
+
+
+### Added
+
+- Link trust levels: full (share all) and restricted (share nothing unless opted in)
+- Channel mode +R: restricted — channel stays local, never federated
+- Channel mode +S <server>: shared — explicitly share channel with named server
+- Mutual +S required for restricted links — both sides must agree
+- Safe default: inbound links from unknown peers default to restricted
+
+
+### Changed
+
+- Link format extended: name:host:port:password:trust (trust defaults to full)
+- Burst and relay filtered through should_relay() based on trust + channel modes
+
 ## [0.3.1] - 2026-03-22
 
 

{agentirc_cli-0.3.1 → agentirc_cli-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentirc-cli
-Version: 0.3.1
+Version: 0.4.0
 Summary: IRC protocol chatrooms for AI agents (and humans allowed)
 Project-URL: Homepage, https://github.com/OriNachum/agentirc
 Author: Ori Nachum

agentirc_cli-0.4.0/agentirc/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.4.0"

{agentirc_cli-0.3.1 → agentirc_cli-0.4.0}/agentirc/cli.py

@@ -36,20 +36,29 @@ logger = logging.getLogger("agentirc")
 
 
 def _parse_link(value: str):
-    """Parse a link spec: name:host:port:password"""
+    """Parse a link spec: name:host:port:password[:trust]
+
+    Trust is extracted from the end if it matches a known value.
+    This allows passwords containing colons.
+    """
     from agentirc.server.config import LinkConfig
 
+    # Check if the last segment is a trust level
+    trust = "full"
+    if value.endswith(":full") or value.endswith(":restricted"):
+        value, trust = value.rsplit(":", 1)
+
     parts = value.split(":", 3)
     if len(parts) != 4:
         raise argparse.ArgumentTypeError(
-            f"Link must be name:host:port:password, got: {value}"
+            f"Link must be name:host:port:password[:trust], got: {value}"
         )
     name, host, port_str, password = parts
     try:
         port = int(port_str)
     except ValueError:
         raise argparse.ArgumentTypeError(f"Invalid port: {port_str}")
-    return LinkConfig(name=name, host=host, port=port, password=password)
+    return LinkConfig(name=name, host=host, port=port, password=password, trust=trust)
 
 DEFAULT_CONFIG = os.path.expanduser("~/.agentirc/agents.yaml")
 LOG_DIR = os.path.expanduser("~/.agentirc/logs")
@@ -247,7 +256,7 @@ async def _run_server(name: str, host: str, port: int, links: list | None = None
     # Connect to configured peers
     for lc in config.links:
         try:
-            await ircd.connect_to_peer(lc.host, lc.port, lc.password)
+            await ircd.connect_to_peer(lc.host, lc.port, lc.password, lc.trust)
             logger.info("Linking to %s at %s:%d", lc.name, lc.host, lc.port)
         except Exception as e:
             logger.error("Failed to link to %s: %s", lc.name, e)

{agentirc_cli-0.3.1 → agentirc_cli-0.4.0}/agentirc/server/__main__.py

@@ -6,18 +6,26 @@ from agentirc.server.ircd import IRCd
 
 
 def parse_link(value: str) -> LinkConfig:
-    """Parse a link spec: name:host:port:password"""
+    """Parse a link spec: name:host:port:password[:trust]
+
+    Trust is extracted from the end if it matches a known value.
+    This allows passwords containing colons.
+    """
+    trust = "full"
+    if value.endswith(":full") or value.endswith(":restricted"):
+        value, trust = value.rsplit(":", 1)
+
     parts = value.split(":", 3)
     if len(parts) != 4:
         raise argparse.ArgumentTypeError(
-            f"Link must be name:host:port:password, got: {value}"
+            f"Link must be name:host:port:password[:trust], got: {value}"
         )
     name, host, port_str, password = parts
     try:
         port = int(port_str)
     except ValueError:
         raise argparse.ArgumentTypeError(f"Invalid port: {port_str}")
-    return LinkConfig(name=name, host=host, port=port, password=password)
+    return LinkConfig(name=name, host=host, port=port, password=password, trust=trust)
 
 
 async def main() -> None:
@@ -44,7 +52,7 @@ async def main() -> None:
     # Connect to configured peers
     for lc in config.links:
         try:
-            await ircd.connect_to_peer(lc.host, lc.port, lc.password)
+            await ircd.connect_to_peer(lc.host, lc.port, lc.password, lc.trust)
             print(f"Linking to {lc.name} at {lc.host}:{lc.port}")
         except Exception as e:
             print(f"Failed to link to {lc.name}: {e}")

{agentirc_cli-0.3.1 → agentirc_cli-0.4.0}/agentirc/server/channel.py

@@ -17,6 +17,8 @@ class Channel:
         self.members: set[Client] = set()
         self.operators: set[Client] = set()
         self.voiced: set[Client] = set()
+        self.restricted = False       # +R mode — never federate
+        self.shared_with: set[str] = set()  # +S servers — share with these servers
 
     def _local_members(self) -> set[Client]:
         """Return only local (non-remote) members."""

{agentirc_cli-0.3.1 → agentirc_cli-0.4.0}/agentirc/server/client.py

@@ -391,41 +391,58 @@ class Client:
             return
 
         param_queue = list(msg.params[2:])
-        param_modes = {"o", "v"}
+        param_modes = {"o", "v", "S"}
 
         adding = True
         applied_modes = []
-        applied_nicks: list[str] = []
+        applied_params: list[str] = []
         for ch in modestring:
             if ch == "+":
                 adding = True
             elif ch == "-":
                 adding = False
+            elif ch == "R":
+                # +R / -R — restrict channel from federation
+                if adding:
+                    channel.restricted = True
+                else:
+                    channel.restricted = False
+                applied_modes.append(("+" if adding else "-") + ch)
             elif ch in param_modes:
                 if not param_queue:
                     continue
-                target_nick = param_queue.pop(0)
-                target_client = self.server.clients.get(target_nick)
-                if not target_client or target_client not in channel.members:
-                    await self.send_numeric(
-                        replies.ERR_USERNOTINCHANNEL,
-                        target_nick,
-                        channel_name,
-                        "They aren't on that channel",
-                    )
-                    continue
-                if ch == "o":
+                param_value = param_queue.pop(0)
+                if ch == "S":
+                    # +S <server> / -S <server> — share with specific servers
                     if adding:
-                        channel.operators.add(target_client)
+                        channel.shared_with.add(param_value)
                     else:
-                        channel.operators.discard(target_client)
-                elif ch == "v":
-                    if adding:
-                        channel.voiced.add(target_client)
-                    else:
-                        channel.voiced.discard(target_client)
-                applied_modes.append(("+" if adding else "-") + ch)
-                applied_nicks.append(target_nick)
+                        channel.shared_with.discard(param_value)
+                    applied_modes.append(("+" if adding else "-") + ch)
+                    applied_params.append(param_value)
+                else:
+                    target_nick = param_value
+                    target_client = self.server.clients.get(target_nick)
+                    if not target_client or target_client not in channel.members:
+                        await self.send_numeric(
+                            replies.ERR_USERNOTINCHANNEL,
+                            target_nick,
+                            channel_name,
+                            "They aren't on that channel",
+                        )
+                        continue
+                    if ch == "o":
+                        if adding:
+                            channel.operators.add(target_client)
+                        else:
+                            channel.operators.discard(target_client)
+                    elif ch == "v":
+                        if adding:
+                            channel.voiced.add(target_client)
+                        else:
+                            channel.voiced.discard(target_client)
+                    applied_modes.append(("+" if adding else "-") + ch)
+                    applied_params.append(target_nick)
 
         # Auto-promote if no operators remain
         if not channel.operators and channel.members:
@@ -435,7 +452,7 @@ class Client:
             mode_msg = Message(
                 prefix=self.prefix,
                 command="MODE",
-                params=[channel_name, "".join(applied_modes)] + applied_nicks,
+                params=[channel_name, "".join(applied_modes)] + applied_params,
             )
             for member in list(channel.members):
                 await member.send(mode_msg)

{agentirc_cli-0.3.1 → agentirc_cli-0.4.0}/agentirc/server/config.py

@@ -9,6 +9,7 @@ class LinkConfig:
     host: str
     port: int
     password: str
+    trust: str = "full"  # "full" or "restricted"
 
 
 @dataclass

{agentirc_cli-0.3.1 → agentirc_cli-0.4.0}/agentirc/server/ircd.py

@@ -102,13 +102,13 @@ class IRCd:
             await self._server.wait_closed()
 
     async def connect_to_peer(
-        self, host: str, port: int, password: str
+        self, host: str, port: int, password: str, trust: str = "full"
     ) -> ServerLink:
         """Initiate an outbound S2S connection."""
         from agentirc.server.server_link import ServerLink
 
         reader, writer = await asyncio.open_connection(host, port)
-        link = ServerLink(reader, writer, self, password, initiator=True)
+        link = ServerLink(reader, writer, self, password, initiator=True, trust=trust)
         asyncio.create_task(link.handle())
         return link
 
@@ -139,7 +139,7 @@ class IRCd:
                 writer.close()
                 return
 
-            link = ServerLink(reader, writer, self, password=None, initiator=False)
+            link = ServerLink(reader, writer, self, password=None, initiator=False, trust="restricted")
             try:
                 await link.handle(initial_msg=text)
             except (ConnectionError, asyncio.IncompleteReadError):

{agentirc_cli-0.3.1 → agentirc_cli-0.4.0}/agentirc/server/server_link.py

@@ -23,15 +23,17 @@ class ServerLink:
         reader: asyncio.StreamReader,
         writer: asyncio.StreamWriter,
         server: IRCd,
-        password: str,
+        password: str | None,
         *,
         initiator: bool = False,
+        trust: str = "full",
     ):
         self.reader = reader
         self.writer = writer
         self.server = server
         self.password = password
         self.initiator = initiator
+        self.trust = trust
         self.peer_name: str | None = None
         self.peer_description: str = ""
         self._authenticated = False
@@ -40,6 +42,19 @@ class ServerLink:
         self._peer_pass: str | None = None
         self.last_seen_seq: int = 0
 
+    def should_relay(self, channel_name: str) -> bool:
+        """Check if a channel event should be relayed over this link."""
+        channel = self.server.channels.get(channel_name)
+        if channel is None:
+            return False
+        if channel.restricted:
+            return False
+        if self.trust == "full":
+            return True
+        if self.trust == "restricted":
+            return self.peer_name in channel.shared_with
+        return False
+
     async def send_raw(self, line: str) -> None:
         try:
             self.writer.write(f"{line}\r\n".encode("utf-8"))
@@ -121,7 +136,7 @@ class ServerLink:
         if not (self._got_pass and self._got_server):
             return
 
-        # For inbound links, look up expected password by peer name
+        # For inbound links, look up expected password and trust by peer name
         if not self.initiator and self.password is None:
             link_config = None
             for lc in self.server.config.links:
@@ -133,6 +148,7 @@ class ServerLink:
                 await self.send_raw(f"ERROR :No link configured for {self.peer_name}")
                 raise ConnectionError(f"No link config for {self.peer_name}")
             self.password = link_config.password
+            self.trust = link_config.trust
 
         if self._peer_pass != self.password:
             logger.warning("Bad password from peer %s", self.peer_name)
@@ -172,8 +188,10 @@ class ServerLink:
                 f"SNICK {client.nick} {client.user} {client.host} :{client.realname}"
             )
 
-        # Send channel membership
+        # Send channel membership (filtered by trust)
         for channel in self.server.channels.values():
+            if not self.should_relay(channel.name):
+                continue
             local_nicks = [
                 m.nick for m in channel.members
                 if not isinstance(m, RemoteClient)
@@ -182,8 +200,10 @@ class ServerLink:
                 nicks_str = " ".join(local_nicks)
                 await self.send_raw(f"SJOIN {channel.name} {nicks_str}")
 
-        # Send channel topics
+        # Send channel topics (filtered by trust)
         for channel in self.server.channels.values():
+            if not self.should_relay(channel.name):
+                continue
             if channel.topic:
                 # Find who set it (use first local member as setter)
                 local_members = [
@@ -229,6 +249,19 @@ class ServerLink:
         channel_name = msg.params[0]
         nicks = msg.params[1:]
 
+        # Check incoming trust: if we have a restricted trust for this peer,
+        # only accept channel data for channels that have +S <peer>
+        existing = self.server.channels.get(channel_name)
+        if existing:
+            if existing.restricted:
+                return
+            if self.trust == "restricted" and self.peer_name not in existing.shared_with:
+                return
+        else:
+            # Channel doesn't exist locally yet — restricted links cannot create new channels
+            if self.trust == "restricted":
+                return
+
         channel = self.server.get_or_create_channel(channel_name)
 
         for nick in nicks:
@@ -255,6 +288,11 @@ class ServerLink:
 
         channel = self.server.channels.get(channel_name)
         if channel:
+            # Check incoming trust
+            if channel.restricted:
+                return
+            if self.trust == "restricted" and self.peer_name not in channel.shared_with:
+                return
             channel.topic = topic
 
     # --- Real-time relay handlers (incoming from peer) ---
@@ -267,6 +305,15 @@ class ServerLink:
         sender_nick = msg.params[1]
         text = msg.params[2]
 
+        # Check incoming trust for channel messages
+        if target.startswith("#"):
+            channel = self.server.channels.get(target)
+            if channel:
+                if channel.restricted:
+                    return
+                if self.trust == "restricted" and self.peer_name not in channel.shared_with:
+                    return
+
         relay = Message(
             prefix=f"{sender_nick}!*@*",
             command="PRIVMSG",
@@ -322,6 +369,15 @@ class ServerLink:
         sender_nick = msg.params[1]
         text = msg.params[2]
 
+        # Check incoming trust for channel notices
+        if target.startswith("#"):
+            channel = self.server.channels.get(target)
+            if channel:
+                if channel.restricted:
+                    return
+                if self.trust == "restricted" and self.peer_name not in channel.shared_with:
+                    return
+
         rc = self.server.remote_clients.get(sender_nick)
         prefix = rc.prefix if rc else f"{sender_nick}!*@*"
         relay = Message(prefix=prefix, command="NOTICE", params=[target, text])
@@ -361,6 +417,12 @@ class ServerLink:
         if not channel:
             return
 
+        # Check incoming trust
+        if channel.restricted:
+            return
+        if self.trust == "restricted" and self.peer_name not in channel.shared_with:
+            return
+
         # Notify local members
         part_params = [channel_name, reason] if reason else [channel_name]
         part_msg = Message(prefix=rc.prefix, command="PART", params=part_params)
@@ -454,6 +516,9 @@ class ServerLink:
         if event.type == EventType.MESSAGE:
             target = event.channel or event.data.get("target", "")
             text = event.data.get("text", "")
+            # Filter channel messages through trust check
+            if target.startswith("#") and not self.should_relay(target):
+                return
             cmd = event.data.get("notice") and "SNOTICE" or "SMSG"
             await self.send_raw(
                 f":{origin} {cmd} {target} {event.nick} :{text}"
@@ -469,6 +534,9 @@ class ServerLink:
         if event.type == EventType.MESSAGE:
             target = event.channel or event.data.get("target", "")
             text = event.data.get("text", "")
+            # Filter channel messages through trust check
+            if target.startswith("#") and not self.should_relay(target):
+                return
             if event.data.get("notice"):
                 await self.send_raw(
                     f":{origin} SNOTICE {target} {event.nick} :{text}"
@@ -479,11 +547,15 @@ class ServerLink:
                 )
         elif event.type == EventType.JOIN:
             channel_name = event.channel
+            if not self.should_relay(channel_name):
+                return
             await self.send_raw(
                 f":{origin} SJOIN {channel_name} {event.nick}"
             )
         elif event.type == EventType.PART:
             channel_name = event.channel
+            if not self.should_relay(channel_name):
+                return
             reason = event.data.get("reason", "")
             await self.send_raw(
                 f":{origin} SPART {channel_name} {event.nick} :{reason}"
@@ -495,6 +567,8 @@ class ServerLink:
             )
         elif event.type == EventType.TOPIC:
             channel_name = event.channel
+            if not self.should_relay(channel_name):
+                return
             topic = event.data.get("topic", "")
             await self.send_raw(
                 f":{origin} STOPIC {channel_name} {event.nick} :{topic}"

{agentirc_cli-0.3.1 → agentirc_cli-0.4.0}/docs/layer4-federation.md

@@ -63,22 +63,57 @@ agentirc server start --name thor --port 6668 --link spark:localhost:6667:secret
 
 ### Link Format
 
+```text
+--link name:host:port:password[:trust]
 ```
---link name:host:port:password
+
+Trust is `full` (default) or `restricted`:
+
+- **full** — share all channels (except `+R` restricted ones). Use for trusted
+  home mesh servers.
+- **restricted** — share nothing unless both sides explicitly agree with `+S`.
+  Use for external or public servers.
+
+```bash
+# Home mesh — full trust (default)
+agentirc server start --name spark --port 6667 --link thor:machineB:6667:secret
+
+# Public server — restricted trust
+agentirc server start --name spark --port 6667 --link public:example.com:6667:pubpass:restricted
 ```
 
+### Channel Federation Modes
+
+| Mode | Meaning |
+|------|---------|
+| `+R` | Restricted — channel stays local, never shared (even on full links) |
+| `+S <server>` | Shared — share this channel with the named server |
+| `-R` | Remove restricted flag |
+| `-S <server>` | Stop sharing with server |
+
+Examples:
+
+```text
+MODE #internal +R              # keep this channel local
+MODE #collab +S public-server  # share with public-server
+MODE #collab -S public-server  # stop sharing
+```
+
+For restricted links, **both sides** must set `+S` for a channel to sync.
+This prevents one server from unilaterally pulling channels from another.
+
 ### Programmatic
 
 ```python
-await server_a.connect_to_peer("localhost", 6668, "shared_secret")
+await server_a.connect_to_peer("localhost", 6668, "shared_secret", trust="full")
 ```
 
 ## What Syncs
 
 - Client presence (SNICK on registration and burst)
-- Channel membership (SJOIN/SPART)
-- Messages (SMSG/SNOTICE)
-- Topics (STOPIC)
+- Channel membership (SJOIN/SPART) — filtered by trust and channel modes
+- Messages (SMSG/SNOTICE) — filtered by trust and channel modes
+- Topics (STOPIC) — filtered by trust and channel modes
 - Client disconnects (SQUITUSER)
 - @mention notifications across servers
 
@@ -87,6 +122,7 @@ await server_a.connect_to_peer("localhost", 6668, "shared_secret")
 - Authentication
 - Skills data (populated independently via synced events)
 - Channel modes/operators (local authority only)
+- Channels marked `+R` (restricted)
 
 ## Wire Protocol
 

{agentirc_cli-0.3.1 → agentirc_cli-0.4.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "agentirc-cli"
-version = "0.3.1"
+version = "0.4.0"
 description = "IRC protocol chatrooms for AI agents (and humans allowed)"
 readme = "README.md"
 license = "MIT"