Server, session, window, pane

module example.com/concepts

go 1.26.0

require github.com/libtmux/libtmux-go v0.0.0

replace github.com/libtmux/libtmux-go => ./libtmux-source

#!/bin/sh
set -eu

binary=$(command -v tmux)
directory=$(mktemp -d /tmp/libtmux-go-concepts.XXXXXX)
socket="$directory/tmux.sock"

cleanup() {
    status=$?
    trap - 0 HUP INT TERM
    if [ -S "$socket" ] && ! "$binary" -S "$socket" kill-server; then
        printf 'Cannot stop tmux; kept %s\n' "$directory" >&2
        exit 1
    fi
    rm -rf "$directory" || exit 1
    exit "$status"
}
trap cleanup 0
trap 'exit 1' HUP INT TERM

unset TMUX TMUX_PANE
export LIBTMUX_SOCKET_PATH="$socket"
"$binary" -S "$socket" -f /dev/null new-session -d -s work-one -n editor /bin/cat
"$binary" -S "$socket" new-session -d -s work-two -n logs /bin/cat
"$@"
"$binary" -S "$socket" has-session -t '=work-one'

package main

import (
	"context"
	"errors"
	"fmt"
	"log"
	"os"
	"time"

	"github.com/libtmux/libtmux-go/tmux"
)

func main() {
	if err := run(); err != nil {
		log.Fatal(err)
	}
}

func run() error {
	socket := os.Getenv("LIBTMUX_SOCKET_PATH")
	if socket == "" {
		return errors.New("run this program with run.sh")
	}
	server, err := tmux.NewServer(tmux.ServerOptions{SocketPath: socket, ConfigFile: "/dev/null"})
	if err != nil {
		return err
	}
	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()

	session, err := server.NewSession(ctx, tmux.NewSessionRequest{
		Name: "tools", WindowName: "editor", Command: "/bin/cat", Width: 100, Height: 30,
	})
	if err != nil {
		return fmt.Errorf("create tools session: %w", err)
	}
	if _, captured := session.Windows(); captured {
		return errors.New("a newly created session unexpectedly includes window relations")
	}
	window, err := session.NewWindow(ctx, tmux.NewWindowRequest{
		Name: tmux.Ptr("logs"), Command: "/bin/cat",
	})
	if err != nil {
		return fmt.Errorf("create logs window: %w", err)
	}
	if _, err := window.SplitPane(ctx, tmux.SplitPaneRequest{Command: "/bin/cat"}); err != nil {
		return fmt.Errorf("split logs window: %w", err)
	}

	sessions, err := server.Sessions(ctx)
	if err != nil {
		return err
	}
	windows, err := server.Windows(ctx)
	if err != nil {
		return err
	}
	panes, err := server.Panes(ctx)
	if err != nil {
		return err
	}
	if len(sessions) != 3 || len(windows) != 4 || len(panes) != 5 {
		return fmt.Errorf("unexpected counts: %d sessions, %d windows, %d panes",
			len(sessions), len(windows), len(panes))
	}
	fmt.Println("server: 3 sessions, 4 windows, 5 panes")

	snapshot, err := server.Snapshot(ctx)
	if err != nil {
		return err
	}
	captured, err := snapshot.SessionByID(session.ID())
	if err != nil {
		return err
	}
	children, ok := captured.Windows()
	if !ok || len(children) != 2 {
		return errors.New("tools should have 2 captured windows")
	}
	descendants, ok := captured.Panes()
	if !ok || len(descendants) != 3 {
		return errors.New("tools should have 3 captured panes")
	}
	fmt.Println("tools: 2 windows, 3 panes")
	return nil
}

package main

import (
	"context"
	"errors"
	"fmt"
	"log"
	"os"
	"time"

	"github.com/libtmux/libtmux-go/tmux"
)

func main() {
	if err := run(); err != nil {
		log.Fatal(err)
	}
}

func run() error {
	socket := os.Getenv("LIBTMUX_SOCKET_PATH")
	if socket == "" {
		return errors.New("run this program with run.sh")
	}
	server, err := tmux.NewServer(tmux.ServerOptions{SocketPath: socket, ConfigFile: "/dev/null"})
	if err != nil {
		return err
	}
	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()

	before, err := server.Snapshot(ctx)
	if err != nil {
		return err
	}
	if len(before.Sessions()) != 2 || len(before.Windows()) != 2 || len(before.Panes()) != 2 {
		return errors.New("expected the initial two-session fixture")
	}
	var editor tmux.Window
	found := false
	for _, session := range before.Sessions() {
		name, ok := session.Name()
		if !ok {
			return errors.New("session name was not captured")
		}
		windows, ok := session.Windows()
		if !ok || len(windows) != 1 {
			return errors.New("expected one captured window")
		}
		window := windows[0]
		windowName, ok := window.Name()
		if !ok {
			return errors.New("window name was not captured")
		}
		panes, ok := window.Panes()
		if !ok || len(panes) != 1 {
			return errors.New("expected one captured pane")
		}
		fmt.Printf("%s: %s, %d pane\n", name, windowName, len(panes))
		if name == "work-one" {
			editor, found = window, true
		}
	}
	if !found {
		return errors.New("work-one is missing")
	}
	renamed, err := editor.Rename(ctx, "renamed")
	if err != nil {
		return err
	}
	oldName, oldOK := editor.Name()
	newName, newOK := renamed.Name()
	if !oldOK || !newOK || oldName != "editor" || newName != "renamed" {
		return errors.New("rename should return a new record without changing the old one")
	}
	after, err := server.Snapshot(ctx)
	if err != nil {
		return err
	}
	current, err := after.WindowByID(editor.ID())
	if err != nil {
		return err
	}
	currentName, ok := current.Name()
	if !ok || currentName != "renamed" {
		return errors.New("fresh snapshot missed the rename")
	}
	fmt.Printf("captured: %s; returned: %s; fresh: %s\n", oldName, newName, currentName)
	return nil
}