agentirc-cli 4.1.2__tar.gz → 4.1.3__tar.gz

{agentirc_cli-4.1.2 → agentirc_cli-4.1.3}/CHANGELOG.md

@@ -4,6 +4,13 @@ All notable changes to this project will be documented in this file.
 
 Format follows [Keep a Changelog](https://keepachangelog.com/).
 
+## [4.1.3] - 2026-04-06
+
+
+### Fixed
+
+- mesh update now discovers and restarts all running servers instead of only the one in mesh.yaml
+
 ## [4.1.2] - 2026-04-06
 
 

{agentirc_cli-4.1.2 → agentirc_cli-4.1.3}/PKG-INFO

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

{agentirc_cli-4.1.2 → agentirc_cli-4.1.3}/culture/cli/mesh.py

@@ -549,23 +549,76 @@ def _restart_mesh_services(
                 check=False,
             )
 
-    print("\nUpdate complete. All services restarted.")
-
-
-def _cmd_update(args: argparse.Namespace) -> None:
-    from culture.mesh_config import load_mesh_config
+    print()
+
+
+def _resolve_mesh_for_server(server_name: str, config_path: str):
+    """Find or build a MeshConfig for *server_name*.
+
+    Resolution order:
+    1. mesh.yaml — use directly if its server.name matches.
+    2. agents.yaml — build via from_daemon_config(), preserving host, port,
+       and links from the old mesh.yaml. Saves the updated mesh.yaml so
+       future runs are consistent.
+    """
+    from culture.mesh_config import (
+        from_daemon_config,
+        load_mesh_config,
+        merge_links,
+        save_mesh_config,
+    )
 
+    old_server = None
     try:
-        mesh = load_mesh_config(args.config)
+        old_mesh = load_mesh_config(config_path)
+        if old_mesh.server.name == server_name:
+            return old_mesh
+        old_server = old_mesh.server
     except FileNotFoundError:
-        mesh = generate_mesh_from_agents(args.config)
-        if mesh is None:
-            sys.exit(1)
+        pass
+
+    if os.path.isfile(DEFAULT_CONFIG):
+        daemon_config = load_config(DEFAULT_CONFIG)
+        if daemon_config.server.name == server_name:
+            mesh = from_daemon_config(daemon_config)
+            if old_server is not None:
+                mesh.server.host = old_server.host
+                mesh.server.port = old_server.port
+                merge_links(mesh, old_server.links)
+            save_mesh_config(mesh, config_path)
+            return mesh
+
+    return None
 
-    server_name = mesh.server.name
+
+def _cmd_update(args: argparse.Namespace) -> None:
+    from culture.mesh_config import load_mesh_config
+    from culture.pidfile import list_servers
 
     if not _upgrade_culture_package(args):
         return
 
     culture_bin = shutil.which("culture") or "culture"
-    _restart_mesh_services(mesh, server_name, culture_bin, args.config, args.dry_run)
+
+    running = list_servers()
+
+    if running:
+        for srv in running:
+            mesh = _resolve_mesh_for_server(srv["name"], args.config)
+            if mesh is None:
+                print(
+                    f"  Warning: no config found for server '{srv['name']}', skipping",
+                    file=sys.stderr,
+                )
+                continue
+            _restart_mesh_services(mesh, srv["name"], culture_bin, args.config, args.dry_run)
+    else:
+        try:
+            mesh = load_mesh_config(args.config)
+        except FileNotFoundError:
+            mesh = generate_mesh_from_agents(args.config)
+            if mesh is None:
+                sys.exit(1)
+        _restart_mesh_services(mesh, mesh.server.name, culture_bin, args.config, args.dry_run)
+
+    print("Update complete. All services restarted.")

{agentirc_cli-4.1.2 → agentirc_cli-4.1.3}/culture/mesh_config.py

@@ -108,6 +108,15 @@ def from_daemon_config(daemon_config: DaemonConfig) -> MeshConfig:
     return MeshConfig(server=server, agents=agents)
 
 
+def merge_links(target: MeshConfig, source_links: list[MeshLinkConfig]) -> None:
+    """Copy link configs from *source_links* into *target* if not already present."""
+    existing = {link.name for link in target.server.links}
+    for link in source_links:
+        if link.name not in existing:
+            target.server.links.append(link)
+            existing.add(link.name)
+
+
 def save_mesh_config(config: MeshConfig, path: str | Path = DEFAULT_MESH_PATH) -> None:
     """Serialize mesh config to YAML and write atomically."""
     path = Path(path)

{agentirc_cli-4.1.2 → agentirc_cli-4.1.3}/docs/operations/cli.md

@@ -288,8 +288,11 @@ walkthrough.
 
 ### `culture update`
 
-Upgrade the `culture` package and restart all mesh services defined in
-`mesh.yaml`.
+Upgrade the `culture` package and restart all running servers. The command
+discovers running servers from PID files rather than relying solely on
+`mesh.yaml`, so it restarts every server on the machine even if `mesh.yaml`
+is stale or names a different server. When no servers are running, it falls
+back to `mesh.yaml`.
 
 ```bash
 culture update                          # upgrade package + restart everything

{agentirc_cli-4.1.2 → agentirc_cli-4.1.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "agentirc-cli"
-version = "4.1.2"
+version = "4.1.3"
 description = "Legacy alias for culture — install culture instead"
 readme = "README.md"
 license = "MIT"

{agentirc_cli-4.1.2 → agentirc_cli-4.1.3}/tests/test_mesh_config.py

@@ -11,6 +11,7 @@ from culture.mesh_config import (
     MeshServerConfig,
     from_daemon_config,
     load_mesh_config,
+    merge_links,
     save_mesh_config,
 )
 
@@ -153,3 +154,39 @@ def test_from_daemon_config_empty_agents():
     assert mesh.server.name == "test"
     assert mesh.server.port == 7000
     assert mesh.agents == []
+
+
+def test_merge_links_appends_missing():
+    """merge_links adds links not already present."""
+    target = MeshConfig(
+        server=MeshServerConfig(
+            name="spark",
+            links=[MeshLinkConfig(name="thor", host="1.2.3.4", port=6667)],
+        ),
+    )
+    source = [
+        MeshLinkConfig(name="orin", host="5.6.7.8", port=6668),
+    ]
+    merge_links(target, source)
+    assert len(target.server.links) == 2
+    assert target.server.links[1].name == "orin"
+
+
+def test_merge_links_skips_duplicates():
+    """merge_links does not duplicate links already present."""
+    target = MeshConfig(
+        server=MeshServerConfig(
+            name="spark",
+            links=[MeshLinkConfig(name="thor", host="1.2.3.4", port=6667)],
+        ),
+    )
+    source = [
+        MeshLinkConfig(name="thor", host="9.9.9.9", port=9999),
+        MeshLinkConfig(name="orin", host="5.6.7.8", port=6668),
+    ]
+    merge_links(target, source)
+    assert len(target.server.links) == 2
+    names = [l.name for l in target.server.links]
+    assert names == ["thor", "orin"]
+    # Original thor link is unchanged
+    assert target.server.links[0].host == "1.2.3.4"

agentirc_cli-4.1.3/tests/test_setup_update_cli.py

@@ -0,0 +1,185 @@
+# tests/test_setup_update_cli.py
+"""Lightweight parser tests for setup and update subcommands."""
+
+from unittest.mock import patch
+
+import pytest
+
+from culture.cli import _build_parser
+from culture.mesh_config import MeshAgentConfig, MeshConfig, MeshLinkConfig, MeshServerConfig
+
+
+def test_setup_parser():
+    """setup subcommand parses --config and --uninstall."""
+    p = _build_parser()
+    args = p.parse_args(["mesh", "setup", "--uninstall"])
+    assert args.command == "mesh"
+    assert args.mesh_command == "setup"
+    assert args.uninstall is True
+
+    args = p.parse_args(["mesh", "setup", "--config", "/tmp/mesh.yaml"])
+    assert args.config == "/tmp/mesh.yaml"
+
+
+def test_update_parser():
+    """update subcommand parses --dry-run, --skip-upgrade, --config."""
+    p = _build_parser()
+    args = p.parse_args(["mesh", "update", "--dry-run", "--skip-upgrade"])
+    assert args.command == "mesh"
+    assert args.mesh_command == "update"
+    assert args.dry_run is True
+    assert args.skip_upgrade is True
+
+    args = p.parse_args(["mesh", "update", "--config", "/tmp/mesh.yaml"])
+    assert args.config == "/tmp/mesh.yaml"
+
+
+def test_setup_in_dispatch():
+    """setup command is wired into the mesh module."""
+    from culture.cli import mesh
+
+    assert hasattr(mesh, "_cmd_setup")
+    assert callable(mesh._cmd_setup)
+
+
+def test_update_in_dispatch():
+    """update command is wired into the mesh module."""
+    from culture.cli import mesh
+
+    assert hasattr(mesh, "_cmd_update")
+    assert callable(mesh._cmd_update)
+
+
+# ---- _cmd_update behaviour tests ----
+
+_MESH_MOD = "culture.cli.mesh"
+
+
+@pytest.fixture
+def update_args(tmp_path):
+    """Minimal argparse namespace for _cmd_update."""
+    p = _build_parser()
+    config = str(tmp_path / "mesh.yaml")
+    return p.parse_args(["mesh", "update", "--skip-upgrade", "--dry-run", "--config", config])
+
+
+@patch("culture.pidfile.list_servers")
+@patch(f"{_MESH_MOD}._resolve_mesh_for_server")
+@patch(f"{_MESH_MOD}._restart_mesh_services")
+@patch(f"{_MESH_MOD}._upgrade_culture_package", return_value=True)
+def test_update_discovers_running_servers(
+    _mock_upgrade, mock_restart, mock_resolve, mock_list, update_args
+):
+    """_cmd_update restarts every running server, not just mesh.yaml."""
+    from culture.cli.mesh import _cmd_update
+
+    spark_mesh = MeshConfig(server=MeshServerConfig(name="spark"))
+    mock_list.return_value = [{"name": "spark", "pid": 1, "port": 6667}]
+    mock_resolve.return_value = spark_mesh
+
+    _cmd_update(update_args)
+
+    mock_resolve.assert_called_once_with("spark", update_args.config)
+    mock_restart.assert_called_once()
+    assert mock_restart.call_args[0][1] == "spark"
+
+
+@patch("culture.pidfile.list_servers", return_value=[])
+@patch("culture.mesh_config.load_mesh_config")
+@patch(f"{_MESH_MOD}._restart_mesh_services")
+@patch(f"{_MESH_MOD}._upgrade_culture_package", return_value=True)
+def test_update_falls_back_to_mesh_yaml_when_no_servers(
+    _mock_upgrade, mock_restart, mock_load, _mock_list, update_args
+):
+    """When no servers are running, fall back to mesh.yaml."""
+    from culture.cli.mesh import _cmd_update
+
+    mesh = MeshConfig(server=MeshServerConfig(name="culture"))
+    mock_load.return_value = mesh
+
+    _cmd_update(update_args)
+
+    mock_load.assert_called_once_with(update_args.config)
+    mock_restart.assert_called_once()
+    assert mock_restart.call_args[0][1] == "culture"
+
+
+@patch("culture.pidfile.list_servers")
+@patch(f"{_MESH_MOD}._restart_mesh_services")
+@patch(f"{_MESH_MOD}._upgrade_culture_package", return_value=True)
+def test_update_skips_server_without_config(
+    _mock_upgrade, mock_restart, mock_list, update_args, capsys
+):
+    """Servers with no matching config are skipped with a warning."""
+    from culture.cli.mesh import _cmd_update
+
+    mock_list.return_value = [{"name": "unknown", "pid": 1, "port": 6667}]
+
+    with patch(f"{_MESH_MOD}._resolve_mesh_for_server", return_value=None):
+        _cmd_update(update_args)
+
+    mock_restart.assert_not_called()
+    assert "no config found" in capsys.readouterr().err
+
+
+# ---- _resolve_mesh_for_server tests ----
+
+
+def test_resolve_uses_mesh_yaml_when_name_matches(tmp_path):
+    """_resolve_mesh_for_server returns mesh.yaml config when server name matches."""
+    from culture.cli.mesh import _resolve_mesh_for_server
+
+    mesh = MeshConfig(
+        server=MeshServerConfig(name="spark", links=[MeshLinkConfig(name="thor", host="1.2.3.4")]),
+        agents=[MeshAgentConfig(nick="claude", workdir="/tmp")],
+    )
+    config_path = str(tmp_path / "mesh.yaml")
+    from culture.mesh_config import save_mesh_config
+
+    save_mesh_config(mesh, config_path)
+
+    result = _resolve_mesh_for_server("spark", config_path)
+    assert result is not None
+    assert result.server.name == "spark"
+    assert len(result.server.links) == 1
+
+
+def test_resolve_rebuilds_from_agents_yaml_preserving_links(tmp_path):
+    """When mesh.yaml has wrong name, rebuild from agents.yaml and keep links."""
+    from culture.cli.mesh import _resolve_mesh_for_server
+    from culture.clients.claude.config import AgentConfig, DaemonConfig, ServerConnConfig
+    from culture.mesh_config import save_mesh_config
+
+    # mesh.yaml says "culture" but running server is "spark"
+    old_mesh = MeshConfig(
+        server=MeshServerConfig(
+            name="culture",
+            host="127.0.0.1",
+            port=7000,
+            links=[MeshLinkConfig(name="thor", host="1.2.3.4")],
+        ),
+    )
+    config_path = str(tmp_path / "mesh.yaml")
+    save_mesh_config(old_mesh, config_path)
+
+    # agents.yaml says "spark"
+    daemon = DaemonConfig(
+        server=ServerConnConfig(name="spark", host="localhost", port=6667),
+        agents=[AgentConfig(nick="spark-claude", agent="claude", directory="/tmp")],
+    )
+
+    with patch(f"{_MESH_MOD}.DEFAULT_CONFIG", str(tmp_path / "agents.yaml")):
+        from culture.clients.claude.config import save_config
+
+        save_config(str(tmp_path / "agents.yaml"), daemon)
+        result = _resolve_mesh_for_server("spark", config_path)
+
+    assert result is not None
+    assert result.server.name == "spark"
+    assert len(result.agents) == 1
+    assert result.agents[0].nick == "claude"
+    # Server settings from old mesh.yaml are preserved
+    assert result.server.host == "127.0.0.1"
+    assert result.server.port == 7000
+    assert len(result.server.links) == 1
+    assert result.server.links[0].name == "thor"

{agentirc_cli-4.1.2 → agentirc_cli-4.1.3}/uv.lock

@@ -561,7 +561,7 @@ wheels = [
 
 [[package]]
 name = "culture"
-version = "4.1.2"
+version = "4.1.3"
 source = { editable = "." }
 dependencies = [
     { name = "aiohttp" },

agentirc_cli-4.1.2/tests/test_setup_update_cli.py

@@ -1,45 +0,0 @@
-# tests/test_setup_update_cli.py
-"""Lightweight parser tests for setup and update subcommands."""
-
-from culture.cli import _build_parser
-
-
-def test_setup_parser():
-    """setup subcommand parses --config and --uninstall."""
-    p = _build_parser()
-    args = p.parse_args(["mesh", "setup", "--uninstall"])
-    assert args.command == "mesh"
-    assert args.mesh_command == "setup"
-    assert args.uninstall is True
-
-    args = p.parse_args(["mesh", "setup", "--config", "/tmp/mesh.yaml"])
-    assert args.config == "/tmp/mesh.yaml"
-
-
-def test_update_parser():
-    """update subcommand parses --dry-run, --skip-upgrade, --config."""
-    p = _build_parser()
-    args = p.parse_args(["mesh", "update", "--dry-run", "--skip-upgrade"])
-    assert args.command == "mesh"
-    assert args.mesh_command == "update"
-    assert args.dry_run is True
-    assert args.skip_upgrade is True
-
-    args = p.parse_args(["mesh", "update", "--config", "/tmp/mesh.yaml"])
-    assert args.config == "/tmp/mesh.yaml"
-
-
-def test_setup_in_dispatch():
-    """setup command is wired into the mesh module."""
-    from culture.cli import mesh
-
-    assert hasattr(mesh, "_cmd_setup")
-    assert callable(mesh._cmd_setup)
-
-
-def test_update_in_dispatch():
-    """update command is wired into the mesh module."""
-    from culture.cli import mesh
-
-    assert hasattr(mesh, "_cmd_update")
-    assert callable(mesh._cmd_update)