Attaching to tmux

# Server() with no arguments talks to tmux's own default socket.
# Server(socket_name=...) or Server(socket_path=...) pick a different one.
server = libtmux.Server()

# from_env() is also on Session, Window, and Pane, for code running inside a
# pane that wants to ask "where am I" instead of being told.
server = libtmux.Server.from_env()

// Behaves like the other ports' bare form. Naming a socket wasn't confirmed
// against a checked snippet for this page — check the port's own reference.
const server = new Server();

// Resolves the tmux binary once through the snapshotted PATH and freezes
// it. SocketName and SocketPath select a socket explicitly (SocketPath wins
// if both are set); a Server built this way does not drift if the
// environment changes later.
server, err := tmux.NewServer(tmux.ServerOptions{})

// Server::new() uses the process's own environment. from_env() reads the
// TMUX variable directly; find.rs tries the pane-local one first and falls
// back to a fresh connection.
let server = Server::from_env().or_else(|_| Server::new())?;

Server server = Server.open(
    ServerConfig.builder().endpoint(ServerEndpoint.socketPath(socket)).build());

// The pane-local read-back: takes nothing, returns empty outside a pane.
TmuxEnvironment.current();

// Resolves in a fixed order: an explicit ServerConnectionOptions, then
// LIBTMUX_SOCKET_PATH, then LIBTMUX_SOCKET_NAME (under TMUX_TMPDIR, or
// /tmp), then the socket named "default". A named option always wins over
// an environment variable.
Server server = await Server.ConnectAsync();

// The separate pane-local read-back; ConnectAsync never consults TMUX.
Server fromPane = await Server.FromEnvironment();

// Four named constructors instead of one flexible one — pick the one that
// names how you're reaching this tmux:
libtmux::Server::from_env();          // inside tmux
libtmux::Server::at_socket_name(name);
libtmux::Server::at_socket_path(path);
libtmux::Server::at_default();        // "my tmux", to a person

// The literal quickstart — there is no bare no-argument constructor, so
// naming the socket is not optional the way it is elsewhere.
let server = try Server(socketName: "default")

# default only stands in for *absence*: an ambiguous match still raises
# MultipleObjectsReturned even with a default supplied — handing back an
# arbitrary match from several is how a script ends up driving the wrong
# pane. See Filtering and queries.
session = server.sessions.get(session_name="demo", default=None)
if session is None:
    session = server.new_session(session_name="demo")

const session = snapshot.sessions.where({ name: "demo" }).oneOrUndefined();

// Push the check into tmux itself with a typed filter, rather than reading
// everything back and filtering in the process.
live := tmux.TmuxFilter("#{==:#{session_name},demo}")
sessions, err := server.SearchSessions(ctx, &live)

Session session = server.hasSession("work")
        ? server.sessions().stream()
                .filter(candidate -> candidate.name().equals("work"))
                .findFirst()
                .orElseThrow()
        : server.newSession("work");

// hasSession answers the question directly as a Bool, no exception needed
// either way.
if try await server.hasSession("work") == false {
    _ = try await server.newSession(named: "work", windowName: "start")
}