Swift API

Up Root

struct libtmux-swift latest

Session

A tmux session, as it was when the listing was read.

Base types CopyableDecodableEncodableEquatableFilterableHashableIdentifiableSendableSendableMetatype

Source and package

Qualified name: Session
Package: libtmux-swift
Source: Sources/LibTmux/Session.swift
Other languages: Perlclass ErlangPowerShellcmdlet Juliastruct Elixirstruct Haskell Common Lispclass PythonRubyLuaTypeScriptRustGoJavaC#C++KotlinScalaOCamlF#module Clojurefunction

struct Session : struct Session struct [source] ¶

Description#

This is a value, not a live handle: nothing here re-reads tmux, and two copies never disagree. Ask the server again for a newer view.

Examples#

Create a session and refresh its snapshot. Create a detached session with an editor window, add a logs window, then look up the session by its stable ID. The original Session still reports one window; the fresh snapshot reports two. Use Swift 6.2 or newer and tmux 3.3a or newer on Linux or macOS. In an empty directory, save this consumer package as Package.swift; SwiftPM fetches the library from release 0.1.1:

// swift-tools-version: 6.2
import PackageDescription

let package = Package(
    name: "ApiExample",
    platforms: [.macOS(.v13)],
    dependencies: [
        .package(url: "https://github.com/libtmux/libtmux-swift.git", from: "0.1.1")
    ],
    targets: [
        .executableTarget(
            name: "ApiExample",
            dependencies: [
                .product(name: "LibTmux", package: "libtmux-swift"),
                .product(name: "TmuxFixture", package: "libtmux-swift"),
            ],
            path: "Sources"
        )
    ]
)

Create a Sources directory and save this complete program as Sources/Example.swift. The withTmuxServer fixture owns a private tmux server and stops it after success or failure. Ordinary application code uses Server for its own socket; these examples use the fixture until their setup moves to ordinary server objects. View source

import Foundation
import LibTmux
import TmuxFixture

@main
struct ApiNewSession {
    static func main() async {
        do {
            try await withTmuxServer { @Sendable server in
                let session = try await server.newSession(named: "work", windowName: "editor")
                _ = try await server.newWindow(in: session, named: "logs")
                guard let refreshed = try await server.session(session.id) else {
                    throw ExampleError.sessionDisappeared
                }
                print("Created: \(session.name)")
                print("Original windows: \(session.windowCount)")
                print("Current windows: \(refreshed.windowCount)")
            }
        } catch {
            FileHandle.standardError.write(Data("Example failed: \(error)\n".utf8))
            exit(EXIT_FAILURE)
        }
    }

    enum ExampleError: Error {
        case sessionDisappeared
    }
}

Build and run the saved program. An operation or cleanup error produces a failing exit status. Set LIBTMUX_TMUX_BIN to an absolute executable path to select a tmux version:

$ swift run ApiExample

Expected output:

Created: work
Original windows: 1
Current windows: 2

Members11#

Common operations5#

id: let id: SessionID property tmux's own session id, stable for the session's lifetime — $0, $1. Names are not: a session can be renamed, and two servers can both have a 0.
name: let name: String property What a person calls it, and what tmux matches when a command names a session. Renameable, so it is not an identity.
isAttached: let isAttached: Bool property Whether any client is looking at this session. Opening a connection attaches one, so this reads differently from inside Server.connected(attachingTo:_:) — see <doc:Modes>.
createdAt: let createdAt: Int property When tmux created the session, in seconds since the epoch. tmux's clock, not this process's.
windowCount: let windowCount: Int property tmux's own count, so a caller needing only the number does not have to list the windows to get it.

Other members6#

filterFieldID(for:) method The stable wire id for a key path, or nil if the property is not filterable.
filterFieldType(_:) method The value kind an id names, or nil when this model does not know it.
filterFormatField(_:) method The tmux format field an id reads, or nil when it has no single one.
filterValue(_:of:) method Reads the field an id names, or nil if this model has no such field.
incarnation: let incarnation: ServerIncarnation property The daemon this value was read from.
init(id:name:windowCount:isAttached:createdAt:incarnation:) method

Inherited members2 members#

Reached through Equatable.!=(_:_:), Decodable.init(from:).

!=(_:_:) function inherited Returns a Boolean value indicating whether two values are not equal.
init(from:) method inherited Creates a new instance by decoding from the given decoder.

Guides#

Pages that discuss Session.

Concepts: Server, session, window, pane
Ports: Swift workspace builder behavior
Swift workspace builder API
Topics: Architecture
Format-token fields
Traversal

In other ports#

A tmux session

Equivalents of A tmux session in other languages
Language	Equivalent
Python	`libtmux.Session`
Ruby	`LibTmux::Session`
Lua	`libtmux.Session`
PowerShell	`LibTmux\Get-TmuxSession` This cmdlet reads and returns shared .NET `LibTmux.Session` objects. Child windows and panes require further acquisition.
Julia	`LibTmux.SessionSnapshot` `SessionSnapshot` holds captured session data. Actions use its `SessionRef`, a typed identity bound to an observed daemon generation.
Erlang	`#tmux_model:session{}`
Elixir	`LibTmux.Session` `Session` is an immutable observation. Fields not captured read as `:unloaded`.
Haskell	No public Haskell equivalent is implemented; the current modules expose scalar values and version parsing.
Common Lisp	`libtmux:session` `session` is an immutable captured entity. The same name also has a relation accessor with a distinct public identity.
TypeScript	`session.Session`
Rust	`session.Session`
Go	`tmux.Session`
Java	`io.github.libtmux.Session`
Clojure	`libtmux.core/sessions!` Acquires a vector of captured session maps. The session value is a map, not a wrapper class.
Kotlin	`io.github.libtmux.kotlin.Session`
Scala	`io.github.libtmux.scaladsl.Session`
C#	`LibTmux.Session`
F#	`LibTmux.FSharp.Session` This F# module builds deferred child queries from a shared .NET `LibTmux.Session` and its server association. `Query.list` acquires their results from tmux.
C++	`libtmux::Session`
OCaml	`Libtmux.Session.t`
Perl	`LibTmux::Session` A captured read-only entity; explicit Server operations accept its stable identity.

Scripting & web

Compiled & native

JVM

.NET

BEAM

tmux

Session

Description#

Examples#

Members11#

Common operations5#

Other members6#

Inherited members2 members#

Guides#

In other ports#

Description#

Examples#

Members11#

Common operations5#

Other members6#

Inherited members2 members#

Guides#

In other ports#

Related types#