agentirc-cli 4.3.7__tar.gz → 4.4.1__tar.gz

{agentirc_cli-4.3.7 → agentirc_cli-4.4.1}/CHANGELOG.md

@@ -4,6 +4,33 @@ All notable changes to this project will be documented in this file.
 
 Format follows [Keep a Changelog](https://keepachangelog.com/).
 
+## [4.4.1] - 2026-04-07
+
+
+### Fixed
+
+- Config save operations no longer strip backend-specific fields like acp_command (#150)
+- Agent status detail uses cached description by default, --full for live query; IPC deadline increased to 15s (#152)
+- DMs now activate agents — _detect_and_fire_mention handles direct messages in all backends (#153)
+- ACP agent runner preserves HOME/XDG_CONFIG_HOME for auth tokens; warns on authMethods, fails fast on session creation failure (#154)
+- _coerce_to_acp_agent now copies the icon field (#155)
+- _make_backend_config passes supervisor, poll_interval, sleep_start, sleep_end to non-claude backends (#156)
+- ACP load_config strips unknown fields, matching claude/codex/copilot pattern (#157)
+
+## [4.4.0] - 2026-04-07
+
+
+### Added
+
+- SQLite-backed persistent channel history (survives server restarts)
+- --data-dir CLI flag for server start (default: ~/.culture/data)
+
+
+### Fixed
+
+- Multi-line messages truncated to first line in send_privmsg and thread methods
+- data_dir never wired to ServerConfig, silently disabling room/thread persistence
+
 ## [4.3.7] - 2026-04-07
 
 

{agentirc_cli-4.3.7 → agentirc_cli-4.4.1}/PKG-INFO

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

{agentirc_cli-4.3.7 → agentirc_cli-4.4.1}/culture/cli/agent.py

@@ -455,8 +455,12 @@ 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,
+        supervisor=config.supervisor,
         webhooks=config.webhooks,
         buffer_size=config.buffer_size,
+        poll_interval=config.poll_interval,
+        sleep_start=config.sleep_start,
+        sleep_end=config.sleep_end,
         agents=config.agents,
     )
 
@@ -484,6 +488,7 @@ def _coerce_to_acp_agent(agent: AgentConfig):
         model=agent.model,
         system_prompt=agent.system_prompt,
         tags=agent.tags,
+        icon=agent.icon,
     )
 
 

{agentirc_cli-4.3.7 → agentirc_cli-4.4.1}/culture/cli/server.py

@@ -74,6 +74,11 @@ def register(subparsers: argparse._SubParsersAction) -> None:
         action="store_true",
         help="Run in foreground (for service managers)",
     )
+    srv_start.add_argument(
+        "--data-dir",
+        default=os.path.expanduser("~/.culture/data"),
+        help="Data directory for persistent storage (default: ~/.culture/data)",
+    )
 
     srv_stop = server_sub.add_parser("stop", help="Stop the IRC server daemon")
     srv_stop.add_argument("--name", default=None, help=_SERVER_NAME_HELP)
@@ -279,7 +284,9 @@ def _run_foreground(args: argparse.Namespace, pid_name: str, links: list) -> Non
     print(f"  Webhook port: {args.webhook_port}")
     _maybe_set_default_server(args.name)
     try:
-        asyncio.run(_run_server(args.name, args.host, args.port, links, args.webhook_port))
+        asyncio.run(
+            _run_server(args.name, args.host, args.port, links, args.webhook_port, args.data_dir)
+        )
     finally:
         remove_pid(pid_name)
 
@@ -369,7 +376,9 @@ def _daemonize_server(args: argparse.Namespace, pid_name: str, links: list) -> N
     write_pid(pid_name, os.getpid())
 
     try:
-        asyncio.run(_run_server(args.name, args.host, args.port, links, args.webhook_port))
+        asyncio.run(
+            _run_server(args.name, args.host, args.port, links, args.webhook_port, args.data_dir)
+        )
     finally:
         remove_pid(pid_name)
         os._exit(0)
@@ -391,14 +400,24 @@ def _server_start(args: argparse.Namespace) -> None:
 
 
 async def _run_server(
-    name: str, host: str, port: int, links: list | None = None, webhook_port: int = 7680
+    name: str,
+    host: str,
+    port: int,
+    links: list | None = None,
+    webhook_port: int = 7680,
+    data_dir: str = "",
 ) -> None:
     """Run the IRC server (called in the daemon child process)."""
     from culture.server.config import ServerConfig
     from culture.server.ircd import IRCd
 
     config = ServerConfig(
-        name=name, host=host, port=port, webhook_port=webhook_port, links=links or []
+        name=name,
+        host=host,
+        port=port,
+        webhook_port=webhook_port,
+        links=links or [],
+        data_dir=data_dir,
     )
     ircd = IRCd(config)
     await ircd.start()

{agentirc_cli-4.3.7 → agentirc_cli-4.4.1}/culture/cli/shared/display.py

@@ -37,7 +37,8 @@ def print_agent_detail(agent, config_path: str, args: argparse.Namespace) -> Non
     print(f"  PID:        {pid or '-'}")
 
     if status == "running":
-        resp = asyncio.run(ipc_request(agent_socket_path(agent.nick), "status", query=True))
+        query = getattr(args, "full", False)
+        resp = asyncio.run(ipc_request(agent_socket_path(agent.nick), "status", query=query))
         if resp and resp.get("ok"):
             data = resp.get("data", {})
             print(f"  Activity:   {data.get('description', 'nothing')}")

{agentirc_cli-4.3.7 → agentirc_cli-4.4.1}/culture/cli/shared/ipc.py

@@ -31,7 +31,7 @@ async def ipc_request(socket_path: str, msg_type: str, **kwargs) -> dict | None:
         writer.write(encode_message(req))
         await writer.drain()
         loop = asyncio.get_running_loop()
-        deadline = loop.time() + 3.0
+        deadline = loop.time() + 15.0
         while True:
             remaining = deadline - loop.time()
             if remaining <= 0:

{agentirc_cli-4.3.7 → agentirc_cli-4.4.1}/culture/clients/acp/agent_runner.py

@@ -70,11 +70,12 @@ class ACPAgentRunner:
         """Start the ACP agent as a subprocess and initialize a session."""
         self._stopping = False
 
-        # Isolate from host config (XDG, etc.)
+        # Isolate data/state dirs to prevent session interference, but
+        # preserve HOME and XDG_CONFIG_HOME so the agent finds auth tokens.
         self._isolated_home = tempfile.mkdtemp(prefix="culture-acp-")
         isolated_env = dict(os.environ)
-        isolated_env["HOME"] = self._isolated_home
-        isolated_env.pop("XDG_CONFIG_HOME", None)
+        isolated_env["XDG_DATA_HOME"] = os.path.join(self._isolated_home, ".local", "share")
+        isolated_env["XDG_STATE_HOME"] = os.path.join(self._isolated_home, ".local", "state")
 
         cmd_label = " ".join(self.acp_command)
         try:
@@ -108,6 +109,18 @@ class ACPAgentRunner:
             )
             logger.info("ACP initialized (%s): %s", cmd_label, resp)
 
+            # Log available auth methods as a hint
+            init_result = resp.get("result", {})
+            auth_methods = init_result.get("authMethods", [])
+            if auth_methods:
+                descriptions = [m.get("description", m.get("id", "unknown")) for m in auth_methods]
+                logger.warning(
+                    "ACP agent (%s) reports auth methods: %s. "
+                    "If prompts fail, configure auth tokens.",
+                    cmd_label,
+                    ", ".join(descriptions),
+                )
+
             # Create a session with model selection
             session_params = {
                 "cwd": self.directory,
@@ -120,6 +133,13 @@ class ACPAgentRunner:
             logger.info("ACP session/new raw response: %s", json.dumps(resp)[:500])
             result = resp.get("result", {})
             self._session_id = result.get("sessionId")
+            if not self._session_id:
+                # Session creation failed — likely auth or model issue
+                error = resp.get("error", {})
+                error_msg = error.get("message", "unknown error")
+                if auth_methods:
+                    error_msg += f". Auth may be required: {', '.join(descriptions)}"
+                raise RuntimeError(f"ACP agent ({cmd_label}) session creation failed: {error_msg}")
             self._running = True
             logger.info("ACP session started (%s): %s", cmd_label, self._session_id)
 

{agentirc_cli-4.3.7 → agentirc_cli-4.4.1}/culture/clients/acp/config.py

@@ -93,8 +93,10 @@ def load_config(path: str | Path) -> DaemonConfig:
     webhooks = WebhookConfig(**raw.get("webhooks", {}))
 
     agents = []
+    known_agent_fields = {f.name for f in AgentConfig.__dataclass_fields__.values()}
     for agent_raw in raw.get("agents", []):
-        agents.append(AgentConfig(**agent_raw))
+        filtered = {k: v for k, v in agent_raw.items() if k in known_agent_fields}
+        agents.append(AgentConfig(**filtered))
 
     return DaemonConfig(
         server=server,
@@ -157,6 +159,32 @@ def save_config(path: str | Path, config: DaemonConfig) -> None:
         raise
 
 
+def _load_raw_yaml(path: str | Path) -> dict:
+    """Load raw YAML from a config file, returning empty dict if missing."""
+    path = Path(path)
+    if not path.exists():
+        return {}
+    with open(path) as f:
+        return yaml.safe_load(f) or {}
+
+
+def _save_raw_yaml(path: str | Path, raw: dict) -> None:
+    """Write raw YAML dict atomically."""
+    path = Path(path)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    fd, tmp_path = tempfile.mkstemp(dir=str(path.parent), suffix=".yaml.tmp")
+    try:
+        with os.fdopen(fd, "w") as f:
+            yaml.dump(raw, f, default_flow_style=False, sort_keys=False)
+        os.replace(tmp_path, str(path))
+    except BaseException:
+        try:
+            os.unlink(tmp_path)
+        except OSError:
+            pass
+        raise
+
+
 def add_agent_to_config(
     path: str | Path,
     agent: AgentConfig,
@@ -166,20 +194,21 @@ def add_agent_to_config(
 
     If server_name is provided, updates config.server.name.
     Raises ValueError if an agent with the same nick already exists.
+    Operates on raw YAML to preserve backend-specific fields.
     """
-    config = load_config_or_default(path)
-
-    if server_name is not None:
-        config.server.name = server_name
+    raw = _load_raw_yaml(path)
+    agents = raw.setdefault("agents", [])
 
-    # Check for nick collision
-    for existing in config.agents:
-        if existing.nick == agent.nick:
+    for existing in agents:
+        if existing.get("nick") == agent.nick:
             raise ValueError(f"Agent with nick {agent.nick!r} already exists in config")
 
-    config.agents.append(agent)
-    save_config(path, config)
-    return config
+    if server_name is not None:
+        raw.setdefault("server", {})["name"] = server_name
+
+    agents.append(asdict(agent))
+    _save_raw_yaml(path, raw)
+    return load_config(path)
 
 
 def rename_server(
@@ -189,23 +218,26 @@ def rename_server(
     """Rename the server and update all agent nick prefixes.
 
     Returns (old_name, [(old_nick, new_nick), ...]).
+    Operates on raw YAML to preserve backend-specific fields.
     """
-    config = load_config_or_default(path)
-    old_name = config.server.name
+    raw = _load_raw_yaml(path)
+    server = raw.get("server", {})
+    old_name = server.get("name", ServerConnConfig().name)
 
     if old_name == new_name:
         return old_name, []
 
-    # Plan renames and check for collisions before mutating
+    agents = raw.get("agents", [])
     prefix = f"{old_name}-"
     plan: list[tuple[int, str, str]] = []
-    for i, agent in enumerate(config.agents):
-        if agent.nick.startswith(prefix):
-            new_nick = f"{new_name}-{agent.nick[len(prefix):]}"
-            plan.append((i, agent.nick, new_nick))
+    for i, agent_raw in enumerate(agents):
+        nick = agent_raw.get("nick", "")
+        if nick.startswith(prefix):
+            new_nick = f"{new_name}-{nick[len(prefix):]}"
+            plan.append((i, nick, new_nick))
 
     planned_nicks = {new_nick for _, _, new_nick in plan}
-    existing_nicks = {a.nick for a in config.agents} - {old for _, old, _ in plan}
+    existing_nicks = {a.get("nick", "") for a in agents} - {old for _, old, _ in plan}
     collisions = planned_nicks & existing_nicks
     if collisions:
         raise ValueError(
@@ -213,14 +245,15 @@ def rename_server(
             f"duplicate nick(s): {', '.join(sorted(collisions))}"
         )
 
-    config.server.name = new_name
+    server["name"] = new_name
+    raw["server"] = server
 
     renamed: list[tuple[str, str]] = []
     for i, old_nick, new_nick in plan:
-        config.agents[i].nick = new_nick
+        agents[i]["nick"] = new_nick
         renamed.append((old_nick, new_nick))
 
-    save_config(path, config)
+    _save_raw_yaml(path, raw)
     return old_name, renamed
 
 
@@ -232,19 +265,19 @@ def rename_agent(
     """Rename an agent's nick in the config.
 
     Raises ValueError if old_nick is not found or new_nick already exists.
+    Operates on raw YAML to preserve backend-specific fields.
     """
-    config = load_config_or_default(path)
+    raw = _load_raw_yaml(path)
+    agents = raw.get("agents", [])
 
-    # Check new nick doesn't collide
-    for agent in config.agents:
-        if agent.nick == new_nick:
+    for agent_raw in agents:
+        if agent_raw.get("nick") == new_nick:
             raise ValueError(f"Agent with nick {new_nick!r} already exists in config")
 
-    # Find and rename
-    for agent in config.agents:
-        if agent.nick == old_nick:
-            agent.nick = new_nick
-            save_config(path, config)
+    for agent_raw in agents:
+        if agent_raw.get("nick") == old_nick:
+            agent_raw["nick"] = new_nick
+            _save_raw_yaml(path, raw)
             return
 
     raise ValueError(f"Agent {old_nick!r} not found in config")
@@ -260,18 +293,14 @@ def remove_agent(
     agents that the typed schema would strip.
     Raises ValueError if the agent is not found.
     """
-    path = Path(path)
-    if not path.exists():
+    raw = _load_raw_yaml(path)
+    if not raw:
         raise ValueError(f"Agent {nick!r} not found in config")
 
-    with open(path) as f:
-        raw = yaml.safe_load(f) or {}
-
     agents = raw.get("agents", [])
     for i, agent_raw in enumerate(agents):
         if agent_raw.get("nick") == nick:
             agents.pop(i)
-            with open(path, "w") as f:
-                yaml.dump(raw, f, default_flow_style=False, sort_keys=False)
+            _save_raw_yaml(path, raw)
             return
     raise ValueError(f"Agent {nick!r} not found in config")

{agentirc_cli-4.3.7 → agentirc_cli-4.4.1}/culture/clients/acp/irc_transport.py

@@ -87,16 +87,26 @@ class IRCTransport:
         self.connected = False
 
     async def send_privmsg(self, target: str, text: str) -> None:
-        await self._send_raw(f"PRIVMSG {target} :{text}")
+        for line in text.splitlines():
+            if line:
+                await self._send_raw(f"PRIVMSG {target} :{line}")
 
     async def send_thread_create(self, channel: str, thread_name: str, text: str) -> None:
-        await self._send_raw(f"THREAD CREATE {channel} {thread_name} :{text}")
+        lines = [l for l in text.splitlines() if l]
+        if not lines:
+            return
+        await self._send_raw(f"THREAD CREATE {channel} {thread_name} :{lines[0]}")
+        for line in lines[1:]:
+            await self._send_raw(f"THREAD REPLY {channel} {thread_name} :{line}")
 
     async def send_thread_reply(self, channel: str, thread_name: str, text: str) -> None:
-        await self._send_raw(f"THREAD REPLY {channel} {thread_name} :{text}")
+        for line in text.splitlines():
+            if line:
+                await self._send_raw(f"THREAD REPLY {channel} {thread_name} :{line}")
 
     async def send_thread_close(self, channel: str, thread_name: str, summary: str) -> None:
-        await self._send_raw(f"THREADCLOSE {channel} {thread_name} :{summary}")
+        clean = " ".join(summary.splitlines()).strip()
+        await self._send_raw(f"THREADCLOSE {channel} {thread_name} :{clean}")
 
     async def send_threads_list(self, channel: str) -> None:
         await self._send_raw(f"THREADS {channel}")
@@ -203,6 +213,10 @@ class IRCTransport:
         """Check if the message mentions this agent and fire the callback."""
         if not self.on_mention:
             return
+        # DMs always activate (target is the agent's own nick)
+        if target == self.nick:
+            self.on_mention(target, sender, text)
+            return
         short = self.nick.split("-", 1)[1] if "-" in self.nick else None
         if re.search(rf"@{re.escape(self.nick)}\b", text) or (
             short and re.search(rf"@{re.escape(short)}\b", text)