agentirc-cli 6.2.3__tar.gz → 7.1.0__tar.gz

{agentirc_cli-6.2.3 → agentirc_cli-7.1.0}/.github/workflows/security-checks.yml

@@ -33,7 +33,7 @@ jobs:
         continue-on-error: true
 
       - name: Run Safety dependency check
-        run: uv run safety check --full-report --output json > safety-results.json
+        run: uv run safety check --output json > safety-results.json
         continue-on-error: true
 
       - name: Upload Security Results

{agentirc_cli-6.2.3 → agentirc_cli-7.1.0}/CHANGELOG.md

@@ -4,6 +4,101 @@ All notable changes to this project will be documented in this file.
 
 Format follows [Keep a Changelog](https://keepachangelog.com/).
 
+## [7.1.0] - 2026-04-17
+
+
+### Changed
+
+- Refactored _handle_channel_mode in culture/agentirc/client.py: extracted _apply_mode_char and _broadcast_mode_change helpers to drop cognitive complexity from 21 to ≤15 (SonarCloud S3776)
+- Background task GC safety in ircd.py _notify_local_quit: asyncio.ensure_future replaced with a tracked asyncio.create_task using the existing self._background_tasks set + add_done_callback(discard) pattern
+
+
+### Fixed
+
+- culture mesh update no longer hangs on broken/unresponsive systemd units — all subprocess calls in persistence.py and cli/mesh.py now have explicit timeouts (30s for service restarts, 30s for CLI fallbacks, 120s for package upgrade)
+- fires_event chain not triggering downstream bots (#260) — the bot.yaml loader now accepts fires_event at the top level as well as under output:, so configs that put the block at the top level emit events as expected
+- Daemon log flushing stops after startup — replaced logging.basicConfig's default StreamHandler (which inherits stderr buffering from interpreter startup) with an explicit logging.FileHandler so runtime log records flush per-record
+
+## [7.0.4] - 2026-04-17
+
+
+### Fixed
+
+- Reduce cognitive complexity and fix code quality issues across CLI modules (SonarCloud S3776, S1192, S5886, S108)
+
+## [7.0.3] - 2026-04-17
+
+
+### Fixed
+
+- Duplicate _ERR_CHANNEL_PREFIX string in all 5 daemon files (S1192)
+- Cognitive complexity in claude/daemon.py _poll_loop (CC 22, S3776)
+- Cognitive complexity in agent-harness/daemon.py _poll_loop (CC 22, S3776)
+- Cognitive complexity in codex/daemon.py _relay_response_to_irc (CC 44, S3776)
+- Cognitive complexity in copilot/daemon.py _relay_response_to_irc (CC 23, S3776)
+- Cognitive complexity in acp/daemon.py _relay_response_to_irc (CC 23, S3776)
+- Cognitive complexity in acp/agent_runner.py start() (CC 17, S3776)
+
+## [7.0.2] - 2026-04-17
+
+
+### Fixed
+
+- Cognitive complexity in observer.py (CC 22→~13)
+- Cognitive complexity in ircd.py (CC 18→~12)
+- Cognitive complexity in server_link.py (CC 33→~14)
+
+## [7.0.1] - 2026-04-17
+
+
+### Fixed
+
+- Wrong AgentConfig/DaemonConfig import types in test helpers (S5655)
+- Constant if-False condition replaced with unreachable yield pattern (S5797)
+
+## [7.0.0] - 2026-04-17
+
+Mesh Events (issue #123) — lifecycle and activity notifications as IRCv3-tagged
+PRIVMSGs, event-triggered bots, and pub/sub composition chains.
+
+> Versions 6.3.0 through 6.11.2 were development increments for this feature
+> and were never published. Their changes are consolidated here as 7.0.0.
+
+### Breaking Changes
+
+None. Existing clients, bots, and federation links continue to work unchanged.
+The major bump reflects the scope of the feature addition (new protocol verb,
+new subsystem, new bot trigger type).
+
+### Added
+
+- **Event system** — `system-<server>` pseudo-user surfaces lifecycle events
+  as IRCv3-tagged PRIVMSGs with `@event=<type>;event-data=<b64json>` tags
+- **Built-in event catalog** — 18 event types across channel-scoped
+  (`user.join/part/quit`, `room.create/archive/meta`, `tags.update`) and global
+  (`agent.connect/disconnect`, `server.wake/sleep/link/unlink`,
+  `console.open/close`)
+- **IRCv3 message-tags** — `Message.parse()` extracts tags; CAP negotiation
+  (`CAP REQ :message-tags`) in all agent backends and server
+- **`#system` channel** — auto-created at startup for global event delivery;
+  `system-<server>` VirtualClient auto-joined
+- **Reserved `system-*` nicks** — rejected for non-server clients
+  (`432 ERR_ERRONEUSNICKNAME`)
+- **SEVENT S2S verb** — generic federation relay for lifecycle events with
+  `_origin` loop prevention and trust policy filtering
+- **HistorySkill** stores lifecycle events — `HISTORY RECENT` replays
+  agent.connect, server.wake, room.create, etc.
+- **Filter DSL** — safe recursive-descent expression parser (`==`, `!=`, `in`,
+  `and`, `or`, `not`, dotted field access) for bot event triggers
+- **Bot event triggers** — `trigger.type: event` with filter DSL evaluation;
+  `fires_event` output for pub/sub bot chains with rate limiting (10/sec)
+- **System bots** — package-bundled bots discovered at startup from
+  `culture/bots/system/<name>/bot.yaml`; welcome bot greets on `user.join`
+- **All-backends CAP** — claude, codex, copilot, acp, and agent-harness
+  transports negotiate `message-tags` during connection
+- **Documentation** — `docs/agentirc/events.md`, `docs/agentirc/bots.md`,
+  `culture/protocol/extensions/events.md`
+
 ## [6.2.3] - 2026-04-15
 
 

{agentirc_cli-6.2.3 → agentirc_cli-7.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentirc-cli
-Version: 6.2.3
+Version: 7.1.0
 Summary: Legacy alias for culture — install culture instead
 Project-URL: Homepage, https://github.com/OriNachum/culture
 Author: Ori Nachum

{agentirc_cli-6.2.3 → agentirc_cli-7.1.0}/culture/agentirc/client.py

@@ -9,6 +9,7 @@ from typing import TYPE_CHECKING
 from culture.agentirc.channel import Channel
 from culture.agentirc.skill import Event, EventType
 from culture.aio import maybe_await
+from culture.constants import SYSTEM_USER_PREFIX
 from culture.protocol import replies
 from culture.protocol.message import Message
 
@@ -35,6 +36,7 @@ class Client:
         self.channels: set[Channel] = set()
         self._registered = False
         self.tags: list[str] = []
+        self.caps: set[str] = set()
         self.modes: set[str] = set()
         self.icon: str | None = None
 
@@ -49,6 +51,28 @@ class Client:
         except OSError:
             pass  # Client disconnected; cleanup happens in ircd._handle_connection
 
+    async def send_raw(self, line: str) -> None:
+        """Write a pre-formatted IRC line to the client socket.
+
+        Appends CRLF internally, matching ServerLink.send_raw convention.
+        """
+        try:
+            self.writer.write(f"{line}\r\n".encode("utf-8"))
+            await self.writer.drain()
+        except OSError:
+            pass  # Client disconnected; cleanup happens in ircd._handle_connection
+
+    async def send_tagged(self, msg: Message) -> None:
+        """Send a Message, stripping tags for clients that haven't negotiated message-tags."""
+        if msg.tags and "message-tags" not in self.caps:
+            msg = Message(
+                tags={},
+                prefix=msg.prefix,
+                command=msg.command,
+                params=list(msg.params),
+            )
+        await self.send(msg)
+
     async def send_numeric(self, code: str, *params: str) -> None:
         target = self.nick or "*"
         msg = Message(
@@ -114,6 +138,29 @@ class Client:
     def _handle_pong(self, msg: Message) -> None:
         pass  # Client responding to our ping
 
+    async def _handle_cap(self, msg: Message) -> None:
+        sub = msg.params[0].upper() if msg.params else ""
+        if sub == "LS":
+            await self.send_raw(
+                f":{self.server.config.name} CAP {self.nick or '*'} LS :message-tags"
+            )
+        elif sub == "REQ":
+            requested = msg.params[1].split() if len(msg.params) >= 2 else []
+            supported = {"message-tags"}
+            if all(cap in supported for cap in requested):
+                self.caps.update(requested)
+                await self.send_raw(
+                    f":{self.server.config.name} CAP {self.nick or '*'}"
+                    f" ACK :{' '.join(requested)}"
+                )
+            else:
+                await self.send_raw(
+                    f":{self.server.config.name} CAP {self.nick or '*'}"
+                    f" NAK :{' '.join(requested)}"
+                )
+        elif sub == "END":
+            pass  # no registration-gating in v1
+
     async def _handle_nick(self, msg: Message) -> None:
         if not msg.params:
             await self.send_numeric(replies.ERR_NONICKNAMEGIVEN, "No nickname given")
@@ -121,6 +168,15 @@ class Client:
 
         nick = msg.params[0]
 
+        # Reject reserved system-* nick prefix
+        if nick.startswith(SYSTEM_USER_PREFIX):
+            await self.send_numeric(
+                replies.ERR_ERRONEUSNICKNAME,
+                nick,
+                "Nickname prefix 'system-' is reserved",
+            )
+            return
+
         # Enforce server name prefix
         expected_prefix = f"{self.server.config.name}-"
         if not nick.startswith(expected_prefix):
@@ -227,10 +283,6 @@ class Client:
         for member in list(channel.members):
             await member.send(join_msg)
 
-        await self.server.emit_event(
-            Event(type=EventType.JOIN, channel=channel_name, nick=self.nick)
-        )
-
         # Send topic if set
         if channel.topic:
             await self.send_numeric(replies.RPL_TOPIC, channel_name, channel.topic)
@@ -238,6 +290,12 @@ class Client:
         # Send names list
         await self._send_names(channel)
 
+        # Emit event AFTER delivering all join-related numerics (topic, NAMES)
+        # so that the event PRIVMSG doesn't interleave with 353/366 in client buffers.
+        await self.server.emit_event(
+            Event(type=EventType.JOIN, channel=channel_name, nick=self.nick)
+        )
+
     async def _handle_part(self, msg: Message) -> None:
         if not msg.params:
             await self.send_numeric(replies.ERR_NEEDMOREPARAMS, "PART", replies.MSG_NEEDMOREPARAMS)
@@ -386,6 +444,56 @@ class Client:
         applied_modes.append(("+" if adding else "-") + ch)
         applied_params.append(target_nick)
 
+    _PARAM_MODES = frozenset({"o", "v", "S"})
+
+    async def _apply_mode_char(
+        self,
+        channel,
+        channel_name: str,
+        ch: str,
+        adding: bool,
+        param_queue: list[str],
+        applied_modes: list[str],
+        applied_params: list[str],
+    ) -> None:
+        """Apply a single mode character. Consumes one param from param_queue when needed."""
+        if ch == "R":
+            self._apply_mode_r(channel, adding, applied_modes)
+            return
+        if ch not in self._PARAM_MODES or not param_queue:
+            return
+        param_value = param_queue.pop(0)
+        if ch == "S":
+            self._apply_mode_s(channel, adding, param_value, applied_modes, applied_params)
+        else:
+            await self._apply_mode_membership(
+                channel,
+                channel_name,
+                ch,
+                adding,
+                param_value,
+                applied_modes,
+                applied_params,
+            )
+
+    async def _broadcast_mode_change(
+        self,
+        channel,
+        channel_name: str,
+        applied_modes: list[str],
+        applied_params: list[str],
+    ) -> None:
+        """Send the aggregated MODE message to all channel members."""
+        if not applied_modes:
+            return
+        mode_msg = Message(
+            prefix=self.prefix,
+            command="MODE",
+            params=[channel_name, "".join(applied_modes)] + applied_params,
+        )
+        for member in list(channel.members):
+            await member.send(mode_msg)
+
     async def _handle_channel_mode(self, msg: Message) -> None:
         channel_name = msg.params[0]
         channel = self.server.channels.get(channel_name)
@@ -399,7 +507,6 @@ class Client:
             await self.send_numeric(replies.RPL_CHANNELMODEIS, channel_name, "+")
             return
 
-        modestring = msg.params[1]
         if not channel.is_operator(self):
             await self.send_numeric(
                 replies.ERR_CHANOPRIVSNEEDED,
@@ -408,50 +515,90 @@ class Client:
             )
             return
 
+        modestring = msg.params[1]
         param_queue = list(msg.params[2:])
-        param_modes = {"o", "v", "S"}
-
         adding = True
-        applied_modes = []
+        applied_modes: list[str] = []
         applied_params: list[str] = []
         for ch in modestring:
             if ch == "+":
                 adding = True
             elif ch == "-":
                 adding = False
-            elif ch == "R":
-                self._apply_mode_r(channel, adding, applied_modes)
-            elif ch in param_modes:
-                if not param_queue:
-                    continue
-                param_value = param_queue.pop(0)
-                if ch == "S":
-                    self._apply_mode_s(channel, adding, param_value, applied_modes, applied_params)
-                else:
-                    await self._apply_mode_membership(
-                        channel,
-                        channel_name,
-                        ch,
-                        adding,
-                        param_value,
-                        applied_modes,
-                        applied_params,
-                    )
+            else:
+                await self._apply_mode_char(
+                    channel,
+                    channel_name,
+                    ch,
+                    adding,
+                    param_queue,
+                    applied_modes,
+                    applied_params,
+                )
 
         # Auto-promote if no operators remain
         if not channel.operators and channel.members:
             channel.operators.add(min(channel.members, key=lambda m: m.nick))
 
-        if applied_modes:
-            mode_msg = Message(
-                prefix=self.prefix,
-                command="MODE",
-                params=[channel_name, "".join(applied_modes)] + applied_params,
+        await self._broadcast_mode_change(channel, channel_name, applied_modes, applied_params)
+
+    _VALID_USER_MODE_CHARS = frozenset("HABC")
+    _USER_MODE_EDGE_EVENTS: dict[tuple[str, bool], EventType] = {
+        ("A", True): EventType.AGENT_CONNECT,
+        ("A", False): EventType.AGENT_DISCONNECT,
+        ("C", True): EventType.CONSOLE_OPEN,
+        ("C", False): EventType.CONSOLE_CLOSE,
+    }
+
+    def _apply_user_mode_char(self, ch: str, adding: bool) -> EventType | None:
+        """Mutate ``self.modes`` for a single mode char and return the edge event, if any.
+
+        Returns None if the char is unknown or the transition was a no-op
+        (setting an already-set mode or clearing an already-clear one).
+        """
+        if ch not in self._VALID_USER_MODE_CHARS:
+            return None
+        had = ch in self.modes
+        if adding:
+            self.modes.add(ch)
+        else:
+            self.modes.discard(ch)
+        if had == adding:
+            return None
+        return self._USER_MODE_EDGE_EVENTS.get((ch, adding))
+
+    def _parse_mode_edges(self, modestring: str) -> list[EventType]:
+        """Apply each char of ``modestring`` and collect the emitted edge events."""
+        pending: list[EventType] = []
+        adding = True
+        for ch in modestring:
+            if ch == "+":
+                adding = True
+            elif ch == "-":
+                adding = False
+            else:
+                event = self._apply_user_mode_char(ch, adding)
+                if event is not None:
+                    pending.append(event)
+        return pending
+
+    async def _emit_user_mode_events(self, pending: list[EventType]) -> None:
+        for event_type in pending:
+            await self.server.emit_event(
+                Event(
+                    type=event_type,
+                    channel=None,
+                    nick=self.nick,
+                    data={"nick": self.nick},
+                )
             )
-            for member in list(channel.members):
-                await member.send(mode_msg)
 
     async def _handle_user_mode(self, msg: Message) -> None:
+        # Reject pre-registration so an unregistered socket cannot inject
+        # agent.connect / console.open into #system by sending MODE after NICK
+        # but before USER.
+        if not self._registered:
+            return
         target_nick = msg.params[0]
         if target_nick != self.nick:
             await self.send_numeric(
@@ -459,19 +606,11 @@ class Client:
                 "Can't change mode for other users",
             )
             return
-        if len(msg.params) > 1:
-            modestring = msg.params[1]
-            adding = True
-            for ch in modestring:
-                if ch == "+":
-                    adding = True
-                elif ch == "-":
-                    adding = False
-                elif ch in ("H", "A", "B"):
-                    if adding:
-                        self.modes.add(ch)
-                    else:
-                        self.modes.discard(ch)
+
+        modestring = msg.params[1] if len(msg.params) > 1 else ""
+        pending = self._parse_mode_edges(modestring)
+        await self._emit_user_mode_events(pending)
+
         mode_str = "+" + "".join(sorted(self.modes)) if self.modes else "+"
         await self.send_numeric(replies.RPL_UMODEIS, mode_str)
 

{agentirc_cli-6.2.3 → agentirc_cli-7.1.0}/culture/agentirc/config.py

@@ -22,3 +22,4 @@ class ServerConfig:
     webhook_port: int = 7680
     data_dir: str = ""
     links: list[LinkConfig] = field(default_factory=list)
+    system_bots: dict = field(default_factory=dict)

agentirc_cli-7.1.0/culture/agentirc/events.py

@@ -0,0 +1,117 @@
+"""Event type catalog and render-template registry.
+
+Event type names follow the dotted-lowercase convention enforced by
+`EVENT_TYPE_RE` in `culture.constants`. Render templates map a type to a
+function that produces the human-readable PRIVMSG body for humans and
+vanilla IRC clients. The structured payload is attached as IRCv3 message
+tags by the server's emit path (see `culture/agentirc/ircd.py`); this
+module is presentation-only.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any, Callable
+
+from culture.agentirc.skill import EventType
+from culture.constants import EVENT_TYPE_RE
+
+logger = logging.getLogger(__name__)
+
+# Event types whose content is already delivered to clients via the normal
+# IRC path (PRIVMSG, NOTICE, TOPIC) or has dedicated storage (threads).
+# Used by both IRCd._surface_event_privmsg (to avoid double-delivery) and
+# HistorySkill (to avoid double-storage).  Keep this as the single source
+# of truth — do not duplicate.
+NO_SURFACE_EVENT_TYPES: frozenset[str] = frozenset(
+    {
+        EventType.MESSAGE.value,
+        EventType.THREAD_CREATE.value,
+        EventType.THREAD_MESSAGE.value,
+        EventType.THREAD_CLOSE.value,
+        EventType.TOPIC.value,
+    }
+)
+
+RenderFn = Callable[[dict[str, Any], str | None], str]
+
+_TEMPLATES: dict[str, RenderFn] = {}
+
+
+def register(event_type: str, fn: RenderFn) -> None:
+    _TEMPLATES[event_type] = fn
+
+
+def validate_event_type(name: str) -> bool:
+    return bool(EVENT_TYPE_RE.match(name))
+
+
+def render_event(event_type: str, data: dict[str, Any], channel: str | None) -> str:
+    fn = _TEMPLATES.get(event_type)
+    if fn is None:
+        return f"{event_type} {data}"
+    try:
+        return fn(data, channel)
+    except Exception:
+        logger.exception("render template for %s failed", event_type)
+        return f"{event_type} {data}"
+
+
+# -------- built-in render templates --------
+
+
+def _nick_action(verb: str) -> RenderFn:
+    def _render(data, channel):
+        nick = data.get("nick", "<unknown>")
+        if channel:
+            return f"{nick} {verb} {channel}"
+        return f"{nick} {verb}"
+
+    return _render
+
+
+register("user.join", _nick_action("joined"))
+register("user.part", _nick_action("left"))
+register(
+    "user.quit",
+    lambda d, c: f"{d.get('nick', '<unknown>')} quit: {d.get('reason', '')}".rstrip(": "),
+)
+
+register("agent.connect", lambda d, c: f"{d.get('nick', '<unknown>')} connected")
+register(
+    "agent.disconnect",
+    lambda d, c: f"{d.get('nick', '<unknown>')} disconnected",
+)
+
+register("console.open", lambda d, c: f"{d.get('nick', '<unknown>')} opened a console")
+register("console.close", lambda d, c: f"{d.get('nick', '<unknown>')} closed their console")
+
+register("server.wake", lambda d, c: f"server {d.get('server', '<unknown>')} is up")
+register(
+    "server.sleep",
+    lambda d, c: f"server {d.get('server', '<unknown>')} is shutting down",
+)
+register("server.link", lambda d, c: f"linked to {d.get('peer', '<unknown>')}")
+register("server.unlink", lambda d, c: f"unlinked from {d.get('peer', '<unknown>')}")
+
+register("room.create", lambda d, c: f"{d.get('nick', '<unknown>')} created room {c}")
+register("room.archive", lambda d, c: f"{d.get('nick', '<unknown>')} archived {c}")
+register("room.meta", lambda d, c: f"{d.get('nick', '<unknown>')} updated {c} metadata")
+
+register(
+    "thread.create",
+    lambda d, c: f"{d.get('nick', '<unknown>')} started thread [{d.get('thread', '?')}] in {c}",
+)
+register(
+    "thread.message",
+    lambda d, c: f"[{d.get('thread', '?')}] {d.get('nick', '<unknown>')}: {d.get('text', '')}",
+)
+register(
+    "thread.close",
+    lambda d, c: f"thread [{d.get('thread', '?')}] in {c} closed",
+)
+
+register(
+    "tags.update",
+    lambda d, c: f"{d.get('nick', '<unknown>')} tags → {', '.join(d.get('tags', []))}",
+)