feat(server): Add socket_name_factory and on_init callbacks

Add two new optional parameters to Server constructor:

- socket_name_factory: Callable[[], str]
  Generates unique socket names for new servers. Used when socket_name
  is not provided. Useful for creating multiple servers with unique names.

- on_init: Callable[[Server], None]
  Callback that runs after server initialization. Useful for tracking
  server instances and performing cleanup in tests.

The socket_name_factory is tried after socket_name, maintaining backward
compatibility while adding flexibility for dynamic socket name generation.

Example:

def socket_name_factory() -> str:
    return f"tmux_{next(counter)}"
    server = Server(socket_name_factory=socket_name_factory)

This enables better testing patterns and more flexible server creation,
particularly in test environments where unique socket names are needed.

Author: tony

src/libtmux/server.py

@@ -59,6 +59,8 @@ class Server(EnvironmentMixin):
     socket_path : str, optional
     config_file : str, optional
     colors : str, optional
+    on_init : callable, optional
+    socket_name_factory : callable, optional
 
     Examples
     --------
@@ -110,6 +112,8 @@ def __init__(
         socket_path: str | pathlib.Path | None = None,
         config_file: str | None = None,
         colors: int | None = None,
+        on_init: t.Callable[[Server], None] | None = None,
+        socket_name_factory: t.Callable[[], str] | None = None,
         **kwargs: t.Any,
     ) -> None:
         EnvironmentMixin.__init__(self, "-g")
@@ -120,6 +124,8 @@ def __init__(
             self.socket_path = socket_path
         elif socket_name is not None:
             self.socket_name = socket_name
+        elif socket_name_factory is not None:
+            self.socket_name = socket_name_factory()
 
         tmux_tmpdir = pathlib.Path(os.getenv("TMUX_TMPDIR", "/tmp"))
         socket_name = self.socket_name or "default"
@@ -137,6 +143,9 @@ def __init__(
         if colors:
             self.colors = colors
 
+        if on_init is not None:
+            on_init(self)
+
     def is_alive(self) -> bool:
         """Return True if tmux server alive.
 

tests/test_server.py

@@ -228,3 +228,71 @@ def test_raise_if_dead_does_not_raise_if_alive(server: Server) -> None:
     """Verify new_session() does not raise if tmux server is alive."""
     server.new_session()
     server.raise_if_dead()
+
+
+def test_on_init(server: Server) -> None:
+    """Verify on_init callback is called during Server initialization."""
+    called_with: list[Server] = []
+
+    def on_init(server: Server) -> None:
+        called_with.append(server)
+
+    myserver = Server(socket_name="test_on_init", on_init=on_init)
+    try:
+        assert len(called_with) == 1
+        assert called_with[0] is myserver
+    finally:
+        if myserver.is_alive():
+            myserver.kill()
+
+
+def test_socket_name_factory(server: Server) -> None:
+    """Verify socket_name_factory generates socket names."""
+    socket_names: list[str] = []
+
+    def socket_name_factory() -> str:
+        name = f"test_socket_{len(socket_names)}"
+        socket_names.append(name)
+        return name
+
+    myserver = Server(socket_name_factory=socket_name_factory)
+    try:
+        assert myserver.socket_name == "test_socket_0"
+        assert socket_names == ["test_socket_0"]
+
+        # Creating another server should use factory again
+        myserver2 = Server(socket_name_factory=socket_name_factory)
+        try:
+            assert myserver2.socket_name == "test_socket_1"
+            assert socket_names == ["test_socket_0", "test_socket_1"]
+        finally:
+            if myserver2.is_alive():
+                myserver2.kill()
+    finally:
+        if myserver.is_alive():
+            myserver.kill()
+        if myserver2.is_alive():
+            myserver2.kill()
+
+
+def test_socket_name_precedence(server: Server) -> None:
+    """Verify socket_name takes precedence over socket_name_factory."""
+
+    def socket_name_factory() -> str:
+        return "from_factory"
+
+    myserver = Server(
+        socket_name="explicit_name",
+        socket_name_factory=socket_name_factory,
+    )
+    myserver2 = Server(socket_name_factory=socket_name_factory)
+    try:
+        assert myserver.socket_name == "explicit_name"
+
+        # Without socket_name, factory is used
+        assert myserver2.socket_name == "from_factory"
+    finally:
+        if myserver.is_alive():
+            myserver.kill()
+        if myserver2.is_alive():
+            myserver2.kill()