agentirc-cli 4.3.4__tar.gz → 4.3.6__tar.gz

{agentirc_cli-4.3.4 → agentirc_cli-4.3.6}/CHANGELOG.md

@@ -4,6 +4,38 @@ All notable changes to this project will be documented in this file.
 
 Format follows [Keep a Changelog](https://keepachangelog.com/).
 
+## [4.3.6] - 2026-04-07
+
+
+### Changed
+
+- CLI module docstring updated with current subcommand sets (#147)
+
+
+### Fixed
+
+- agent message silently succeeds for nonexistent targets (#132)
+- channel message silently succeeds for nonexistent channels (#133)
+- agent sleep/wake error messages use wrong command names (#134)
+- server subcommands ignore default server, hardcode culture (#135)
+- agent start/stop inconsistent behavior with no nick argument (#137)
+- channel message and bot create accept empty strings (#138)
+- bot archive/unarchive missing --config flag (#139)
+- inconsistent error message casing in agent archive vs unarchive (#140)
+- channel commands show confusing timeout error when server is down (#141)
+- uncaught PackageNotFoundError in version fallback (#142)
+- culture --version flag not supported (#143)
+- agent/channel message silently succeeds for nonexistent or empty targets (#144)
+- channel read displays raw Unix timestamps instead of human-readable format (#145)
+- server default accepts nonexistent server names without validation (#146)
+
+## [4.3.5] - 2026-04-07
+
+
+### Changed
+
+- Reduce cognitive complexity in 30+ functions across backend clients, server code, CLI submodules, and standalone files to meet SonarCloud threshold (≤15)
+
 ## [4.3.4] - 2026-04-07
 
 

{agentirc_cli-4.3.4 → agentirc_cli-4.3.6}/PKG-INFO

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

{agentirc_cli-4.3.4 → agentirc_cli-4.3.6}/culture/__init__.py

@@ -7,4 +7,7 @@ except PackageNotFoundError:
     try:
         __version__ = _v("agentirc-cli")
     except PackageNotFoundError:
-        __version__ = _v("agentirc")
+        try:
+            __version__ = _v("agentirc")
+        except PackageNotFoundError:
+            __version__ = "0.0.0-dev"

{agentirc_cli-4.3.4 → agentirc_cli-4.3.6}/culture/cli/__init__.py

@@ -1,11 +1,11 @@
 """Unified CLI entry point for culture.
 
 Commands are organized into noun-based groups:
-    culture agent    {create,join,start,stop,status,rename,assign,sleep,wake,learn,message,read}
-    culture server   {start,stop,status,default,rename}
+    culture agent    {create,join,start,stop,status,rename,assign,sleep,wake,learn,message,read,archive,unarchive,delete}
+    culture server   {start,stop,status,default,rename,archive,unarchive}
     culture mesh     {overview,setup,update,console}
     culture channel  {list,read,message,who}
-    culture bot      {create,start,stop,list,inspect}
+    culture bot      {create,start,stop,list,inspect,archive,unarchive}
     culture skills   {install}
 """
 
@@ -15,6 +15,7 @@ import argparse
 import logging
 import sys
 
+from culture import __version__
 from culture.cli import agent, bot, channel, mesh, server, skills
 
 GROUPS = [agent, server, mesh, channel, bot, skills]
@@ -25,6 +26,7 @@ def _build_parser() -> argparse.ArgumentParser:
         prog="culture",
         description="culture — AI agent IRC mesh",
     )
+    parser.add_argument("--version", action="version", version=f"%(prog)s {__version__}")
     sub = parser.add_subparsers(dest="command")
     for group in GROUPS:
         group.register(sub)

{agentirc_cli-4.3.4 → agentirc_cli-4.3.6}/culture/cli/agent.py

@@ -201,59 +201,83 @@ def dispatch(args: argparse.Namespace) -> None:
 # -----------------------------------------------------------------------
 
 
-def _create_agent_config(args: argparse.Namespace, full_nick: str) -> AgentConfig:
-    """Build a backend-specific AgentConfig from CLI args."""
-    if args.agent == "codex":
-        from culture.clients.codex.config import AgentConfig as CodexAgentConfig
-
-        return CodexAgentConfig(
-            nick=full_nick,
-            agent="codex",
-            directory=os.getcwd(),
-            channels=[DEFAULT_CHANNEL],
-        )
-    if args.agent == "copilot":
-        from culture.clients.copilot.config import AgentConfig as CopilotAgentConfig
-
-        return CopilotAgentConfig(
-            nick=full_nick,
-            agent="copilot",
-            directory=os.getcwd(),
-            channels=[DEFAULT_CHANNEL],
-        )
-    if args.agent == "acp":
-        import json as _json
+def _create_codex_config(full_nick: str) -> AgentConfig:
+    """Build a CodexAgentConfig."""
+    from culture.clients.codex.config import AgentConfig as CodexAgentConfig
 
-        from culture.clients.acp.config import AgentConfig as ACPAgentConfig
+    return CodexAgentConfig(
+        nick=full_nick,
+        agent="codex",
+        directory=os.getcwd(),
+        channels=[DEFAULT_CHANNEL],
+    )
 
-        acp_cmd = ["opencode", "acp"]
-        if args.acp_command:
-            try:
-                acp_cmd = _json.loads(args.acp_command)
-            except _json.JSONDecodeError:
-                acp_cmd = args.acp_command.split()
-        if (
-            not isinstance(acp_cmd, list)
-            or not acp_cmd
-            or not all(isinstance(s, str) for s in acp_cmd)
-        ):
-            print("Error: --acp-command must be a non-empty list of strings", file=sys.stderr)
-            sys.exit(1)
-        return ACPAgentConfig(
-            nick=full_nick,
-            agent="acp",
-            acp_command=acp_cmd,
-            directory=os.getcwd(),
-            channels=[DEFAULT_CHANNEL],
-        )
+
+def _create_copilot_config(full_nick: str) -> AgentConfig:
+    """Build a CopilotAgentConfig."""
+    from culture.clients.copilot.config import AgentConfig as CopilotAgentConfig
+
+    return CopilotAgentConfig(
+        nick=full_nick,
+        agent="copilot",
+        directory=os.getcwd(),
+        channels=[DEFAULT_CHANNEL],
+    )
+
+
+def _parse_acp_command(raw_command: str | None) -> list[str]:
+    """Parse and validate the ACP command from CLI args."""
+    import json as _json
+
+    acp_cmd = ["opencode", "acp"]
+    if raw_command:
+        try:
+            acp_cmd = _json.loads(raw_command)
+        except _json.JSONDecodeError:
+            acp_cmd = raw_command.split()
+    if not isinstance(acp_cmd, list) or not acp_cmd or not all(isinstance(s, str) for s in acp_cmd):
+        print("Error: --acp-command must be a non-empty list of strings", file=sys.stderr)
+        sys.exit(1)
+    return acp_cmd
+
+
+def _create_acp_config(full_nick: str, args: argparse.Namespace) -> AgentConfig:
+    """Build an ACPAgentConfig."""
+    from culture.clients.acp.config import AgentConfig as ACPAgentConfig
+
+    acp_cmd = _parse_acp_command(args.acp_command)
+    return ACPAgentConfig(
+        nick=full_nick,
+        agent="acp",
+        acp_command=acp_cmd,
+        directory=os.getcwd(),
+        channels=[DEFAULT_CHANNEL],
+    )
+
+
+def _create_default_config(full_nick: str, backend: str) -> AgentConfig:
+    """Build a default (claude) AgentConfig."""
     return AgentConfig(
         nick=full_nick,
-        agent=args.agent,
+        agent=backend,
         directory=os.getcwd(),
         channels=[DEFAULT_CHANNEL],
     )
 
 
+def _create_agent_config(args: argparse.Namespace, full_nick: str) -> AgentConfig:
+    """Build a backend-specific AgentConfig from CLI args."""
+    factories = {
+        "codex": lambda: _create_codex_config(full_nick),
+        "copilot": lambda: _create_copilot_config(full_nick),
+        "acp": lambda: _create_acp_config(full_nick, args),
+    }
+    factory = factories.get(args.agent)
+    if factory:
+        return factory()
+    return _create_default_config(full_nick, args.agent)
+
+
 def _cmd_create(args: argparse.Namespace) -> None:
     config = load_config_or_default(args.config)
 
@@ -387,6 +411,32 @@ def _probe_server_connection(host: str, port: int, server_name: str) -> None:
         sys.exit(1)
 
 
+def _start_foreground(config: DaemonConfig, agents: list[AgentConfig]) -> None:
+    """Start a single agent in the foreground."""
+    if len(agents) != 1:
+        print("--foreground requires a single agent nick, not --all", file=sys.stderr)
+        sys.exit(1)
+    agent = agents[0]
+    print(f"Starting agent {agent.nick} in foreground...")
+    asyncio.run(_run_single_agent(config, agent))
+
+
+def _start_background(config: DaemonConfig, agents: list[AgentConfig]) -> None:
+    """Start agents in background mode (fork on Unix, single on Windows)."""
+    if sys.platform == "win32":
+        if len(agents) != 1:
+            print(
+                "Multi-agent daemon mode not supported on Windows. Start agents individually.",
+                file=sys.stderr,
+            )
+            sys.exit(1)
+        agent = agents[0]
+        print(f"Starting agent {agent.nick}...")
+        asyncio.run(_run_single_agent(config, agent))
+    else:
+        _run_multi_agents(config, agents)
+
+
 def _cmd_start(args: argparse.Namespace) -> None:
     config = load_config(args.config)
 
@@ -395,86 +445,88 @@ def _cmd_start(args: argparse.Namespace) -> None:
     server_name = config.server.name
     _probe_server_connection(config.server.host, config.server.port, server_name)
 
-    foreground = getattr(args, "foreground", False)
-
-    if foreground:
-        if len(agents) != 1:
-            print("--foreground requires a single agent nick, not --all", file=sys.stderr)
-            sys.exit(1)
-        agent = agents[0]
-        print(f"Starting agent {agent.nick} in foreground...")
-        asyncio.run(_run_single_agent(config, agent))
+    if getattr(args, "foreground", False):
+        _start_foreground(config, agents)
     else:
-        if sys.platform == "win32":
-            if len(agents) == 1:
-                agent = agents[0]
-                print(f"Starting agent {agent.nick}...")
-                asyncio.run(_run_single_agent(config, agent))
-            else:
-                print(
-                    "Multi-agent daemon mode not supported on Windows. Start agents individually.",
-                    file=sys.stderr,
-                )
-                sys.exit(1)
-        else:
-            _run_multi_agents(config, agents)
+        _start_background(config, agents)
+
+
+def _make_backend_config(config: DaemonConfig, backend_daemon_config_cls):
+    """Build a backend-specific DaemonConfig from the base config."""
+    return backend_daemon_config_cls(
+        server=config.server,
+        webhooks=config.webhooks,
+        buffer_size=config.buffer_size,
+        agents=config.agents,
+    )
+
+
+def _create_codex_daemon(config: DaemonConfig, agent: AgentConfig):
+    """Create a Codex backend daemon."""
+    from culture.clients.codex.config import DaemonConfig as CodexDaemonConfig
+    from culture.clients.codex.daemon import CodexDaemon
+
+    return CodexDaemon(_make_backend_config(config, CodexDaemonConfig), agent)
+
+
+def _coerce_to_acp_agent(agent: AgentConfig):
+    """Ensure agent is an ACPAgentConfig, converting if necessary."""
+    from culture.clients.acp.config import AgentConfig as ACPAgentConfig
+
+    if isinstance(agent, ACPAgentConfig):
+        return agent
+    return ACPAgentConfig(
+        nick=agent.nick,
+        agent="acp",
+        acp_command=getattr(agent, "acp_command", None) or ["opencode", "acp"],
+        directory=agent.directory,
+        channels=agent.channels,
+        model=agent.model,
+        system_prompt=agent.system_prompt,
+        tags=agent.tags,
+    )
+
+
+def _create_acp_daemon(config: DaemonConfig, agent: AgentConfig):
+    """Create an ACP backend daemon."""
+    from culture.clients.acp.config import DaemonConfig as ACPDaemonConfig
+    from culture.clients.acp.daemon import ACPDaemon
+
+    return ACPDaemon(
+        _make_backend_config(config, ACPDaemonConfig),
+        _coerce_to_acp_agent(agent),
+    )
+
+
+def _create_copilot_daemon(config: DaemonConfig, agent: AgentConfig):
+    """Create a Copilot backend daemon."""
+    from culture.clients.copilot.config import DaemonConfig as CopilotDaemonConfig
+    from culture.clients.copilot.daemon import CopilotDaemon
+
+    return CopilotDaemon(_make_backend_config(config, CopilotDaemonConfig), agent)
+
+
+def _create_claude_daemon(config: DaemonConfig, agent: AgentConfig):
+    """Create the default Claude backend daemon."""
+    from culture.clients.claude.daemon import AgentDaemon
+
+    return AgentDaemon(config, agent)
+
+
+_BACKEND_DAEMON_FACTORIES = {
+    "codex": _create_codex_daemon,
+    "acp": _create_acp_daemon,
+    "opencode": _create_acp_daemon,
+    "copilot": _create_copilot_daemon,
+}
 
 
 async def _run_single_agent(config: DaemonConfig, agent: AgentConfig) -> None:
     """Run a single agent daemon in the foreground."""
     backend = getattr(agent, "agent", "claude")
 
-    if backend == "codex":
-        from culture.clients.codex.config import DaemonConfig as CodexDaemonConfig
-        from culture.clients.codex.daemon import CodexDaemon
-
-        codex_config = CodexDaemonConfig(
-            server=config.server,
-            webhooks=config.webhooks,
-            buffer_size=config.buffer_size,
-            agents=config.agents,
-        )
-        daemon = CodexDaemon(codex_config, agent)
-    elif backend in ("acp", "opencode"):
-        from culture.clients.acp.config import AgentConfig as ACPAgentConfig
-        from culture.clients.acp.config import DaemonConfig as ACPDaemonConfig
-        from culture.clients.acp.daemon import ACPDaemon
-
-        acp_config = ACPDaemonConfig(
-            server=config.server,
-            webhooks=config.webhooks,
-            buffer_size=config.buffer_size,
-            agents=config.agents,
-        )
-        if not isinstance(agent, ACPAgentConfig):
-            acp_agent = ACPAgentConfig(
-                nick=agent.nick,
-                agent="acp",
-                acp_command=getattr(agent, "acp_command", None) or ["opencode", "acp"],
-                directory=agent.directory,
-                channels=agent.channels,
-                model=agent.model,
-                system_prompt=agent.system_prompt,
-                tags=agent.tags,
-            )
-        else:
-            acp_agent = agent
-        daemon = ACPDaemon(acp_config, acp_agent)
-    elif backend == "copilot":
-        from culture.clients.copilot.config import DaemonConfig as CopilotDaemonConfig
-        from culture.clients.copilot.daemon import CopilotDaemon
-
-        copilot_config = CopilotDaemonConfig(
-            server=config.server,
-            webhooks=config.webhooks,
-            buffer_size=config.buffer_size,
-            agents=config.agents,
-        )
-        daemon = CopilotDaemon(copilot_config, agent)
-    else:
-        from culture.clients.claude.daemon import AgentDaemon
-
-        daemon = AgentDaemon(config, agent)
+    factory = _BACKEND_DAEMON_FACTORIES.get(backend, _create_claude_daemon)
+    daemon = factory(config, agent)
 
     stop_event = asyncio.Event()
     daemon.set_stop_event(stop_event)
@@ -524,30 +576,38 @@ def _run_multi_agents(config: DaemonConfig, agents: list[AgentConfig]) -> None:
             print(f"Started {agent.nick} (PID {pid})")
 
 
-def _cmd_stop(args: argparse.Namespace) -> None:
-    config = load_config_or_default(args.config)
-
+def _resolve_agents_to_stop(config, args) -> list:
+    """Resolve which agents should be stopped, or exit with an error."""
     if args.all:
-        agents = config.agents
-    elif args.nick:
+        return config.agents
+    if args.nick:
         agent = config.get_agent(args.nick)
         if not agent:
             print(f"Agent '{args.nick}' not found in config", file=sys.stderr)
             sys.exit(1)
-        agents = [agent]
-    else:
-        if len(config.agents) == 1:
-            agents = config.agents
-        elif len(config.agents) == 0:
-            print(NO_AGENTS_MSG, file=sys.stderr)
-            sys.exit(1)
-        else:
-            print(
-                "Multiple agents configured. Specify a nick or use --all.",
-                file=sys.stderr,
-            )
-            sys.exit(1)
+        return [agent]
+    if len(config.agents) == 1:
+        return config.agents
+    if len(config.agents) == 0:
+        print(NO_AGENTS_MSG, file=sys.stderr)
+        sys.exit(1)
+    # Multiple agents: try to match by current working directory
+    cwd_real = os.path.realpath(os.getcwd())
+    cwd_matches = [a for a in config.agents if os.path.realpath(a.directory) == cwd_real]
+    if len(cwd_matches) == 1:
+        return cwd_matches
+    print(
+        "Multiple agents configured. Specify a nick or use --all.",
+        file=sys.stderr,
+    )
+    for a in config.agents:
+        print(f"  {a.nick}", file=sys.stderr)
+    sys.exit(1)
 
+
+def _cmd_stop(args: argparse.Namespace) -> None:
+    config = load_config_or_default(args.config)
+    agents = _resolve_agents_to_stop(config, args)
     for agent in agents:
         stop_agent(agent.nick)
 
@@ -710,13 +770,13 @@ def _cmd_assign(args: argparse.Namespace) -> None:
 # -----------------------------------------------------------------------
 
 
-def _resolve_ipc_targets(config, args, action_verb: str) -> list:
+def _resolve_ipc_targets(config, args, command_name: str) -> list:
     """Resolve which agents to send IPC messages to."""
     if args.nick and args.all:
         print("Cannot specify both nick and --all", file=sys.stderr)
         sys.exit(1)
     if not args.nick and not args.all:
-        print(f"Usage: culture agent {action_verb} <nick> or --all", file=sys.stderr)
+        print(f"Usage: culture agent {command_name} <nick> or --all", file=sys.stderr)
         sys.exit(1)
     if args.all:
         return config.agents
@@ -737,20 +797,22 @@ def _send_ipc(agent, msg_type: str, action_verb: str) -> None:
         print(f"{agent.nick}: failed (not running?)", file=sys.stderr)
 
 
-def _ipc_to_agents(args: argparse.Namespace, msg_type: str, action_verb: str) -> None:
+def _ipc_to_agents(
+    args: argparse.Namespace, msg_type: str, action_verb: str, command_name: str
+) -> None:
     """Send an IPC message (pause/resume) to one or all agents."""
     config = load_config_or_default(args.config)
-    targets = _resolve_ipc_targets(config, args, action_verb)
+    targets = _resolve_ipc_targets(config, args, command_name)
     for agent in targets:
         _send_ipc(agent, msg_type, action_verb)
 
 
 def _cmd_sleep(args: argparse.Namespace) -> None:
-    _ipc_to_agents(args, "pause", "paused")
+    _ipc_to_agents(args, "pause", "paused", "sleep")
 
 
 def _cmd_wake(args: argparse.Namespace) -> None:
-    _ipc_to_agents(args, "resume", "resumed")
+    _ipc_to_agents(args, "resume", "resumed", "wake")
 
 
 def _cmd_learn(args: argparse.Namespace) -> None:
@@ -785,6 +847,16 @@ def _cmd_learn(args: argparse.Namespace) -> None:
 
 
 def _cmd_message(args: argparse.Namespace) -> None:
+    if not args.target.strip():
+        print("Error: target nick cannot be empty", file=sys.stderr)
+        sys.exit(1)
+    if not args.text.strip():
+        print("Error: message text cannot be empty", file=sys.stderr)
+        sys.exit(1)
+    config = load_config_or_default(args.config)
+    if not config.get_agent(args.target):
+        print(f"Agent '{args.target}' not found in config", file=sys.stderr)
+        sys.exit(1)
     observer = get_observer(args.config)
     asyncio.run(observer.send_message(args.target, args.text))
     print(f"Sent to {args.target}")

{agentirc_cli-4.3.4 → agentirc_cli-4.3.6}/culture/cli/bot.py

@@ -49,9 +49,11 @@ def register(subparsers: argparse._SubParsersAction) -> None:
     bot_archive = bot_sub.add_parser("archive", help="Archive a bot")
     bot_archive.add_argument("name", help="Bot name to archive")
     bot_archive.add_argument("--reason", default="", help="Reason for archiving")
+    bot_archive.add_argument("--config", default=DEFAULT_CONFIG, help=_CONFIG_HELP)
 
     bot_unarchive = bot_sub.add_parser("unarchive", help="Restore an archived bot")
     bot_unarchive.add_argument("name", help="Bot name to unarchive")
+    bot_unarchive.add_argument("--config", default=DEFAULT_CONFIG, help=_CONFIG_HELP)
 
 
 def dispatch(args: argparse.Namespace) -> None:
@@ -87,6 +89,9 @@ def dispatch(args: argparse.Namespace) -> None:
 def _bot_create(args: argparse.Namespace) -> None:
     from culture.bots.config import BOTS_DIR, BotConfig, save_bot_config
 
+    if not args.name.strip():
+        print("Error: bot name cannot be empty", file=sys.stderr)
+        sys.exit(1)
     name = args.name
     config = load_config_or_default(args.config)
     server_name = config.server.name
@@ -152,6 +157,15 @@ def _bot_stop(args: argparse.Namespace) -> None:
     print("(Live reload via IPC will be available in a future release.)")
 
 
+def _should_include_bot(bot_config, owner: str | None, show_archived: bool) -> bool:
+    """Return True if the bot should be included in the listing."""
+    if owner and bot_config.owner != owner:
+        return False
+    if not show_archived and bot_config.archived:
+        return False
+    return True
+
+
 def _load_and_filter_bots(args) -> list:
     """Load bot configs, filtering by owner and archived status."""
     from culture.bots.config import BOTS_DIR, load_bot_config
@@ -168,11 +182,8 @@ def _load_and_filter_bots(args) -> list:
             config = load_bot_config(yaml_path)
         except Exception:
             continue
-        if args.owner and config.owner != args.owner:
-            continue
-        if not show_all and config.archived:
-            continue
-        bots.append(config)
+        if _should_include_bot(config, args.owner, show_all):
+            bots.append(config)
     return bots
 
 

{agentirc_cli-4.3.4 → agentirc_cli-4.3.6}/culture/cli/channel.py

@@ -50,11 +50,26 @@ def dispatch(args: argparse.Namespace) -> None:
         "who": _cmd_who,
     }
     handler = handlers.get(args.channel_command)
-    if handler:
-        handler(args)
-    else:
+    if not handler:
         print(f"Unknown channel command: {args.channel_command}", file=sys.stderr)
         sys.exit(1)
+    try:
+        handler(args)
+    except (ConnectionError, ConnectionRefusedError, TimeoutError, OSError) as exc:
+        msg = str(exc)
+        if (
+            "Timed out" in msg
+            or "Connection refused" in msg
+            or "Connect call failed" in msg
+            or not msg  # TimeoutError from asyncio often has empty message
+        ):
+            print(
+                "Error: cannot connect to IRC server. Is the server running?\n"
+                "  Start it with: culture server start",
+                file=sys.stderr,
+            )
+            sys.exit(1)
+        raise
 
 
 # -----------------------------------------------------------------------
@@ -76,6 +91,9 @@ def _cmd_list(args: argparse.Namespace) -> None:
 
 
 def _cmd_read(args: argparse.Namespace) -> None:
+    if not args.target.strip():
+        print("Error: channel name cannot be empty", file=sys.stderr)
+        sys.exit(1)
     observer = get_observer(args.config)
     channel = args.target if args.target.startswith("#") else f"#{args.target}"
     messages = asyncio.run(observer.read_channel(channel, limit=args.limit))
@@ -89,6 +107,12 @@ def _cmd_read(args: argparse.Namespace) -> None:
 
 
 def _cmd_message(args: argparse.Namespace) -> None:
+    if not args.target.strip():
+        print("Error: channel name cannot be empty", file=sys.stderr)
+        sys.exit(1)
+    if not args.text.strip():
+        print("Error: message text cannot be empty", file=sys.stderr)
+        sys.exit(1)
     observer = get_observer(args.config)
     target = args.target if args.target.startswith("#") else f"#{args.target}"
     asyncio.run(observer.send_message(target, args.text))
@@ -96,6 +120,9 @@ def _cmd_message(args: argparse.Namespace) -> None:
 
 
 def _cmd_who(args: argparse.Namespace) -> None:
+    if not args.target.strip():
+        print("Error: channel name cannot be empty", file=sys.stderr)
+        sys.exit(1)
     observer = get_observer(args.config)
     target = args.target
     nicks = asyncio.run(observer.who(target))