F# API

module libtmux-fsharp latest

Server

Namespace L.FSharp LibTmux.FSharp

Starts server reads and queries with the caller's cancellation token.

View as Markdown

Source and package

Module: LibTmux.FSharp
Package: LibTmux.FSharp
Source: src/LibTmux.FSharp/Hierarchy.fsi

module Server module [source] ¶

Examples#

Create owned session and window scopes with the core LibTmux API, split a pane with Pane.split, then rename and select the window, select the first pane again, arrange the window, title the pane and kill the split with the F# helpers. Renaming and selecting return a handle carrying the state afterwards. Disposing the owned window also stops its panes. For F# session descriptions, use Server.newSession with SessionSpec. Use Linux or macOS with Git, tmux 3.2a or newer, .NET SDK 10.0.303, and the .NET 8 and 10 runtimes. In an empty directory, fetch the documented library revision:

$ git clone https://github.com/libtmux/libtmux-dotnet.git libtmux-source && \
  git -C libtmux-source checkout --detach cf34b255c896d19a97e7d7fabea58609c916012d

Save this complete consumer setup as global.json: View source

{
  "sdk": {
    "version": "10.0.303",
    "rollForward": "disable",
    "allowPrerelease": false
  },
  "test": {
    "runner": "Microsoft.Testing.Platform"
  }
}

Save this complete consumer setup as NuGet.config: View source

<?xml version="1.0" encoding="utf-8"?>
<configuration>
  <packageSources>
    <clear />
    <add key="libtmux-source" value="libtmux-source/artifacts/api-example-packages" />
    <add key="nuget.org" value="https://api.nuget.org/v3/index.json" />
  </packageSources>
  <packageSourceMapping>
    <clear />
    <packageSource key="libtmux-source">
      <package pattern="LibTmux" />
      <package pattern="LibTmux.*" />
    </packageSource>
    <packageSource key="nuget.org">
      <package pattern="*" />
    </packageSource>
  </packageSourceMapping>
</configuration>

Save this complete consumer setup as Example.fsproj: View source

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFrameworks>net8.0;net10.0</TargetFrameworks>
    <LangVersion>10.0</LangVersion>
    <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
    <DisableImplicitFSharpCoreReference>true</DisableImplicitFSharpCoreReference>
    <DisableImplicitLibraryPacksFolder>true</DisableImplicitLibraryPacksFolder>
  </PropertyGroup>
  <ItemGroup>
    <Compile Include="Program.fs" />
    <PackageReference Include="FSharp.Core" Version="[10.1.303]" />
    <PackageReference Include="LibTmux.FSharp" Version="[0.0.0-alpha.20]" />
  </ItemGroup>
</Project>

Save this complete program as Program.fs. It creates a private server with LibTmux.Server.CreateOwnedAsync; use! disposes owned scopes after success, cancellation or failure. The F# facade has no separate server constructor. View source

open System
open System.Threading
open LibTmux
open LibTmux.FSharp

let runAsync () =
    task {
        use deadline = new CancellationTokenSource(TimeSpan.FromSeconds 10.)
        let token = deadline.Token

        let options =
            ServerConnectionOptions(
                SocketName = "fsharp-create-" + Guid.NewGuid().ToString("N"),
                ConfigurationFile = "/dev/null"
            )

        use! owned = options |> Server.createOwned token

        use! session =
            owned.Value.CreateOwnedSessionAsync(
                NewSessionRequest(Name = "demo", WindowName = "shell", Command = "/bin/cat"),
                token
            )

        use! window =
            session.Value.CreateOwnedWindowAsync(
                NewWindowRequest(Name = "editor", Command = "/bin/cat", Attach = false),
                token
            )

        let! panes = window.Value.GetPanesAsync(token)
        let original = panes |> Seq.exactlyOne

        let! added =
            original
            |> Pane.split token (SplitPaneRequest(Direction = PaneDirection.Right, Command = "/bin/cat"))

        // Renaming and selecting return a handle carrying the state afterwards.
        let! notes = window.Value |> Window.rename token "notes"
        let wasCurrent = notes.Active
        let! current = notes |> Window.select token
        let! focused = original |> Pane.select token
        let! _ = current |> Window.selectLayout token "even-horizontal"
        let! titled = focused |> Pane.setTitle token "editor"
        do! added |> Pane.kill token

        let server = owned.Value
        let! windows = server |> Server.windows |> Query.list token
        let! allPanes = server |> Server.panes |> Query.list token

        printfn "Created session demo and window editor."
        printfn "The split made a new pane: %b" (added.Id <> original.Id)
        printfn "Renamed to %s; current before select: %b, after: %b" current.Name wasCurrent current.Active
        printfn "First pane active again: %b; titled %s" focused.Active titled.Title
        printfn "Windows: %d; panes after the kill: %d" windows.Count allPanes.Count
    }

runAsync().GetAwaiter().GetResult()

Build the exact source packages and the saved consumer, then run both supported frameworks. The local package feed prevents an unrelated published package from satisfying the restore. Each program checks its result and exits unsuccessfully after an unhandled error:

$ export NUGET_PACKAGES="$PWD/packages" && \
  dotnet restore libtmux-source/src/LibTmux.FSharp/LibTmux.FSharp.fsproj --locked-mode && \
  dotnet pack libtmux-source/src/LibTmux/LibTmux.csproj \
    --configuration Release --no-restore -p:ContinuousIntegrationBuild=true \
    --output "$PWD/libtmux-source/artifacts/api-example-packages" && \
  dotnet pack libtmux-source/src/LibTmux.FSharp/LibTmux.FSharp.fsproj \
    --configuration Release --no-restore -p:ContinuousIntegrationBuild=true \
    --output "$PWD/libtmux-source/artifacts/api-example-packages" && \
  dotnet restore Example.fsproj --configfile NuGet.config && \
  dotnet build Example.fsproj --configuration Release --no-restore --warnaserror && \
  export LIBTMUX_TMUX="$(command -v tmux)" && \
  export TMUX_TMPDIR=/tmp/libtmux-dotnet-dev && \
  mkdir -p "$TMUX_TMPDIR" && \
  unset TMUX TMUX_PANE && \
  dotnet bin/Release/net8.0/Example.dll && \
  dotnet bin/Release/net10.0/Example.dll

Expected program output from each framework:

Created session demo and window editor.
The split made a new pane: true
Renamed to notes; current before select: false, after: true
First pane active again: true; titled editor
Windows: 2; panes after the kill: 2

Discussed in Server, session, window, pane · Attaching to tmux , .NET interoperation , Quick start

Members13 members#

Collections and queries4 members#

sessions function Queries every session.
windows function Queries window placements across all sessions.
panes function Queries every pane.
clients function Queries attached clients.

Common operations9 members#

capture function Returns a new server handle captured to the requested depth.
createOwned function Starts a server on the socket the options name and owns it; disposing the scope stops it.
newSession function Creates a session as described: its windows, and each window's splits.
within function Returns the server with every command bounded by a timeout, for it and every handle taken from it.
connect function Attaches to a server already listening on the socket the options name.
tryFindPane function Returns a pane or None after a successful lookup establishes absence.
tryFindClient function Returns the client with an exact name or None after a successful listing finds no match.
tryFindSession function Returns a session or None after a successful lookup establishes absence.
tryFindWindow function Returns a window or None after a successful lookup establishes absence.

Scripting & web

Compiled & native

JVM

.NET

tmux

Server

Examples#

Members13 members#

Collections and queries4 members#

Common operations9 members#

Examples#

Members13 members#

Collections and queries4 members#

Common operations9 members#

Related types#