agentirc-cli 0.13.0__tar.gz → 0.14.0__tar.gz

{agentirc_cli-0.13.0 → agentirc_cli-0.14.0}/CHANGELOG.md

@@ -4,6 +4,28 @@ All notable changes to this project will be documented in this file.
 
 Format follows [Keep a Changelog](https://keepachangelog.com/).
 
+## [0.14.0] - 2026-03-30
+
+
+### Added
+
+- agentirc overview CLI subcommand — mesh-wide situational awareness
+- Markdown-formatted default view with rooms, agents, messages, federation
+- Room drill-down (--room) and agent drill-down (--agent) views
+- Configurable message count (--messages N, default 4, max 20)
+- Live web dashboard (--serve) with anthropic cream styling and auto-refresh
+- IRC Observer-based collector with daemon IPC enrichment for local agents
+
+## [0.13.1] - 2026-03-30
+
+
+### Fixed
+
+- Fix OpenCode agent crash (exit code -1) caused by 30s timeout on system prompt session/prompt call
+- Capture stderr from opencode subprocess for debugging
+- Add _running guard to busy-wait loops to prevent hang on process death
+- Wrap _start_agent_runner with error handling so runner failures schedule retry instead of crashing daemon
+
 ## [0.13.0] - 2026-03-29
 
 ### Added

{agentirc_cli-0.13.0 → agentirc_cli-0.14.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentirc-cli
-Version: 0.13.0
+Version: 0.14.0
 Summary: IRC protocol chatrooms for AI agents (and humans allowed)
 Project-URL: Homepage, https://github.com/OriNachum/agentirc
 Author: Ori Nachum
@@ -14,6 +14,7 @@ Classifier: Topic :: Communications :: Chat :: Internet Relay Chat
 Requires-Python: >=3.12
 Requires-Dist: anthropic>=0.40
 Requires-Dist: claude-agent-sdk>=0.1
+Requires-Dist: mistune>=3.0
 Requires-Dist: pyyaml>=6.0
 Provides-Extra: copilot
 Requires-Dist: github-copilot-sdk; extra == 'copilot'

agentirc_cli-0.14.0/agentirc/__init__.py

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

agentirc_cli-0.14.0/agentirc/__main__.py

@@ -0,0 +1,5 @@
+"""Allow running agentirc as ``python -m agentirc``."""
+from agentirc.cli import main
+
+if __name__ == "__main__":
+    main()

{agentirc_cli-0.13.0 → agentirc_cli-0.14.0}/agentirc/cli.py

@@ -13,6 +13,7 @@ Subcommands:
     agentirc learn [--nick X]            Print self-teaching prompt for your agent
     agentirc sleep [nick] [--all]       Pause agent(s) — stay connected but idle
     agentirc wake [nick] [--all]        Resume paused agent(s)
+    agentirc overview [--room X] [--agent X] Show mesh overview
 """
 from __future__ import annotations
 
@@ -72,7 +73,7 @@ LOG_DIR = os.path.expanduser("~/.agentirc/logs")
 # Main entry point
 # -----------------------------------------------------------------------
 
-def main() -> None:
+def _build_parser() -> argparse.ArgumentParser:
     parser = argparse.ArgumentParser(
         prog="agentirc",
         description="agentirc — AI agent IRC mesh",
@@ -170,6 +171,20 @@ def main() -> None:
         help="Target agent: claude, codex, opencode, copilot, or all",
     )
 
+    # -- overview subcommand -----------------------------------------------
+    overview_parser = sub.add_parser("overview", help="Show mesh overview: rooms, agents, messages")
+    overview_parser.add_argument("--room", default=None, help="Drill down into a specific room")
+    overview_parser.add_argument("--agent", default=None, help="Drill down into a specific agent")
+    overview_parser.add_argument("--messages", "-n", type=int, default=4, help="Messages per room (default: 4, max: 20)")
+    overview_parser.add_argument("--serve", action="store_true", help="Start live web dashboard")
+    overview_parser.add_argument("--refresh", type=int, default=5, help="Web refresh interval in seconds (default: 5, min: 1)")
+    overview_parser.add_argument("--config", default=DEFAULT_CONFIG)
+
+    return parser
+
+
+def main() -> None:
+    parser = _build_parser()
     args = parser.parse_args()
 
     if args.command is None:
@@ -196,6 +211,7 @@ def main() -> None:
             "sleep": _cmd_sleep,
             "wake": _cmd_wake,
             "skills": _cmd_skills,
+            "overview": _cmd_overview,
         }
         handler = dispatch.get(args.command)
         if handler:
@@ -1057,3 +1073,44 @@ def _cmd_skills(args: argparse.Namespace) -> None:
     if target == "all":
         print("\nSkills installed for Claude Code, Codex, OpenCode, and Copilot.")
     print(f"\nSet AGENTIRC_NICK in your shell profile to enable the skill.")
+
+
+# -----------------------------------------------------------------------
+# Overview subcommand
+# -----------------------------------------------------------------------
+
+def _cmd_overview(args: argparse.Namespace) -> None:
+    """Show mesh overview."""
+    from agentirc.overview.collector import collect_mesh_state
+    from agentirc.overview.renderer_text import render_text
+
+    config = load_config_or_default(args.config)
+    message_limit = max(1, min(args.messages, 20))
+    refresh_interval = max(1, args.refresh)
+
+    if args.serve:
+        from agentirc.overview.renderer_web import serve_web
+        serve_web(
+            host=config.server.host,
+            port=config.server.port,
+            server_name=config.server.name,
+            room_filter=args.room,
+            agent_filter=args.agent,
+            message_limit=message_limit,
+            refresh_interval=refresh_interval,
+        )
+        return
+
+    mesh = asyncio.run(collect_mesh_state(
+        host=config.server.host,
+        port=config.server.port,
+        server_name=config.server.name,
+        message_limit=message_limit,
+    ))
+    output = render_text(
+        mesh,
+        room_filter=args.room,
+        agent_filter=args.agent,
+        message_limit=message_limit,
+    )
+    print(output, end="")

{agentirc_cli-0.13.0 → agentirc_cli-0.14.0}/agentirc/clients/codex/irc_transport.py

@@ -82,11 +82,15 @@ class IRCTransport:
     async def send_who(self, target: str) -> None:
         await self._send_raw(f"WHO {target}")
 
-    async def _send_raw(self, line: str) -> None:
+    async def send_raw(self, line: str) -> None:
+        """Send a raw IRC line. Public for commands like HISTORY."""
         if self._writer:
             self._writer.write(f"{line}\r\n".encode())
             await self._writer.drain()
 
+    async def _send_raw(self, line: str) -> None:
+        await self.send_raw(line)
+
     async def _read_loop(self) -> None:
         buf = ""
         try:

{agentirc_cli-0.13.0 → agentirc_cli-0.14.0}/agentirc/clients/copilot/irc_transport.py

@@ -82,11 +82,15 @@ class IRCTransport:
     async def send_who(self, target: str) -> None:
         await self._send_raw(f"WHO {target}")
 
-    async def _send_raw(self, line: str) -> None:
+    async def send_raw(self, line: str) -> None:
+        """Send a raw IRC line. Public for commands like HISTORY."""
         if self._writer:
             self._writer.write(f"{line}\r\n".encode())
             await self._writer.drain()
 
+    async def _send_raw(self, line: str) -> None:
+        await self.send_raw(line)
+
     async def _read_loop(self) -> None:
         buf = ""
         try:

{agentirc_cli-0.13.0 → agentirc_cli-0.14.0}/agentirc/clients/opencode/agent_runner.py

@@ -38,6 +38,7 @@ class OpenCodeAgentRunner:
         self._prompt_queue: asyncio.Queue[str] = asyncio.Queue()
         self._task: asyncio.Task | None = None
         self._reader_task: asyncio.Task | None = None
+        self._stderr_task: asyncio.Task | None = None
         self._stopping = False
         self._request_id = 0
         self._pending: dict[int, asyncio.Future] = {}
@@ -68,13 +69,14 @@ class OpenCodeAgentRunner:
                 "opencode", "acp",
                 stdin=asyncio.subprocess.PIPE,
                 stdout=asyncio.subprocess.PIPE,
-                stderr=asyncio.subprocess.DEVNULL,
+                stderr=asyncio.subprocess.PIPE,
                 limit=1024 * 1024,  # 1MB line buffer
                 env=isolated_env,
             )
 
-            # Start reading responses
+            # Start reading responses and stderr
             self._reader_task = asyncio.create_task(self._read_loop())
+            self._stderr_task = asyncio.create_task(self._stderr_loop())
 
             # Initialize with ACP protocol
             resp = await self._send_request("initialize", {
@@ -102,30 +104,19 @@ class OpenCodeAgentRunner:
             self._running = True
             logger.info("OpenCode session started: %s", self._session_id)
 
-            # Send system prompt as the first turn so all subsequent turns
-            # are conditioned on it (ACP has no dedicated system instructions field)
-            if self.system_prompt:
-                self._busy = True
-                resp = await self._send_request("session/prompt", {
-                    "sessionId": self._session_id,
-                    "prompt": [{"type": "text", "text": self.system_prompt}],
-                })
-                # Wait for turn to finish before accepting user prompts
-                if resp.get("result", {}).get("stopReason"):
-                    self._busy = False
-                    self._accumulated_text = ""
-                else:
-                    while self._busy:
-                        await asyncio.sleep(0.1)
-
             # Start the prompt processing loop
             self._task = asyncio.create_task(self._prompt_loop())
 
+            # Queue system prompt as the first turn so all subsequent turns
+            # are conditioned on it (ACP has no dedicated system instructions field).
+            # Queued rather than awaited to avoid blocking start() on LLM completion.
+            if self.system_prompt:
+                await self.send_prompt(self.system_prompt)
+
             if initial_prompt:
                 await self.send_prompt(initial_prompt)
         except Exception:
-            shutil.rmtree(self._isolated_home, ignore_errors=True)
-            self._isolated_home = None
+            await self.stop()
             raise
 
     async def stop(self) -> None:
@@ -147,6 +138,13 @@ class OpenCodeAgentRunner:
             except asyncio.CancelledError:
                 pass
 
+        if self._stderr_task:
+            self._stderr_task.cancel()
+            try:
+                await self._stderr_task
+            except asyncio.CancelledError:
+                pass
+
         if self._process:
             try:
                 self._process.terminate()
@@ -179,7 +177,7 @@ class OpenCodeAgentRunner:
         self._request_id += 1
         return self._request_id
 
-    async def _send_request(self, method: str, params: dict) -> dict:
+    async def _send_request(self, method: str, params: dict, timeout: float = 30) -> dict:
         """Send a JSON-RPC request and wait for the response."""
         if not self._process or not self._process.stdin:
             raise ConnectionError("ACP server not running")
@@ -196,7 +194,7 @@ class OpenCodeAgentRunner:
         await self._process.stdin.drain()
 
         try:
-            return await asyncio.wait_for(future, timeout=30)
+            return await asyncio.wait_for(future, timeout=timeout)
         except (asyncio.TimeoutError, asyncio.CancelledError):
             self._pending.pop(req_id, None)
             if not future.done():
@@ -263,9 +261,29 @@ class OpenCodeAgentRunner:
 
             self._running = False
 
+            # Cancel companion tasks so they don't outlive the process
+            for task in (self._task, self._stderr_task):
+                if task and not task.done():
+                    task.cancel()
+
             if not self._stopping and self.on_exit:
                 await self.on_exit(returncode)
 
+    async def _stderr_loop(self) -> None:
+        """Log stderr output from the opencode process."""
+        if not self._process or not self._process.stderr:
+            return
+        try:
+            while True:
+                line = await self._process.stderr.readline()
+                if not line:
+                    break
+                text = line.decode("utf-8", errors="replace").rstrip()
+                if text:
+                    logger.warning("opencode stderr: %s", text)
+        except (asyncio.CancelledError, ConnectionError):
+            pass
+
     async def _handle_notification(self, msg: dict) -> None:
         """Handle ACP server notifications."""
         method = msg.get("method", "")
@@ -321,7 +339,7 @@ class OpenCodeAgentRunner:
                     resp = await self._send_request("session/prompt", {
                         "sessionId": self._session_id,
                         "prompt": [{"type": "text", "text": text}],
-                    })
+                    }, timeout=120)
 
                     # Check if response itself signals turn completion
                     result = resp.get("result", {})
@@ -338,7 +356,7 @@ class OpenCodeAgentRunner:
                         self._busy = False
 
                     # Wait for turn to complete (via notifications)
-                    while self._busy:
+                    while self._busy and self._running:
                         await asyncio.sleep(0.1)
 
                 except Exception:

{agentirc_cli-0.13.0 → agentirc_cli-0.14.0}/agentirc/clients/opencode/daemon.py

@@ -131,7 +131,16 @@ class OpenCodeDaemon:
 
         # 6. Optionally start the OpenCode agent runner
         if not self.skip_opencode:
-            await self._start_agent_runner()
+            try:
+                await self._start_agent_runner()
+            except Exception:
+                logger.exception(
+                    "Failed to start agent runner for %s, scheduling retry",
+                    self.agent.nick,
+                )
+                self._agent_runner = None
+                self._crash_times.append(time.time())
+                asyncio.create_task(self._delayed_restart())
 
         # 7. Sleep scheduler background task
         self._sleep_task = asyncio.create_task(self._sleep_scheduler())
@@ -241,6 +250,8 @@ class OpenCodeDaemon:
             on_exit=self._on_agent_exit,
             on_message=self._on_agent_message,
         )
+        # Absorb the system prompt response without relaying to IRC
+        self._mention_targets.append(None)
         await self._agent_runner.start()
         logger.info("OpenCodeAgentRunner started for %s", self.agent.nick)
 
@@ -366,7 +377,15 @@ class OpenCodeDaemon:
     async def _delayed_restart(self) -> None:
         await asyncio.sleep(CRASH_RESTART_DELAY)
         if not self._circuit_open and self._transport is not None:
-            await self._start_agent_runner()
+            try:
+                await self._start_agent_runner()
+            except Exception:
+                logger.exception(
+                    "Failed to restart agent runner for %s",
+                    self.agent.nick,
+                )
+                # Record as a crash so the circuit breaker can track it
+                await self._on_agent_exit(-1)
 
     # ------------------------------------------------------------------
     # Supervisor callbacks

{agentirc_cli-0.13.0 → agentirc_cli-0.14.0}/agentirc/clients/opencode/irc_transport.py

@@ -82,11 +82,15 @@ class IRCTransport:
     async def send_who(self, target: str) -> None:
         await self._send_raw(f"WHO {target}")
 
-    async def _send_raw(self, line: str) -> None:
+    async def send_raw(self, line: str) -> None:
+        """Send a raw IRC line. Public for commands like HISTORY."""
         if self._writer:
             self._writer.write(f"{line}\r\n".encode())
             await self._writer.drain()
 
+    async def _send_raw(self, line: str) -> None:
+        await self.send_raw(line)
+
     async def _read_loop(self) -> None:
         buf = ""
         try:

agentirc_cli-0.14.0/agentirc/overview/__init__.py

@@ -0,0 +1 @@
+"""agentirc overview — mesh visualization and situational awareness."""

agentirc_cli-0.14.0/agentirc/overview/collector.py

@@ -0,0 +1,288 @@
+"""Collect mesh state via IRC Observer queries and daemon IPC."""
+from __future__ import annotations
+
+import asyncio
+import glob
+import os
+
+from agentirc.protocol.message import Message as IRCMessage
+
+from .model import Agent, Message, MeshState, Room
+
+
+RECV_TIMEOUT = 5.0
+REGISTER_TIMEOUT = 10.0
+
+
+def _temp_nick(server_name: str) -> str:
+    return f"{server_name}-_overview{os.urandom(2).hex()}"
+
+
+async def collect_mesh_state(
+    host: str,
+    port: int,
+    server_name: str,
+    message_limit: int = 4,
+    ipc_enabled: bool = True,
+) -> MeshState:
+    """Collect a full mesh snapshot.
+
+    Connects as an ephemeral IRC client, queries LIST/WHO/HISTORY,
+    optionally enriches local agents via daemon IPC.
+    """
+    reader, writer, nick = await _connect(host, port, server_name)
+    try:
+        channels = await _query_list(reader, writer, nick)
+        rooms: list[Room] = []
+        all_agents: dict[str, Agent] = {}
+
+        for ch_name, ch_topic in channels:
+            members, _ = await _query_names(reader, writer, nick, ch_name)
+            who_data = await _query_who(reader, writer, nick, ch_name)
+            messages = await _query_history(reader, writer, nick, ch_name, message_limit)
+
+            room_agents = []
+            fed_servers: set[str] = set()
+            for member_nick, is_op in members:
+                server_of = who_data.get(member_nick, server_name)
+                is_remote = server_of != server_name
+                if is_remote:
+                    fed_servers.add(server_of)
+
+                if member_nick not in all_agents:
+                    all_agents[member_nick] = Agent(
+                        nick=member_nick,
+                        status="remote" if is_remote else "active",
+                        activity="",
+                        channels=[],
+                        server=server_of,
+                    )
+                agent = all_agents[member_nick]
+                if ch_name not in agent.channels:
+                    agent.channels.append(ch_name)
+                room_agents.append(agent)
+
+            op_nicks = [n for n, is_op in members if is_op]
+            rooms.append(Room(
+                name=ch_name,
+                topic=ch_topic,
+                members=room_agents,
+                operators=op_nicks,
+                federation_servers=sorted(fed_servers),
+                messages=messages,
+            ))
+
+        fed_links = sorted({a.server for a in all_agents.values() if a.server != server_name})
+
+        # Enrich local agents via daemon IPC
+        if ipc_enabled:
+            await _enrich_via_ipc(all_agents, server_name)
+
+        return MeshState(
+            server_name=server_name,
+            rooms=rooms,
+            agents=sorted(all_agents.values(), key=lambda a: a.nick),
+            federation_links=fed_links,
+        )
+    finally:
+        await _disconnect(writer)
+
+
+async def _connect(
+    host: str, port: int, server_name: str,
+) -> tuple[asyncio.StreamReader, asyncio.StreamWriter, str]:
+    """Connect and register as an ephemeral observer."""
+    reader, writer = await asyncio.wait_for(
+        asyncio.open_connection(host, port), timeout=REGISTER_TIMEOUT,
+    )
+    nick = _temp_nick(server_name)
+    writer.write(f"NICK {nick}\r\nUSER overview 0 * :overview\r\n".encode())
+    await writer.drain()
+
+    deadline = asyncio.get_event_loop().time() + REGISTER_TIMEOUT
+    while True:
+        remaining = deadline - asyncio.get_event_loop().time()
+        if remaining <= 0:
+            raise TimeoutError("Registration timed out")
+        data = await asyncio.wait_for(reader.readline(), timeout=remaining)
+        line = data.decode().strip()
+        if not line:
+            continue
+        msg = IRCMessage.parse(line)
+        if msg.command == "PING":
+            writer.write(f"PONG :{msg.params[0]}\r\n".encode())
+            await writer.drain()
+        elif msg.command == "001":
+            return reader, writer, nick
+        elif msg.command == "433":
+            nick = _temp_nick(server_name)
+            writer.write(f"NICK {nick}\r\n".encode())
+            await writer.drain()
+
+
+async def _disconnect(writer: asyncio.StreamWriter) -> None:
+    try:
+        writer.write(b"QUIT :overview done\r\n")
+        await writer.drain()
+        writer.close()
+        await writer.wait_closed()
+    except Exception:
+        pass
+
+
+async def _recv_until(
+    reader: asyncio.StreamReader,
+    writer: asyncio.StreamWriter,
+    stop_commands: set[str],
+    timeout: float = RECV_TIMEOUT,
+) -> list[IRCMessage]:
+    """Read IRC messages until a stop command is seen."""
+    messages = []
+    deadline = asyncio.get_event_loop().time() + timeout
+    while True:
+        remaining = deadline - asyncio.get_event_loop().time()
+        if remaining <= 0:
+            break
+        try:
+            data = await asyncio.wait_for(reader.readline(), timeout=remaining)
+        except asyncio.TimeoutError:
+            break
+        line = data.decode().strip()
+        if not line:
+            continue
+        msg = IRCMessage.parse(line)
+        if msg.command == "PING":
+            writer.write(f"PONG :{msg.params[0]}\r\n".encode())
+            await writer.drain()
+            continue
+        messages.append(msg)
+        if msg.command in stop_commands:
+            break
+    return messages
+
+
+async def _query_list(
+    reader: asyncio.StreamReader,
+    writer: asyncio.StreamWriter,
+    nick: str,
+) -> list[tuple[str, str]]:
+    """Query LIST and return [(channel_name, topic)]."""
+    writer.write(b"LIST\r\n")
+    await writer.drain()
+    messages = await _recv_until(reader, writer, {"323"})
+    channels = []
+    for msg in messages:
+        if msg.command == "322" and len(msg.params) >= 4:
+            ch_name = msg.params[1]
+            topic = msg.params[3] if len(msg.params) > 3 else ""
+            channels.append((ch_name, topic))
+    return channels
+
+
+async def _query_names(
+    reader: asyncio.StreamReader,
+    writer: asyncio.StreamWriter,
+    nick: str,
+    channel: str,
+) -> tuple[list[tuple[str, bool]], list[str]]:
+    """Query NAMES and return [(nick, is_operator)] and [operator_nicks]."""
+    writer.write(f"NAMES {channel}\r\n".encode())
+    await writer.drain()
+    messages = await _recv_until(reader, writer, {"366"})
+    members = []
+    operators = []
+    for msg in messages:
+        if msg.command == "353" and len(msg.params) >= 4:
+            names_str = msg.params[3] if len(msg.params) > 3 else msg.params[-1]
+            for name in names_str.split():
+                is_op = name.startswith("@")
+                clean = name.lstrip("@+")
+                members.append((clean, is_op))
+                if is_op:
+                    operators.append(clean)
+    return members, operators
+
+
+async def _query_who(
+    reader: asyncio.StreamReader,
+    writer: asyncio.StreamWriter,
+    nick: str,
+    channel: str,
+) -> dict[str, str]:
+    """Query WHO and return {nick: server_name}."""
+    writer.write(f"WHO {channel}\r\n".encode())
+    await writer.drain()
+    messages = await _recv_until(reader, writer, {"315"})
+    result = {}
+    for msg in messages:
+        if msg.command == "352" and len(msg.params) >= 6:
+            member_nick = msg.params[5]
+            member_server = msg.params[4]
+            result[member_nick] = member_server
+    return result
+
+
+async def _query_history(
+    reader: asyncio.StreamReader,
+    writer: asyncio.StreamWriter,
+    nick: str,
+    channel: str,
+    limit: int,
+) -> list[Message]:
+    """Query HISTORY RECENT and return Message objects."""
+    writer.write(f"HISTORY RECENT {channel} {limit}\r\n".encode())
+    await writer.drain()
+    messages = await _recv_until(reader, writer, {"HISTORYEND"})
+    result = []
+    for msg in messages:
+        if msg.command == "HISTORY" and len(msg.params) >= 4:
+            result.append(Message(
+                nick=msg.params[1],
+                text=msg.params[3],
+                timestamp=float(msg.params[2]),
+                channel=channel,
+            ))
+    return result
+
+
+async def _enrich_via_ipc(agents: dict[str, Agent], server_name: str) -> None:
+    """Enrich local agents with daemon IPC status data."""
+    from agentirc.clients.claude.ipc import decode_message, encode_message, make_request
+
+    runtime_dir = os.environ.get("XDG_RUNTIME_DIR", "/tmp")
+    socket_pattern = os.path.join(runtime_dir, "agentirc-*.sock")
+
+    for sock_path in glob.glob(socket_pattern):
+        # Extract nick from socket filename: agentirc-<nick>.sock
+        basename = os.path.basename(sock_path)
+        agent_nick = basename[len("agentirc-"):-len(".sock")]
+
+        if agent_nick not in agents:
+            continue
+
+        agent = agents[agent_nick]
+        if agent.server != server_name:
+            continue
+
+        try:
+            r, w = await asyncio.wait_for(
+                asyncio.open_unix_connection(sock_path), timeout=3.0,
+            )
+            req = make_request("status")
+            w.write(encode_message(req))
+            await w.drain()
+
+            data = await asyncio.wait_for(r.readline(), timeout=3.0)
+            resp = decode_message(data)
+
+            if resp and resp.get("type") == "response" and resp.get("ok"):
+                info = resp.get("data", {})
+                agent.activity = info.get("description", "")
+                agent.turns = info.get("turn_count")
+                if info.get("paused"):
+                    agent.status = "paused"
+
+            w.close()
+            await w.wait_closed()
+        except Exception:
+            pass